@mycadet/assistant 0.12.10 → 0.13.0

package/src/__tests__/transfer-progress-screen.test.ts

@@ -1,1217 +0,0 @@
-/**
- * Tests for the transfer progress screen view model.
- *
- * Covers:
- * - Disabled state: screen not accessible when earlier steps incomplete
- * - Exporting state: export phase in progress
- * - Polling state: managed async export job polling
- * - Importing state: import phase in progress
- * - Success state: full import summary with details
- * - Error states: retryable vs non-retryable, failed phase inference
- * - Retry behavior: reset and re-execute after error
- * - Back navigation: return to preflight-review step
- * - Continue action: proceed to rebind-secrets step
- * - Transfer flow execution: runtime (sync) and managed (async) flows
- * - State persistence/resume: derive correct screen state after resume
- * - State change callbacks: UI reactivity during transfer
- */
-
-import { describe, expect, test } from "bun:test";
-
-import type {
-  ExportManagedResult,
-  ImportCommitResponse,
-  ImportPreflightResponse,
-  TransportConfig,
-  ValidateResponse,
-} from "../runtime/migrations/migration-transport.js";
-import type {
-  MigrationWizardState,
-  StepExecutorOptions,
-  WizardStep,
-} from "../runtime/migrations/migration-wizard.js";
-import {
-  completeRebindSecrets,
-  createWizardState,
-  deserializeWizardState,
-  prepareForResume,
-  selectDirection,
-  serializeWizardState,
-  setBundleUploaded,
-} from "../runtime/migrations/migration-wizard.js";
-import type { TransferScreenState } from "../runtime/migrations/transfer-progress-screen.js";
-import {
-  deriveTransferScreenState,
-  executeTransferFlow,
-  goBackToPreflight,
-  isTransferScreenAccessible,
-  retryTransferFlow,
-} from "../runtime/migrations/transfer-progress-screen.js";
-
-// ---------------------------------------------------------------------------
-// Test helpers
-// ---------------------------------------------------------------------------
-
-function mockFetch(
-  status: number,
-  body: unknown,
-  headers?: Record<string, string>,
-): typeof fetch {
-  return (async () => {
-    const responseHeaders = new Headers(headers);
-    if (
-      typeof body === "object" &&
-      body !== undefined &&
-      !(body instanceof ArrayBuffer)
-    ) {
-      responseHeaders.set("Content-Type", "application/json");
-      return new Response(JSON.stringify(body), {
-        status,
-        headers: responseHeaders,
-      });
-    }
-    if (body instanceof ArrayBuffer) {
-      return new Response(body, { status, headers: responseHeaders });
-    }
-    return new Response(String(body), { status, headers: responseHeaders });
-  }) as unknown as typeof fetch;
-}
-
-function runtimeConfig(overrides?: Partial<TransportConfig>): TransportConfig {
-  return {
-    baseURL: "http://localhost:7821",
-    target: "runtime",
-    authHeader: "Bearer test-jwt",
-    fetchFn: mockFetch(200, {}),
-    ...overrides,
-  };
-}
-
-function managedConfig(overrides?: Partial<TransportConfig>): TransportConfig {
-  return {
-    baseURL: "https://cloud.mycadet.ai",
-    target: "managed",
-    authHeader: "session-token-abc",
-    fetchFn: mockFetch(200, {}),
-    ...overrides,
-  };
-}
-
-function makeExecutorOptions(
-  overrides?: Partial<StepExecutorOptions>,
-): StepExecutorOptions {
-  return {
-    sourceConfig: runtimeConfig(),
-    destConfig: runtimeConfig(),
-    bundleData: new ArrayBuffer(16),
-    ...overrides,
-  };
-}
-
-function makeValidateSuccess(): ValidateResponse {
-  return {
-    is_valid: true,
-    errors: [],
-    manifest: {
-      schema_version: 1,
-      bundle_id: "00000000-0000-4000-8000-000000000000",
-      created_at: "2026-03-01T00:00:00Z",
-      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-      origin: { mode: "self-hosted-local" },
-      compatibility: {
-        min_runtime_version: "0.0.0-test",
-        max_runtime_version: null,
-      },
-      contents: [{ path: "config.json", sha256: "abc123", size_bytes: 1024 }],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-  };
-}
-
-function makePreflightSuccess(): ImportPreflightResponse {
-  return {
-    can_import: true,
-    summary: {
-      total_files: 3,
-      files_to_create: 1,
-      files_to_overwrite: 1,
-      files_unchanged: 1,
-      files_to_skip: 0,
-    },
-    files: [
-      {
-        path: "config.json",
-        action: "overwrite",
-        bundle_size: 1024,
-        current_size: 800,
-        bundle_sha256: "abc123",
-        current_sha256: "old123",
-      },
-    ],
-    conflicts: [],
-    manifest: {
-      schema_version: 1,
-      bundle_id: "00000000-0000-4000-8000-000000000000",
-      created_at: "2026-03-01T00:00:00Z",
-      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-      origin: { mode: "self-hosted-local" },
-      compatibility: {
-        min_runtime_version: "0.0.0-test",
-        max_runtime_version: null,
-      },
-      contents: [{ path: "config.json", sha256: "abc123", size_bytes: 1024 }],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-  };
-}
-
-function makeImportSuccess(): ImportCommitResponse {
-  return {
-    success: true,
-    summary: {
-      total_files: 3,
-      files_created: 1,
-      files_overwritten: 1,
-      files_skipped: 1,
-      backups_created: 1,
-    },
-    files: [
-      {
-        path: "config.json",
-        disk_path: "/data/config.json",
-        action: "overwritten",
-        size: 1024,
-        sha256: "abc123",
-        backup_path: "/data/config.json.bak",
-      },
-    ],
-    manifest: {
-      schema_version: 1,
-      bundle_id: "00000000-0000-4000-8000-000000000000",
-      created_at: "2026-03-01T00:00:00Z",
-      assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
-      origin: { mode: "self-hosted-local" },
-      compatibility: {
-        min_runtime_version: "0.0.0-test",
-        max_runtime_version: null,
-      },
-      contents: [{ path: "config.json", sha256: "abc123", size_bytes: 1024 }],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-    warnings: ["Backup created for config.json"],
-  };
-}
-
-/** Advance state to a specific step for testing. */
-function advanceTo(step: WizardStep): MigrationWizardState {
-  let state = createWizardState();
-  const stepOrder: WizardStep[] = [
-    "select-direction",
-    "upload-bundle",
-    "validate",
-    "preflight-review",
-    "transfer",
-    "rebind-secrets",
-    "complete",
-  ];
-  const targetIdx = stepOrder.indexOf(step);
-
-  if (targetIdx >= 1) {
-    state = selectDirection(state, "managed-to-self-hosted");
-  }
-  if (targetIdx >= 2) {
-    state = setBundleUploaded(state);
-  }
-  if (targetIdx >= 3) {
-    state = {
-      ...state,
-      steps: { ...state.steps, validate: { status: "success" } },
-      validateResult: makeValidateSuccess(),
-      currentStep: "preflight-review",
-    };
-  }
-  if (targetIdx >= 4) {
-    state = {
-      ...state,
-      steps: { ...state.steps, "preflight-review": { status: "success" } },
-      preflightResult: makePreflightSuccess(),
-      currentStep: "transfer",
-    };
-  }
-  if (targetIdx >= 5) {
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "success" } },
-      importResult: makeImportSuccess(),
-      currentStep: "rebind-secrets",
-    };
-  }
-  if (targetIdx >= 6) {
-    state = completeRebindSecrets(state);
-  }
-
-  return state;
-}
-
-// ---------------------------------------------------------------------------
-// Disabled state
-// ---------------------------------------------------------------------------
-
-describe("deriveTransferScreenState -- disabled", () => {
-  test("returns disabled when on select-direction step", () => {
-    const state = createWizardState();
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on upload-bundle step", () => {
-    const state = advanceTo("upload-bundle");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on validate step", () => {
-    const state = advanceTo("validate");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on preflight-review step (not yet completed)", () => {
-    const state = advanceTo("preflight-review");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("isTransferScreenAccessible returns false for early steps", () => {
-    expect(isTransferScreenAccessible(createWizardState())).toBe(false);
-  });
-
-  test("isTransferScreenAccessible returns false for validate step", () => {
-    const state = advanceTo("validate");
-    expect(isTransferScreenAccessible(state)).toBe(false);
-  });
-
-  test("isTransferScreenAccessible returns true for transfer step", () => {
-    const state = advanceTo("transfer");
-    expect(isTransferScreenAccessible(state)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Importing state (default phase -- import-only flow)
-// ---------------------------------------------------------------------------
-
-describe("deriveTransferScreenState -- importing (default)", () => {
-  test("shows importing when transfer step is idle (preparing)", () => {
-    const state = advanceTo("transfer");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("importing");
-    if (screen.phase === "importing") {
-      expect(screen.message).toContain("Importing");
-    }
-  });
-
-  test("shows importing when transfer step is loading with no export result", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "loading" } },
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("importing");
-    if (screen.phase === "importing") {
-      expect(screen.message).toContain("Importing");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Polling state
-// ---------------------------------------------------------------------------
-
-describe("deriveTransferScreenState -- polling", () => {
-  test("shows polling when managed export result exists with pending status", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "loading" } },
-      exportResult: {
-        ok: true,
-        jobId: "exp-123",
-        status: "pending",
-      } as ExportManagedResult,
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("polling");
-    if (screen.phase === "polling") {
-      expect(screen.jobId).toBe("exp-123");
-      expect(screen.message).toContain("export job");
-    }
-  });
-
-  test("shows polling when managed export result exists with processing status", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "loading" } },
-      exportResult: {
-        ok: true,
-        jobId: "exp-456",
-        status: "processing",
-      } as ExportManagedResult,
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("polling");
-    if (screen.phase === "polling") {
-      expect(screen.jobId).toBe("exp-456");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Importing state
-// ---------------------------------------------------------------------------
-
-describe("deriveTransferScreenState -- importing", () => {
-  test("shows importing when runtime export result exists but no import result", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "loading" } },
-      exportResult: {
-        ok: true,
-        filename: "export.vbundle",
-        schemaVersion: 1,
-        checksum: "abc",
-      },
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("importing");
-    if (screen.phase === "importing") {
-      expect(screen.message).toContain("Importing");
-    }
-  });
-
-  test("shows importing when managed export completed and import in progress", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "loading" } },
-      exportResult: {
-        ok: true,
-        jobId: "exp-789",
-        status: "complete",
-      } as ExportManagedResult,
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("importing");
-    if (screen.phase === "importing") {
-      expect(screen.message).toContain("Importing");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Success state
-// ---------------------------------------------------------------------------
-
-describe("deriveTransferScreenState -- success", () => {
-  test("shows success with import summary after transfer completes", () => {
-    const state = advanceTo("rebind-secrets");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("success");
-    if (screen.phase === "success") {
-      expect(screen.importSummary.totalFiles).toBe(3);
-      expect(screen.importSummary.filesCreated).toBe(1);
-      expect(screen.importSummary.filesOverwritten).toBe(1);
-      expect(screen.importSummary.filesSkipped).toBe(1);
-      expect(screen.importSummary.backupsCreated).toBe(1);
-      expect(screen.importSummary.warnings).toHaveLength(1);
-      expect(screen.importSummary.warnings[0]).toContain("Backup");
-    }
-  });
-
-  test("canContinue is true when rebind-secrets step is accessible", () => {
-    const state = advanceTo("rebind-secrets");
-    const screen = deriveTransferScreenState(state);
-    if (screen.phase === "success") {
-      expect(screen.canContinue).toBe(true);
-    }
-  });
-
-  test("success state persists when viewing from later steps", () => {
-    const state = advanceTo("complete");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("success");
-  });
-
-  test("shows success with empty summary when importResult is missing (defensive)", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "success" } },
-      currentStep: "rebind-secrets",
-      // No importResult
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("success");
-    if (screen.phase === "success") {
-      expect(screen.importSummary.totalFiles).toBe(0);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Error states
-// ---------------------------------------------------------------------------
-
-describe("deriveTransferScreenState -- error", () => {
-  test("shows error when transfer step fails with retryable error", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "export: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("error");
-    if (screen.phase === "error") {
-      expect(screen.error.message).toContain("HTTP 500");
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-
-  test("shows error when transfer step fails with non-retryable error", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "import: HTTP 400",
-            code: "HTTP_400",
-            retryable: false,
-          },
-        },
-      },
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("error");
-    if (screen.phase === "error") {
-      expect(screen.canRetry).toBe(false);
-    }
-  });
-
-  test("infers failed phase as import when no export result exists (import-only flow)", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "import: HTTP 503",
-            code: "HTTP_503",
-            retryable: true,
-          },
-        },
-      },
-    };
-    const screen = deriveTransferScreenState(state);
-    if (screen.phase === "error") {
-      expect(screen.failedPhase).toBe("import");
-    }
-  });
-
-  test("infers failed phase as export for EXPORT_JOB_FAILED code", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "Export job failed: Timeout",
-            code: "EXPORT_JOB_FAILED",
-            retryable: true,
-          },
-        },
-      },
-      exportResult: {
-        ok: true,
-        jobId: "exp-fail",
-        status: "pending",
-      } as ExportManagedResult,
-    };
-    const screen = deriveTransferScreenState(state);
-    if (screen.phase === "error") {
-      expect(screen.failedPhase).toBe("export");
-    }
-  });
-
-  test("infers failed phase as export for NO_DOWNLOAD_URL code", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "Export completed but no download URL was provided",
-            code: "NO_DOWNLOAD_URL",
-            retryable: true,
-          },
-        },
-      },
-      exportResult: {
-        ok: true,
-        jobId: "exp-no-url",
-        status: "complete",
-      } as ExportManagedResult,
-    };
-    const screen = deriveTransferScreenState(state);
-    if (screen.phase === "error") {
-      expect(screen.failedPhase).toBe("export");
-    }
-  });
-
-  test("infers failed phase as import when import result exists and failed", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "Disk full",
-            code: "write_failed",
-            retryable: true,
-          },
-        },
-      },
-      exportResult: {
-        ok: true,
-        filename: "export.vbundle",
-        schemaVersion: 1,
-        checksum: "abc",
-      },
-      importResult: {
-        success: false,
-        reason: "write_failed",
-        message: "Disk full",
-      },
-    };
-    const screen = deriveTransferScreenState(state);
-    if (screen.phase === "error") {
-      expect(screen.failedPhase).toBe("import");
-    }
-  });
-
-  test("infers failed phase as poll for managed export transport error during download", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "Failed to download export: HTTP 404",
-            code: "HTTP_404",
-            retryable: false,
-          },
-        },
-      },
-      exportResult: {
-        ok: true,
-        jobId: "exp-download-fail",
-        status: "complete",
-      } as ExportManagedResult,
-      // No importResult -- download failed before import
-    };
-    const screen = deriveTransferScreenState(state);
-    if (screen.phase === "error") {
-      expect(screen.failedPhase).toBe("poll");
-    }
-  });
-
-  test("shows default error when step has error status but no error details", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: { status: "error" },
-      },
-    };
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("error");
-    if (screen.phase === "error") {
-      expect(screen.error.message).toBe("Transfer failed");
-      expect(screen.error.retryable).toBe(false);
-      expect(screen.canRetry).toBe(false);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Retry behavior
-// ---------------------------------------------------------------------------
-
-describe("retryTransferFlow", () => {
-  test("retries transfer step after export error", async () => {
-    let state = advanceTo("transfer");
-    const importResponse = makeImportSuccess();
-
-    // Simulate a failed export
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "export: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-    };
-
-    const archiveBytes = new ArrayBuffer(32);
-    const sourceFetch = (async () => {
-      return new Response(archiveBytes, {
-        status: 200,
-        headers: {
-          "Content-Disposition": 'attachment; filename="export.vbundle"',
-          "X-Vbundle-Schema-Version": "1",
-          "X-Vbundle-Manifest-Sha256": "abc",
-        },
-      });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-    });
-
-    const result = await retryTransferFlow(state, options);
-    expect(result.steps.transfer.status).toBe("success");
-    expect(result.currentStep).toBe("rebind-secrets");
-  });
-
-  test("throws when trying to retry non-retryable error", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "Fatal error",
-            retryable: false,
-          },
-        },
-      },
-    };
-
-    const options = makeExecutorOptions();
-    expect(retryTransferFlow(state, options)).rejects.toThrow(
-      "not in a retryable error state",
-    );
-  });
-
-  test("emits state change on reset before retry", async () => {
-    let state = advanceTo("transfer");
-    const importResponse = makeImportSuccess();
-
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "export: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-    };
-
-    const archiveBytes = new ArrayBuffer(32);
-    const sourceFetch = (async () => {
-      return new Response(archiveBytes, {
-        status: 200,
-        headers: {
-          "Content-Disposition": 'attachment; filename="export.vbundle"',
-          "X-Vbundle-Schema-Version": "1",
-          "X-Vbundle-Manifest-Sha256": "abc",
-        },
-      });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const stateChanges: MigrationWizardState[] = [];
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-      onStateChange: (s) => stateChanges.push(s),
-    });
-
-    await retryTransferFlow(state, options);
-
-    // The first state change should be the reset (idle status)
-    expect(stateChanges.length).toBeGreaterThan(0);
-    expect(stateChanges[0].steps.transfer.status).toBe("idle");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Transfer flow execution
-// ---------------------------------------------------------------------------
-
-describe("executeTransferFlow", () => {
-  test("runtime export + import -- success", async () => {
-    const archiveBytes = new ArrayBuffer(32);
-    const importResponse = makeImportSuccess();
-
-    const sourceFetch = (async () => {
-      return new Response(archiveBytes, {
-        status: 200,
-        headers: {
-          "Content-Disposition": 'attachment; filename="export.vbundle"',
-          "X-Vbundle-Schema-Version": "1",
-          "X-Vbundle-Manifest-Sha256": "abc",
-        },
-      });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const state = advanceTo("transfer");
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-    });
-
-    const result = await executeTransferFlow(state, options);
-    expect(result.steps.transfer.status).toBe("success");
-    expect(result.currentStep).toBe("rebind-secrets");
-
-    const screen = deriveTransferScreenState(result);
-    expect(screen.phase).toBe("success");
-    if (screen.phase === "success") {
-      expect(screen.importSummary.totalFiles).toBe(3);
-    }
-  });
-
-  test("managed export + poll + import -- success", async () => {
-    let fetchCallCount = 0;
-    const importResponse = makeImportSuccess();
-
-    const sourceFetch = (async (url: string | URL | Request) => {
-      fetchCallCount++;
-      const urlStr = String(url);
-      if (urlStr.endsWith("/export/")) {
-        return new Response(
-          JSON.stringify({ job_id: "exp-1", status: "pending" }),
-          {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-      if (urlStr.includes("/export/") && urlStr.includes("/status/")) {
-        if (fetchCallCount <= 3) {
-          return new Response(
-            JSON.stringify({ status: "processing", job_id: "exp-1" }),
-            {
-              status: 200,
-              headers: { "Content-Type": "application/json" },
-            },
-          );
-        }
-        return new Response(
-          JSON.stringify({
-            status: "complete",
-            job_id: "exp-1",
-            download_url: "https://cdn.example.com/export.vbundle",
-          }),
-          {
-            status: 200,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-      if (urlStr === "https://cdn.example.com/export.vbundle") {
-        return new Response(new ArrayBuffer(32), { status: 200 });
-      }
-      return new Response("Not found", { status: 404 });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const state = advanceTo("transfer");
-    const options = makeExecutorOptions({
-      sourceConfig: managedConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-    });
-
-    const result = await executeTransferFlow(state, options);
-    expect(result.steps.transfer.status).toBe("success");
-    expect(result.currentStep).toBe("rebind-secrets");
-  });
-
-  test("transfer failure sets error state with import phase", async () => {
-    const state = advanceTo("transfer");
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: mockFetch(500, "Server Error") }),
-    });
-
-    const result = await executeTransferFlow(state, options);
-    expect(result.steps.transfer.status).toBe("error");
-
-    const screen = deriveTransferScreenState(result);
-    expect(screen.phase).toBe("error");
-    if (screen.phase === "error") {
-      expect(screen.canRetry).toBe(true);
-      expect(screen.failedPhase).toBe("import");
-    }
-  });
-
-  test("import failure sets error state with import reason", async () => {
-    const archiveBytes = new ArrayBuffer(32);
-    const importResponse: ImportCommitResponse = {
-      success: false,
-      reason: "write_failed",
-      message: "Disk full",
-    };
-
-    const sourceFetch = (async () => {
-      return new Response(archiveBytes, {
-        status: 200,
-        headers: {
-          "Content-Disposition": 'attachment; filename="export.vbundle"',
-          "X-Vbundle-Schema-Version": "1",
-          "X-Vbundle-Manifest-Sha256": "abc",
-        },
-      });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const state = advanceTo("transfer");
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-    });
-
-    const result = await executeTransferFlow(state, options);
-    expect(result.steps.transfer.status).toBe("error");
-    expect(result.steps.transfer.error?.message).toContain("Disk full");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Back navigation
-// ---------------------------------------------------------------------------
-
-describe("goBackToPreflight", () => {
-  test("navigates back to preflight-review from transfer", () => {
-    const state = advanceTo("transfer");
-    const result = goBackToPreflight(state);
-    expect(result.currentStep).toBe("preflight-review");
-    expect(result.steps.transfer.status).toBe("idle");
-  });
-
-  test("clears export and import results when going back", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      exportResult: {
-        ok: true,
-        filename: "export.vbundle",
-        schemaVersion: 1,
-        checksum: "abc",
-      },
-      importResult: makeImportSuccess(),
-    };
-    const result = goBackToPreflight(state);
-    expect(result.exportResult).toBeUndefined();
-    expect(result.importResult).toBeUndefined();
-  });
-
-  test("preserves validation results but clears preflight when going back", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      validateResult: makeValidateSuccess(),
-      preflightResult: makePreflightSuccess(),
-    };
-    const result = goBackToPreflight(state);
-    // Validation results are preserved since we're only going back to preflight
-    expect(result.validateResult).toBeDefined();
-    // Preflight results are cleared because going back resets the target step
-    expect(result.preflightResult).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// State change callbacks
-// ---------------------------------------------------------------------------
-
-describe("executeTransferFlow -- onStateChange callbacks", () => {
-  test("emits state changes during transfer flow", async () => {
-    const archiveBytes = new ArrayBuffer(32);
-    const importResponse = makeImportSuccess();
-
-    const sourceFetch = (async () => {
-      return new Response(archiveBytes, {
-        status: 200,
-        headers: {
-          "Content-Disposition": 'attachment; filename="export.vbundle"',
-          "X-Vbundle-Schema-Version": "1",
-          "X-Vbundle-Manifest-Sha256": "abc",
-        },
-      });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const state = advanceTo("transfer");
-    const stateChanges: TransferScreenState[] = [];
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-      onStateChange: (s) => stateChanges.push(deriveTransferScreenState(s)),
-    });
-
-    await executeTransferFlow(state, options);
-
-    // Should have gone through at least the loading state
-    const phases = stateChanges.map((s) => s.phase);
-    expect(phases).toContain("importing");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// State persistence and resume
-// ---------------------------------------------------------------------------
-
-describe("transfer screen state persistence/resume", () => {
-  test("derives correct state after serialize + deserialize at transfer step", () => {
-    const state = advanceTo("transfer");
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    // After deserialization, hasBundleData is false, so prepareForResume
-    // should redirect to upload-bundle
-    const resumed = prepareForResume(restored!);
-    const screen = deriveTransferScreenState(resumed);
-    expect(screen.phase).toBe("disabled");
-    expect(resumed.currentStep).toBe("upload-bundle");
-  });
-
-  test("derives correct state after resume at transfer step with loading status", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: { ...state.steps, transfer: { status: "loading" } },
-    };
-
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    // prepareForResume resets loading to idle and redirects to upload-bundle
-    // because hasBundleData is false after deserialization
-    const resumed = prepareForResume(restored!);
-    expect(resumed.currentStep).toBe("upload-bundle");
-  });
-
-  test("success results persist across serialize/deserialize", () => {
-    let state = advanceTo("rebind-secrets");
-    state = {
-      ...state,
-      importResult: makeImportSuccess(),
-    };
-
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    const screen = deriveTransferScreenState(restored!);
-    expect(screen.phase).toBe("success");
-    if (screen.phase === "success") {
-      expect(screen.importSummary.totalFiles).toBe(3);
-    }
-  });
-
-  test("error state is preserved after serialize/deserialize", () => {
-    let state = advanceTo("transfer");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        transfer: {
-          status: "error",
-          error: {
-            message: "export: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-    };
-
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    // The raw deserialized state (before resume) preserves the error
-    const screen = deriveTransferScreenState(restored!);
-    expect(screen.phase).toBe("error");
-    if (screen.phase === "error") {
-      expect(screen.error.message).toContain("HTTP 500");
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Edge cases
-// ---------------------------------------------------------------------------
-
-describe("transfer screen edge cases", () => {
-  test("handles transfer step at complete state -- success visible", () => {
-    const state = advanceTo("complete");
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("success");
-  });
-
-  test("handles transfer error from wrong step gracefully", () => {
-    const state = advanceTo("validate");
-    // Attempting to derive transfer screen from validate step
-    const screen = deriveTransferScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("runtime flow does not show polling phase", async () => {
-    const archiveBytes = new ArrayBuffer(32);
-    const importResponse = makeImportSuccess();
-
-    const sourceFetch = (async () => {
-      return new Response(archiveBytes, {
-        status: 200,
-        headers: {
-          "Content-Disposition": 'attachment; filename="export.vbundle"',
-          "X-Vbundle-Schema-Version": "1",
-          "X-Vbundle-Manifest-Sha256": "abc",
-        },
-      });
-    }) as unknown as typeof fetch;
-
-    const destFetch = (async () => {
-      return new Response(JSON.stringify(importResponse), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const state = advanceTo("transfer");
-    const stateChanges: TransferScreenState[] = [];
-    const options = makeExecutorOptions({
-      sourceConfig: runtimeConfig({ fetchFn: sourceFetch }),
-      destConfig: runtimeConfig({ fetchFn: destFetch }),
-      onStateChange: (s) => stateChanges.push(deriveTransferScreenState(s)),
-    });
-
-    await executeTransferFlow(state, options);
-
-    // Runtime flow should not have any polling phases
-    const phases = stateChanges.map((s) => s.phase);
-    expect(phases).not.toContain("polling");
-  });
-
-  test("transfer flow throws when called from wrong step", async () => {
-    const state = advanceTo("validate");
-    const options = makeExecutorOptions();
-    try {
-      await executeTransferFlow(state, options);
-      expect(true).toBe(false);
-    } catch (err) {
-      expect((err as Error).message).toContain("wrong step");
-    }
-  });
-});