fimo 0.6.0 → 0.7.0-experimental.2

package/scripts/lib/postinstall-onboarding.test.ts

@@ -1,82 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { isGlobalInstall, parseYesNo, shouldPromptForGlobalSkills } from './postinstall-onboarding.mjs';
-
-describe('isGlobalInstall', () => {
-  it('detects npm global installs', () => {
-    expect(isGlobalInstall({ npm_config_global: 'true' })).toBe(true);
-  });
-
-  it('detects package-manager location=global installs', () => {
-    expect(isGlobalInstall({ npm_config_location: 'global' })).toBe(true);
-  });
-
-  it('ignores local installs', () => {
-    expect(isGlobalInstall({})).toBe(false);
-  });
-});
-
-describe('shouldPromptForGlobalSkills', () => {
-  it('prompts only for interactive global installs', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toEqual({ ok: true });
-  });
-
-  it('skips CI and non-interactive installs', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', CI: '1' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'ci' });
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true' },
-        stdinIsTTY: false,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'non-interactive' });
-  });
-
-  it('honors the explicit skip env var', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', FIMO_SKIP_POSTINSTALL_PROMPT: '1' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'disabled' });
-  });
-
-  it('skips package-manager assume-yes installs', () => {
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', npm_config_yes: 'true' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'assume-yes-install' });
-    expect(
-      shouldPromptForGlobalSkills({
-        env: { npm_config_global: 'true', npm_config_force: 'true' },
-        stdinIsTTY: true,
-        stdoutIsTTY: true,
-      })
-    ).toMatchObject({ ok: false, reason: 'assume-yes-install' });
-  });
-});
-
-describe('parseYesNo', () => {
-  it('parses yes, no, and empty defaults', () => {
-    expect(parseYesNo('y')).toBe(true);
-    expect(parseYesNo('no')).toBe(false);
-    expect(parseYesNo('', true)).toBe(true);
-    expect(parseYesNo('', false)).toBe(false);
-  });
-});

package/scripts/lib/release-core.mjs

