fimo 0.7.0-experimental.1 → 0.7.0-experimental.2

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

@@ -1,144 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { syncSchemas } from './sync-schemas.js';
-let scratch;
-beforeEach(() => {
-    scratch = mkdtempSync(join(tmpdir(), 'fimo-sync-schemas-'));
-    mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
-});
-afterEach(() => {
-    rmSync(scratch, { recursive: true, force: true });
-});
-function writeSchema(name, schema) {
-    writeFileSync(join(scratch, 'src/schemas', `${name}.json`), JSON.stringify(schema, null, 2));
-}
-describe('syncSchemas', () => {
-    it('generates raw references plus typed populated helpers', () => {
-        writeSchema('Author', {
-            uid: 'Author',
-            name: 'Authors',
-            fields: {
-                name: { type: 'string' },
-            },
-        });
-        writeSchema('Post', {
-            uid: 'Post',
-            name: 'Posts',
-            fields: {
-                title: { type: 'string' },
-                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 });
-        const post = readFileSync(join(scratch, 'src/schemas/Post.ts'), 'utf-8');
-        const postTypes = readFileSync(join(scratch, 'src/schemas/Post.types.ts'), 'utf-8');
-        expect(post).toContain('import { wrapWithSource as wrapAuthorWithSource } from "./Author";');
-        expect(post).toContain('isPopulatedEntry(value) ? wrapAuthorWithSource(value) : value');
-        expect(post).toContain('function isPopulatedEntry(value: unknown): value is PopulatedEntryRecord');
-        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 WithReferences<PostReferences>');
-        expect(post).not.toContain('type FimoReference');
-        expect(post).toContain('Promise<PostResult<undefined, TPopulate>>');
-        expect(post).toContain('TPopulate extends PostPopulate | undefined');
-        expect(post).toContain('wrapAuthorWithSource(value)');
-        expect(post).toContain('wrapWithSource(value)');
-        expect(post).toContain('export async function create(payload: PostInput): Promise<Post>');
-        expect(post).toContain('export async function getById');
-        expect(post).toContain('string | { id: string; locale?: string }');
-        expect(post).toContain('typeof value === "string"');
-        expect(post).toContain('/entries/Post/');
-        expect(post).not.toContain('/v2/entries');
-        expect(post).toContain('return wrapWithSource(data.data);');
-        expect(post).toContain('mutationFn   : (payload) => create(withMutationLocale(payload, activeLocale))');
-        expect(post).toContain('mutationFn   : ({ id, ...patch }) => update(id, withMutationLocale(patch, activeLocale))');
-        expect(post).toContain('qk.byId(vars.id, { locale: vars.locale ?? activeLocale })');
-        expect(post).toContain('{ ...value, locale: value.locale ?? activeLocale }');
-        expect(postTypes).toContain('import type { Author } from "./Author.types";');
-        expect(postTypes).toContain('export interface Post extends WithReferences<PostReferences>');
-        expect(postTypes).toContain('  id: string;');
-        expect(postTypes).toContain('  entryId: string;');
-        expect(postTypes).toContain('  documentId: string;');
-        expect(postTypes).toContain('  locale: string;');
-        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 PostReferences');
-        expect(postTypes).toContain('export interface PostInput');
-        expect(postTypes).toContain('author?: FimoReference | null;');
-        expect(postTypes).toContain('author: Author | null;');
-        expect(postTypes).toContain('contributors: Author[];');
-        expect(postTypes).toContain('relatedPosts: Post[];');
-        expect(postTypes).toContain('export type PostResult<');
-        expect(postTypes).not.toContain('PostPopulated');
-    });
-    it('generates effective-locale shared types and locale-sensitive populated target keys', () => {
-        writeSchema('Homepage', {
-            uid: 'Homepage',
-            name: 'Homepages',
-            fields: { title: { type: 'string' } },
-        });
-        writeSchema('Category', {
-            uid: 'Category',
-            name: 'Categories',
-            i18n: { enabled: false },
-            fields: { name: { type: 'string' } },
-        });
-        writeSchema('Settings', {
-            uid: 'Settings',
-            name: 'Settings',
-            i18n: { enabled: false },
-            fields: {
-                homepage: { type: 'reference', target: 'Homepage' },
-                category: { type: 'reference', target: 'Category' },
-            },
-        });
-        syncSchemas({ cwd: scratch, verbose: false });
-        const settings = readFileSync(join(scratch, 'src/schemas/Settings.ts'), 'utf-8');
-        const settingsTypes = readFileSync(join(scratch, 'src/schemas/Settings.types.ts'), 'utf-8');
-        const homepageTypes = readFileSync(join(scratch, 'src/schemas/Homepage.types.ts'), 'utf-8');
-        expect(settingsTypes).toContain('locale: string;');
-        expect(settingsTypes).not.toContain('locale?: string;');
-        expect(homepageTypes).toContain('locale: string;');
-        expect(settings).toContain('const LOCALIZED_CONTENT = false;');
-        expect(settings).toContain('const LOCALIZED_REFERENCE_FIELDS = new Set<string>(["homepage"]);');
-        expect(settings).toContain('    locale,');
-        expect(settings).toContain('readLocale(params, LOCALIZED_CONTENT, useQueryLocale(params.locale))');
-        expect(settings.match(/readLocale\(params, LOCALIZED_CONTENT, useQueryLocale\(params\.locale\)\)/g)?.length).toBe(4);
-        expect(settings.match(/const locale = useQueryLocale\(options\.locale\);/g)?.length).toBe(2);
-    });
-    it('generates singleton document APIs without collection mutations', () => {
-        writeSchema('Settings', {
-            uid: 'Settings',
-            name: 'Settings',
-            isSingleton: true,
-            i18n: { enabled: false },
-            fields: { siteName: { type: 'string', required: true } },
-        });
-        syncSchemas({ cwd: scratch, verbose: false });
-        const settings = readFileSync(join(scratch, 'src/schemas/Settings.ts'), 'utf-8');
-        const settingsTypes = readFileSync(join(scratch, 'src/schemas/Settings.types.ts'), 'utf-8');
-        expect(settings).toContain('fetch(`${base}${withReadOptions(`/documents/Settings`, options)}`');
-        expect(settings).toContain('`Settings.id:${id}:${encodeURIComponent(locale)}`');
-        expect(settingsTypes).toContain('id: string;');
-        expect(settingsTypes).toContain('entryId: string;');
-        expect(settingsTypes).toContain('locale?: string;');
-        expect(settings).toContain('export async function update(payload: Partial<SettingsInput>)');
-        expect(settings).toContain('mutationFn: (payload) => update(withMutationLocale(payload, activeLocale))');
-        expect(settings).toContain('export function useSuspenseGet');
-        expect(settings).not.toContain('export async function create(');
-        expect(settings).not.toContain('export async function remove(');
-        expect(settings).not.toContain('export function useCreate(');
-        expect(settings).not.toContain('export function useList(');
-        expect(settings).not.toContain('export function useInfiniteList(');
-        expect(settings).not.toContain('useInfiniteQuery');
-        expect(settingsTypes).toContain('siteName: string;');
-        expect(settingsTypes).not.toContain('documentId?: string;');
-    });
-});

package/dist/scripts/validate-route-metadata.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/scripts/validate-route-metadata.test.js

@@ -1,116 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { validateRouteMetadata } from './validate-route-metadata';
-describe('validateRouteMetadata i18n checks', () => {
-    let scratch = null;
-    afterEach(() => {
-        if (scratch) {
-            rmSync(scratch, { recursive: true, force: true });
-            scratch = null;
-        }
-    });
-    it('accepts fimoRoutes() with canonical routes and multi-locale path prefixes', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en',
-                    locales: ['en', 'es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    home: { path: '/', label: 'Home' },
-                    pricing: { path: '/pricing', label: 'Pricing' },
-                },
-            },
-            routesSource: `import type { RouteConfig } from '@react-router/dev/routes';
-import { index, route } from '@react-router/dev/routes';
-import { fimoRoutes } from 'fimo/react-router/routes';
-
-const routes = [
-  index('./pages/Index.tsx', { id: 'home' }),
-  route('pricing', './pages/Pricing.tsx', { id: 'pricing' }),
-] satisfies RouteConfig;
-
-export default fimoRoutes(routes) satisfies RouteConfig;
-`,
-            files: ['src/pages/Index.tsx', 'src/pages/Pricing.tsx'],
-        });
-        expect(validateRouteMetadata({ cwd }).errors).toEqual([]);
-    });
-    it('rejects invalid locale config', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en--US',
-                    locales: ['es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    home: { path: '/', label: 'Home' },
-                },
-            },
-            routesSource: `import { index } from '@react-router/dev/routes';
-export default [index('./pages/Index.tsx')];
-`,
-            files: ['src/pages/Index.tsx'],
-        });
-        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
-        expect(errors).toContain('Invalid i18n.defaultLocale "en--US"');
-        expect(errors).toContain('i18n.locales must include i18n.defaultLocale');
-    });
-    it('rejects canonical routes that claim locale prefixes', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en',
-                    locales: ['en', 'es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    spanish: { path: '/es', label: 'Spanish' },
-                },
-            },
-            routesSource: `import { route } from '@react-router/dev/routes';
-export default [route('es', './pages/Spanish.tsx')];
-`,
-            files: ['src/pages/Spanish.tsx'],
-        });
-        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
-        expect(errors).toContain('uses reserved locale prefix "es"');
-    });
-    it('warns as an error when top-level dynamic routes can capture locale URLs without fimoRoutes()', () => {
-        const cwd = writeProject({
-            config: {
-                i18n: {
-                    defaultLocale: 'en',
-                    locales: ['en', 'es'],
-                    routing: { strategy: 'path-prefix' },
-                },
-                routes: {
-                    page: { path: '/:slug', label: 'Page', params: { slug: { schema: 'Page', queryField: 'slug' } } },
-                },
-            },
-            routesSource: `import { route } from '@react-router/dev/routes';
-export default [route(':slug', './pages/Page.tsx')];
-`,
-            files: ['src/pages/Page.tsx'],
-        });
-        const errors = validateRouteMetadata({ cwd }).errors.join('\n');
-        expect(errors).toContain('top-level dynamic route');
-        expect(errors).toContain('fimoRoutes(routes)');
-    });
-    function writeProject(args) {
-        scratch = mkdtempSync(join(tmpdir(), 'fimo-route-metadata-'));
-        mkdirSync(join(scratch, 'src'), { recursive: true });
-        writeFileSync(join(scratch, 'fimo-config.json'), JSON.stringify(args.config, null, 2));
-        writeFileSync(join(scratch, 'src', 'routes.ts'), args.routesSource);
-        for (const file of args.files) {
-            mkdirSync(join(scratch, file, '..'), { recursive: true });
-            writeFileSync(join(scratch, file), 'export default function Page() { return null; }\n');
-        }
-        return scratch;
-    }
-});

