fimo 0.7.0-experimental.3 → 0.7.0-staging.1

package/dist/runtime/react-router/routes.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest';
+import { fimoRoutes } from './routes';
+describe('fimoRoutes', () => {
+    const config = {
+        i18n: {
+            defaultLocale: 'en',
+            locales: ['en', 'es'],
+            routing: {
+                strategy: 'path-prefix',
+                prefixDefaultLocale: false,
+            },
+        },
+    };
+    it('adds concrete non-default locale aliases that reuse the same route modules', () => {
+        const routes = fimoRoutes([
+            { index: true, file: './pages/Index.tsx', id: 'home' },
+            { path: 'pricing', file: './pages/Pricing.tsx', id: 'pricing' },
+            { path: 'blog/:slug', file: './pages/BlogPost.tsx', id: 'blog-post' },
+        ], { config });
+        expect(routes).toEqual([
+            { index: true, file: './pages/Index.tsx', id: 'home' },
+            { path: 'pricing', file: './pages/Pricing.tsx', id: 'pricing' },
+            { path: 'blog/:slug', file: './pages/BlogPost.tsx', id: 'blog-post' },
+            { file: './pages/Index.tsx', id: 'fimo.es.home', path: 'es' },
+            { path: 'es/pricing', file: './pages/Pricing.tsx', id: 'fimo.es.pricing' },
+            { path: 'es/blog/:slug', file: './pages/BlogPost.tsx', id: 'fimo.es.blog-post' },
+        ]);
+    });
+    it('can prefix the default locale when configured', () => {
+        const routes = fimoRoutes([{ index: true, file: './pages/Index.tsx', id: 'home' }], {
+            config: {
+                i18n: {
+                    ...config.i18n,
+                    routing: {
+                        strategy: 'path-prefix',
+                        prefixDefaultLocale: true,
+                    },
+                },
+            },
+        });
+        expect(routes).toEqual([
+            { index: true, file: './pages/Index.tsx', id: 'home' },
+            { file: './pages/Index.tsx', id: 'fimo.en.home', path: 'en' },
+            { file: './pages/Index.tsx', id: 'fimo.es.home', path: 'es' },
+        ]);
+    });
+    it('localizes children below a pathless layout without duplicating files', () => {
+        const routes = fimoRoutes([
+            {
+                file: './pages/Layout.tsx',
+                id: 'site-layout',
+                children: [
+                    { index: true, file: './pages/Index.tsx', id: 'home' },
+                    { path: 'pricing', file: './pages/Pricing.tsx', id: 'pricing' },
+                ],
+            },
+        ], { config });
+        expect(routes[1]).toMatchObject({
+            file: './pages/Layout.tsx',
+            id: 'fimo.es.site-layout',
+            children: [
+                { file: './pages/Index.tsx', id: 'fimo.es.home', path: 'es' },
+                { path: 'es/pricing', file: './pages/Pricing.tsx', id: 'fimo.es.pricing' },
+            ],
+        });
+    });
+});

package/dist/runtime/routing/AppResetScrollOnNavigate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppResetScrollOnNavigate.d.ts","sourceRoot":"","sources":["../../../src/runtime/routing/AppResetScrollOnNavigate.tsx"],"names":[],"mappings":"AAGA,wBAAgB,wBAAwB,SAUvC"}

package/dist/runtime/routing/AppRoutesProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppRoutesProvider.d.ts","sourceRoot":"","sources":["../../../src/runtime/routing/AppRoutesProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA0C,MAAM,OAAO,CAAC;AAG/D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAUhD,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,QAAS,SAAQ,IAAI,CAAC,WAAW,EAAE,UAAU,GAAG,SAAS,CAAC;IACzE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,KAAK,CAAC,SAAS,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACjC,QAAQ,CAAC,EAAE,QAAQ,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,YAAa,SAAQ,IAAI,CAAC,QAAQ,EAAE,SAAS,GAAG,UAAU,GAAG,QAAQ,CAAC;IACrF,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAmBD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,QAAQ,EAAE,EAAE,QAAQ,SAAK,GAAG,YAAY,EAAE,CA4BlF;AAED,wBAAgB,iBAAiB,CAAC,EAAE,SAAS,EAAE,QAAQ,EAAE,EAAE;IAAE,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAoEhH"}

package/dist/runtime/seo/buildSeoForPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSeoForPath.d.ts","sourceRoot":"","sources":["../../../src/runtime/seo/buildSeoForPath.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAK1E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAExF;AA+BD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAMrE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAclG"}

package/dist/runtime/seo/htmlProps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlProps.d.ts","sourceRoot":"","sources":["../../../src/runtime/seo/htmlProps.ts"],"names":[],"mappings":"AAQA;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,eAAe,CAAC,EAAE,MAAM,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,KAAK,GAAG,KAAK,CAAA;CAAE,CAIlH"}

package/dist/runtime/seo/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/seo/index.ts"],"names":[],"mappings":"AAEA,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAE9B,wBAAsB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE;;;GAIvE"}

