fimo 0.4.0-experimental.4 → 0.4.0-staging.1

package/dist/scripts/generated-types.test.js

@@ -0,0 +1,172 @@
+import { execFileSync } from 'node:child_process';
+import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { afterAll, describe, expect, it } from 'vitest';
+import { syncSchemas } from './sync-schemas.js';
+/**
+ * The generated-types gate: generate hooks + types from fixture schemas that
+ * cover every field type and reference shape, add usage code written the way
+ * an agent writes site code, and run the real TypeScript compiler over the
+ * output. A template regression fails this test — never a user project.
+ */
+const here = dirname(fileURLToPath(import.meta.url));
+const requireFromHere = createRequire(import.meta.url);
+const runtimeBarrel = resolve(here, '../runtime/index.ts');
+const tscBin = requireFromHere.resolve('typescript/bin/tsc');
+const fixtureRoot = mkdtempSync(join(tmpdir(), 'fimo-generated-types-'));
+const schemasDir = join(fixtureRoot, 'src', 'schemas');
+const SCHEMAS = {
+    Author: {
+        uid: 'Author',
+        name: 'Author',
+        i18n: { enabled: true },
+        fields: {
+            name: { type: 'string', required: true },
+            bio: { type: 'richtext' },
+            avatar: { type: 'media' },
+            active: { type: 'boolean' },
+            bornAt: { type: 'date' },
+            meta: { type: 'json' },
+            rating: { type: 'number' },
+        },
+    },
+    Video: {
+        uid: 'Video',
+        name: 'Video',
+        i18n: { enabled: false },
+        fields: {
+            title: { type: 'string', required: true },
+            clips: { type: 'media', multiple: true },
+        },
+    },
+    Post: {
+        uid: 'Post',
+        name: 'Post',
+        i18n: { enabled: true },
+        fields: {
+            title: { type: 'string', required: true },
+            author: { type: 'reference', target: 'Author' },
+            contributors: { type: 'reference', target: 'Author', many: true },
+            related: { type: 'reference', target: 'Post', many: true },
+        },
+    },
+    Page: {
+        uid: 'Page',
+        name: 'Page',
+        i18n: { enabled: true },
+        fields: {
+            title: { type: 'string' },
+            featured: { type: 'reference', targets: ['Post', 'Video'], many: true },
+            hero: { type: 'reference', targets: ['Author', 'Video'] },
+        },
+    },
+    SiteSettings: {
+        uid: 'SiteSettings',
+        name: 'SiteSettings',
+        isSingleton: true,
+        i18n: { enabled: false },
+        fields: {
+            siteName: { type: 'string', required: true },
+        },
+    },
+};
+const USAGE = `// Agent-style usage of the generated types — compile-time contract.
+import type { PageResult, PageWhere } from "./Page";
+import type { PostResult } from "./Post";
+
+export function renderFeatured(page: PageResult<undefined, readonly ["featured", "hero"]>): string[] {
+  const out: string[] = [];
+  for (const item of page.featured) {
+    switch (item.$type) {
+      case "Post":
+        out.push(\`post \${String(item.title)} by \${item.author?.documentId ?? "nobody"}\`);
+        break;
+      case "Video":
+        out.push(\`video \${String(item.title)} with \${item.clips.length} clip(s)\`);
+        break;
+      default: {
+        const exhaustive: never = item;
+        return exhaustive;
+      }
+    }
+  }
+  const hero = page.hero;
+  if (hero && hero.$type === "Author") {
+    out.push(\`hero \${String(hero.name)}\`);
+  }
+  return out;
+}
+
+export function renderPost(post: PostResult<undefined, readonly ["author", "contributors"]>): string {
+  const contributors = post.contributors.map((author) => String(author.name)).join(", ");
+  return \`\${String(post.title)} — \${post.author ? String(post.author.name) : "anonymous"} (\${contributors})\`;
+}
+
+export function whereContract(): PageWhere {
+  return {
+    title: "Home",
+    // @ts-expect-error filtering on polymorphic reference fields is not supported
+    featured: "some-document-id",
+  };
+}
+`;
+const SHIMS = `declare module "virtual:fimo-config" {
+  const config: Record<string, unknown>;
+  export default config;
+}
+declare module "virtual:translations" {
+  export const dictionaries: Record<string, Record<string, string>>;
+  export const defaultLocale: string;
+  export const signature: string;
+  export const updatedAt: string;
+}
+declare module "*.css" {}
+`;
+afterAll(() => {
+    rmSync(fixtureRoot, { recursive: true, force: true });
+});
+describe('generated types gate', () => {
+    it('generates hooks + types for every field shape and the output typechecks with agent-style usage', () => {
+        mkdirSync(schemasDir, { recursive: true });
+        // Real react-query types: the fixture resolves them like a real project.
+        const reactQueryDir = dirname(requireFromHere.resolve('@tanstack/react-query/package.json'));
+        mkdirSync(join(fixtureRoot, 'node_modules', '@tanstack'), { recursive: true });
+        symlinkSync(reactQueryDir, join(fixtureRoot, 'node_modules', '@tanstack', 'react-query'));
+        for (const [uid, schema] of Object.entries(SCHEMAS)) {
+            writeFileSync(join(schemasDir, `${uid}.json`), JSON.stringify(schema, null, 2));
+        }
+        const result = syncSchemas({ cwd: fixtureRoot, verbose: false });
+        expect(result.created).toBeGreaterThanOrEqual(Object.keys(SCHEMAS).length * 2);
+        writeFileSync(join(schemasDir, 'usage.ts'), USAGE);
+        writeFileSync(join(fixtureRoot, 'shims.d.ts'), SHIMS);
+        writeFileSync(join(fixtureRoot, 'tsconfig.json'), JSON.stringify({
+            compilerOptions: {
+                strict: true,
+                noEmit: true,
+                skipLibCheck: true,
+                target: 'ES2022',
+                module: 'ESNext',
+                moduleResolution: 'bundler',
+                jsx: 'react-jsx',
+                allowImportingTsExtensions: true,
+                baseUrl: '.',
+                paths: {
+                    'fimo/ui': [runtimeBarrel],
+                },
+            },
+            include: ['src/**/*.ts', 'shims.d.ts'],
+        }, null, 2));
+        let output = '';
+        try {
+            output = execFileSync(process.execPath, [tscBin, '-p', fixtureRoot], { encoding: 'utf8' });
+        }
+        catch (error) {
+            const failure = error;
+            throw new Error(`generated types failed to typecheck:\n${failure.stdout ?? ''}${failure.stderr ?? ''}`);
+        }
+        expect(output.trim()).toBe('');
+    }, 120_000);
+});