package/dist/scripts/validate-schemas.test.d.ts

@@ -1 +0,0 @@
-export {};

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

@@ -1,263 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { validateSchemas } from './validate-schemas';
-describe('validateSchemas', () => {
-    let scratch = null;
-    afterEach(() => {
-        if (scratch) {
-            rmSync(scratch, { recursive: true, force: true });
-            scratch = null;
-        }
-    });
-    function writeProject(schemas) {
-        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
-        mkdirSync(join(scratch, 'src/schemas'), { recursive: true });
-        for (const [fileName, schema] of Object.entries(schemas)) {
-            writeFileSync(join(scratch, 'src/schemas', fileName), typeof schema === 'string' ? schema : JSON.stringify(schema, null, 2));
-        }
-        return scratch;
-    }
-    it('accepts a valid schema', () => {
-        const cwd = writeProject({
-            'Author.json': {
-                uid: 'Author',
-                name: 'Authors',
-                fields: {
-                    name: { type: 'string' },
-                },
-            },
-            'BlogPost.json': {
-                uid: 'BlogPost',
-                name: 'Blog Posts',
-                fields: {
-                    title: { type: 'string' },
-                    body: { type: 'richtext' },
-                    coverImage: { type: 'media' },
-                    featured: { type: 'boolean' },
-                    author: { type: 'reference', target: 'Author' },
-                },
-            },
-        });
-        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 2 });
-    });
-    it('accepts self-referential reference fields', () => {
-        const cwd = writeProject({
-            'Item.json': {
-                uid: 'Item',
-                name: 'Items',
-                fields: {
-                    title: { type: 'string' },
-                    parent: { type: 'reference', target: 'Item' },
-                },
-            },
-        });
-        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
-    });
-    it('accepts a non-localized schema policy', () => {
-        const cwd = writeProject({
-            'Author.json': {
-                uid: 'Author',
-                name: 'Authors',
-                i18n: { enabled: false },
-                fields: { name: { type: 'string' } },
-            },
-        });
-        expect(validateSchemas({ cwd })).toEqual({ errors: [], schemasChecked: 1 });
-    });
-    it('rejects a non-boolean singleton policy', () => {
-        const cwd = writeProject({
-            'Settings.json': {
-                uid: 'Settings',
-                name: 'Settings',
-                isSingleton: 'yes',
-                fields: {},
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toEqual([expect.objectContaining({ rule: 'schemas/singleton' })]);
-    });
-    it.each([true, { enabled: 'no' }, { enabled: false, fallback: 'en' }, { fallback: 'en' }])('rejects an invalid schema-level i18n policy %#', (i18n) => {
-        const cwd = writeProject({
-            'Author.json': {
-                uid: 'Author',
-                name: 'Authors',
-                i18n,
-                fields: { name: { type: 'string' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/i18n' });
-    });
-    it('returns no errors when the schemas directory does not exist', () => {
-        scratch = mkdtempSync(join(tmpdir(), 'validate-schemas-'));
-        expect(validateSchemas({ cwd: scratch })).toEqual({ errors: [], schemasChecked: 0 });
-    });
-    it('rejects reserved field names like slug', () => {
-        const cwd = writeProject({
-            'TeamMember.json': {
-                uid: 'TeamMember',
-                name: 'Team Members',
-                fields: {
-                    name: { type: 'string' },
-                    slug: { type: 'string' },
-                },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/reserved-field', file: 'src/schemas/TeamMember.json' });
-        expect(errors[0].message).toContain('"slug" is reserved');
-        expect(errors[0].message).toContain('entry data');
-    });
-    it('rejects every reserved metadata name', () => {
-        const cwd = writeProject({
-            'Bad.json': {
-                uid: 'Bad',
-                name: 'Bad',
-                fields: Object.fromEntries(['id', 'entryId', 'documentId', 'slug', 'locale', 'createdAt', 'updatedAt', '__fimo'].map((name) => [
-                    name,
-                    { type: 'string' },
-                ])),
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(8);
-        expect(errors.every((err) => err.rule === 'schemas/reserved-field')).toBe(true);
-    });
-    it('rejects unsupported field types', () => {
-        const cwd = writeProject({
-            'Product.json': {
-                uid: 'Product',
-                name: 'Products',
-                fields: { price: { type: 'decimal' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/field-type' });
-        expect(errors[0].message).toContain('"decimal"');
-        expect(errors[0].message).toContain('string, richtext, media');
-    });
-    it('rejects reference fields without a valid target', () => {
-        const cwd = writeProject({
-            'Post.json': {
-                uid: 'Post',
-                name: 'Posts',
-                fields: { author: { type: 'reference' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-target' });
-    });
-    it('rejects reference fields targeting a missing local schema', () => {
-        const cwd = writeProject({
-            'Post.json': {
-                uid: 'Post',
-                name: 'Posts',
-                fields: { author: { type: 'reference', target: 'Author' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-target' });
-        expect(errors[0].message).toContain('unknown schema "Author"');
-    });
-    it('rejects reference-only properties on scalar fields', () => {
-        const cwd = writeProject({
-            'Post.json': {
-                uid: 'Post',
-                name: 'Posts',
-                fields: { author: { type: 'string', target: 'Author' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/reference-shape' });
-    });
-    it('rejects schema uid names that cannot be used as content type identifiers', () => {
-        const cwd = writeProject({
-            'blog-post.json': {
-                uid: 'blog-post',
-                name: 'Blog Posts',
-                fields: { title: { type: 'string' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/type-name' });
-    });
-    it('rejects field names that cannot be used in generated source paths', () => {
-        const cwd = writeProject({
-            'Page.json': {
-                uid: 'Page',
-                name: 'Pages',
-                fields: { 'hero-title': { type: 'string' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/field-name' });
-    });
-    it('rejects field-level i18n settings', () => {
-        const cwd = writeProject({
-            'Page.json': {
-                uid: 'Page',
-                name: 'Pages',
-                fields: { title: { type: 'string', i18n: true } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
-    });
-    it('rejects reference-level locale settings', () => {
-        const cwd = writeProject({
-            'Page.json': {
-                uid: 'Page',
-                name: 'Pages',
-                fields: { parent: { type: 'reference', target: 'Page', localized: true } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/field-i18n' });
-        expect(errors[0].message).toContain('"localized"');
-    });
-    it('rejects a uid that does not match the file name', () => {
-        const cwd = writeProject({
-            'TeamMember.json': {
-                uid: 'Member',
-                name: 'Team Members',
-                fields: { name: { type: 'string' } },
-            },
-        });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/uid' });
-    });
-    it('rejects missing uid, name, and fields', () => {
-        const cwd = writeProject({ 'Empty.json': {} });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors.map((err) => err.rule)).toEqual(['schemas/uid', 'schemas/name', 'schemas/fields']);
-    });
-    it('reports invalid JSON', () => {
-        const cwd = writeProject({ 'Broken.json': '{ not json' });
-        const { errors } = validateSchemas({ cwd });
-        expect(errors).toHaveLength(1);
-        expect(errors[0]).toMatchObject({ rule: 'schemas/parse' });
-    });
-    it('validates multiple files and counts them', () => {
-        const cwd = writeProject({
-            'Good.json': { uid: 'Good', name: 'Good', fields: { title: { type: 'string' } } },
-            'Bad.json': { uid: 'Bad', name: 'Bad', fields: { slug: { type: 'string' } } },
-        });
-        const result = validateSchemas({ cwd });
-        expect(result.schemasChecked).toBe(2);
-        expect(result.errors).toHaveLength(1);
-        expect(result.errors[0].file).toBe('src/schemas/Bad.json');
-    });
-});

package/scripts/add-ext.mjs

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-// Rewrite relative imports to add `.js` extensions (required by Node ESM).
-// Idempotent. Preserves all other code.
-import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
-import { extname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = resolve(fileURLToPath(import.meta.url), '..');
-const ROOTS = process.argv.slice(2).map((p) => resolve(p));
-
-const IMPORT_RE = /(from\s+|import\s*\(\s*)(['"])(\.\.?\/[^'"\s]+?)\2/g;
-
-function walk(dir, out) {
-  for (const name of readdirSync(dir)) {
-    if (['node_modules', 'dist', '.git'].includes(name)) continue;
-    const p = `${dir}/${name}`;
-    const st = statSync(p);
-    if (st.isDirectory()) walk(p, out);
-    else if (/\.(ts|tsx|mts|mjs)$/.test(name) && !name.endsWith('.d.ts')) out.push(p);
-  }
-}
-
-function rewriteOne(filePath) {
-  const src = readFileSync(filePath, 'utf-8');
-  const dir = filePath.split('/').slice(0, -1).join('/');
-  let mutated = false;
-  const out = src.replace(IMPORT_RE, (match, lead, quote, spec) => {
-    const ext = extname(spec);
-    if (ext) return match;
-    const candidate = resolve(dir, spec);
-    if (existsSync(candidate) && statSync(candidate).isDirectory()) {
-      mutated = true;
-      return `${lead}${quote}${spec}/index.js${quote}`;
-    }
-    mutated = true;
-    return `${lead}${quote}${spec}.js${quote}`;
-  });
-  if (mutated) {
-    writeFileSync(filePath, out);
-    console.log(`updated ${filePath.slice(HERE.length - 7)}`);
-  }
-}
-
-const files = [];
-for (const r of ROOTS) walk(r, files);
-for (const f of files) rewriteOne(f);
-console.log(`[add-ext] processed ${files.length} files`);

package/scripts/bump-version.mjs

@@ -1,58 +0,0 @@
-#!/usr/bin/env node
-// Bumps the Fimo CLI version in apps/cli/package.json — NO git tag, NO commit.
-//
-// Under the branch-driven release model the version lives in
-// apps/cli/package.json and you bump it in a PR. CI creates the
-// `cli@<version>` git tag when it publishes `@latest` on a `production`
-// merge, so this script must NOT create a tag — that would collide with
-// CI's tag-guard (the publish would skip, thinking the version already
-// shipped).
-//
-// Usage:
-//   pnpm -F fimo release:bump patch
-//   pnpm -F fimo release:bump minor
-//   pnpm -F fimo release:bump major
-//   pnpm -F fimo release:bump 1.2.3            # explicit version
-//
-// After bumping, commit the change in your PR. Merging it through to
-// `production` is what publishes `@latest` and creates the tag.
-
-import { spawnSync } from 'node:child_process';
-import { dirname, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-const CLI_ROOT = resolve(HERE, '..');
-
-const VALID_INCREMENTS = new Set(['major', 'minor', 'patch', 'premajor', 'preminor', 'prepatch', 'prerelease']);
-
-const args = process.argv.slice(2);
-if (args.length === 0) {
-  console.error(
-    '[cli/bump] usage: pnpm -F fimo release:bump <patch|minor|major|premajor|preminor|prepatch|prerelease|X.Y.Z> [--preid <id>]'
-  );
-  process.exit(1);
-}
-
-const increment = args[0];
-const isExplicitVersion = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/.test(increment);
-if (!VALID_INCREMENTS.has(increment) && !isExplicitVersion) {
-  console.error(
-    `[cli/bump] invalid increment "${increment}". expected one of ${[...VALID_INCREMENTS].join('|')} or an explicit X.Y.Z.`
-  );
-  process.exit(1);
-}
-
-// Bump package.json ONLY — `--no-git-tag-version` skips both the commit and
-// the tag. CI owns the `cli@<version>` tag (created on the @latest publish).
-// Use pnpm (not npm) — npm chokes on the `workspace:*` devDeps.
-const versionArgs = ['version', '--no-git-tag-version', ...args];
-console.log(`[cli/bump] $ pnpm ${versionArgs.join(' ')}`);
-const result = spawnSync('pnpm', versionArgs, { cwd: CLI_ROOT, stdio: 'inherit' });
-if (result.status !== 0) {
-  console.error(`[cli/bump] pnpm version failed (exit ${result.status}).`);
-  process.exit(result.status ?? 1);
-}
-
-console.log('[cli/bump] bumped apps/cli/package.json (no tag, no commit).');
-console.log('[cli/bump] commit it in your PR — merging to `production` publishes @latest + tags it.');