package/dist/runtime/seo/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../../../src/runtime/seo/resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,OAAO,EAAY,MAAM,gCAAgC,CAAC;AAErG;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,cAAc,2HAWsB,CAAC;AAElD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAO1D;AAUD,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAoBzG;AAED,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,GAAG,SAAS,GAClD,eAAe,GAAG,SAAS,CAuB7B;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAapE;AAED,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAQ1F;AAaD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,SAAS,CAwBhH"}

package/dist/runtime/shared/fimo-config.server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.server.d.ts","sourceRoot":"","sources":["../../../src/runtime/shared/fimo-config.server.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAA4C,MAAM,wBAAwB,CAAC;AAiBnG;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,CAe3D;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUxD"}

package/dist/runtime/shared/fimo-config.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fimo-config.types.d.ts","sourceRoot":"","sources":["../../../src/runtime/shared/fimo-config.types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtF,GAAG,CAAC,EAAE,QAAQ,CAAC;CAChB;AAED,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,EAAE,aAAa,CAAC;IACzB,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,qBAAqB,CAAC;CACjC;AAED,MAAM,WAAW,UAAU;IACzB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACzC,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC3B"}

package/dist/runtime/t/OptionalTracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionalTracking.d.ts","sourceRoot":"","sources":["../../../src/runtime/t/OptionalTracking.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9C,KAAK,iBAAiB,GAAG,OAAO,QAAQ,CAAC;AACzC,KAAK,cAAc,GAAG;IAAE,QAAQ,EAAE,iBAAiB,CAAA;CAAE,CAAC;AACtD,KAAK,cAAc,GAAG,MAAM,OAAO,CAAC,cAAc,CAAC,CAAC;AACpD,KAAK,YAAY,GAAG,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,CAAC;AAIvE,wBAAsB,qBAAqB,CAAC,YAAY,GAAE,cAAoC,mCAM7F;AAED,wBAAgB,gBAAgB,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,kDAoBtE"}

package/dist/runtime/t/OptionalTracking.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=OptionalTracking.test.d.ts.map

package/dist/runtime/t/OptionalTracking.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OptionalTracking.test.d.ts","sourceRoot":"","sources":["../../../src/runtime/t/OptionalTracking.test.ts"],"names":[],"mappings":""}

package/dist/runtime/t/OptionalTracking.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, it } from 'vitest';
+import { loadPageviewComponent } from './OptionalTracking.js';
+describe('loadPageviewComponent', () => {
+    it('returns the Pageview component when the tracking chunk loads', async () => {
+        const Pageview = () => null;
+        await expect(loadPageviewComponent(async () => ({ Pageview }))).resolves.toBe(Pageview);
+    });
+    it('fails closed when the tracking chunk is blocked', async () => {
+        await expect(loadPageviewComponent(async () => Promise.reject(new Error('blocked')))).resolves.toBeNull();
+    });
+});

package/dist/runtime/t/Pageview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pageview.d.ts","sourceRoot":"","sources":["../../../src/runtime/t/Pageview.tsx"],"names":[],"mappings":"AAGA,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA+HF,wBAAgB,QAAQ,CAAC,EAAE,MAAM,EAAE,EAAE;IAAE,MAAM,EAAE,YAAY,EAAE,CAAA;CAAE,QAkB9D"}

package/dist/runtime/templates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.d.ts","sourceRoot":"","sources":["../../src/runtime/templates.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,mBAAmB,oDAAqD,CAAC;AACtF,MAAM,MAAM,iBAAiB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AACrE,eAAO,MAAM,gBAAgB,EAAE,iBAAkC,CAAC;AAElE;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,iBAAoC,GAAG,MAAM,CAEvF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAM7C;AAqBD,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,wBAAgB,eAAe,IAAI,WAAW,CAS7C;AAED,wBAAgB,aAAa,IAAI,MAAM,GAAG,IAAI,CAW7C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC/C,MAAM,GAAG,IAAI,CAUf;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,GAAG,IAAI,EACrB,OAAO,GAAE;IAAE,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC5E,MAAM,GAAG,IAAI,CAcf;AAED,uDAAuD;AACvD,wBAAgB,cAAc,CAAC,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAAG,MAAM,GAAG,IAAI,CAE9F;AAED,wBAAgB,oBAAoB,CAClC,OAAO,GAAE;IAAE,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GACzE,MAAM,GAAG,IAAI,CASf;AAED,wBAAgB,qBAAqB,CAAC,SAAS,GAAE,MAAqB,GAAG,iBAAiB,CAezF;AAiBD,UAAU,WAAW;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC1C;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,GAAE,MAAM,GAAG,IAAuB,GAAG,OAAO,CA2B/F"}

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?.id ?? "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/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' })]);
+    });
+});

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

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

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

@@ -0,0 +1,144 @@
+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

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

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

@@ -0,0 +1,116 @@
+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

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