diff --git a/src/components/Dropdown/index.tsx b/src/components/Dropdown/index.tsx
index 055fd959..da0a1885 100644
--- a/src/components/Dropdown/index.tsx
+++ b/src/components/Dropdown/index.tsx
@@ -1,19 +1,19 @@
 import { Select } from "antd";
 import { map } from "lodash-es";
-import { Dictionary, RecipeManifest } from "../../types";
+import { Dictionary, RecipeMetadata } from "../../types";
 
 interface DropdownProps {
     placeholder: string;
     defaultValue?: string;
-    options: Dictionary<RecipeManifest>;
+    options: Dictionary<RecipeMetadata>;
     onChange: (value: string) => void;
 }
 
 const Dropdown = (props: DropdownProps): JSX.Element => {
     const { placeholder, options, onChange, defaultValue } = props;
     const selectOptions = map(options, (opt, key) => ({
-        label: opt.name || key,
-        value: opt.recipe,
+        label: opt.displayName || key,
+        value: opt.recipeId,
     }));
 
     return (
diff --git a/src/components/GradientInput/index.tsx b/src/components/GradientInput/index.tsx
index bfbd8fac..93a8e91a 100644
--- a/src/components/GradientInput/index.tsx
+++ b/src/components/GradientInput/index.tsx
@@ -2,9 +2,8 @@ import { Select, Slider, InputNumber } from "antd";
 import { GradientOption } from "../../types";
 import {
     useSelectedRecipeId,
-    useUpdateRecipeObj,
     useGetCurrentValue,
-    useCurrentRecipeString,
+    useEditRecipe,
 } from "../../state/store";
 import { getSelectedGradient, deriveGradientStrength, round2, toStore } from "../../utils/gradient";
 import "./style.css";
@@ -19,10 +18,8 @@ interface GradientInputProps {
 const GradientInput = (props: GradientInputProps): JSX.Element => {
     const { displayName, description, gradientOptions, defaultValue } = props;
     const selectedRecipeId = useSelectedRecipeId();
-    const updateRecipeObj = useUpdateRecipeObj();
+    const editRecipe = useEditRecipe();
     const getCurrentValue = useGetCurrentValue();
-    // Force re-render after restore/navigation
-    useCurrentRecipeString();
 
     const { currentGradient, selectedOption } = getSelectedGradient(
         gradientOptions,
@@ -36,20 +33,17 @@ const GradientInput = (props: GradientInputProps): JSX.Element => {
         if (!selectedRecipeId) return;
         const selectedOption = gradientOptions.find(option => option.value === value);
         if (!selectedOption || !selectedOption.path) return;
-
-        // Make changes to JSON recipe
-        const changes: Record<string, string | number> = {[selectedOption.path]: value};
         if (selectedOption.packing_mode && selectedOption.packing_mode_path) {
-            changes[selectedOption.packing_mode_path] = selectedOption.packing_mode;
+            editRecipe(selectedRecipeId, selectedOption.packing_mode_path, selectedOption.packing_mode);
         }
-        updateRecipeObj(selectedRecipeId, changes);
+        editRecipe(selectedRecipeId, selectedOption.path, value);
     };
 
     const handleStrengthChange = (val: number | null) => {
         if (val == null || !selectedRecipeId || !gradientStrengthData) return;
         const uiVal = round2(val);
         const storeVal = toStore(uiVal);
-        updateRecipeObj(selectedRecipeId, { [gradientStrengthData.path]: storeVal });
+        editRecipe(selectedRecipeId, gradientStrengthData.path, storeVal);
     };
 
     const selectOptions = gradientOptions.map((option) => ({
diff --git a/src/components/InputSwitch/index.tsx b/src/components/InputSwitch/index.tsx
index 07ceb9b1..c830cb54 100644
--- a/src/components/InputSwitch/index.tsx
+++ b/src/components/InputSwitch/index.tsx
@@ -3,9 +3,9 @@ import { Input, InputNumber, Select, Slider } from "antd";
 import { GradientOption } from "../../types";
 import {
     useSelectedRecipeId,
-    useUpdateRecipeObj,
     useGetCurrentValue,
-    useCurrentRecipeString,
+    useEditRecipe,
+    useRecipes,
 } from "../../state/store";
 import GradientInput from "../GradientInput";
 import "./style.css";
@@ -28,9 +28,9 @@ const InputSwitch = (props: InputSwitchProps): JSX.Element => {
     const { displayName, inputType, dataType, description, min, max, options, id, gradientOptions, conversionFactor, unit } = props;
 
     const selectedRecipeId = useSelectedRecipeId();
-    const updateRecipeObj = useUpdateRecipeObj();
+    const editRecipe = useEditRecipe();
     const getCurrentValue = useGetCurrentValue();
-    const recipeVersion = useCurrentRecipeString();
+    const recipes = useRecipes();
 
     // Conversion factor for numeric inputs where we want to display a
     // different unit in the UI than is stored in the recipe
@@ -59,7 +59,7 @@ const InputSwitch = (props: InputSwitchProps): JSX.Element => {
     // Reset local state when store value (or recipe) changes
     useEffect(() => {
         setValue(getCurrentValueMemo());
-    }, [getCurrentValueMemo, recipeVersion]);
+    }, [getCurrentValueMemo, recipes]);
 
     const handleInputChange = (value: string | number | null) => {
         if (value == null || !selectedRecipeId) return;
@@ -68,7 +68,7 @@ const InputSwitch = (props: InputSwitchProps): JSX.Element => {
             // Convert back to original units for updating recipe object
             value = value / conversion;
         }
-        updateRecipeObj(selectedRecipeId, { [id]: value });
+        editRecipe(selectedRecipeId, id, value);
     };
 
     switch (inputType) {
diff --git a/src/components/JSONViewer/index.tsx b/src/components/JSONViewer/index.tsx
index 2e83b403..65293b68 100644
--- a/src/components/JSONViewer/index.tsx
+++ b/src/components/JSONViewer/index.tsx
@@ -7,12 +7,11 @@ import {
     returnOneElement,
 } from "./formattingUtils";
 import "./style.css";
+import { ViewableRecipe } from "../../types";
 
 interface JSONViewerProps {
     title: string;
-    content: string;
-    isEditable: boolean;
-    onChange: (value: string) => void;
+    content?: ViewableRecipe;
 }
 
 const JSONViewer = (props: JSONViewerProps): JSX.Element | null => {
@@ -22,8 +21,6 @@ const JSONViewer = (props: JSONViewerProps): JSX.Element | null => {
         return null;
     }
 
-    const contentAsObj = JSON.parse(content);
-
     // descriptions for top level key-value pairs
     const descriptions: DescriptionsItemProps[] = [];
     // trees for nested objects like 'objects', 'composition', 'gradients'
@@ -44,7 +41,7 @@ const JSONViewer = (props: JSONViewerProps): JSX.Element | null => {
     };
 
     // top level objects, like name, bounding_box, etc.
-    Object.entries(contentAsObj).forEach(([key, value]) => {
+    Object.entries(content).forEach(([key, value]) => {
         if (typeof value === "string") {
             descriptions.push({
                 label: convertUnderscoreToSpace(key),
diff --git a/src/components/PackingInput/index.tsx b/src/components/PackingInput/index.tsx
index 4bcce8ed..a68f4feb 100644
--- a/src/components/PackingInput/index.tsx
+++ b/src/components/PackingInput/index.tsx
@@ -3,15 +3,12 @@ import { Tabs } from "antd";
 
 import {
     useSelectedRecipeId,
-    useCurrentRecipeString,
-    useFieldsToDisplay,
-    useInputOptions,
-    useIsLoading,
-    useLoadInputOptions,
     useSelectRecipe,
-    useUpdateRecipeString,
     useStartPacking,
     useLoadAllRecipes,
+    useCurrentRecipeObject,
+    useInputOptions,
+    useLoadInputOptions,
 } from "../../state/store";
 import Dropdown from "../Dropdown";
 import JSONViewer from "../JSONViewer";
@@ -29,15 +26,12 @@ interface PackingInputProps {
 const PackingInput = (props: PackingInputProps): JSX.Element => {
     const { startPacking } = props;
     const selectedRecipeId = useSelectedRecipeId();
-    const recipeString = useCurrentRecipeString();
-    const fieldsToDisplay = useFieldsToDisplay();
+    const recipeObj = useCurrentRecipeObject();
     const inputOptions = useInputOptions();
-    const isLoading = useIsLoading();
 
     const loadInputOptions = useLoadInputOptions();
     const loadAllRecipes = useLoadAllRecipes();
     const selectRecipe = useSelectRecipe();
-    const updateRecipeString = useUpdateRecipeString();
     const storeStartPacking = useStartPacking();
 
     const preFetchInputsAndRecipes = useCallback(async () => {
@@ -54,15 +48,12 @@ const PackingInput = (props: PackingInputProps): JSX.Element => {
         await storeStartPacking(startPacking);
     };
 
-    const handleRecipeStringChange = (newString: string) => {
-        if (selectedRecipeId) {
-            updateRecipeString(selectedRecipeId, newString);
-        }
-    };
+    const loadingText = (<div>Loading...</div>)
 
-    if (isLoading) {
-        return <div>Loading...</div>;
-    }
+    // No recipe or dropdown options to load
+    if (!recipeObj && !inputOptions[selectedRecipeId]) {
+        return loadingText;
+    }   
 
     return (
         <>
@@ -75,19 +66,19 @@ const PackingInput = (props: PackingInputProps): JSX.Element => {
                     onChange={selectRecipe}
                 />
             </div>
-            <Tabs defaultActiveKey="1" className="recipe-content">
-                <Tabs.TabPane tab="Edit" key="1">
-                    <RecipeForm onStartPacking={handleStartPacking} />
-                </Tabs.TabPane>
-                <Tabs.TabPane tab="Full Recipe" key="2">
-                    <JSONViewer
-                        title="Recipe"
-                        content={recipeString}
-                        isEditable={fieldsToDisplay === undefined}
-                        onChange={handleRecipeStringChange}
-                    />
-                </Tabs.TabPane>
-            </Tabs>
+            {/* Options menu loaded, but no recipe to load yet */}
+            {!recipeObj ? (
+                loadingText
+            ) : (
+                <Tabs defaultActiveKey="1" className="recipe-content">
+                    <Tabs.TabPane tab="Edit" key="1">
+                        <RecipeForm onStartPacking={handleStartPacking} />
+                    </Tabs.TabPane>
+                    <Tabs.TabPane tab="Full Recipe" key="2">
+                        <JSONViewer title="Recipe" content={recipeObj} />
+                    </Tabs.TabPane>
+                </Tabs>
+            )}
         </>
     );
 };
diff --git a/src/components/Viewer/index.tsx b/src/components/Viewer/index.tsx
index 8a2dc79d..804376a4 100644
--- a/src/components/Viewer/index.tsx
+++ b/src/components/Viewer/index.tsx
@@ -1,15 +1,41 @@
+import { LoadingOutlined } from "@ant-design/icons";
 import { SIMULARIUM_EMBED_URL } from "../../constants/urls";
-import { useResultUrl } from "../../state/store";
+import { useCurrentRecipeObject, useIsModified, useIsPacking, useResultUrl } from "../../state/store";
 import "./style.css";
 
 const Viewer = (): JSX.Element => {
     const resultUrl = useResultUrl();
+    const recipeObject = useCurrentRecipeObject();
+    const isLoading = !recipeObject;
+    const isPacking = useIsPacking();
+    const isModified = useIsModified();
+
+    let overlayText = "";
+    if (isLoading) {
+        overlayText = "Loading...";
+    } else if (isPacking) {
+        overlayText = "Running...";
+    } else if (isModified) {
+        overlayText = "Re-run packing to view result";
+    }
+
+    const showOverlay = isLoading || isPacking || isModified;
+    const showSpinner = isLoading || isPacking;
+
     return (
         <div className="viewer-container">
             <iframe
                 className="simularium-embed"
                 src={`${SIMULARIUM_EMBED_URL}${resultUrl}`}
             />
+            {showOverlay && (
+                <div className="viewer-overlay">
+                    <div className="overlay-content">
+                        {showSpinner && <LoadingOutlined />}
+                        <p>{overlayText}</p>
+                    </div>
+                </div>
+            )}
         </div>
     );
 };
diff --git a/src/components/Viewer/style.css b/src/components/Viewer/style.css
index 25ca27d7..e9dc7d4c 100644
--- a/src/components/Viewer/style.css
+++ b/src/components/Viewer/style.css
@@ -1,6 +1,7 @@
 .viewer-container {
     width: 100%;
     height: 100%;
+    position: relative;
 }
 
 .simularium-embed {
@@ -8,3 +9,30 @@
     height: 100%;
     border: 1px solid black;
 }
+
+.viewer-overlay {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background-color: #DCDDE5;
+    color: #468ADE;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.overlay-content {
+    color: #468ADE;
+    font-size: 32px;
+    text-align: center;
+}
+
+.dark-theme .viewer-overlay {
+    background-color: #2C2F38;
+}
+
+.dark-theme .overlay-content {
+    color: #8b91ff;
+}
diff --git a/src/state/store.ts b/src/state/store.ts
index 141d8806..d8b3d6dc 100644
--- a/src/state/store.ts
+++ b/src/state/store.ts
@@ -1,40 +1,29 @@
 import { create } from "zustand";
 import { subscribeWithSelector } from "zustand/middleware";
-import { get as lodashGet, set as lodashSet } from "lodash-es";
-import { PackingResult, RecipeManifest } from "../types";
-import { getFirebaseRecipe, jsonToString } from "../utils/recipeLoader";
-import { getPackingInputsDict } from "../utils/firebase";
+import { isEmpty, isEqual, get as lodashGet } from "lodash-es";
+import { PackingResult, RecipeData, RecipeMetadata } from "../types";
+import { jsonToString } from "../utils/recipeLoader";
+import { getRecipeDataFromFirebase, getRecipeMetadataFromFirebase } from "../utils/firebase";
 import { EMPTY_PACKING_RESULT } from "./constants";
-
-export interface RecipeData {
-    id: string;
-    originalString: string;
-    currentString: string;
-    isModified: boolean;
-}
+import { buildRecipeObject } from "./utils";
 
 export interface RecipeState {
     selectedRecipeId: string;
-    inputOptions: Record<string, RecipeManifest>;
+    inputOptions: Record<string, RecipeMetadata>;
     recipes: Record<string, RecipeData>;
     packingResults: Record<string, PackingResult>;
 }
 
 export interface UIState {
-    isLoading: boolean;
     isPacking: boolean;
 }
 
 type Actions = {
     loadInputOptions: () => Promise<void>;
-    loadAllRecipes: () => Promise<void>;
-    selectRecipe: (inputName: string) => Promise<void>;
     loadRecipe: (recipeId: string) => Promise<void>;
-    updateRecipeString: (recipeId: string, newString: string) => void;
-    updateRecipeObj: (
-        recipeId: string,
-        updates: Record<string, string | number>
-    ) => void;
+    loadAllRecipes: () => Promise<void>;
+    selectRecipe: (recipeId: string) => Promise<void>;
+    editRecipe: (recipeID: string, path: string, value: string | number) => void;
     restoreRecipeDefault: (recipeId: string) => void;
     getCurrentValue: (path: string) => string | number | undefined;
     getOriginalValue: (path: string) => string | number | undefined;
@@ -58,7 +47,6 @@ const initialState: RecipeState & UIState = {
     selectedRecipeId: INITIAL_RECIPE_ID,
     inputOptions: {},
     recipes: {},
-    isLoading: false,
     isPacking: false,
     packingResults: { [INITIAL_RECIPE_ID]: EMPTY_PACKING_RESULT },
 };
@@ -68,55 +56,47 @@ export const useRecipeStore = create<RecipeStore>()(
         ...initialState,
 
         loadInputOptions: async () => {
-            set({ isLoading: true });
-            try {
-                const inputOptions = await getPackingInputsDict();
-                set({ inputOptions });
-            } finally {
-                set({ isLoading: false });
-            }
+            // Early return to prevent re-querying after options have loaded
+            if (!isEmpty(get().inputOptions)) return;
+            const inputOptions = await getRecipeMetadataFromFirebase();
+            set({ inputOptions });
         },
 
         loadRecipe: async (recipeId) => {
-            if (get().recipes[recipeId]) return;
-            const recJson = await getFirebaseRecipe(recipeId);
-            const recStr = jsonToString(recJson);
+            const { recipes, inputOptions } = get();
+            if (recipes[recipeId]) return;
+            const editableFieldIds = inputOptions[recipeId].editableFieldIds;
+            const rec = await getRecipeDataFromFirebase(recipeId, editableFieldIds);
             set((s) => ({
                 recipes: {
                     ...s.recipes,
-                    [recipeId]: {
-                        id: recipeId,
-                        originalString: recStr,
-                        currentString: recStr,
-                        isModified: false,
-                    },
+                    [recipeId]: rec
                 },
             }));
         },
 
         loadAllRecipes: async () => {
-            const { inputOptions, recipes, loadRecipe } = get();
-
-            const ids = new Set<string>();
-            Object.values(inputOptions).forEach((opt) => {
-                if (opt?.recipe) ids.add(opt.recipe);
-            });
-            const recipesToLoad = [...ids].filter((id) => !recipes[id]);
-            if (!recipesToLoad.length) return;
-            set({ isLoading: true });
-            try {
-                await Promise.all(recipesToLoad.map((id) => loadRecipe(id)));
-            } finally {
-                set({ isLoading: false });
-            }
-            let recipeToLoad = INITIAL_RECIPE_ID;
-            if (!get().recipes[INITIAL_RECIPE_ID]) {
-                console.warn(
-                    `Initial recipe ID ${INITIAL_RECIPE_ID} not found, selecting first available recipe.`
-                );
-                recipeToLoad = Object.keys(get().recipes)[0];
-            }
-            get().selectRecipe(recipeToLoad);
+            const { inputOptions, loadRecipe } = get();
+
+            const optionList = Object.values(inputOptions || {});
+            if (optionList.length === 0) return;
+
+            const recipeIds = optionList
+                .map(o => o?.recipeId)
+                .filter(id => id && !get().recipes[id]);
+            
+            // Make sure our default initial is in the options we queried
+            const initialIdToLoad =
+                recipeIds.includes(INITIAL_RECIPE_ID) ? INITIAL_RECIPE_ID : recipeIds[0];
+
+            // Ensure the bootstrap recipe is loaded & selected
+            await loadRecipe(initialIdToLoad);
+
+            // Load remaining recipes in the background (don’t block)
+            const remainingRecipesToLoad = recipeIds.filter(
+                id => id !== initialIdToLoad
+            );
+            Promise.all(remainingRecipesToLoad.map((id) => loadRecipe(id)));
         },
 
         selectRecipe: async (recipeId) => {
@@ -127,8 +107,8 @@ export const useRecipeStore = create<RecipeStore>()(
                 selectedRecipeId: recipeId,
             });
 
-            if (sel.recipe && !get().recipes[sel.recipe]) {
-                await get().loadRecipe(sel.recipe);
+            if (sel.recipeId && !get().recipes[sel.recipeId]) {
+                await get().loadRecipe(sel.recipeId);
             }
         },
 
@@ -168,70 +148,69 @@ export const useRecipeStore = create<RecipeStore>()(
             });
         },
 
-        updateRecipeString: (recipeId, newString) => {
-            set((s) => {
-                const rec = s.recipes[recipeId];
-                if (!rec) return s;
-                return {
-                    recipes: {
-                        ...s.recipes,
-                        [recipeId]: {
-                            ...rec,
-                            currentString: newString,
-                            isModified: newString !== rec.originalString,
-                        },
-                    },
-                };
-            });
-        },
-
-        updateRecipeObj: (recipeId, updates) => {
+        editRecipe: (recipeId, path, value) => {
             const rec = get().recipes[recipeId];
             if (!rec) return;
 
-            try {
-                const obj = JSON.parse(rec.currentString);
+            const newEdits = { ...rec.edits };
 
-                for (const [path, value] of Object.entries(updates)) {
-                    lodashSet(obj, path, value);
-                }
-                get().updateRecipeString(
-                    recipeId,
-                    JSON.stringify(obj, null, 2)
-                );
-            } catch {
-                // TODO: better error handling
-                console.warn("Failed to update recipe object");
+            const defaultValue = lodashGet(rec.defaultRecipeData, path);
+            if (isEqual(defaultValue, value)) {
+                delete newEdits[path]; // no longer different from default
+            } else {
+                newEdits[path] = value;
             }
-        },
 
-        restoreRecipeDefault: (recipeId) => {
-            const rec = get().recipes[recipeId];
-            if (rec) get().updateRecipeString(recipeId, rec.originalString);
+            set((state) => ({
+                recipes: {
+                    ...state.recipes,
+                    [recipeId]: {
+                        ...rec,
+                        edits: newEdits
+                    },
+                },
+            }));
         },
 
+
         getCurrentValue: (path) => {
             const { selectedRecipeId, recipes } = get();
-            const str = recipes[selectedRecipeId]?.currentString;
-            if (!str) return undefined;
-            try {
-                const obj = JSON.parse(str);
-                const v = lodashGet(obj, path);
-                return typeof v === "string" || typeof v === "number"
-                    ? v
-                    : undefined;
-            } catch {
-                console.warn("Failed to retrieve value.");
+            const rec = recipes[selectedRecipeId];
+            if (!rec) return undefined;
+
+            // First check if an edited value exists at this path
+            const editedValue = lodashGet(rec.edits, path);
+            if (editedValue !== undefined) {
+                if (typeof editedValue === "string" || typeof editedValue === "number") {
+                    return editedValue;
+                }
                 return undefined;
             }
+
+            // Otherwise, fall back to the default recipe
+            const defaultValue = lodashGet(rec.defaultRecipeData, path);
+            if (typeof defaultValue === "string" || typeof defaultValue === "number") {
+                return defaultValue;
+            }
+
+            return undefined;
+        },
+
+        getOriginalValue: (path) => {
+            const { selectedRecipeId, recipes } = get();
+            const rec = recipes[selectedRecipeId]?.defaultRecipeData;
+            if (!rec) return undefined;
+            const v = lodashGet(rec, path);
+            return (typeof v === "string" || typeof v === "number") ? v : undefined;
         },
 
         startPacking: async (callback) => {
             const s = get();
             const input = s.inputOptions[s.selectedRecipeId];
-            const configId = input?.config ?? "";
-            const recipeString =
-                s.recipes[s.selectedRecipeId]?.currentString ?? "";
+            const configId = input?.configId ?? "";
+            const recipeObject = buildRecipeObject(s.recipes[s.selectedRecipeId]);
+            if (!recipeObject) return;
+            const recipeString = jsonToString(recipeObject);
             set({ isPacking: true });
             try {
                 await callback(s.selectedRecipeId, configId, recipeString);
@@ -240,51 +219,54 @@ export const useRecipeStore = create<RecipeStore>()(
             }
         },
 
-        getOriginalValue: (path) => {
-            const { selectedRecipeId, recipes } = get();
-            const str = recipes[selectedRecipeId]?.originalString;
-            if (!str) return undefined;
-            try {
-                const obj = JSON.parse(str);
-                const v = lodashGet(obj, path);
-                return typeof v === "string" || typeof v === "number"
-                    ? v
-                    : undefined;
-            } catch {
-                console.warn("Failed to retrieve default value.");
-                return undefined;
-            }
+        restoreRecipeDefault: (recipeId) => {
+            set(state => {
+                const rec = state.recipes[recipeId];
+                if (!rec) return {};
+                return {
+                    recipes: {
+                        ...state.recipes,
+                        [recipeId]: {
+                            ...rec,
+                            edits: {},
+                        },
+                    },
+                };
+            });
         },
+
     }))
 );
 
-// simple selectors
-export const useSelectedRecipeId = () =>
-    useRecipeStore((s) => s.selectedRecipeId);
-export const useCurrentRecipeString = () =>
-    useRecipeStore((s) => s.recipes[s.selectedRecipeId]?.currentString ?? "");
-export const useInputOptions = () => useRecipeStore((s) => s.inputOptions);
 
-export const useIsLoading = () => useRecipeStore((s) => s.isLoading);
-export const useIsPacking = () => useRecipeStore((s) => s.isPacking);
+// Basic selectors
+export const useSelectedRecipeId = () => useRecipeStore(s => s.selectedRecipeId);
+export const useInputOptions = () => useRecipeStore((s) => s.inputOptions);
+export const useIsPacking = () => useRecipeStore(s => s.isPacking);
 export const useFieldsToDisplay = () =>
-    useRecipeStore((s) => s.inputOptions[s.selectedRecipeId]?.editable_fields);
-export const useIsCurrentRecipeModified = () =>
-    useRecipeStore((s) => s.recipes[s.selectedRecipeId]?.isModified ?? false);
-export const useGetOriginalValue = () =>
-    useRecipeStore((s) => s.getOriginalValue);
-const usePackingResults = () => useRecipeStore((s) => s.packingResults);
+    useRecipeStore((s) => s.recipes[s.selectedRecipeId]?.editableFields);
+export const useRecipes = () => useRecipeStore(s => s.recipes)
+export const usePackingResults = () => useRecipeStore(s => s.packingResults);
 
-// compound selectors
+export const useCurrentRecipeObject = () => {
+    const recipe = useCurrentRecipeData();
+    return recipe ? buildRecipeObject(recipe) : undefined;
+}
 
-const useCurrentRecipeManifest = () => {
+const useCurrentRecipeMetadata = () => {
     const selectedRecipeId = useSelectedRecipeId();
     const inputOptions = useInputOptions();
     if (!selectedRecipeId) return undefined;
     return inputOptions[selectedRecipeId];
 };
 
-const useCurrentPackingResult = () => {
+export const useCurrentRecipeData = () => {
+    const selectedRecipeId = useSelectedRecipeId();
+    const recipes = useRecipes();
+    return recipes[selectedRecipeId] || undefined;
+}
+
+export const useCurrentPackingResult = () => {
     const selectedRecipeId = useSelectedRecipeId();
     const packingResults = usePackingResults();
     return (
@@ -292,9 +274,13 @@ const useCurrentPackingResult = () => {
     );
 };
 
-const useDefaultResultPath = () => {
-    const manifest = useCurrentRecipeManifest();
-    return manifest?.defaultResultPath || "";
+export const useDefaultResultPath = () => {
+    const manifest = useCurrentRecipeMetadata();
+    // the default URL is stored in the metadata which loads before
+    // the recipe is queried, using both data here prevents the viewer
+    // loading ahead of the recipe
+    const recipe = useCurrentRecipeData();
+    return (recipe && manifest?.defaultResultPath) || "";
 };
 
 export const useRunTime = () => {
@@ -330,20 +316,24 @@ export const useResultUrl = () => {
     return path;
 };
 
-// action selectors (stable identities)
+export const useIsModified = () => {
+    const recipe = useCurrentRecipeData();
+    return (recipe && !isEmpty(recipe.edits));
+}
+
+// Action selectors
 export const useLoadInputOptions = () =>
     useRecipeStore((s) => s.loadInputOptions);
 export const useLoadAllRecipes = () => useRecipeStore((s) => s.loadAllRecipes);
 export const useSelectRecipe = () => useRecipeStore((s) => s.selectRecipe);
-export const useUpdateRecipeObj = () =>
-    useRecipeStore((s) => s.updateRecipeObj);
-export const useUpdateRecipeString = () =>
-    useRecipeStore((s) => s.updateRecipeString);
+export const useEditRecipe = () => useRecipeStore(s => s.editRecipe);
 export const useRestoreRecipeDefault = () =>
     useRecipeStore((s) => s.restoreRecipeDefault);
 export const useStartPacking = () => useRecipeStore((s) => s.startPacking);
 export const useGetCurrentValue = () =>
     useRecipeStore((s) => s.getCurrentValue);
+export const useGetOriginalValue = () =>
+    useRecipeStore((s) => s.getOriginalValue);
 export const useSetPackingResults = () =>
     useRecipeStore((s) => s.setPackingResults);
 export const useSetJobLogs = () => useRecipeStore((s) => s.setJobLogs);
diff --git a/src/state/utils.ts b/src/state/utils.ts
new file mode 100644
index 00000000..402e4ac8
--- /dev/null
+++ b/src/state/utils.ts
@@ -0,0 +1,11 @@
+import { set as lodashSet } from "lodash-es";
+import { RecipeData, ViewableRecipe } from "../types";
+
+export const buildRecipeObject = (recipe: RecipeData): ViewableRecipe => {
+    const clone = structuredClone(recipe.defaultRecipeData);
+    for (const [path, value] of Object.entries(recipe.edits)) {
+        lodashSet(clone, path, value);
+    }
+    return clone;
+}
+
diff --git a/src/style/themeRoot.tsx b/src/style/themeRoot.tsx
index b835a577..a29c3600 100644
--- a/src/style/themeRoot.tsx
+++ b/src/style/themeRoot.tsx
@@ -18,7 +18,9 @@ export function ThemeRoot({ children }: { children: React.ReactNode }) {
 
     return (
         <ConfigProvider theme={isDark ? darkTheme : lightTheme}>
-            {children}
+            <div className={isDark ? "dark-theme" : "light-theme"}>
+                {children}
+            </div>
         </ConfigProvider>
     );
-}
\ No newline at end of file
+}
diff --git a/src/types/index.ts b/src/types/index.ts
index 685bcb78..693dc370 100644
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -16,13 +16,23 @@ export interface Dictionary<T> {
     [Key: string]: T;
 }
 
-export type RecipeManifest = {
-    name?: string;
-    config: string;
-    recipe: string;
+// The fields in RecipeMetadata are available immediately when we run
+// getAllDocsFromCollection
+export interface RecipeMetadata {
+    recipeId: string;
+    configId: string;
+    displayName: string;
+    editableFieldIds: string[];
     defaultResultPath?: string;
-    editable_fields?: EditableField[];
-};
+}
+
+export interface RecipeData {
+    recipeId: string;
+    defaultRecipeData: ViewableRecipe;
+    editableFields: EditableField[];
+    defaultResultPath?: string;
+    edits: Record<string, string | number>;
+}
 
 export type JobStatusObject = {
     status: string;
diff --git a/src/utils/firebase.ts b/src/utils/firebase.ts
index 04c5a879..9f9558f9 100644
--- a/src/utils/firebase.ts
+++ b/src/utils/firebase.ts
@@ -21,11 +21,13 @@ import {
 } from "../constants/firebase";
 import {
     FirestoreDoc,
-    RecipeManifest,
     Dictionary,
     EditableField,
     JobStatusObject,
+    RecipeData,
+    RecipeMetadata,
 } from "../types";
+import { getFirebaseRecipe } from "./recipeLoader";
 
 const getEnvVar = (key: string): string => {
     // check if we're in a browser environment (Vite)
@@ -163,31 +165,47 @@ const getEditableFieldsList = async (
     return docs;
 };
 
-const getPackingInputsDict = async (): Promise<Dictionary<RecipeManifest>> => {
-    const docs = await getAllDocsFromCollection(
-        FIRESTORE_COLLECTIONS.PACKING_INPUTS
-    );
-    const inputsDict: Dictionary<RecipeManifest> = {};
+/**
+ * These RecipeMetadata fields are queried as a group, and quick to retrieve from the backend.
+ * Slower loading fields are defined as RecipeData and queried individually.
+ */
+const getRecipeMetadataFromFirebase = async (): Promise<Record<string, RecipeMetadata>> => {
+    const docs = await getAllDocsFromCollection(FIRESTORE_COLLECTIONS.PACKING_INPUTS);
+    const inputsDict: Dictionary<RecipeMetadata> = {};
     for (const doc of docs) {
         const displayName = doc[FIRESTORE_FIELDS.NAME];
         const config = doc[FIRESTORE_FIELDS.CONFIG];
-        const recipe = doc[FIRESTORE_FIELDS.RECIPE];
-        const editableFields = await getEditableFieldsList(
-            doc[FIRESTORE_FIELDS.EDITABLE_FIELDS] || []
-        );
-        const result = doc[FIRESTORE_FIELDS.RESULT_PATH] || "";
-        if (config && recipe) {
-            inputsDict[recipe] = {
-                [FIRESTORE_FIELDS.NAME]: displayName,
-                [FIRESTORE_FIELDS.CONFIG]: config,
-                [FIRESTORE_FIELDS.RECIPE]: recipe,
-                [FIRESTORE_FIELDS.EDITABLE_FIELDS]: editableFields,
-                defaultResultPath: result,
+        const recipeId = doc[FIRESTORE_FIELDS.RECIPE];
+        const editableFieldIds = doc[FIRESTORE_FIELDS.EDITABLE_FIELDS];
+        const defaultResultPath = doc[FIRESTORE_FIELDS.RESULT_PATH] || "";
+
+        if (displayName && config && recipeId)  {
+            inputsDict[recipeId] = {
+                recipeId: recipeId,
+                configId: config,
+                displayName,
+                editableFieldIds: editableFieldIds || [],
+                defaultResultPath
             };
         }
     }
     return inputsDict;
-};
+}
+
+/**
+ * Retrieves both the recipe and its editable fields from Firebase for a given recipe ID and list of editable field IDs.
+ * This process is slower than retrieving metadata alone and should be called when full recipe data is required. Returns a RecipeData object.
+ */
+const getRecipeDataFromFirebase = async (recipeId: string, editableFieldIds: string[]): Promise<RecipeData> => {
+    const defaultRecipeData = await getFirebaseRecipe(recipeId);
+    const editableFields = await getEditableFieldsList(editableFieldIds) || [];
+    return {
+        recipeId,
+        defaultRecipeData,
+        editableFields,
+        edits: {}
+    }
+}
 
 const getDocsByIds = async (coll: string, ids: string[]) => {
     const querySnapshot = await queryDocumentsByIds(coll, ids);
@@ -249,6 +267,7 @@ export {
     getJobStatus,
     addRecipe,
     docCleanup,
-    getPackingInputsDict,
+    getRecipeMetadataFromFirebase,
+    getRecipeDataFromFirebase,
     getOutputsDirectory,
 };