@@ -1,225 +0,0 @@
-// Shared release-core: the channel-aware release.json bake.
-//
-// This is the single place that stamps which environment a published
-// build talks to. Both the npm publish path and any future CI job call
-// it, so the "which URL goes in which build" decision can't drift.
-//
-// `release.json` is a publish artifact: it is gitignored (apps/cli/.gitignore)
-// and only exists transiently while packing. The CLI reads it at runtime as
-// `FIMO_API_URL env || baked release.json || localhost` — so the bake only
-// governs a bare `npm i -g fimo` with no env set. The sandbox always
-// overrides it via the injected `.env`.
-
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-import { ALLOWED_API_URLS } from './channels.mjs';
-
-const TEMPLATE_PKG_REL = 'templates/react-router/package.json';
-const TEMPLATE_LOCK_REL = 'templates/react-router/pnpm-lock.yaml';
-
-/**
- * Write a `release.json` for a published (`source: 'npm'`) build using the
- * channel's baked URLs. Refuses any apiUrl not on the allowlist so a
- * tunnel/localhost can never reach the public registry (D5).
- *
- * @param {string} cliRoot - apps/cli root
- * @param {import('./channels.mjs').Channel} channel
- * @returns {string} the path written
- */
-export function writeReleaseJson(cliRoot, channel) {
-  if (!ALLOWED_API_URLS.has(channel.apiUrl)) {
-    throw new Error(
-      `Refusing to bake non-allowlisted apiUrl "${channel.apiUrl}" into a published package. ` +
-        `Published channels may bake only staging or prod (D5).`
-    );
-  }
-  const payload = {
-    source: channel.source,
-    apiUrl: channel.apiUrl,
-    webUrl: channel.webUrl,
-  };
-  const file = resolve(cliRoot, 'release.json');
-  writeFileSync(file, JSON.stringify(payload, null, 2) + '\n');
-  return file;
-}
-
-/**
- * Pin the bundled template's `fimo` dependency to an exact version at pack
- * time, so a project scaffolded from `fimo@X` depends on exactly `fimo@X`
- * (immutable, reproducible — no mutable URL, no caret drift). The committed
- * template keeps a dev-friendly value; this overwrites it only for the
- * tarball and the returned function restores it afterwards.
- *
- * @param {string} cliRoot
- * @param {string} version - exact version to pin (e.g. "0.3.0" or "0.3.0-experimental.4")
- * @returns {() => void} restore - rewrites the original file contents back
- */
-export function pinTemplateFimo(cliRoot, version) {
-  const file = resolve(cliRoot, TEMPLATE_PKG_REL);
-  if (!existsSync(file)) {
-    return () => {};
-  }
-  const original = readFileSync(file, 'utf8');
-  const pkg = JSON.parse(original);
-  let changed = false;
-  for (const field of ['dependencies', 'devDependencies']) {
-    if (pkg[field] && typeof pkg[field].fimo === 'string' && pkg[field].fimo !== version) {
-      pkg[field].fimo = version;
-      changed = true;
-    }
-  }
-  if (changed) {
-    writeFileSync(file, JSON.stringify(pkg, null, 2) + '\n');
-  }
-  return () => writeFileSync(file, original);
-}
-
-/**
- * Remove the template's pnpm-lock.yaml from the tarball at pack time.
- *
- * We can't ship a correct lockfile: it would have to pin the exact version
- * we're about to publish, which isn't on the registry yet (chicken-and-egg).
- * A stale lockfile pinning a different spec than package.json breaks frozen
- * installs (the 2026-06-11 outage class). With an exact, immutable version in
- * package.json, `fimo create` + a fresh `pnpm install` resolves
- * deterministically — so shipping no lockfile is the correct choice.
- * `scaffold.ts` already deletes the lockfile whenever it rewrites the dep, so
- * this only matters for the exact-npm-match path, but it's always safe.
- *
- * @param {string} cliRoot
- * @returns {() => void} restore - rewrites the original lockfile back, if any
- */
-export function stripTemplateLockfile(cliRoot) {
-  const file = resolve(cliRoot, TEMPLATE_LOCK_REL);
-  if (!existsSync(file)) {
-    return () => {};
-  }
-  const original = readFileSync(file, 'utf8');
-  rmSync(file, { force: true });
-  return () => writeFileSync(file, original);
-}
-
-/**
- * Parse `npm view <name> versions --json` output into a flat list of version
- * strings, tolerating every shape npm has shipped: an array of strings
- * (npm <= 11), a bare string when exactly one version is published
- * (npm <= 11), and the npm 12 wrapper — "npm view --json now always returns
- * an array", one entry per matched version, i.e. `[[...versions]]` for a bare
- * package name. Returns null when nothing version-shaped survives (error
- * envelopes, empty output), so callers fall back to the run-number/timestamp
- * counter instead of trusting garbage.
- *
- * @param {string} stdout - raw stdout of `npm view <name> versions --json`
- * @returns {string[] | null}
- */
-export function parsePublishedVersions(stdout) {
-  let parsed;
-  try {
-    parsed = JSON.parse(stdout);
-  } catch {
-    return null;
-  }
-  const versions = (Array.isArray(parsed) ? parsed : [parsed]).flat().filter((version) => typeof version === 'string');
-  return versions.length > 0 ? versions : null;
-}
-
-/**
- * Next per-version prerelease counter: one past the highest already-published
- * `<base>-<distTag>.<n>` on npm. Counting from what's actually published
- * (instead of resetting blindly to 1) keeps the counter collision-proof even
- * when the projected base flaps back to a value that already has prereleases —
- * npm versions are immutable, so a blind reset would make the publish fail.
- *
- * @param {readonly string[]} existingVersions - all published versions of the package
- * @param {string} base - X.Y.Z base (no prerelease suffix)
- * @param {string} distTag
- * @returns {number}
- */
-export function nextPrereleaseCounter(existingVersions, base, distTag) {
-  const prefix = `${base}-${distTag}.`;
-  let max = 0;
-  for (const version of existingVersions) {
-    if (!version.startsWith(prefix)) {
-      continue;
-    }
-    const n = Number(version.slice(prefix.length));
-    if (Number.isInteger(n) && n > max) {
-      max = n;
-    }
-  }
-  return max + 1;
-}
-
-/**
- * Compute the version to publish for a channel.
- * - Stable (`latest`) publishes the exact package.json version.
- * - Prerelease channels synthesize a disposable `X.Y.Z-<distTag>.<n>`.
- *   `n` counts per base version (`0.3.5-staging.1`, `.2`, …) when the
- *   published versions could be fetched from npm; otherwise it falls back
- *   to the CI run number, then a timestamp.
- *
- * @param {string} baseVersion - package.json version
- * @param {import('./channels.mjs').Channel} channel
- * @param {{ runId?: string, existingVersions?: readonly string[] }} [opts]
- * @returns {string}
- */
-export function computePublishVersion(baseVersion, channel, opts = {}) {
-  if (!channel.prerelease) {
-    return baseVersion;
-  }
-  // Strip any existing prerelease suffix from the base so we don't stack them.
-  const base = baseVersion.split('-')[0];
-  const n = opts.existingVersions
-    ? String(nextPrereleaseCounter(opts.existingVersions, base, channel.distTag))
-    : (opts.runId ?? String(Date.now()));
-  return `${base}-${channel.distTag}.${n}`;
-}
-
-const BUMP_RANK = { patch: 1, minor: 2, major: 3 };
-
-/**
- * Peek at pending changeset files and compute the version the next
- * `changeset version` run will produce for `fimo`. Prerelease channels use
- * this as their base so a staging build advertises the version prod will
- * actually ship (`0.3.4-staging.26` while 0.3.4 is pending) instead of the
- * already-released base. No pending changesets (or no .changeset dir) →
- * base unchanged.
- *
- * @param {string} baseVersion - package.json version
- * @param {string} changesetDir - absolute path to the repo's .changeset dir
- * @returns {string}
- */
-export function nextVersionFromChangesets(baseVersion, changesetDir) {
-  let entries;
-  try {
-    entries = readdirSync(changesetDir);
-  } catch {
-    return baseVersion;
-  }
-
-  let maxBump = null;
-  for (const name of entries) {
-    if (!name.endsWith('.md') || name === 'README.md') {
-      continue;
-    }
-    const text = readFileSync(join(changesetDir, name), 'utf8');
-    const frontmatter = text.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? '';
-    const bump = frontmatter.match(/['"]?fimo['"]?\s*:\s*(patch|minor|major)/)?.[1];
-    if (bump && (!maxBump || BUMP_RANK[bump] > BUMP_RANK[maxBump])) {
-      maxBump = bump;
-    }
-  }
-
-  if (!maxBump) {
-    return baseVersion;
-  }
-  const [major, minor, patch] = baseVersion.split('-')[0].split('.').map(Number);
-  if (maxBump === 'major') {
-    return `${major + 1}.0.0`;
-  }
-  if (maxBump === 'minor') {
-    return `${major}.${minor + 1}.0`;
-  }
-  return `${major}.${minor}.${patch + 1}`;
-}

package/scripts/lib/release-core.test.ts

@@ -1,147 +0,0 @@
-import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-
-import { afterEach, describe, expect, it } from 'vitest';
-
-import {
-  computePublishVersion,
-  nextPrereleaseCounter,
-  nextVersionFromChangesets,
-  parsePublishedVersions,
-  // @ts-expect-error plain mjs module without types
-} from './release-core.mjs';
-
-const stagingChannel = { prerelease: true, distTag: 'staging' };
-const latestChannel = { prerelease: false, distTag: 'latest' };
-
-describe('computePublishVersion', () => {
-  it('returns the base version verbatim for stable channels', () => {
-    expect(computePublishVersion('0.3.3', latestChannel, { runId: '7' })).toBe('0.3.3');
-  });
-
-  it('synthesizes a prerelease version from the run id', () => {
-    expect(computePublishVersion('0.3.3', stagingChannel, { runId: '26' })).toBe('0.3.3-staging.26');
-  });
-
-  it('strips an existing prerelease suffix before synthesizing', () => {
-    expect(computePublishVersion('0.3.3-staging.9', stagingChannel, { runId: '26' })).toBe('0.3.3-staging.26');
-  });
-
-  it('counts per base version when published versions are provided', () => {
-    const existingVersions = ['0.3.4', '0.3.5-staging.1', '0.3.5-staging.2'];
-    expect(computePublishVersion('0.3.5', stagingChannel, { runId: '30', existingVersions })).toBe('0.3.5-staging.3');
-  });
-
-  it('starts at 1 for a base with no published prereleases', () => {
-    const existingVersions = ['0.3.4', '0.3.4-staging.26', '0.3.4-staging.27'];
-    expect(computePublishVersion('0.3.5', stagingChannel, { runId: '30', existingVersions })).toBe('0.3.5-staging.1');
-  });
-});
-
-describe('parsePublishedVersions', () => {
-  it('passes through the npm <= 11 array-of-strings shape', () => {
-    expect(parsePublishedVersions('["0.3.4", "0.3.5-staging.1"]')).toEqual(['0.3.4', '0.3.5-staging.1']);
-  });
-
-  it('wraps the npm <= 11 bare string returned for a single published version', () => {
-    expect(parsePublishedVersions('"0.0.0"')).toEqual(['0.0.0']);
-  });
-
-  it('unwraps the npm 12 shape (--json always returns an array)', () => {
-    expect(parsePublishedVersions('[["0.3.4", "0.3.5-staging.1", "0.3.5"]]')).toEqual([
-      '0.3.4',
-      '0.3.5-staging.1',
-      '0.3.5',
-    ]);
-  });
-
-  it('returns null for unparseable output', () => {
-    expect(parsePublishedVersions('')).toBeNull();
-    expect(parsePublishedVersions('npm ERR! something')).toBeNull();
-  });
-
-  it('returns null when nothing version-shaped survives (error envelopes, empty lists)', () => {
-    expect(parsePublishedVersions('{"error":{"code":"E401"}}')).toBeNull();
-    expect(parsePublishedVersions('[]')).toBeNull();
-    expect(parsePublishedVersions('[{"error":{"code":"E404"}}]')).toBeNull();
-    expect(parsePublishedVersions('null')).toBeNull();
-  });
-});
-
-describe('nextPrereleaseCounter', () => {
-  it('returns 1 when nothing matches the base + tag', () => {
-    expect(nextPrereleaseCounter([], '0.3.5', 'staging')).toBe(1);
-    expect(nextPrereleaseCounter(['0.3.5', '0.3.5-experimental.4'], '0.3.5', 'staging')).toBe(1);
-  });
-
-  it('continues past the highest published counter for the base', () => {
-    const versions = ['0.3.4-staging.26', '0.3.4-staging.27', '0.3.3-staging.25'];
-    expect(nextPrereleaseCounter(versions, '0.3.4', 'staging')).toBe(28);
-  });
-
-  it('does not confuse prefix-sharing bases (0.3.4 vs 0.3.40)', () => {
-    expect(nextPrereleaseCounter(['0.3.40-staging.9'], '0.3.4', 'staging')).toBe(1);
-  });
-
-  it('ignores non-integer counters (timestamps still count, garbage does not)', () => {
-    expect(nextPrereleaseCounter(['0.3.4-staging.abc', '0.3.4-staging.2.5'], '0.3.4', 'staging')).toBe(1);
-    expect(nextPrereleaseCounter(['0.3.3-experimental.1783410168478'], '0.3.3', 'experimental')).toBe(1783410168479);
-  });
-});
-
-describe('nextVersionFromChangesets', () => {
-  let dir: string;
-
-  afterEach(() => {
-    if (dir) {
-      rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  function changesetDir(files: Record<string, string>): string {
-    dir = mkdtempSync(join(tmpdir(), 'changesets-'));
-    writeFileSync(join(dir, 'README.md'), '# Changesets\n');
-    for (const [name, frontmatter] of Object.entries(files)) {
-      writeFileSync(join(dir, name), `---\n${frontmatter}\n---\n\nsummary\n`);
-    }
-    return dir;
-  }
-
-  it('returns the base when the directory does not exist', () => {
-    expect(nextVersionFromChangesets('0.3.3', '/nonexistent/.changeset')).toBe('0.3.3');
-  });
-
-  it('returns the base when no changesets are pending', () => {
-    expect(nextVersionFromChangesets('0.3.3', changesetDir({}))).toBe('0.3.3');
-  });
-
-  it('applies a patch bump for pending patch changesets', () => {
-    const d = changesetDir({ 'a.md': "'fimo': patch" });
-    expect(nextVersionFromChangesets('0.3.3', d)).toBe('0.3.4');
-  });
-
-  it('takes the max bump across pending changesets', () => {
-    const d = changesetDir({
-      'a.md': "'fimo': patch",
-      'b.md': "'fimo': minor",
-      'c.md': "'fimo': patch",
-    });
-    expect(nextVersionFromChangesets('0.3.3', d)).toBe('0.4.0');
-  });
-
-  it('handles major bumps and double-quoted package names', () => {
-    const d = changesetDir({ 'a.md': '"fimo": major' });
-    expect(nextVersionFromChangesets('0.3.3', d)).toBe('1.0.0');
-  });
-
-  it('ignores changesets for other packages', () => {
-    const d = changesetDir({ 'a.md': "'@fimo/fimovm': minor" });
-    expect(nextVersionFromChangesets('0.3.3', d)).toBe('0.3.3');
-  });
-
-  it('ignores an existing prerelease suffix on the base', () => {
-    const d = changesetDir({ 'a.md': "'fimo': patch" });
-    expect(nextVersionFromChangesets('0.3.3-staging.9', d)).toBe('0.3.4');
-  });
-});

package/scripts/migration-qa-gate.test.ts

@@ -1,155 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const SCRIPT = path.resolve(__dirname, '../assets/skills/fimo-migration/scripts/write-migration-report.mjs');
-
-interface GateResult {
-  status: number | null;
-  report: string;
-}
-
-let dir: string;
-
-beforeEach(() => {
-  dir = mkdtempSync(path.join(tmpdir(), 'fimo-qa-gate-'));
-});
-
-afterEach(() => {
-  rmSync(dir, { recursive: true, force: true });
-});
-
-function runGate(manifest: unknown, opts: { withBuildArtifact?: boolean } = {}): GateResult {
-  mkdirSync(path.join(dir, '.fimo', 'migration'), { recursive: true });
-  writeFileSync(path.join(dir, '.fimo', 'migration', 'manifest.json'), JSON.stringify(manifest, null, 2));
-  if (opts.withBuildArtifact) {
-    mkdirSync(path.join(dir, 'dist', 'client'), { recursive: true });
-    writeFileSync(path.join(dir, 'dist', 'client', 'index.html'), '<html></html>');
-  }
-  const reportPath = path.join(dir, 'report.md');
-  const child = spawnSync(process.execPath, [SCRIPT, dir, '--no-update-manifest', '--output', reportPath], {
-    encoding: 'utf8',
-  });
-  return { status: child.status, report: readFileSync(reportPath, 'utf8') };
-}
-
-function statusLine(report: string): string {
-  const lines = report.split('\n');
-  const idx = lines.findIndex((line) => line.trim() === '## Status');
-  return lines[idx + 2]?.trim() ?? '';
-}
-
-function checkFailed(report: string, id: string): boolean {
-  return report.includes(`- [ ] `) && new RegExp(`- \\[ \\] .*\\(${id}\\)`).test(report);
-}
-
-describe('migration QA gate (write-migration-report.mjs)', () => {
-  it('fails generated-only entries even when seed JSON exists (no silent pass)', () => {
-    const { status, report } = runGate({
-      source: { mode: 'url-only', platform: 'wix' },
-      routes: [{ route: '/', status: 'verified' }],
-      contentTypes: [{ name: 'game', status: 'generated' }],
-      entries: [{ contentType: 'game', sourceCount: 11, generatedCount: 11, importedCount: 0 }],
-      media: [],
-      forms: [],
-      unresolved: [],
-    });
-    expect(status).toBe(1);
-    expect(statusLine(report)).toBe('draft-only');
-    expect(checkFailed(report, 'cms-counts')).toBe(true);
-    expect(checkFailed(report, 'schemas-pushed')).toBe(true);
-  });
-
-  it('fails referenced media that is only bundled locally under public/', () => {
-    const { status, report } = runGate({
-      source: { mode: 'url-only', platform: 'wix' },
-      routes: [{ route: '/', status: 'verified' }],
-      contentTypes: [],
-      entries: [],
-      media: [{ id: 'm1', referencedBy: ['/'], status: 'imported', targetUrl: '/assets/thepark/hero.webp' }],
-      forms: [],
-      unresolved: [],
-    });
-    expect(status).toBe(1);
-    expect(statusLine(report)).toBe('draft-only');
-    expect(checkFailed(report, 'media-covered')).toBe(true);
-    expect(report).toContain('Uploaded to Fimo: 0');
-    expect(report).toContain('Bundled locally (not uploaded): 1');
-  });
-
-  it('passes when entries are imported, schemas pushed, and media uploaded to Fimo', () => {
-    const { status, report } = runGate(
-      {
-        source: { mode: 'url-only', platform: 'wix' },
-        routes: [{ route: '/', status: 'verified' }],
-        contentTypes: [{ name: 'game', status: 'imported' }],
-        entries: [{ contentType: 'game', sourceCount: 3, generatedCount: 3, importedCount: 3, status: 'imported' }],
-        media: [
-          { id: 'm1', referencedBy: ['/'], targetAssetId: '11111111-1111-1111-1111-111111111111' },
-          {
-            id: 'm2',
-            referencedBy: ['/'],
-            targetUrl: 'https://assets.fimo.team/abc/hero.webp',
-            sourceUrl: 'https://static.wixstatic.com/hero.webp',
-          },
-        ],
-        forms: [],
-        unresolved: [],
-      },
-      { withBuildArtifact: true }
-    );
-    expect(status).toBe(0);
-    expect(statusLine(report)).toBe('complete');
-    expect(report).toContain('Uploaded to Fimo: 2');
-  });
-
-  it('rejects a target URL that merely echoes the source URL (nothing uploaded)', () => {
-    const { status, report } = runGate({
-      source: { mode: 'url-only', platform: 'wix' },
-      routes: [{ route: '/', status: 'verified' }],
-      contentTypes: [],
-      entries: [],
-      media: [
-        {
-          id: 'm1',
-          referencedBy: ['/'],
-          sourceUrl: 'https://static.wixstatic.com/hero.webp',
-          targetUrl: 'https://static.wixstatic.com/hero.webp',
-        },
-      ],
-      forms: [],
-      unresolved: [],
-    });
-    expect(status).toBe(1);
-    expect(checkFailed(report, 'media-covered')).toBe(true);
-  });
-
-  it('allows complete-with-unresolved when gaps are explicit, owner-visible unresolved items', () => {
-    const { status, report } = runGate(
-      {
-        source: { mode: 'url-only', platform: 'wix' },
-        routes: [{ route: '/', status: 'verified' }],
-        contentTypes: [{ name: 'game', status: 'unresolved' }],
-        entries: [{ contentType: 'game', sourceCount: 5, generatedCount: 5, importedCount: 0, status: 'unresolved' }],
-        media: [{ id: 'm1', referencedBy: ['/'], status: 'unresolved' }],
-        forms: [],
-        unresolved: [
-          {
-            severity: 'high',
-            area: 'cms',
-            message: 'Game entries need a source export before import.',
-            suggestedAction: 'Provide the Wix CMS export and re-run import.',
-          },
-        ],
-      },
-      { withBuildArtifact: true }
-    );
-    expect(status).toBe(0);
-    expect(statusLine(report)).toBe('complete-with-unresolved');
-  });
-});