astro-tractstack 2.1.2 → 2.2.0

package/templates/src/components/edit/state/SaveModal.tsx

@@ -3,25 +3,10 @@ import { Dialog } from '@ark-ui/react/dialog';
 import { Portal } from '@ark-ui/react/portal';
 import { navigate } from 'astro:transitions/client';
 import { getCtx } from '@/stores/nodes';
-import {
-  transformLivePaneForSave,
-  transformStoryFragmentForSave,
-} from '@/utils/etl/index';
-import {
-  getPendingImageOperation,
-  clearPendingImageOperation,
-  pendingHomePageSlugStore,
-} from '@/stores/storykeep';
+import { pendingHomePageSlugStore } from '@/stores/storykeep';
 import { startLoadingAnimation } from '@/utils/helpers';
-import { processClassesForViewports } from '@/utils/compositor/reduceNodesClassNames';
-import type {
-  FlatNode,
-  BaseNode,
-  PaneNode,
-  StoryFragmentNode,
-  MarkdownPaneFragmentNode,
-  GridLayoutNode,
-} from '@/types/compositorTypes';
+import { executeSavePipeline } from '@/utils/compositor/savePipeline';
+import type { PaneNode, StoryFragmentNode } from '@/types/compositorTypes';
 
 type SaveStage =
   | 'PREPARING'
@@ -52,13 +37,6 @@ interface SaveModalProps {
   hydrate?: boolean;
 }
 
