fimo 0.7.0-experimental.2 → 0.7.0-experimental.4

package/dist/scripts/frameworks/vite/routes.js

@@ -0,0 +1,93 @@
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+const titleCase = (seg) => seg
+    .replace(/[_\-]+/g, ' ')
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/\s+/)
+    .filter(Boolean)
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
+    .join(' ');
+const ROUTE_SOURCE = /\.(tsx|jsx|ts|js)$/;
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', '.git']);
+/**
+ * Route discovery for Vite React SPAs: there is no file convention, so the
+ * routes live in react-router code. v1 reads LITERAL, ABSOLUTE paths from the
+ * two mainstream declaration shapes —
+ *
+ *   <Route path="/pricing" element={…} />          (JSX tree)
+ *   createBrowserRouter([{ path: '/pricing', … }])  (object form)
+ *
+ * — in files that import react-router. Relative child paths and index routes
+ * need the router's nesting semantics to resolve; they (and `*` wildcards)
+ * stay out of v1: the fimo-config route registry accepts manual entries for
+ * anything the scan cannot see, and scanned routes only ever ADD to it.
+ */
+export function discoverReactRouterDomRoutes(rootDir) {
+    const srcDir = join(rootDir, 'src');
+    const files = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (SKIP_DIRS.has(entry)) {
+                continue;
+            }
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                walk(full);
+            }
+            else if (ROUTE_SOURCE.test(entry)) {
+                files.push(full);
+            }
+        }
+    };
+    walk(srcDir);
+    const routes = new Map();
+    for (const file of files) {
+        let code;
+        try {
+            code = readFileSync(file, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (!/from\s+['"]react-router(?:-dom)?['"]/.test(code)) {
+            continue;
+        }
+        const paths = [
+            ...[...code.matchAll(/<Route\b[^>]*\bpath\s*=\s*(?:"([^"]+)"|'([^']+)'|\{\s*(?:"([^"]+)"|'([^']+)')\s*\})/g)],
+            ...[...code.matchAll(/\bpath\s*:\s*(?:"([^"]+)"|'([^']+)')/g)],
+        ]
+            .map((match) => match.slice(1).find(Boolean))
+            .filter((path) => typeof path === 'string');
+        for (const raw of paths) {
+            if (!raw.startsWith('/') || raw.includes('*')) {
+                continue;
+            }
+            const path = raw !== '/' && raw.endsWith('/') ? raw.slice(0, -1) : raw;
+            if (routes.has(path)) {
+                continue;
+            }
+            const parts = path.split('/').filter(Boolean);
+            const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
+            routes.set(path, {
+                id: path === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
+                path,
+                label: path === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? path),
+            });
+        }
+    }
+    return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
+}

package/dist/scripts/frameworks/vite/routes.test.d.ts

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

package/dist/scripts/frameworks/vite/routes.test.js

@@ -0,0 +1,73 @@
+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 { discoverReactRouterDomRoutes } from './routes.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'vite-routes-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+};
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('discoverReactRouterDomRoutes', () => {
+    it('reads literal absolute paths from JSX Route trees', () => {
+        const root = project({
+            'src/App.tsx': `import { BrowserRouter, Route, Routes } from 'react-router-dom';
+export function App() {
+  return (
+    <BrowserRouter>
+      <Routes>
+        <Route path="/" element={<Home />} />
+        <Route path="/about" element={<About />} />
+        <Route path="/features/pricing" element={<Pricing />} />
+        <Route path={'/contact'} element={<Contact />} />
+      </Routes>
+    </BrowserRouter>
+  );
+}
+`,
+        });
+        const routes = discoverReactRouterDomRoutes(root);
+        expect(routes.map((route) => route.path)).toEqual(['/', '/about', '/contact', '/features/pricing']);
+        expect(routes[0]).toEqual({ id: 'home', path: '/', label: 'Home' });
+        expect(routes.find((route) => route.path === '/features/pricing')).toEqual({
+            id: 'features-pricing',
+            path: '/features/pricing',
+            label: 'Pricing',
+        });
+    });
+    it('reads object-form routers and keeps :params, skipping wildcards and relative paths', () => {
+        const root = project({
+            'src/router.ts': `import { createBrowserRouter } from 'react-router-dom';
+export const router = createBrowserRouter([
+  { path: '/', element: null },
+  { path: '/posts/:slug', element: null },
+  { path: '*', element: null },
+  { path: 'relative-child', element: null },
+]);
+`,
+        });
+        const routes = discoverReactRouterDomRoutes(root);
+        expect(routes.map((route) => route.path)).toEqual(['/', '/posts/:slug']);
+        expect(routes.find((route) => route.path === '/posts/:slug')).toEqual({
+            id: 'posts-slug',
+            path: '/posts/:slug',
+            label: 'Posts',
+        });
+    });
+    it('ignores path-shaped literals in files that do not import react-router', () => {
+        const root = project({
+            'src/config.ts': `export const nav = [{ path: '/dashboard', label: 'Dashboard' }];\n`,
+        });
+        expect(discoverReactRouterDomRoutes(root)).toEqual([]);
+    });
+});

package/dist/scripts/frameworks/vite/wiring.d.ts

@@ -0,0 +1,10 @@
+import type { RootWiringResult } from '../next/wiring.js';
+/**
+ * Vite React SPA root wiring: wrap the root render argument with
+ * `FimoSpaProviders` (client-side label fetch; inline fallbacks until it
+ * resolves) and import the project's fimo-config.json. Only the mainstream
+ * entry shape is touched — a `createRoot(…).render(<JSX/>)` (or legacy
+ * `ReactDOM.render(<JSX/>, …)`) call whose first argument is a JSX element.
+ * Anything else bails with the reason and stays agent work via the recipe.
+ */
+export declare function ensureSpaEntryWiring(cwd: string): RootWiringResult;

package/dist/scripts/frameworks/vite/wiring.js

@@ -0,0 +1,99 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSync } from 'oxc-parser';
+/**
+ * Vite React SPA root wiring: wrap the root render argument with
+ * `FimoSpaProviders` (client-side label fetch; inline fallbacks until it
+ * resolves) and import the project's fimo-config.json. Only the mainstream
+ * entry shape is touched — a `createRoot(…).render(<JSX/>)` (or legacy
+ * `ReactDOM.render(<JSX/>, …)`) call whose first argument is a JSX element.
+ * Anything else bails with the reason and stays agent work via the recipe.
+ */
+export function ensureSpaEntryWiring(cwd) {
+    const entryFile = ['src/main.tsx', 'src/main.jsx', 'src/index.tsx', 'src/index.jsx']
+        .map((candidate) => path.join(cwd, candidate))
+        .find((candidate) => fs.existsSync(candidate));
+    const bail = (reason, rel = 'src/main.tsx') => ({
+        changes: [],
+        warnings: [`Root wiring not applied: ${reason} — follow the SPA recipe in the agent prompt (${rel}).`],
+        wired: false,
+    });
+    if (!entryFile) {
+        return bail('no src/main or src/index entry file found');
+    }
+    const rel = path.relative(cwd, entryFile);
+    const code = fs.readFileSync(entryFile, 'utf8');
+    if (code.includes('FimoSpaProviders')) {
+        return { changes: [], warnings: [], wired: true };
+    }
+    let program;
+    try {
+        program = parseSync(entryFile, code).program;
+    }
+    catch {
+        return bail('entry file could not be parsed', rel);
+    }
+    // The JSX argument of the root render call, found structurally: a call
+    // whose callee property is `render` with a JSX element first argument
+    // (covers `createRoot(…).render(<X/>)` and `ReactDOM.render(<X/>, node)`).
+    const renderArg = (function find(node) {
+        if (!node || typeof node !== 'object') {
+            return null;
+        }
+        const candidate = node;
+        if (candidate.type === 'CallExpression' &&
+            candidate.callee?.type === 'MemberExpression' &&
+            candidate.callee?.property?.name === 'render' &&
+            (candidate.arguments?.[0]?.type === 'JSXElement' || candidate.arguments?.[0]?.type === 'JSXFragment')) {
+            return candidate.arguments[0];
+        }
+        for (const value of Object.values(candidate)) {
+            if (Array.isArray(value)) {
+                for (const entry of value) {
+                    const found = find(entry);
+                    if (found) {
+                        return found;
+                    }
+                }
+            }
+            else if (value && typeof value === 'object') {
+                const found = find(value);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        return null;
+    })(program);
+    if (!renderArg) {
+        return bail('no root render call with a JSX argument found', rel);
+    }
+    const configImportPath = path
+        .relative(path.dirname(entryFile), path.join(cwd, 'fimo-config.json'))
+        .split(path.sep)
+        .join('/');
+    const jsx = code.slice(renderArg.start, renderArg.end);
+    const open = '<FimoSpaProviders\n' +
+        '    config={fimoConfig}\n' +
+        '    apiUrl={import.meta.env.VITE_API_URL}\n' +
+        '    previewScriptUrl={import.meta.env.DEV ? import.meta.env.VITE_FIMO_PREVIEW_SCRIPT_URL : undefined}\n' +
+        '  >';
+    let next = code.slice(0, renderArg.start) + `${open}\n    ${jsx}\n  </FimoSpaProviders>` + code.slice(renderArg.end);
+    // AST-positioned like ensureFimoImport: a multiline import's first line is
+    // not the end of the imports.
+    const importBlock = `import { FimoSpaProviders } from 'fimo/react';\nimport fimoConfig from '${configImportPath.startsWith('.') ? configImportPath : `./${configImportPath}`}';`;
+    let lastImportEnd = -1;
+    for (const node of program.body ?? []) {
+        if (node.type === 'ImportDeclaration') {
+            lastImportEnd = node.end;
+        }
+    }
+    // The wrap edit above only touched positions at/after renderArg.start,
+    // which is always beyond the import block, so import spans still hold.
+    next =
+        lastImportEnd >= 0
+            ? `${next.slice(0, lastImportEnd)}\n${importBlock}${next.slice(lastImportEnd)}`
+            : `${importBlock}\n${next}`;
+    fs.writeFileSync(entryFile, next);
+    return { changes: [`wired FimoSpaProviders into ${rel}`], warnings: [], wired: true };
+}

package/dist/scripts/frameworks/vite/wiring.test.d.ts

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

package/dist/scripts/frameworks/vite/wiring.test.js

@@ -0,0 +1,88 @@
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureSpaEntryWiring } from './wiring.js';
+let dir;
+const project = (files) => {
+    dir = mkdtempSync(join(tmpdir(), 'vite-wiring-'));
+    for (const [rel, content] of Object.entries(files)) {
+        const full = join(dir, rel);
+        mkdirSync(join(full, '..'), { recursive: true });
+        writeFileSync(full, content);
+    }
+    return dir;
+};
+afterEach(() => {
+    if (dir) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+});
+describe('ensureSpaEntryWiring', () => {
+    it('wraps the StrictMode root render and imports the config', () => {
+        const root = project({
+            'src/main.tsx': `import { StrictMode } from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from './App';
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);
+`,
+        });
+        const result = ensureSpaEntryWiring(root);
+        const code = readFileSync(join(root, 'src/main.tsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual(['wired FimoSpaProviders into src/main.tsx']);
+        expect(code).toContain("import { FimoSpaProviders } from 'fimo/react';");
+        expect(code).toContain("import fimoConfig from '../fimo-config.json';");
+        expect(code).toContain('<FimoSpaProviders');
+        expect(code).toContain('config={fimoConfig}');
+        expect(code).toContain('apiUrl={import.meta.env.VITE_API_URL}');
+        expect(code).toContain('previewScriptUrl={import.meta.env.DEV ? import.meta.env.VITE_FIMO_PREVIEW_SCRIPT_URL : undefined}');
+        // The original tree stays inside the provider.
+        expect(code.indexOf('<StrictMode>')).toBeGreaterThan(code.indexOf('<FimoSpaProviders'));
+        expect(code.indexOf('</StrictMode>')).toBeLessThan(code.indexOf('</FimoSpaProviders>'));
+        // The config import lands AFTER the last original import, not inside one.
+        expect(code.indexOf("from './App'")).toBeLessThan(code.indexOf('fimo-config.json'));
+    });
+    it('handles a bare render argument and src/index fallback', () => {
+        const root = project({
+            'src/index.jsx': `import ReactDOM from 'react-dom/client';
+import App from './App';
+
+ReactDOM.createRoot(document.getElementById('root')).render(<App />);
+`,
+        });
+        const result = ensureSpaEntryWiring(root);
+        const code = readFileSync(join(root, 'src/index.jsx'), 'utf8');
+        expect(result.wired).toBe(true);
+        expect(code).toContain('<FimoSpaProviders');
+        expect(code).toContain('<App />');
+    });
+    it('is a no-op when the entry is already wired', () => {
+        const wired = `import { FimoSpaProviders } from 'fimo/react';
+import { createRoot } from 'react-dom/client';
+
+createRoot(document.getElementById('root')).render(<FimoSpaProviders config={{}}><p>hi</p></FimoSpaProviders>);
+`;
+        const root = project({ 'src/main.tsx': wired });
+        const result = ensureSpaEntryWiring(root);
+        expect(result.wired).toBe(true);
+        expect(result.changes).toEqual([]);
+        expect(readFileSync(join(root, 'src/main.tsx'), 'utf8')).toBe(wired);
+    });
+    it('bails when there is no entry file or no JSX render call', () => {
+        const empty = project({ 'src/app.ts': 'export {};\n' });
+        expect(ensureSpaEntryWiring(empty).wired).toBe(false);
+        rmSync(empty, { recursive: true, force: true });
+        const noJsx = project({
+            'src/main.tsx': `import { mount } from './mount';\nmount(document.getElementById('root'));\n`,
+        });
+        const result = ensureSpaEntryWiring(noJsx);
+        expect(result.wired).toBe(false);
+        expect(result.warnings[0]).toContain('no root render call');
+    });
+});

package/dist/scripts/generated-types.test.d.ts

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

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

@@ -0,0 +1,212 @@
+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 Post from "./Post";
+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",
+  };
+}
+
+export function paginatedPostContract(): void {
+  const legacy = Post.useGet({ limit: 3 });
+  const page = Post.useList({
+    fields: ["title", "author"] as const,
+    populate: ["author"] as const,
+    limit: 12,
+    offset: 24,
+  });
+  const infinite = Post.useInfiniteList({
+    fields: ["title", "author"] as const,
+    populate: ["author"] as const,
+    limit: 12,
+  });
+
+  const legacyPosts: PostResult[] = legacy.data ?? [];
+  const pagePosts: PostResult<readonly ["title", "author"], readonly ["author"]>[] = page.data?.items ?? [];
+  const total: number = page.data?.pageInfo.total ?? 0;
+  const nextOffset: number | null = page.data?.pageInfo.nextOffset ?? null;
+  const infinitePosts: PostResult<readonly ["title", "author"], readonly ["author"]>[] = infinite.items;
+  const firstAuthorName: string = infinitePosts[0]?.author ? String(infinitePosts[0].author.name) : "";
+  const hasMore: boolean = infinite.hasMore;
+  const isLoadingMore: boolean = infinite.isLoadingMore;
+
+  void infinite.loadMore();
+  // @ts-expect-error infinite lists own offset progression
+  Post.useInfiniteList({ offset: 12 });
+
+  void [legacyPosts, pagePosts, total, nextOffset, infinitePosts, firstAuthorName, hasMore, isLoadingMore];
+}
+
+export async function paginatedPostFetchContract(): Promise<void> {
+  const page = await Post.list({ limit: 12, offset: 24 });
+  const legacyPosts: PostResult[] = await Post.get({ limit: 3 });
+  const pagePosts: PostResult[] = page.items;
+  const hasMore: boolean = page.pageInfo.hasMore;
+
+  void [legacyPosts, pagePosts, hasMore];
+}
+`;
+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/lib/validation-report.d.ts

@@ -23,6 +23,7 @@ export interface PhaseResult {
     skipped?: {
         reason: string;
     };
+    warnings?: string[];
 }
 export interface ValidationReport {
     ok: boolean;

package/dist/scripts/lib/validation-report.js

@@ -76,6 +76,9 @@ function formatPhaseHuman(phase) {
             out.push(`    ${parts.join(', ')}`);
         }
     }
+    for (const warning of phase.warnings ?? []) {
+        out.push(`    ⚠ ${warning}`);
+    }
     for (const err of phase.errors) {
         const loc = err.file ? ` (${err.file}${err.line ? `:${err.line}` : ''}${err.column ? `:${err.column}` : ''})` : '';
         out.push(`    [${err.kind}] ${err.rule}: ${err.message}${loc}`);

package/dist/scripts/lint-translation-keys.test.d.ts

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

package/dist/scripts/lint-translation-keys.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { lintTranslationKeys } from './lint-translation-keys';
+describe('lintTranslationKeys', () => {
+    it('allows literal DB-owned label keys', () => {
+        const errors = lintTranslationKeys('src/pages/Index.tsx', "const title = t('hero.title');");
+        expect(errors).toEqual([]);
+    });
+    it('rejects inline fallback values', () => {
+        const errors = lintTranslationKeys('src/pages/Index.tsx', "const title = t('hero.title', 'Welcome');");
+        expect(errors).toEqual([expect.objectContaining({ rule: 'labels/no-inline-default' })]);
+    });
+    it('rejects dynamic keys', () => {
+        const errors = lintTranslationKeys('src/pages/Index.tsx', 'const title = t(heroKey);');
+        expect(errors).toEqual([expect.objectContaining({ rule: 'translation-keys' })]);
+    });
+});