@mycadet/assistant 0.12.10 → 0.13.0

package/src/__tests__/validation-results-screen.test.ts

@@ -1,1130 +0,0 @@
-/**
- * Tests for the validation results screen view model.
- *
- * Covers:
- * - Disabled state: screen not accessible when earlier steps incomplete
- * - Loading states: validation loading, preflight loading, idle/preparing
- * - Validation error: bundle invalid with error details
- * - Transport error: network failures for validate and preflight steps
- * - Preflight error: preflight validation failure
- * - Success state: full results with summary, files, conflicts
- * - Retry behavior: reset and re-execute on retryable errors
- * - Back navigation: return to upload-bundle step
- * - File grouping: group files by action (create/overwrite/unchanged)
- * - File size formatting: human-readable byte sizes
- * - Validation flow execution: chained validate + preflight
- * - State persistence/resume: derive correct screen state after resume
- */
-
-import { describe, expect, test } from "bun:test";
-
-import type {
-  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 {
-  PreflightFileEntry,
-  ValidationScreenState,
-} from "../runtime/migrations/validation-results-screen.js";
-import {
-  deriveValidationScreenState,
-  executeValidationFlow,
-  formatFileSize,
-  goBackToUpload,
-  groupFilesByAction,
-  isValidationScreenAccessible,
-  retryValidationFlow,
-} from "../runtime/migrations/validation-results-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 makeExecutorOptions(
-  overrides?: Partial<StepExecutorOptions>,
-): StepExecutorOptions {
-  return {
-    sourceConfig: runtimeConfig(),
-    destConfig: runtimeConfig(),
-    bundleData: new ArrayBuffer(16),
-    ...overrides,
-  };
-}
-
-/** 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" } },
-      currentStep: "rebind-secrets",
-    };
-  }
-  if (targetIdx >= 6) {
-    state = completeRebindSecrets(state);
-  }
-
-  return state;
-}
-
-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 },
-        { path: "skills/test.md", sha256: "def456", size_bytes: 2048 },
-      ],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-  };
-}
-
-function makeValidateFailure(): ValidateResponse {
-  return {
-    is_valid: false,
-    errors: [
-      {
-        code: "INVALID_SCHEMA",
-        message: "Bundle schema version 0.5 is not supported",
-        path: "manifest.json",
-      },
-      {
-        code: "MISSING_FILE",
-        message: "Referenced file config.json not found in archive",
-      },
-    ],
-  };
-}
-
-function makePreflightSuccess(): ImportPreflightResponse {
-  return {
-    can_import: true,
-    summary: {
-      total_files: 5,
-      files_to_create: 2,
-      files_to_overwrite: 2,
-      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",
-      },
-      {
-        path: "skills/new-skill.md",
-        action: "create",
-        bundle_size: 512,
-        current_size: null,
-        bundle_sha256: "ghi789",
-        current_sha256: null,
-      },
-      {
-        path: "memory/index.json",
-        action: "overwrite",
-        bundle_size: 4096,
-        current_size: 3500,
-        bundle_sha256: "jkl012",
-        current_sha256: "old012",
-      },
-      {
-        path: "playbooks/default.md",
-        action: "unchanged",
-        bundle_size: 2048,
-        current_size: 2048,
-        bundle_sha256: "mno345",
-        current_sha256: "mno345",
-      },
-      {
-        path: "tools/custom.ts",
-        action: "create",
-        bundle_size: 768,
-        current_size: null,
-        bundle_sha256: "pqr678",
-        current_sha256: null,
-      },
-    ],
-    conflicts: [
-      {
-        code: "SIZE_MISMATCH",
-        message: "config.json will increase from 800B to 1024B",
-        path: "config.json",
-      },
-    ],
-    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 },
-        { path: "skills/new-skill.md", sha256: "ghi789", size_bytes: 512 },
-      ],
-      checksum: "manifest-hash",
-      secrets_redacted: false,
-      export_options: {
-        include_logs: false,
-        include_browser_state: false,
-        include_memory_vectors: false,
-      },
-    },
-  };
-}
-
-function makePreflightFailure(): ImportPreflightResponse {
-  return {
-    can_import: false,
-    validation: {
-      is_valid: false,
-      errors: [
-        {
-          code: "INCOMPATIBLE_VERSION",
-          message: "Bundle requires schema version 2.0, current is 1.0",
-        },
-      ],
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Disabled state
-// ---------------------------------------------------------------------------
-
-describe("deriveValidationScreenState — disabled", () => {
-  test("returns disabled when on select-direction step", () => {
-    const state = createWizardState();
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("returns disabled when on upload-bundle step", () => {
-    const state = advanceTo("upload-bundle");
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("disabled");
-  });
-
-  test("isValidationScreenAccessible returns false for early steps", () => {
-    expect(isValidationScreenAccessible(createWizardState())).toBe(false);
-  });
-
-  test("isValidationScreenAccessible returns true for validate step", () => {
-    const state = advanceTo("validate");
-    expect(isValidationScreenAccessible(state)).toBe(true);
-  });
-
-  test("isValidationScreenAccessible returns true for preflight-review step", () => {
-    const state = advanceTo("preflight-review");
-    expect(isValidationScreenAccessible(state)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Loading states
-// ---------------------------------------------------------------------------
-
-describe("deriveValidationScreenState — loading", () => {
-  test("shows loading when validate step is idle (preparing)", () => {
-    const state = advanceTo("validate");
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("loading");
-    if (screen.phase === "loading") {
-      expect(screen.message).toContain("validation");
-    }
-  });
-
-  test("shows loading when validate step is in loading status", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: { ...state.steps, validate: { status: "loading" } },
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("loading");
-    if (screen.phase === "loading") {
-      expect(screen.message).toContain("Validating");
-    }
-  });
-
-  test("shows loading when preflight-review step is idle (preparing)", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      steps: { ...state.steps, "preflight-review": { status: "idle" } },
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("loading");
-    if (screen.phase === "loading") {
-      expect(screen.message).toContain("import analysis");
-    }
-  });
-
-  test("shows loading when preflight-review step is in loading status", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      steps: { ...state.steps, "preflight-review": { status: "loading" } },
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("loading");
-    if (screen.phase === "loading") {
-      expect(screen.message).toContain("Analyzing");
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Validation error
-// ---------------------------------------------------------------------------
-
-describe("deriveValidationScreenState — validation-error", () => {
-  test("shows validation-error with error details when bundle is invalid", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "Bundle validation failed",
-            code: "INVALID_SCHEMA",
-            retryable: true,
-          },
-        },
-      },
-      validateResult: makeValidateFailure(),
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("validation-error");
-    if (screen.phase === "validation-error") {
-      expect(screen.errors).toHaveLength(2);
-      expect(screen.errors[0].code).toBe("INVALID_SCHEMA");
-      expect(screen.errors[0].message).toContain("schema version");
-      expect(screen.errors[1].code).toBe("MISSING_FILE");
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-
-  test("shows validation-error as non-retryable when error is not retryable", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "Bundle validation failed",
-            code: "INVALID_SCHEMA",
-            retryable: false,
-          },
-        },
-      },
-      validateResult: makeValidateFailure(),
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("validation-error");
-    if (screen.phase === "validation-error") {
-      expect(screen.canRetry).toBe(false);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Transport error
-// ---------------------------------------------------------------------------
-
-describe("deriveValidationScreenState — transport-error", () => {
-  test("shows transport-error for validate step network failure", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "validate: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-      // No validateResult means it was a transport failure, not a validation failure
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("transport-error");
-    if (screen.phase === "transport-error") {
-      expect(screen.step).toBe("validate");
-      expect(screen.error.message).toContain("HTTP 500");
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-
-  test("shows transport-error for preflight step network failure", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        "preflight-review": {
-          status: "error",
-          error: {
-            message: "import-preflight: HTTP 503",
-            code: "HTTP_503",
-            retryable: true,
-          },
-        },
-      },
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("transport-error");
-    if (screen.phase === "transport-error") {
-      expect(screen.step).toBe("preflight-review");
-      expect(screen.error.message).toContain("HTTP 503");
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-
-  test("shows transport-error with 429 rate limit as retryable", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "validate: HTTP 429",
-            code: "HTTP_429",
-            retryable: true,
-          },
-        },
-      },
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("transport-error");
-    if (screen.phase === "transport-error") {
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Preflight error
-// ---------------------------------------------------------------------------
-
-describe("deriveValidationScreenState — preflight-error", () => {
-  test("shows preflight-error when preflight validation fails", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        "preflight-review": {
-          status: "error",
-          error: {
-            message: "Import preflight validation failed",
-            code: "INCOMPATIBLE_VERSION",
-            retryable: true,
-          },
-        },
-      },
-      preflightResult: makePreflightFailure(),
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("preflight-error");
-    if (screen.phase === "preflight-error") {
-      expect(screen.error.message).toContain("preflight");
-      expect(screen.canRetry).toBe(true);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Success state
-// ---------------------------------------------------------------------------
-
-describe("deriveValidationScreenState — success", () => {
-  test("shows success with full results when both steps pass", () => {
-    const state = advanceTo("transfer");
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("success");
-    if (screen.phase === "success") {
-      expect(screen.validation.isValid).toBe(true);
-      expect(screen.validation.manifest.schema_version).toBe(1);
-    }
-  });
-
-  test("includes preflight summary counts", () => {
-    const state = advanceTo("transfer");
-    const screen = deriveValidationScreenState(state);
-    if (screen.phase === "success") {
-      expect(screen.preflight.summary.totalFiles).toBe(5);
-      expect(screen.preflight.summary.filesToCreate).toBe(2);
-      expect(screen.preflight.summary.filesToOverwrite).toBe(2);
-      expect(screen.preflight.summary.filesUnchanged).toBe(1);
-    }
-  });
-
-  test("includes normalized file entries", () => {
-    const state = advanceTo("transfer");
-    const screen = deriveValidationScreenState(state);
-    if (screen.phase === "success") {
-      expect(screen.preflight.files).toHaveLength(5);
-      const createFile = screen.preflight.files.find(
-        (f) => f.path === "skills/new-skill.md",
-      );
-      expect(createFile).toBeDefined();
-      expect(createFile!.action).toBe("create");
-      expect(createFile!.bundleSize).toBe(512);
-      expect(createFile!.currentSize).toBeNull();
-    }
-  });
-
-  test("includes conflict entries", () => {
-    const state = advanceTo("transfer");
-    const screen = deriveValidationScreenState(state);
-    if (screen.phase === "success") {
-      expect(screen.preflight.conflicts).toHaveLength(1);
-      expect(screen.preflight.conflicts[0].code).toBe("SIZE_MISMATCH");
-      expect(screen.preflight.conflicts[0].path).toBe("config.json");
-    }
-  });
-
-  test("canContinue is true when transfer step is accessible", () => {
-    const state = advanceTo("transfer");
-    const screen = deriveValidationScreenState(state);
-    if (screen.phase === "success") {
-      expect(screen.canContinue).toBe(true);
-    }
-  });
-
-  test("success state persists when viewing from later steps", () => {
-    const state = advanceTo("rebind-secrets");
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("success");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Retry behavior
-// ---------------------------------------------------------------------------
-
-describe("retryValidationFlow", () => {
-  test("retries validate step after transport error", async () => {
-    let state = advanceTo("validate");
-    const validateSuccess = makeValidateSuccess();
-    const preflightSuccess = makePreflightSuccess();
-
-    // Simulate a failed validate step
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "validate: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-    };
-
-    // Set up sequential responses: validate success, then preflight success
-    let callCount = 0;
-    const sequentialFetch = (async () => {
-      callCount++;
-      if (callCount === 1) {
-        return new Response(JSON.stringify(validateSuccess), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-      return new Response(JSON.stringify(preflightSuccess), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const options = makeExecutorOptions({
-      destConfig: runtimeConfig({ fetchFn: sequentialFetch }),
-    });
-
-    const result = await retryValidationFlow(state, options);
-    expect(result.steps["validate"].status).toBe("success");
-    expect(result.currentStep).toBe("transfer");
-  });
-
-  test("retries preflight step after error", async () => {
-    let state = advanceTo("preflight-review");
-    const preflightSuccess = makePreflightSuccess();
-
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        "preflight-review": {
-          status: "error",
-          error: {
-            message: "import-preflight: HTTP 500",
-            code: "HTTP_500",
-            retryable: true,
-          },
-        },
-      },
-    };
-
-    const options = makeExecutorOptions({
-      destConfig: runtimeConfig({
-        fetchFn: mockFetch(200, preflightSuccess),
-      }),
-    });
-
-    const result = await retryValidationFlow(state, options);
-    expect(result.steps["preflight-review"].status).toBe("success");
-    expect(result.currentStep).toBe("transfer");
-  });
-
-  test("throws when trying to retry non-retryable error", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "Fatal error",
-            retryable: false,
-          },
-        },
-      },
-    };
-
-    const options = makeExecutorOptions();
-    expect(retryValidationFlow(state, options)).rejects.toThrow(
-      "not in a retryable error state",
-    );
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Validation flow execution
-// ---------------------------------------------------------------------------
-
-describe("executeValidationFlow", () => {
-  test("runs validate and preflight in sequence on success", async () => {
-    const state = advanceTo("validate");
-    const validateSuccess = makeValidateSuccess();
-    const preflightSuccess = makePreflightSuccess();
-
-    let callCount = 0;
-    const sequentialFetch = (async () => {
-      callCount++;
-      if (callCount === 1) {
-        return new Response(JSON.stringify(validateSuccess), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-      return new Response(JSON.stringify(preflightSuccess), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const stateChanges: MigrationWizardState[] = [];
-    const options = makeExecutorOptions({
-      destConfig: runtimeConfig({ fetchFn: sequentialFetch }),
-      onStateChange: (s) => stateChanges.push(s),
-    });
-
-    const result = await executeValidationFlow(state, options);
-
-    expect(result.steps["validate"].status).toBe("success");
-    expect(result.steps["preflight-review"].status).toBe("success");
-    expect(result.currentStep).toBe("transfer");
-    expect(result.validateResult).toBeDefined();
-    expect(result.preflightResult).toBeDefined();
-
-    // State changes should include loading states
-    const loadingStates = stateChanges.filter(
-      (s) =>
-        s.steps["validate"].status === "loading" ||
-        s.steps["preflight-review"].status === "loading",
-    );
-    expect(loadingStates.length).toBeGreaterThan(0);
-  });
-
-  test("stops at validate when validation fails", async () => {
-    const state = advanceTo("validate");
-    const validateFailure = makeValidateFailure();
-
-    const options = makeExecutorOptions({
-      destConfig: runtimeConfig({
-        fetchFn: mockFetch(200, validateFailure),
-      }),
-    });
-
-    const result = await executeValidationFlow(state, options);
-
-    expect(result.steps["validate"].status).toBe("error");
-    expect(result.currentStep).toBe("validate");
-    expect(result.validateResult).toEqual(validateFailure);
-
-    const screen = deriveValidationScreenState(result);
-    expect(screen.phase).toBe("validation-error");
-  });
-
-  test("stops at validate on transport error", async () => {
-    const state = advanceTo("validate");
-
-    const options = makeExecutorOptions({
-      destConfig: runtimeConfig({
-        fetchFn: mockFetch(500, "Internal server error"),
-      }),
-    });
-
-    const result = await executeValidationFlow(state, options);
-
-    expect(result.steps["validate"].status).toBe("error");
-    expect(result.currentStep).toBe("validate");
-
-    const screen = deriveValidationScreenState(result);
-    expect(screen.phase).toBe("transport-error");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Back navigation
-// ---------------------------------------------------------------------------
-
-describe("goBackToUpload", () => {
-  test("navigates back to upload-bundle from validate", () => {
-    const state = advanceTo("validate");
-    const result = goBackToUpload(state);
-    expect(result.currentStep).toBe("upload-bundle");
-    expect(result.steps["validate"].status).toBe("idle");
-  });
-
-  test("navigates back to upload-bundle from preflight-review", () => {
-    const state = advanceTo("preflight-review");
-    const result = goBackToUpload(state);
-    expect(result.currentStep).toBe("upload-bundle");
-    expect(result.steps["validate"].status).toBe("idle");
-    expect(result.steps["preflight-review"].status).toBe("idle");
-  });
-
-  test("clears validation and preflight results when going back", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      validateResult: makeValidateSuccess(),
-      preflightResult: makePreflightSuccess(),
-    };
-    const result = goBackToUpload(state);
-    expect(result.validateResult).toBeUndefined();
-    expect(result.preflightResult).toBeUndefined();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// File grouping
-// ---------------------------------------------------------------------------
-
-describe("groupFilesByAction", () => {
-  test("groups files by action type", () => {
-    const files: PreflightFileEntry[] = [
-      {
-        path: "a.txt",
-        action: "create",
-        bundleSize: 100,
-        currentSize: null,
-        bundleSha256: "a",
-        currentSha256: null,
-      },
-      {
-        path: "b.txt",
-        action: "overwrite",
-        bundleSize: 200,
-        currentSize: 150,
-        bundleSha256: "b",
-        currentSha256: "b-old",
-      },
-      {
-        path: "c.txt",
-        action: "unchanged",
-        bundleSize: 300,
-        currentSize: 300,
-        bundleSha256: "c",
-        currentSha256: "c",
-      },
-      {
-        path: "d.txt",
-        action: "create",
-        bundleSize: 400,
-        currentSize: null,
-        bundleSha256: "d",
-        currentSha256: null,
-      },
-    ];
-
-    const grouped = groupFilesByAction(files);
-    expect(grouped.create).toHaveLength(2);
-    expect(grouped.overwrite).toHaveLength(1);
-    expect(grouped.unchanged).toHaveLength(1);
-    expect(grouped.create[0].path).toBe("a.txt");
-    expect(grouped.create[1].path).toBe("d.txt");
-    expect(grouped.overwrite[0].path).toBe("b.txt");
-    expect(grouped.unchanged[0].path).toBe("c.txt");
-  });
-
-  test("handles empty file list", () => {
-    const grouped = groupFilesByAction([]);
-    expect(grouped.create).toHaveLength(0);
-    expect(grouped.overwrite).toHaveLength(0);
-    expect(grouped.unchanged).toHaveLength(0);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// File size formatting
-// ---------------------------------------------------------------------------
-
-describe("formatFileSize", () => {
-  test("formats bytes", () => {
-    expect(formatFileSize(0)).toBe("0 B");
-    expect(formatFileSize(100)).toBe("100 B");
-    expect(formatFileSize(1023)).toBe("1023 B");
-  });
-
-  test("formats kilobytes", () => {
-    expect(formatFileSize(1024)).toBe("1.0 KB");
-    expect(formatFileSize(1536)).toBe("1.5 KB");
-    expect(formatFileSize(10240)).toBe("10.0 KB");
-  });
-
-  test("formats megabytes", () => {
-    expect(formatFileSize(1048576)).toBe("1.0 MB");
-    expect(formatFileSize(5242880)).toBe("5.0 MB");
-  });
-
-  test("formats gigabytes", () => {
-    expect(formatFileSize(1073741824)).toBe("1.0 GB");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// State persistence and resume
-// ---------------------------------------------------------------------------
-
-describe("validation screen state persistence/resume", () => {
-  test("derives correct state after serialize + deserialize at validate step", () => {
-    const state = advanceTo("validate");
-    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 = deriveValidationScreenState(resumed);
-    // After resume without bundle data, goes back to upload-bundle
-    expect(screen.phase).toBe("disabled");
-    expect(resumed.currentStep).toBe("upload-bundle");
-  });
-
-  test("derives correct state after resume at preflight-review step with loading status", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      steps: { ...state.steps, "preflight-review": { 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("transfer");
-    state = {
-      ...state,
-      validateResult: makeValidateSuccess(),
-      preflightResult: makePreflightSuccess(),
-    };
-
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    const screen = deriveValidationScreenState(restored!);
-    expect(screen.phase).toBe("success");
-    if (screen.phase === "success") {
-      expect(screen.preflight.summary.totalFiles).toBe(5);
-    }
-  });
-
-  test("error state is preserved after serialize/deserialize", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "Bundle validation failed",
-            code: "INVALID_SCHEMA",
-            retryable: true,
-          },
-        },
-      },
-      validateResult: makeValidateFailure(),
-    };
-
-    const json = serializeWizardState(state);
-    const restored = deserializeWizardState(json);
-    expect(restored).toBeDefined();
-
-    // After deserialization, hasBundleData is false. prepareForResume
-    // will redirect to upload-bundle since bundle data is needed.
-    // But the raw deserialized state (before resume) preserves the error.
-    const screen = deriveValidationScreenState(restored!);
-    expect(screen.phase).toBe("validation-error");
-    if (screen.phase === "validation-error") {
-      expect(screen.errors).toHaveLength(2);
-    }
-  });
-});
-
-// ---------------------------------------------------------------------------
-// State change callbacks
-// ---------------------------------------------------------------------------
-
-describe("executeValidationFlow — onStateChange callbacks", () => {
-  test("emits state changes during validation flow", async () => {
-    const state = advanceTo("validate");
-    const validateSuccess = makeValidateSuccess();
-    const preflightSuccess = makePreflightSuccess();
-
-    let callCount = 0;
-    const sequentialFetch = (async () => {
-      callCount++;
-      if (callCount === 1) {
-        return new Response(JSON.stringify(validateSuccess), {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        });
-      }
-      return new Response(JSON.stringify(preflightSuccess), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }) as unknown as typeof fetch;
-
-    const stateChanges: ValidationScreenState[] = [];
-    const options = makeExecutorOptions({
-      destConfig: runtimeConfig({ fetchFn: sequentialFetch }),
-      onStateChange: (s) => stateChanges.push(deriveValidationScreenState(s)),
-    });
-
-    await executeValidationFlow(state, options);
-
-    // Should have gone through loading states
-    const phases = stateChanges.map((s) => s.phase);
-    expect(phases).toContain("loading");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// Edge cases
-// ---------------------------------------------------------------------------
-
-describe("validation screen edge cases", () => {
-  test("handles validate error without validateResult gracefully", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: {
-          status: "error",
-          error: {
-            message: "Network timeout",
-            retryable: true,
-          },
-        },
-      },
-      // No validateResult — pure transport error
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("transport-error");
-    if (screen.phase === "transport-error") {
-      expect(screen.error.message).toBe("Network timeout");
-    }
-  });
-
-  test("handles preflight error without preflightResult gracefully", () => {
-    let state = advanceTo("preflight-review");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        "preflight-review": {
-          status: "error",
-          error: {
-            message: "Connection refused",
-            retryable: true,
-          },
-        },
-      },
-      // No preflightResult — pure transport error
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("transport-error");
-    if (screen.phase === "transport-error") {
-      expect(screen.error.message).toBe("Connection refused");
-    }
-  });
-
-  test("handles validate step with error but no error details", () => {
-    let state = advanceTo("validate");
-    state = {
-      ...state,
-      steps: {
-        ...state.steps,
-        validate: { status: "error" },
-      },
-    };
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("transport-error");
-    if (screen.phase === "transport-error") {
-      expect(screen.error.message).toBe("Validation failed");
-    }
-  });
-
-  test("handles complete wizard state — success still visible", () => {
-    const state = advanceTo("complete");
-    const screen = deriveValidationScreenState(state);
-    expect(screen.phase).toBe("success");
-  });
-});