-const PROGRESS_PHASES = {
-  PREPARATION: 5,
-  UPLOADS: 60,
-  PROCESSING: 25,
-  FINALIZATION: 10,
-};
-
 const INDETERMINATE_STAGES: SaveStage[] = [
   'COOKING_NODES',
   'SAVING_PANES',
@@ -168,773 +146,27 @@ export default function SaveModal({
     const runSaveProcess = async () => {
       isSaving.current = true;
       const ctx = getCtx();
-      const allDirtyNodes = ctx.getDirtyNodes();
 
       try {
-        setStage('PREPARING');
-        setProgress(PROGRESS_PHASES.PREPARATION);
-        addDebugMessage(
-          `Starting save process... (${
-            isContext ? 'Context' : 'StoryFragment'
-          } mode, ${isCreateMode ? 'CREATE' : 'UPDATE'})`
-        );
-
-        let dirtyPanes = allDirtyNodes.filter(
-          (node) => node.nodeType === 'Pane'
-        );
-        let dirtyStoryFragments = allDirtyNodes.filter(
-          (node) => node.nodeType === 'StoryFragment'
-        );
-
-        if (isContext) {
-          dirtyStoryFragments = [];
-          addDebugMessage('Context mode: Ignoring StoryFragment nodes');
-        }
-
-        const nodesWithPendingFiles = allDirtyNodes.filter(
-          (node): node is BaseNode & { base64Data?: string } =>
-            'base64Data' in node && !!node.base64Data
-        );
-        const storyFragmentsWithPendingImages = dirtyStoryFragments.filter(
-          (fragment) => {
-            const pendingOp = getPendingImageOperation(fragment.id);
-            return pendingOp && pendingOp.type === 'upload';
-          }
-        );
-
-        const totalFileBytes = nodesWithPendingFiles.reduce(
-          (sum, node) => sum + (node.base64Data?.length || 0),
-          0
-        );
-        const totalOgBytes = storyFragmentsWithPendingImages.reduce(
-          (sum, fragment) => {
-            const pendingOp = getPendingImageOperation(fragment.id);
-            return sum + (pendingOp?.data?.length || 0);
+        await executeSavePipeline(
+          ctx,
+          {
+            slug,
+            isContext,
+            isCreateMode,
+            hydrate,
+            tenantId,
+            backendUrl: goBackend,
+            pendingHomePageSlug,
           },
-          0
-        );
-        const totalUploadBytes = totalFileBytes + totalOgBytes;
-        let completedUploadBytes = 0;
-
-        const relevantNodeCount =
-          dirtyPanes.length + dirtyStoryFragments.length;
-        addDebugMessage(
-          `Found ${relevantNodeCount} relevant dirty nodes to save (${dirtyPanes.length} Panes, ${dirtyStoryFragments.length} StoryFragments)`
-        );
-        addDebugMessage(
-          `Found ${storyFragmentsWithPendingImages.length} story fragments with pending OG image operations`
-        );
-        addDebugMessage(
-          `Found ${nodesWithPendingFiles.length} nodes with pending file uploads`
-        );
-
-        if (
-          relevantNodeCount === 0 &&
-          nodesWithPendingFiles.length === 0 &&
-          storyFragmentsWithPendingImages.length === 0 &&
-          !pendingHomePageSlug
-        ) {
-          addDebugMessage('No changes to save');
-          setStage('COMPLETED');
-          setProgress(100);
-          return;
-        }
-
-        const uploadedOGPaths: Record<string, string> = {};
-
-        if (nodesWithPendingFiles.length > 0) {
-          setStage('SAVING_PENDING_FILES');
-          for (let i = 0; i < nodesWithPendingFiles.length; i++) {
-            const fileNode = nodesWithPendingFiles[i];
-            const fileBytes = fileNode.base64Data?.length || 0;
-            const endpoint = `${goBackend}/api/v1/nodes/files/create`;
-
-            setStageProgress({
-              currentStep: i + 1,
-              totalSteps: nodesWithPendingFiles.length,
-              currentFileName: `${fileNode.id}.jpg`,
-              isUploading: true,
-            });
-            addDebugMessage(
-              `Processing file ${i + 1}/${nodesWithPendingFiles.length}: ${
-                fileNode.id
-              } -> POST ${endpoint}`
-            );
-
-            try {
-              const response = await fetch(endpoint, {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/json',
-                  'X-Tenant-ID': tenantId,
-                },
-                credentials: 'include',
-                body: JSON.stringify({ base64Data: fileNode.base64Data }),
-              });
-
-              if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-              }
-
-              const result = await response.json();
-              const updatedNode = { ...fileNode, isChanged: true };
-
-              if ('base64Data' in updatedNode) {
-                delete updatedNode.base64Data;
-              }
-
-              if ('fileId' in updatedNode) {
-                updatedNode.fileId = result.fileId;
-              }
-              if ('src' in updatedNode) {
-                updatedNode.src = result.src;
-              }
-              if ('srcSet' in updatedNode && result.srcSet) {
-                updatedNode.srcSet = result.srcSet;
-              }
-
-              ctx.modifyNodes([updatedNode]);
-
-              addDebugMessage(
-                `File ${fileNode.id} uploaded successfully - got fileId: ${result.fileId}`
-              );
-            } catch (error) {
-              const errorMsg =
-                error instanceof Error ? error.message : 'Unknown error';
-              addDebugMessage(`File ${fileNode.id} upload failed: ${errorMsg}`);
-              throw new Error(
-                `Failed to upload file ${fileNode.id}: ${errorMsg}`
-              );
-            }
-
-            completedUploadBytes += fileBytes;
-            const uploadProgress =
-              totalUploadBytes > 0
-                ? (completedUploadBytes / totalUploadBytes) *
-                  PROGRESS_PHASES.UPLOADS
-                : 0;
-            setProgress(PROGRESS_PHASES.PREPARATION + uploadProgress);
-            setStageProgress((prev) => ({ ...prev, isUploading: false }));
+          {
+            setStage,
+            setProgress,
+            setStageProgress,
+            logDebug: addDebugMessage,
+            setIsIndeterminateStage,
           }
-        }
-
-        if (storyFragmentsWithPendingImages.length > 0) {
-          setStage('PROCESSING_OG_IMAGES');
-          for (let i = 0; i < storyFragmentsWithPendingImages.length; i++) {
-            const fragment = storyFragmentsWithPendingImages[i];
-            const pendingOp = getPendingImageOperation(fragment.id);
-            const imageBytes = pendingOp?.data?.length || 0;
-
-            if (pendingOp && pendingOp.type === 'upload' && pendingOp.data) {
-              const ogUploadEndpoint = `${goBackend}/api/v1/nodes/images/og`;
-              addDebugMessage(
-                `Processing OG image ${i + 1}/${
-                  storyFragmentsWithPendingImages.length
-                }: ${fragment.id} -> POST ${ogUploadEndpoint}`
-              );
-
-              setStageProgress({
-                currentStep: i + 1,
-                totalSteps: storyFragmentsWithPendingImages.length,
-                currentFileName: pendingOp?.filename || `${fragment.id}-og.png`,
-                isUploading: true,
-              });
-
-              const uploadPayload = {
-                data: pendingOp.data,
-                filename:
-                  pendingOp.filename || `${fragment.id}-${Date.now()}.png`,
-              };
-
-              try {
-                const response = await fetch(ogUploadEndpoint, {
-                  method: 'POST',
-                  headers: {
-                    'Content-Type': 'application/json',
-                    'X-Tenant-ID': tenantId,
-                  },
-                  credentials: 'include',
-                  body: JSON.stringify(uploadPayload),
-                });
-
-                if (!response.ok) {
-                  throw new Error(`HTTP error! status: ${response.status}`);
-                }
-
-                const result = await response.json();
-
-                uploadedOGPaths[fragment.id] = result.path;
-                addDebugMessage(
-                  `OG image uploaded successfully: ${result.path}`
-                );
-              } catch (error) {
-                const errorMsg =
-                  error instanceof Error ? error.message : 'Unknown error';
-                addDebugMessage(
-                  `OG image upload failed for ${fragment.id}: ${errorMsg}`
-                );
-                throw new Error(
-                  `Failed to upload OG image for ${fragment.id}: ${errorMsg}`
-                );
-              }
-              completedUploadBytes += imageBytes;
-              const uploadProgress =
-                totalUploadBytes > 0
-                  ? (completedUploadBytes / totalUploadBytes) *
-                    PROGRESS_PHASES.UPLOADS
-                  : 0;
-              setProgress(PROGRESS_PHASES.PREPARATION + uploadProgress);
-              setStageProgress((prev) => ({ ...prev, isUploading: false }));
-            }
-          }
-        }
-
-        if (totalUploadBytes > 0) {
-          setProgress(PROGRESS_PHASES.PREPARATION + PROGRESS_PHASES.UPLOADS);
-        }
-
-        const totalProcessingSteps =
-          dirtyPanes.length + dirtyStoryFragments.length;
-        let completedProcessingSteps = 0;
-
-        // --- NEW COOKING STAGE ---
-        if (allDirtyNodes.length > 0) {
-          setStage('COOKING_NODES');
-          setIsIndeterminateStage(true);
-          addDebugMessage('Cooking nodes for whitelist extraction...');
-
-          const cookingUpdates: BaseNode[] = [];
-
-          allDirtyNodes.forEach((liveNode) => {
-            try {
-              let updatedNode: BaseNode | null = null;
-
-              // Pattern 1: TagElements -> elementCss
-              if (liveNode.nodeType === 'TagElement') {
-                const flatNode = liveNode as FlatNode;
-                const computedCSS = ctx.getNodeClasses(flatNode.id, 'auto', 0);
-                if (flatNode.elementCss !== computedCSS) {
-                  updatedNode = {
-                    ...liveNode,
-                    elementCss: computedCSS,
-                  } as FlatNode;
-                }
-              }
-              // Pattern 2: Markdown Nodes -> parentCss & gridCss
-              else if (liveNode.nodeType === 'Markdown') {
-                const markdownNode = liveNode as MarkdownPaneFragmentNode;
-                let needsUpdate = false;
-                const nextNode = { ...markdownNode };
-
-                // parentCss
-                if (markdownNode.parentClasses) {
-                  const computedParentCss = markdownNode.parentClasses.map(
-                    (_: any, index: number) =>
-                      ctx.getNodeClasses(liveNode.id, 'auto', index)
-                  );
-                  if (
-                    JSON.stringify(markdownNode.parentCss) !==
-                    JSON.stringify(computedParentCss)
-                  ) {
-                    nextNode.parentCss = computedParentCss;
-                    needsUpdate = true;
-                  }
-                }
-
-                // gridCss
-                if (markdownNode.gridClasses) {
-                  const [allClasses] = processClassesForViewports(
-                    markdownNode.gridClasses,
-                    {},
-                    1
-                  );
-                  if (allClasses && allClasses.length > 0) {
-                    const computedGridCss = allClasses[0];
-                    if (markdownNode.gridCss !== computedGridCss) {
-                      nextNode.gridCss = computedGridCss;
-                      needsUpdate = true;
-                    }
-                  }
-                }
-
-                if (needsUpdate) updatedNode = nextNode;
-              }
-              // Pattern 3: GridLayout Nodes -> parentCss & gridCss
-              else if (liveNode.nodeType === 'GridLayoutNode') {
-                const gridNode = liveNode as GridLayoutNode;
-                let needsUpdate = false;
-                const nextNode = { ...gridNode };
-
-                // parentCss
-                if (gridNode.parentClasses) {
-                  const computedParentCss = gridNode.parentClasses.map(
-                    (_: any, index: number) =>
-                      ctx.getNodeClasses(liveNode.id, 'auto', index)
-                  );
-                  if (
-                    JSON.stringify(gridNode.parentCss) !==
-                    JSON.stringify(computedParentCss)
-                  ) {
-                    nextNode.parentCss = computedParentCss.join(` `);
-                    needsUpdate = true;
-                  }
-                }
-
-                // gridCss
-                if (gridNode.gridColumns) {
-                  const { mobile, tablet, desktop } = gridNode.gridColumns;
-                  let computedGridCss = `grid grid-cols-${mobile}`;
-                  if (tablet !== mobile) {
-                    computedGridCss += ` md:grid-cols-${tablet}`;
-                  }
-                  if (desktop !== tablet) {
-                    computedGridCss += ` xl:grid-cols-${desktop}`;
-                  }
-
-                  if (gridNode.gridCss !== computedGridCss) {
-                    nextNode.gridCss = computedGridCss;
-                    needsUpdate = true;
-                  }
-                }
-
-                if (needsUpdate) updatedNode = nextNode;
-              }
-
-              if (updatedNode) {
-                cookingUpdates.push(updatedNode);
-              }
-            } catch (e) {
-              console.warn(`Failed to cook node ${liveNode.id}`, e);
-            }
-          });
-
-          if (cookingUpdates.length > 0) {
-            ctx.modifyNodes(cookingUpdates, {
-              notify: false,
-              recordHistory: false,
-            });
-            addDebugMessage(`Cooked ${cookingUpdates.length} nodes.`);
-          }
-          setIsIndeterminateStage(false);
-        }
-
-        // --- PROCESSING STYLES ---
-        // Moved before SAVING_PANES to ensure the whitelist is generated from the cooked, exhaustive inventory
-        setStage('PROCESSING_STYLES');
-        setIsIndeterminateStage(true);
-        const baseFinalizationProgress =
-          PROGRESS_PHASES.PREPARATION +
-          PROGRESS_PHASES.UPLOADS +
-          PROGRESS_PHASES.PROCESSING;
-        setProgress(
-          baseFinalizationProgress + PROGRESS_PHASES.FINALIZATION / 2
         );
-        addDebugMessage(`Processing styles...`);
-
-        try {
-          const { dirtyPaneIds, classes: dirtyClasses } =
-            ctx.getDirtyNodesClassData();
-
-          const astroEndpoint = `/api/tailwind`;
-          const astroPayload = { dirtyPaneIds, dirtyClasses };
-          const astroResponse = await fetch(astroEndpoint, {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-Tenant-ID': tenantId,
-            },
-            credentials: 'include',
-            body: JSON.stringify(astroPayload),
-          });
-
-          if (!astroResponse.ok) {
-            throw new Error(
-              `CSS generation failed! status: ${astroResponse.status}`
-            );
-          }
-
-          const astroResult = await astroResponse.json();
-
-          if (!astroResult.success || !astroResult.generatedCss) {
-            throw new Error('CSS generation failed: no CSS returned');
-          }
-
-          addDebugMessage(
-            `CSS generated: ${astroResult.generatedCss.length} bytes for ${dirtyClasses.length} classes`
-          );
-
-          const goEndpoint = `${goBackend}/api/v1/tailwind/update`;
-          const goPayload = { frontendCss: astroResult.generatedCss };
-          const goResponse = await fetch(goEndpoint, {
-            method: 'POST',
-            headers: {
-              'Content-Type': 'application/json',
-              'X-Tenant-ID': tenantId,
-            },
-            credentials: 'include',
-            body: JSON.stringify(goPayload),
-          });
-
-          if (!goResponse.ok) {
-            throw new Error(`CSS save failed! status: ${goResponse.status}`);
-          }
-
-          const goResult = await goResponse.json();
-          addDebugMessage(
-            `CSS saved successfully: stylesVer ${goResult.stylesVer}`
-          );
-        } catch (error) {
-          const errorMsg =
-            error instanceof Error ? error.message : 'Unknown error';
-          addDebugMessage(`Styles processing failed: ${errorMsg}`);
-          throw new Error(`Failed to process styles: ${errorMsg}`);
-        } finally {
-          setIsIndeterminateStage(false);
-        }
-
-        // --- SAVING PANES ---
-        // Runs after styles to ensure DB gets minimal, correct payload
-        if (dirtyPanes.length > 0) {
-          setStage('SAVING_PANES');
-          setIsIndeterminateStage(true);
-          setStageProgress({
-            currentStep: 0,
-            totalSteps: dirtyPanes.length,
-          });
-
-          const bulkPayload = dirtyPanes.map((paneNode) =>
-            transformLivePaneForSave(ctx, paneNode.id, isContext)
-          );
-
-          // Update context with minimal strings (idempotent, restoring runtime state)
-          bulkPayload.forEach((payload) => {
-            payload.optionsPayload.nodes.forEach((transformedNode) => {
-              const liveNode = ctx.allNodes.get().get(transformedNode.id);
-              if (!liveNode) return;
-
-              let needsUpdate = false;
-              let updatedNode: BaseNode = { ...liveNode };
-
-              if (
-                transformedNode.nodeType === 'TagElement' &&
-                transformedNode.elementCss
-              ) {
-                const flatNode = liveNode as FlatNode;
-                if (flatNode.elementCss !== transformedNode.elementCss) {
-                  (updatedNode as FlatNode).elementCss =
-                    transformedNode.elementCss;
-                  needsUpdate = true;
-                }
-              }
-
-              if (
-                transformedNode.nodeType === 'Markdown' &&
-                transformedNode.parentCss
-              ) {
-                const markdownNode = liveNode as MarkdownPaneFragmentNode;
-                const currentParentCss = markdownNode.parentCss;
-                const newParentCss = transformedNode.parentCss as string[];
-
-                const isDifferent =
-                  !currentParentCss ||
-                  currentParentCss.length !== newParentCss.length ||
-                  currentParentCss.some(
-                    (css, index) => css !== newParentCss[index]
-                  );
-
-                if (isDifferent) {
-                  (updatedNode as MarkdownPaneFragmentNode).parentCss =
-                    newParentCss;
-                  needsUpdate = true;
-                }
-              }
-
-              if (needsUpdate) {
-                ctx.allNodes.get().set(transformedNode.id, updatedNode);
-              }
-            });
-          });
-
-          const endpoint = `${goBackend}/api/v1/nodes/panes/bulk`;
-          addDebugMessage(
-            `Processing ${dirtyPanes.length} panes via -> POST ${endpoint}`
-          );
-
-          try {
-            const response = await fetch(endpoint, {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-                'X-Tenant-ID': tenantId,
-              },
-              credentials: 'include',
-              body: JSON.stringify({ panes: bulkPayload }),
-            });
-
-            if (!response.ok) {
-              const errorText = await response.text();
-              throw new Error(
-                `HTTP error! status: ${response.status} - ${errorText}`
-              );
-            }
-
-            await response.json();
-            addDebugMessage(
-              `${dirtyPanes.length} panes saved successfully via bulk endpoint.`
-            );
-          } catch (bulkError) {
-            const errorMsg =
-              bulkError instanceof Error
-                ? bulkError.message
-                : 'Unknown bulk save error';
-            addDebugMessage(`Bulk pane save failed: ${errorMsg}`);
-            throw new Error(`Failed to save panes in bulk: ${errorMsg}`);
-          } finally {
-            setIsIndeterminateStage(false);
-          }
-
-          setStageProgress({
-            currentStep: dirtyPanes.length,
-            totalSteps: dirtyPanes.length,
-          });
-          completedProcessingSteps += dirtyPanes.length;
-          const processingProgress =
-            (completedProcessingSteps / totalProcessingSteps) *
-            PROGRESS_PHASES.PROCESSING;
-          setProgress(
-            PROGRESS_PHASES.PREPARATION +
-              PROGRESS_PHASES.UPLOADS +
-              processingProgress
-          );
-        }
-
-        if (!isContext && dirtyStoryFragments.length > 0) {
-          setStage('SAVING_STORY_FRAGMENTS');
-          setStageProgress({
-            currentStep: 0,
-            totalSteps: dirtyStoryFragments.length,
-          });
-          for (let i = 0; i < dirtyStoryFragments.length; i++) {
-            const fragment = dirtyStoryFragments[i];
-
-            try {
-              const payload = await transformStoryFragmentForSave(
-                ctx,
-                fragment.id,
-                tenantId
-              );
-
-              if (uploadedOGPaths[fragment.id]) {
-                payload.socialImagePath = uploadedOGPaths[fragment.id];
-              }
-
-              const endpoint = isCreateMode
-                ? `${goBackend}/api/v1/nodes/storyfragments/create`
-                : `${goBackend}/api/v1/nodes/storyfragments/${payload.id}/complete`;
-              const method = isCreateMode ? 'POST' : 'PUT';
-
-              addDebugMessage(
-                `Processing story fragment ${i + 1}/${
-                  dirtyStoryFragments.length
-                }: ${fragment.id} -> ${method} ${endpoint}`
-              );
-
-              const response = await fetch(endpoint, {
-                method,
-                headers: {
-                  'Content-Type': 'application/json',
-                  'X-Tenant-ID': tenantId,
-                },
-                credentials: 'include',
-                body: JSON.stringify(payload),
-              });
-
-              if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-              }
-
-              await response.json();
-              addDebugMessage(
-                `StoryFragment ${fragment.id} saved successfully`
-              );
-
-              if (uploadedOGPaths[fragment.id]) {
-                clearPendingImageOperation(fragment.id);
-                addDebugMessage(
-                  `Cleared pending image operation for ${fragment.id}`
-                );
-              }
-            } catch (etlError) {
-              const errorMsg =
-                etlError instanceof Error ? etlError.message : 'Unknown error';
-              addDebugMessage(
-                `StoryFragment ${fragment.id} ETL failed: ${errorMsg}`
-              );
-              throw new Error(
-                `Failed to save story fragment ${fragment.id}: ${errorMsg}`
-              );
-            }
-
-            setStageProgress((prev) => ({ ...prev, currentStep: i + 1 }));
-            completedProcessingSteps++;
-            const processingProgress =
-              (completedProcessingSteps / totalProcessingSteps) *
-              PROGRESS_PHASES.PROCESSING;
-            setProgress(
-              PROGRESS_PHASES.PREPARATION +
-                PROGRESS_PHASES.UPLOADS +
-                processingProgress
-            );
-          }
-        }
-
-        if (dirtyPanes.length > 0) {
-          setStage('LINKING_FILES');
-          setIsIndeterminateStage(true);
-          // ... Linking files logic continues ...
-          // Note: Linking files remains after saving panes because it relies on panes existing in DB
-          setProgress(baseFinalizationProgress);
-          addDebugMessage('Starting file-pane relationship linking...');
-
-          const relationships = [];
-          for (const paneNode of dirtyPanes) {
-            const fileIds = ctx.getPaneImageFileIds(paneNode.id);
-            relationships.push({
-              paneId: paneNode.id,
-              fileIds: fileIds,
-            });
-          }
-
-          if (relationships.some((rel) => rel.fileIds.length > 0)) {
-            try {
-              const bulkEndpoint = `${goBackend}/api/v1/nodes/panes/files/bulk`;
-              addDebugMessage(
-                `Linking relationships: ${JSON.stringify(relationships)}`
-              );
-
-              const response = await fetch(bulkEndpoint, {
-                method: 'POST',
-                headers: {
-                  'Content-Type': 'application/json',
-                  'X-Tenant-ID': tenantId,
-                },
-                credentials: 'include',
-                body: JSON.stringify({ relationships }),
-              });
-
-              if (!response.ok) {
-                throw new Error(`HTTP error! status: ${response.status}`);
-              }
-
-              const result = await response.json();
-              addDebugMessage(
-                `File-pane relationships linked successfully: ${result.message}`
-              );
-            } catch (error) {
-              const errorMsg =
-                error instanceof Error ? error.message : 'Unknown error';
-              addDebugMessage(
-                `Failed to link file-pane relationships: ${errorMsg}`
-              );
-              throw new Error(
-                `Failed to link file-pane relationships: ${errorMsg}`
-              );
-            }
-          } else {
-            addDebugMessage('No file relationships to link');
-          }
-          setIsIndeterminateStage(false);
-        }
-
-        if (pendingHomePageSlug) {
-          setStage('UPDATING_HOME_PAGE');
-          setIsIndeterminateStage(true);
-          setProgress(
-            baseFinalizationProgress + (PROGRESS_PHASES.FINALIZATION - 2)
-          );
-          addDebugMessage(`Updating home page to: ${pendingHomePageSlug}`);
-
-          try {
-            const response = await fetch(`${goBackend}/api/v1/config/brand`, {
-              method: 'GET',
-              headers: {
-                'Content-Type': 'application/json',
-                'X-Tenant-ID': tenantId,
-              },
-              credentials: 'include',
-            });
-
-            if (!response.ok) {
-              throw new Error(
-                `Failed to get current brand config: ${response.status}`
-              );
-            }
-
-            const currentBrandConfig = await response.json();
-
-            const updatedBrandConfig = {
-              ...currentBrandConfig,
-              HOME_SLUG: pendingHomePageSlug,
-            };
-
-            const updateResponse = await fetch(
-              `${goBackend}/api/v1/config/brand`,
-              {
-                method: 'PUT',
-                headers: {
-                  'Content-Type': 'application/json',
-                  'X-Tenant-ID': tenantId,
-                },
-                credentials: 'include',
-                body: JSON.stringify(updatedBrandConfig),
-              }
-            );
-
-            if (!updateResponse.ok) {
-              throw new Error(
-                `Failed to update home page: ${updateResponse.status}`
-              );
-            }
-
-            pendingHomePageSlugStore.set(null);
-            addDebugMessage('Home page updated successfully');
-          } catch (error) {
-            const errorMsg =
-              error instanceof Error ? error.message : 'Unknown error';
-            addDebugMessage(`Home page update failed: ${errorMsg}`);
-            throw new Error(`Failed to update home page: ${errorMsg}`);
-          } finally {
-            setIsIndeterminateStage(false);
-          }
-        }
-
-        if (hydrate) {
-          addDebugMessage('Finalizing setup (Kill Switch)...');
-          try {
-            const response = await fetch(`${goBackend}/api/v1/setup/complete`, {
-              method: 'POST',
-              headers: {
-                'Content-Type': 'application/json',
-                'X-Tenant-ID': tenantId,
-              },
-              credentials: 'include',
-              body: JSON.stringify({}),
-            });
-
-            if (!response.ok) {
-              throw new Error(`Kill Switch failed: ${response.status}`);
-            }
-            addDebugMessage('Hydration token cleared.');
-          } catch (e) {
-            console.error('Kill switch error:', e);
-            // We don't throw here to ensure the user still gets to the dashboard
-            addDebugMessage('Warning: Failed to clear hydration token.');
-          }
-        }
-
-        setStage('COMPLETED');
-        setProgress(100);
-        addDebugMessage('Save process completed successfully!');
       } catch (err) {
         setStage('ERROR');
         const errorMessage =