package/dist/scripts/sync-schemas.js

@@ -35,6 +35,9 @@ function normalizeFields(fields) {
         }
         const field = value;
         const target = typeof field.target === 'string' ? field.target : undefined;
+        const targets = Array.isArray(field.targets)
+            ? field.targets.filter((candidate) => typeof candidate === 'string')
+            : undefined;
         return [
             key,
             {
@@ -42,19 +45,29 @@ function normalizeFields(fields) {
                 type: typeof field.type === 'string' ? field.type : undefined,
                 target,
                 targetPascal: target ? pascalCase(target) : undefined,
+                targets: targets && targets.length > 0 ? targets : undefined,
+                targetRefs: targets && targets.length > 0
+                    ? targets.map((candidate) => ({ uid: candidate, pascal: pascalCase(candidate) }))
+                    : undefined,
                 many: typeof field.many === 'boolean' ? field.many : undefined,
                 multiple: typeof field.multiple === 'boolean' ? field.multiple : undefined,
             },
         ];
     }));
 }
-function relationImportsFor(schema, fields) {
+function referenceImportsFor(schema, fields) {
     const imports = new Map();
     for (const field of Object.values(fields)) {
-        if (field.type !== 'relation' || !field.target || field.target === schema.uid) {
+        if (field.type !== 'reference') {
             continue;
         }
-        imports.set(field.target, { uid: field.target, pascal: pascalCase(field.target) });
+        const targets = field.targets ?? (field.target ? [field.target] : []);
+        for (const target of targets) {
+            if (target === schema.uid) {
+                continue;
+            }
+            imports.set(target, { uid: target, pascal: pascalCase(target) });
+        }
     }
     return [...imports.values()].sort((a, b) => a.pascal.localeCompare(b.pascal));
 }
@@ -65,11 +78,17 @@ function schemaToModel(schema, localizedByUid) {
         pascal: pascalCase(schema.uid),
         isSingleton: schema.isSingleton ?? false,
         localized: schema.i18n?.enabled !== false,
-        localizedRelationFields: Object.entries(fields)
-            .filter(([, field]) => field.type === 'relation' && field.target && localizedByUid.get(field.target) !== false)
+        localizedReferenceFields: Object.entries(fields)
+            .filter(([, field]) => {
+            if (field.type !== 'reference') {
+                return false;
+            }
+            const targets = field.targets ?? (field.target ? [field.target] : []);
+            return targets.some((target) => localizedByUid.get(target) !== false);
+        })
             .map(([fieldName]) => fieldName),
         fields,
-        relationImports: relationImportsFor(schema, fields),
+        referenceImports: referenceImportsFor(schema, fields),
     };
 }
 export function syncSchemas(options = {}) {

package/dist/scripts/sync-schemas.test.js

@@ -15,7 +15,7 @@ function writeSchema(name, schema) {
     writeFileSync(join(scratch, 'src/schemas', `${name}.json`), JSON.stringify(schema, null, 2));
 }
 describe('syncSchemas', () => {
-    it('generates raw relation references plus typed populated relation helpers', () => {
+    it('generates raw references plus typed populated helpers', () => {
         writeSchema('Author', {
             uid: 'Author',
             name: 'Authors',
@@ -28,9 +28,9 @@ describe('syncSchemas', () => {
             name: 'Posts',
             fields: {
                 title: { type: 'string' },
-                author: { type: 'relation', target: 'Author' },
-                contributors: { type: 'relation', target: 'Author', many: true },
-                relatedPosts: { type: 'relation', target: 'Post', many: true },
+                author: { type: 'reference', target: 'Author' },
+                contributors: { type: 'reference', target: 'Author', many: true },
+                relatedPosts: { type: 'reference', target: 'Post', many: true },
             },
         });
         expect(syncSchemas({ cwd: scratch, verbose: false })).toEqual({ created: 4, updated: 0, deleted: 0 });
@@ -40,7 +40,7 @@ describe('syncSchemas', () => {
         expect(post).toContain('import type { Post, PostInput, PostPopulate, PostResult, PostFields, PostQuery } from "./Post.types";');
         expect(post).toContain('from "./Post.types";');
         expect(post).not.toContain('import type { Author } from "./Author";');
-        expect(post).not.toContain('export interface Post extends WithRelations<PostRelations>');
+        expect(post).not.toContain('export interface Post extends WithReferences<PostReferences>');
         expect(post).not.toContain('type FimoReference');
         expect(post).toContain('Promise<PostResult<undefined, TPopulate>>');
         expect(post).toContain('TPopulate extends PostPopulate | undefined');
@@ -49,12 +49,12 @@ describe('syncSchemas', () => {
         expect(post).toContain('export async function create(payload: PostInput): Promise<Post>');
         expect(post).toContain('return wrapWithSource(data.data);');
         expect(postTypes).toContain('import type { Author } from "./Author.types";');
-        expect(postTypes).toContain('export interface Post extends WithRelations<PostRelations>');
+        expect(postTypes).toContain('export interface Post extends WithReferences<PostReferences>');
         expect(postTypes).toContain('type FimoReference');
         expect(postTypes).toContain('author: FimoReference | null;');
         expect(postTypes).toContain('contributors: FimoReference[];');
         expect(postTypes).toContain('relatedPosts: FimoReference[];');
-        expect(postTypes).toContain('export interface PostRelations');
+        expect(postTypes).toContain('export interface PostReferences');
         expect(postTypes).toContain('export interface PostInput');
         expect(postTypes).toContain('author?: FimoReference | null;');
         expect(postTypes).toContain('author: Author | null;');
@@ -80,8 +80,8 @@ describe('syncSchemas', () => {
             name: 'Settings',
             i18n: { enabled: false },
             fields: {
-                homepage: { type: 'relation', target: 'Homepage' },
-                category: { type: 'relation', target: 'Category' },
+                homepage: { type: 'reference', target: 'Homepage' },
+                category: { type: 'reference', target: 'Category' },
             },
         });
         syncSchemas({ cwd: scratch, verbose: false });
@@ -92,7 +92,7 @@ describe('syncSchemas', () => {
         expect(settingsTypes).not.toContain('locale?: string;');
         expect(homepageTypes).toContain('locale: string;');
         expect(settings).toContain('const LOCALIZED_CONTENT = false;');
-        expect(settings).toContain('const LOCALIZED_RELATION_FIELDS = new Set<string>(["homepage"]);');
+        expect(settings).toContain('const LOCALIZED_REFERENCE_FIELDS = new Set<string>(["homepage"]);');
         expect(settings).not.toContain('    locale: entry.locale,');
         expect(settings).toContain('readLocale(params, LOCALIZED_CONTENT, useQueryLocale(params.locale))');
         expect(settings.match(/readLocale\(params, LOCALIZED_CONTENT, useQueryLocale\(params\.locale\)\)/g)?.length).toBe(2);

package/dist/scripts/validate-schemas.js

@@ -169,36 +169,71 @@ export function validateSchemaFile(absolutePath, file, schemaUids = new Set()) {
                 file,
             });
         }
-        if (type === 'relation') {
-            const { target, many } = definition;
-            if (typeof target !== 'string' || !CONTENT_TYPE_NAME_PATTERN.test(target)) {
+        if (type === 'reference') {
+            const { target, targets, many } = definition;
+            if (targets !== undefined && target !== undefined) {
                 errors.push({
-                    rule: 'schemas/relation-target',
-                    message: `Relation field "${fieldName}" must declare a valid "target" content type.`,
+                    rule: 'schemas/reference-target',
+                    message: `Reference field "${fieldName}" declares both "target" and "targets" — a field is fixed or polymorphic, never both.`,
+                    file,
+                });
+            }
+            else if (targets !== undefined) {
+                const targetList = Array.isArray(targets) ? targets : null;
+                if (!targetList || targetList.length === 0 || new Set(targetList).size !== targetList.length) {
+                    errors.push({
+                        rule: 'schemas/reference-target',
+                        message: `Reference field "${fieldName}" must declare "targets" as a non-empty array of unique content types.`,
+                        file,
+                    });
+                }
+                else {
+                    for (const candidate of targetList) {
+                        if (typeof candidate !== 'string' || !CONTENT_TYPE_NAME_PATTERN.test(candidate)) {
+                            errors.push({
+                                rule: 'schemas/reference-target',
+                                message: `Reference field "${fieldName}" has an invalid entry in "targets".`,
+                                file,
+                            });
+                        }
+                        else if (schemaUids.size > 0 && !schemaUids.has(candidate)) {
+                            errors.push({
+                                rule: 'schemas/reference-target',
+                                message: `Reference field "${fieldName}" targets unknown schema "${candidate}".`,
+                                file,
+                            });
+                        }
+                    }
+                }
+            }
+            else if (typeof target !== 'string' || !CONTENT_TYPE_NAME_PATTERN.test(target)) {
+                errors.push({
+                    rule: 'schemas/reference-target',
+                    message: `Reference field "${fieldName}" must declare a valid "target" content type (or "targets" for a polymorphic field).`,
                     file,
                 });
             }
             else if (schemaUids.size > 0 && !schemaUids.has(target)) {
                 errors.push({
-                    rule: 'schemas/relation-target',
-                    message: `Relation field "${fieldName}" targets unknown schema "${target}".`,
+                    rule: 'schemas/reference-target',
+                    message: `Reference field "${fieldName}" targets unknown schema "${target}".`,
                     file,
                 });
             }
             if (many !== undefined && typeof many !== 'boolean') {
                 errors.push({
-                    rule: 'schemas/relation-many',
-                    message: `Relation field "${fieldName}" must use a boolean "many" value.`,
+                    rule: 'schemas/reference-many',
+                    message: `Reference field "${fieldName}" must use a boolean "many" value.`,
                     file,
                 });
             }
         }
         else {
-            for (const relationOnlyKey of ['target', 'many']) {
-                if (relationOnlyKey in definition) {
+            for (const referenceOnlyKey of ['target', 'targets', 'many']) {
+                if (referenceOnlyKey in definition) {
                     errors.push({
-                        rule: 'schemas/relation-shape',
-                        message: `Field "${fieldName}": "${relationOnlyKey}" is only supported on relation fields.`,
+                        rule: 'schemas/reference-shape',
+                        message: `Field "${fieldName}": "${referenceOnlyKey}" is only supported on reference fields.`,
                         file,
                     });
                 }

package/dist/scripts/validate-schemas.test.js

@@ -36,20 +36,20 @@ describe('validateSchemas', () => {
                     body: { type: 'richtext' },
                     coverImage: { type: 'media' },
                     featured: { type: 'boolean' },
-                    author: { type: 'relation', target: 'Author' },
+                    author: { type: 'reference', target: 'Author' },
                 },
             },
         });
         expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 2 });
     });
-    it('accepts self-referential relation fields', () => {
+    it('accepts self-referential reference fields', () => {
         const cwd = writeProject({
             'Item.json': {
                 uid: 'Item',
                 name: 'Items',
                 fields: {
                     title: { type: 'string' },
-                    parent: { type: 'relation', target: 'Item' },
+                    parent: { type: 'reference', target: 'Item' },
                 },
             },
         });
@@ -141,32 +141,32 @@ describe('validateSchemas', () => {
         expect(errors[0].message).toContain('"decimal"');
         expect(errors[0].message).toContain('string, richtext, media');
     });
-    it('rejects relation fields without a valid target', () => {
+    it('rejects reference fields without a valid target', () => {
         const cwd = writeProject({
             'Post.json': {
                 uid: 'Post',
                 name: 'Posts',
-                fields: { author: { type: 'relation' } },
+                fields: { author: { type: 'reference' } },
             },
         });
         const { errors } = validateSchemas({ cwd });
         expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/relation-target' });
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-target' });
     });
-    it('rejects relation fields targeting a missing local schema', () => {
+    it('rejects reference fields targeting a missing local schema', () => {
         const cwd = writeProject({
             'Post.json': {
                 uid: 'Post',
                 name: 'Posts',
-                fields: { author: { type: 'relation', target: 'Author' } },
+                fields: { author: { type: 'reference', target: 'Author' } },
             },
         });
         const { errors } = validateSchemas({ cwd });
         expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/relation-target' });
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-target' });
         expect(errors[0].message).toContain('unknown schema "Author"');
     });
-    it('rejects relation-only properties on scalar fields', () => {
+    it('rejects reference-only properties on scalar fields', () => {
         const cwd = writeProject({
             'Post.json': {
                 uid: 'Post',
@@ -176,7 +176,7 @@ describe('validateSchemas', () => {
         });
         const { errors } = validateSchemas({ cwd });
         expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/relation-shape' });
+        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-shape' });
     });
     it('rejects schema uid names that cannot be used as content type identifiers', () => {
         const cwd = writeProject({
@@ -214,12 +214,12 @@ describe('validateSchemas', () => {
         expect(errors).toHaveLength(1);
         expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
     });
-    it('rejects relation-level locale settings', () => {
+    it('rejects reference-level locale settings', () => {
         const cwd = writeProject({
             'Page.json': {
                 uid: 'Page',
                 name: 'Pages',
-                fields: { parent: { type: 'relation', target: 'Page', localized: true } },
+                fields: { parent: { type: 'reference', target: 'Page', localized: true } },
             },
         });
         const { errors } = validateSchemas({ cwd });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.4.0-experimental.4",
+  "version": "0.4.0-staging.1",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"

package/scripts/lib/release-core.mjs

@@ -100,6 +100,30 @@ export function stripTemplateLockfile(cliRoot) {
   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

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

@@ -4,8 +4,13 @@ import { join } from 'node:path';
 
 import { afterEach, describe, expect, it } from 'vitest';
 
-// @ts-expect-error plain mjs module without types
-import { computePublishVersion, nextPrereleaseCounter, nextVersionFromChangesets } from './release-core.mjs';
+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' };
@@ -34,6 +39,36 @@ describe('computePublishVersion', () => {
   });
 });
 
+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);

package/scripts/publish-npm.mjs

@@ -36,6 +36,7 @@ import { writeDevReleaseState } from './lib/dev-release-state.mjs';
 import {
   computePublishVersion,
   nextVersionFromChangesets,
+  parsePublishedVersions,
   pinTemplateFimo,
   stripTemplateLockfile,
   writeReleaseJson,
@@ -72,20 +73,14 @@ function run(cmd, args, cwd) {
 }
 
 // All published versions of the package, or null when the registry can't be
-// reached (offline, first-ever publish) — callers fall back to the
-// run-number/timestamp counter.
+// reached (offline, first-ever publish) or the output shape is unrecognized —
+// callers fall back to the run-number/timestamp counter.
 function fetchPublishedVersions(name) {
   const result = spawnSync('npm', ['view', name, 'versions', '--json'], { encoding: 'utf8' });
   if (result.status !== 0) {
     return null;
   }
-  try {
-    const parsed = JSON.parse(result.stdout);
-    // npm view returns a bare string when exactly one version is published.
-    return Array.isArray(parsed) ? parsed : [parsed];
-  } catch {
-    return null;
-  }
+  return parsePublishedVersions(result.stdout);
 }
 
 const { channel: channelName, dryRun, bootstrap, plan } = parseArgs(process.argv.slice(2));

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.4.0-experimental.4",
+    "fimo": "0.4.0-staging.1",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",