fimo 0.12.0-staging.2 → 0.12.0-staging.4

package/dist/runtime/labels/core.d.ts

@@ -0,0 +1,18 @@
+import { FimoString } from '../primitives/lib/index.js';
+export interface LabelsSnapshot {
+    locale: string;
+    labels: Record<string, string>;
+    updatedAt: string | null;
+}
+export interface Labels {
+    locale: string;
+    snapshot: LabelsSnapshot;
+    t(key: string): FimoString;
+}
+/**
+ * Build the shared label reader used by server `getLabels()` and client
+ * `useLabels()`. Missing keys stay editable but render as an empty string;
+ * snapshots never fall back across locales implicitly.
+ */
+export declare function createLabels(snapshot: LabelsSnapshot): Labels;
+//# sourceMappingURL=core.d.ts.map

package/dist/runtime/labels/core.js

@@ -0,0 +1,15 @@
+import { FimoString } from '../primitives/lib/index.js';
+/**
+ * Build the shared label reader used by server `getLabels()` and client
+ * `useLabels()`. Missing keys stay editable but render as an empty string;
+ * snapshots never fall back across locales implicitly.
+ */
+export function createLabels(snapshot) {
+    return {
+        locale: snapshot.locale,
+        snapshot,
+        t(key) {
+            return new FimoString(snapshot.labels[key] ?? '', `__labels.${snapshot.locale}.${key}.value`);
+        },
+    };
+}

package/dist/runtime/labels/fetch.d.ts

@@ -0,0 +1,7 @@
+import type { ContentRuntime } from '../content/client/runtime.js';
+import { type Labels } from './core.js';
+export interface GetLabelsOptions {
+    locale?: string;
+}
+export declare function fetchLabels(runtime: ContentRuntime, { locale: requestedLocale }?: GetLabelsOptions): Promise<Labels>;
+//# sourceMappingURL=fetch.d.ts.map

package/dist/runtime/labels/fetch.js

@@ -0,0 +1,41 @@
+import { createLabels } from './core.js';
+function dictionaryFrom(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === 'string'));
+}
+function snapshotFrom(body, requestedLocale) {
+    if (Array.isArray(body.data)) {
+        return {
+            locale: requestedLocale,
+            labels: Object.fromEntries(body.data.flatMap((row) => {
+                if (typeof row.key !== 'string') {
+                    return [];
+                }
+                const value = typeof row.value === 'string' ? row.value : row.defaultValue;
+                return [[row.key, typeof value === 'string' ? value : '']];
+            })),
+            updatedAt: null,
+        };
+    }
+    const data = body.data;
+    return {
+        locale: typeof data?.locale === 'string' && data.locale.trim() ? data.locale : requestedLocale,
+        labels: dictionaryFrom(data?.labels),
+        updatedAt: typeof data?.updatedAt === 'string' ? data.updatedAt : null,
+    };
+}
+export async function fetchLabels(runtime, { locale: requestedLocale } = {}) {
+    const locale = requestedLocale?.trim() || runtime.defaultLocale();
+    const url = new URL('/labels', runtime.apiBase());
+    url.searchParams.set('locale', locale);
+    const response = await runtime.fetch(url, {
+        headers: runtime.headers({ Accept: 'application/json' }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to read Fimo labels (${response.status}).`);
+    }
+    const body = (await response.json());
+    return createLabels(snapshotFrom(body, locale));
+}

package/dist/runtime/next/client.d.ts

@@ -18,6 +18,7 @@ export { StaticImage } from '../react/primitives/renderers/StaticImage.js';
 export { Text } from '../react/primitives/editable/Text.js';
 export { Video } from '../react/primitives/editable/Video.js';
 export type { BoolOps, DateOps, Field, Fields, FilterFor, FimoPart, FimoPolymorphicReference, FimoReference, FimoRichTextComponents, FimoRichTextContent, FimoRichTextMarkProps, FimoRichTextNodeProps, FimoSource, NullOnlyOps, NumberOps, Populate, Populated, PopulatedResult, Projected, ProjectedWithPopulate, Query, ReferenceField, ReferenceMap, ScalarOps, Sort, SortField, StringOps, Where, WithReferences, } from '../content/index.js';
-export { FimoNextProvider } from './provider.js';
-export type { FimoNextProviderProps } from './provider.js';
+export { FimoProvider, useLabels } from './provider.js';
+export type { FimoProviderProps } from './provider.js';
+export type { Labels, LabelsSnapshot } from '../labels/core.js';
 //# sourceMappingURL=client.d.ts.map

package/dist/runtime/next/client.js

@@ -19,4 +19,4 @@ export { RichText } from '../react/primitives/editable/RichText.js';
 export { StaticImage } from '../react/primitives/renderers/StaticImage.js';
 export { Text } from '../react/primitives/editable/Text.js';
 export { Video } from '../react/primitives/editable/Video.js';
-export { FimoNextProvider } from './provider.js';
+export { FimoProvider, useLabels } from './provider.js';

package/dist/runtime/next/facade.d.ts

@@ -0,0 +1,8 @@
+import type { ContentClientHandle } from '../content/client/types.js';
+export type NextContentRegistry = Readonly<Record<string, ContentClientHandle>>;
+export interface CreateFimoOptions<TContent extends NextContentRegistry> {
+    content: TContent;
+    locale?: string;
+}
+export declare function createFimo<const TContent extends NextContentRegistry>({ content, locale, }: CreateFimoOptions<TContent>): TContent;
+//# sourceMappingURL=facade.d.ts.map

package/dist/runtime/next/facade.js

@@ -0,0 +1,34 @@
+function withLocale(options, locale) {
+    return { ...options, locale: options?.locale ?? locale };
+}
+function isCollectionClient(client) {
+    return 'list' in client && typeof client.list === 'function';
+}
+function isSingletonClient(client) {
+    return 'get' in client && typeof client.get === 'function';
+}
+function bindLocale(client, locale) {
+    if (isCollectionClient(client)) {
+        return {
+            ...client,
+            getById: (id, options) => client.getById(id, withLocale(options, locale)),
+            getBySlug: (slug, options) => client.getBySlug(slug, withLocale(options, locale)),
+            getByField: (fieldName, value, options) => client.getByField(fieldName, value, withLocale(options, locale)),
+            list: (params) => client.list(withLocale(params, locale)),
+            get: (params) => client.get(withLocale(params, locale)),
+        };
+    }
+    if (isSingletonClient(client)) {
+        return {
+            ...client,
+            get: (options) => client.get(withLocale(options, locale)),
+        };
+    }
+    return client;
+}
+export function createFimo({ content, locale, }) {
+    if (locale === undefined) {
+        return content;
+    }
+    return Object.fromEntries(Object.entries(content).map(([key, client]) => [key, bindLocale(client, locale)]));
+}

package/dist/runtime/next/labels.d.ts

@@ -0,0 +1,7 @@
+import { type GetLabelsOptions } from '../labels/fetch.js';
+/**
+ * Read the labels for an application-resolved locale. When omitted, locale
+ * comes from FIMO_DEFAULT_LOCALE / NEXT_PUBLIC_FIMO_DEFAULT_LOCALE.
+ */
+export declare function getLabels(options?: GetLabelsOptions): Promise<import("./client.js").Labels>;
+//# sourceMappingURL=labels.d.ts.map

package/dist/runtime/next/labels.js

@@ -0,0 +1,9 @@
+import { fetchLabels } from '../labels/fetch.js';
+import { nextServerContentRuntime } from './server-runtime.js';
+/**
+ * Read the labels for an application-resolved locale. When omitted, locale
+ * comes from FIMO_DEFAULT_LOCALE / NEXT_PUBLIC_FIMO_DEFAULT_LOCALE.
+ */
+export function getLabels(options) {
+    return fetchLabels(nextServerContentRuntime, options);
+}

package/dist/runtime/next/provider.d.ts

@@ -1,10 +1,13 @@
 import { QueryClient } from '@tanstack/react-query';
 import { type ReactNode } from 'react';
-export interface FimoNextProviderProps {
+import { type Labels, type LabelsSnapshot } from '../labels/core.js';
+export interface FimoProviderProps {
     children: ReactNode;
+    labels?: LabelsSnapshot;
     locale?: string;
     queryClient?: QueryClient;
 }
-export declare function FimoNextProvider({ children, locale, queryClient }: FimoNextProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function FimoProvider({ children, labels, locale, queryClient }: FimoProviderProps): import("react/jsx-runtime").JSX.Element;
 export declare function useNextContentLocale(requestedLocale: string | undefined, defaultLocale: string): string;
+export declare function useLabels(): Labels;
 //# sourceMappingURL=provider.d.ts.map

package/dist/runtime/next/provider.js

@@ -1,12 +1,25 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { createContext, useContext, useState } from 'react';
-const FimoNextLocaleContext = createContext(undefined);
-export function FimoNextProvider({ children, locale, queryClient }) {
+import { createContext, useContext, useMemo, useState } from 'react';
+import { createLabels } from '../labels/core.js';
+import { nextClientContentRuntime } from './client-runtime.js';
+const FimoNextContext = createContext({});
+export function FimoProvider({ children, labels, locale, queryClient }) {
     const [client] = useState(() => queryClient ?? new QueryClient());
-    return (_jsx(FimoNextLocaleContext.Provider, { value: locale, children: _jsx(QueryClientProvider, { client: client, children: children }) }));
+    const activeLocale = locale?.trim() || labels?.locale;
+    const value = useMemo(() => ({ labels, locale: activeLocale }), [activeLocale, labels]);
+    return (_jsx(FimoNextContext.Provider, { value: value, children: _jsx(QueryClientProvider, { client: client, children: children }) }));
 }
 export function useNextContentLocale(requestedLocale, defaultLocale) {
-    return requestedLocale ?? useContext(FimoNextLocaleContext) ?? defaultLocale;
+    const context = useContext(FimoNextContext);
+    return requestedLocale ?? context.locale ?? defaultLocale;
+}
+export function useLabels() {
+    const context = useContext(FimoNextContext);
+    const locale = context.locale ?? nextClientContentRuntime.defaultLocale();
+    const snapshot = context.labels?.locale === locale
+        ? context.labels
+        : { locale, labels: {}, updatedAt: null };
+    return useMemo(() => createLabels(snapshot), [snapshot]);
 }

package/dist/runtime/next/server.d.ts

@@ -2,6 +2,11 @@ import type { CollectionContentClient, ContentClientConfig, SingletonContentClie
 export { StaticImage } from '../react/primitives/renderers/StaticImage.js';
 export { Text } from './primitives/Text.js';
 export { Boolean, Date, Image, Json, RichText, Video } from './primitives/server.js';
+export { createFimo } from './facade.js';
+export type { CreateFimoOptions, NextContentRegistry } from './facade.js';
+export { getLabels } from './labels.js';
+export type { GetLabelsOptions } from '../labels/fetch.js';
+export type { Labels, LabelsSnapshot } from '../labels/core.js';
 export declare function createContentClient<T extends {
     id: string;
 }, TInput extends object>(config: ContentClientConfig): CollectionContentClient<T, TInput>;

package/dist/runtime/next/server.js

@@ -3,6 +3,8 @@ import { nextServerContentRuntime } from './server-runtime.js';
 export { StaticImage } from '../react/primitives/renderers/StaticImage.js';
 export { Text } from './primitives/Text.js';
 export { Boolean, Date, Image, Json, RichText, Video } from './primitives/server.js';
+export { createFimo } from './facade.js';
+export { getLabels } from './labels.js';
 export function createContentClient(config) {
     return createServerContentClient(config, nextServerContentRuntime);
 }

package/dist/scripts/extract-translations.js

@@ -40,7 +40,14 @@ function extractFromFile(filePath) {
             }
             if (node.type === 'CallExpression') {
                 const callee = node.callee;
-                if (callee?.type === 'Identifier' && callee?.name === 't') {
+                const isTranslationCall = (callee?.type === 'Identifier' && callee.name === 't') ||
+                    (callee?.type === 'MemberExpression' &&
+                        callee.computed === false &&
+                        callee.object?.type === 'Identifier' &&
+                        callee.object.name === 'labels' &&
+                        callee.property?.type === 'Identifier' &&
+                        callee.property.name === 't');
+                if (isTranslationCall) {
                     const args = node.arguments || [];
                     const firstArg = args[0];
                     if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {

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

@@ -1,5 +1,6 @@
 export interface SyncSchemasOptions {
     cwd?: string;
+    framework: string | null;
     verbose?: boolean;
 }
 export interface SyncResult {
@@ -7,4 +8,4 @@ export interface SyncResult {
     updated: number;
     deleted: number;
 }
-export declare function syncSchemas(options?: SyncSchemasOptions): SyncResult;
+export declare function syncSchemas(options: SyncSchemasOptions): SyncResult;

package/dist/scripts/sync-schemas.js

@@ -5,18 +5,22 @@ import { basename, dirname, join, resolve } from 'node:path';
  * hook files generated from the hooks template.
  *
  * - Scans `<cwd>/src/schemas/*.json`.
- * - Renders the shared types plus either the Vite facade or the split Next server/client facades.
+ * - Renders shared types plus either the React facade or split Next server/client facades.
  * - Creates/updates `<Pascal>.types.ts` and `<Pascal>.ts`, plus `<Pascal>.client.ts` for Next; deletes orphans.
  */
-import { pascalCase } from 'change-case';
+import { camelCase, pascalCase } from 'change-case';
 import { Eta } from 'eta';
 import { z } from 'zod';
 import { assetPath } from './utils/assets.js';
 const SCHEMAS_REL = 'src/schemas';
+const GENERATED_REGISTRY_MARKER = '// AUTO-GENERATED by `fimo` from src/schemas/*.json - DO NOT EDIT.';
+// Before 0.7, generated schema clients contained their own runtime. Keep using
+// those projects' bundled templates instead of generating imports they cannot satisfy.
 const MINIMUM_THIN_CONTENT_CLIENT_RUNTIME_VERSION = '0.7.0';
 const CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND = 'npm install fimo@latest';
 const SCHEMA_DEFINITION_SCHEMA = z.object({
     uid: z.string().min(1),
+    name: z.string().min(1).optional(),
     isSingleton: z.boolean().optional(),
     i18n: z.object({ enabled: z.boolean().optional() }).optional(),
     fields: z.record(z.string(), z.unknown()).optional(),
@@ -27,6 +31,7 @@ function getSchemaFiles(schemasDir) {
     }
     return readdirSync(schemasDir)
         .filter((f) => f.endsWith('.json'))
+        .sort()
         .map((f) => join(schemasDir, f));
 }
 function getGeneratedFiles(schemasDir) {
@@ -60,6 +65,16 @@ function isVersionAtLeast(version, minimum) {
     }
     return !parsed.prerelease || parsedMinimum.prerelease;
 }
+function packageExportsSubpath(packageJson, subpath) {
+    if (!packageJson || typeof packageJson !== 'object' || Array.isArray(packageJson)) {
+        return false;
+    }
+    const exports = packageJson.exports;
+    return Boolean(exports &&
+        typeof exports === 'object' &&
+        !Array.isArray(exports) &&
+        Object.prototype.hasOwnProperty.call(exports, subpath));
+}
 function resolveProjectRuntime(cwd) {
     const packagePath = join(cwd, 'node_modules', 'fimo', 'package.json');
     if (!existsSync(packagePath)) {
@@ -67,45 +82,29 @@ function resolveProjectRuntime(cwd) {
             `Run \`${CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND}\` in the project, then run \`npx fimo@latest validate\` again. ` +
             'No generated files were changed.');
     }
-    let version;
+    let packageJson;
     try {
-        version = JSON.parse(readFileSync(packagePath, 'utf-8')).version;
+        packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
     }
     catch {
-        version = null;
+        packageJson = null;
     }
+    const version = packageJson && typeof packageJson === 'object' && !Array.isArray(packageJson)
+        ? packageJson.version
+        : null;
     if (typeof version !== 'string' || !parseVersion(version)) {
         throw new Error(`Cannot generate schema clients with project-local fimo@${typeof version === 'string' ? version : 'unknown'}. ` +
             `Run \`${CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND}\` in the project, then run \`npx fimo@latest validate\` again. ` +
             'No generated files were changed.');
     }
-    return { packageRoot: dirname(packagePath), version };
+    return {
+        packageRoot: dirname(packagePath),
+        version,
+        providesNextRuntime: packageExportsSubpath(packageJson, './next') && packageExportsSubpath(packageJson, './next/client'),
+    };
 }
-function resolveContentRuntimeImport(cwd) {
-    const packagePath = join(cwd, 'package.json');
-    if (!existsSync(packagePath)) {
-        return 'fimo/ui';
-    }
-    let packageJson;
-    try {
-        packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
-    }
-    catch {
-        return 'fimo/ui';
-    }
-    if (!packageJson || typeof packageJson !== 'object' || Array.isArray(packageJson)) {
-        return 'fimo/ui';
-    }
-    const manifest = packageJson;
-    const dependencyGroups = ['dependencies', 'devDependencies', 'peerDependencies'];
-    const usesNext = dependencyGroups.some((group) => {
-        const dependencies = manifest[group];
-        return Boolean(dependencies &&
-            typeof dependencies === 'object' &&
-            !Array.isArray(dependencies) &&
-            typeof dependencies.next === 'string');
-    });
-    return usesNext ? 'fimo/next' : 'fimo/ui';
+function contentRuntimeImportFor(framework) {
+    return framework === 'nextjs' ? 'fimo/next' : 'fimo/ui';
 }
 function templatePath(runtime, fileName) {
     if (runtime && !isVersionAtLeast(runtime.version, MINIMUM_THIN_CONTENT_CLIENT_RUNTIME_VERSION)) {
@@ -113,10 +112,56 @@ function templatePath(runtime, fileName) {
     }
     return assetPath('content-templates', fileName);
 }
+function resolveSchemaGenerationTarget(runtimeImport, runtime) {
+    if (runtimeImport === 'fimo/ui') {
+        return 'react';
+    }
+    if (!runtime.providesNextRuntime) {
+        throw new Error(`Cannot generate schema clients because project-local fimo@${runtime.version} does not provide the ` +
+            'fimo/next and fimo/next/client exports required by this Next.js project. ' +
+            `Run \`${CONTENT_CLIENT_RUNTIME_UPGRADE_COMMAND}\` in the project, then run \`npx fimo@latest validate\` again. ` +
+            'No generated files were changed.');
+    }
+    return 'next';
+}
+function templatesForTarget(target, runtime, runtimeImport) {
+    if (target === 'next') {
+        return [
+            {
+                suffix: '.types.ts',
+                path: templatePath(runtime, 'types-template.eta'),
+                runtimeImport: 'fimo/next',
+            },
+            {
+                suffix: '.ts',
+                path: templatePath(runtime, 'next-server-template.eta'),
+                runtimeImport: 'fimo/next',
+            },
+            {
+                suffix: '.client.ts',
+                path: templatePath(runtime, 'next-client-template.eta'),
+                runtimeImport: 'fimo/next/client',
+            },
+        ];
+    }
+    return [
+        {
+            suffix: '.types.ts',
+            path: templatePath(runtime, 'types-template.eta'),
+            runtimeImport,
+        },
+        {
+            suffix: '.ts',
+            path: templatePath(runtime, 'hooks-template.eta'),
+            runtimeImport,
+        },
+    ];
+}
 function loadSchemas(schemaFiles) {
     const errors = [];
     const schemas = [];
     const outputOwners = new Map();
+    const registryOwners = new Map();
     for (const path of schemaFiles) {
         const fileUid = basename(path, '.json');
         const pascal = pascalCase(fileUid);
@@ -156,13 +201,33 @@ function loadSchemas(schemaFiles) {
             errors.push(`${basename(path)} has an invalid schema shape: ${details}`);
             continue;
         }
-        schemas.push({ pascal, schema: validation.data });
+        const registryKey = camelCase(validation.data.name ?? validation.data.uid);
+        const existingRegistryOwner = registryOwners.get(registryKey);
+        if (existingRegistryOwner && existingRegistryOwner !== fileUid) {
+            errors.push(`${basename(path)} and ${existingRegistryOwner}.json both generate the content registry key "${registryKey}". Rename one schema display name to keep generated registry keys unique.`);
+            continue;
+        }
+        registryOwners.set(registryKey, fileUid);
+        schemas.push({ pascal, registryKey, schema: validation.data });
     }
     if (errors.length > 0) {
         throw new Error(`Cannot generate schema clients:\n- ${errors.join('\n- ')}\nNo generated files were changed.`);
     }
     return schemas;
 }
+function renderContentRegistry(schemas) {
+    const imports = schemas.map(({ pascal }) => `import * as ${pascal} from "./${pascal}";`).join('\n');
+    const entries = schemas.map(({ pascal, registryKey }) => `  ${registryKey}: ${pascal},`).join('\n');
+    return `${GENERATED_REGISTRY_MARKER}
+// Server code imports this registry and passes it to createFimo({ content, locale }).
+
+${imports}
+
+export const content = {
+${entries}
+} as const;
+`;
+}
 function normalizeFields(fields) {
     return Object.fromEntries(Object.entries(fields).map(([key, value]) => {
         if (!value || typeof value !== 'object' || Array.isArray(value)) {
@@ -226,7 +291,7 @@ function schemaToModel(schema, localizedByUid) {
         referenceImports: referenceImportsFor(schema, fields),
     };
 }
-export function syncSchemas(options = {}) {
+export function syncSchemas(options) {
     const cwd = options.cwd ?? process.cwd();
     const log = (msg) => {
         if (options.verbose !== false) {
@@ -234,44 +299,20 @@ export function syncSchemas(options = {}) {
         }
     };
     const schemasDir = resolve(cwd, SCHEMAS_REL);
+    const registryPath = join(schemasDir, 'index.ts');
     const schemaFiles = getSchemaFiles(schemasDir);
     const schemas = loadSchemas(schemaFiles);
     const generatedFilesOnDisk = getGeneratedFiles(schemasDir);
     const runtime = schemas.length > 0 || generatedFilesOnDisk.length > 0 ? resolveProjectRuntime(cwd) : null;
-    const runtimeImport = resolveContentRuntimeImport(cwd);
-    const usesCurrentNextRuntime = runtimeImport === 'fimo/next' &&
-        runtime !== null &&
-        isVersionAtLeast(runtime.version, MINIMUM_THIN_CONTENT_CLIENT_RUNTIME_VERSION);
-    const templates = usesCurrentNextRuntime
-        ? [
-            {
-                suffix: '.types.ts',
-                path: templatePath(runtime, 'types-template.eta'),
-                runtimeImport: 'fimo/next',
-            },
-            {
-                suffix: '.ts',
-                path: templatePath(runtime, 'next-server-template.eta'),
-                runtimeImport: 'fimo/next',
-            },
-            {
-                suffix: '.client.ts',
-                path: templatePath(runtime, 'next-client-template.eta'),
-                runtimeImport: 'fimo/next/client',
-            },
-        ]
-        : [
-            {
-                suffix: '.types.ts',
-                path: templatePath(runtime, 'types-template.eta'),
-                runtimeImport,
-            },
-            {
-                suffix: '.ts',
-                path: templatePath(runtime, 'hooks-template.eta'),
-                runtimeImport,
-            },
-        ];
+    const runtimeImport = contentRuntimeImportFor(options.framework);
+    const generationTarget = runtime ? resolveSchemaGenerationTarget(runtimeImport, runtime) : null;
+    const needsNextRegistry = generationTarget === 'next' && schemas.length > 0;
+    const ownsExistingRegistry = existsSync(registryPath) && readFileSync(registryPath, 'utf-8').startsWith(GENERATED_REGISTRY_MARKER);
+    const shouldGenerateRegistry = needsNextRegistry && (!existsSync(registryPath) || ownsExistingRegistry);
+    if (needsNextRegistry && !shouldGenerateRegistry) {
+        log(`Kept project-owned schema barrel: ${registryPath}`);
+    }
+    const templates = generationTarget && runtime ? templatesForTarget(generationTarget, runtime, runtimeImport) : [];
     const loadedTemplates = templates.map((template) => ({
         ...template,
         source: readFileSync(template.path, 'utf-8'),
@@ -291,6 +332,10 @@ export function syncSchemas(options = {}) {
             generatedFiles.set(tsPath, eta.renderString(template.source, { model, runtimeImport: template.runtimeImport }));
         }
     }
+    if (shouldGenerateRegistry) {
+        expectedTsFiles.add(registryPath);
+        generatedFiles.set(registryPath, renderContentRegistry(schemas));
+    }
     for (const [tsPath, content] of generatedFiles) {
         const dir = dirname(tsPath);
         if (!existsSync(dir)) {
@@ -320,6 +365,13 @@ export function syncSchemas(options = {}) {
             }
         }
     }
+    if (!shouldGenerateRegistry &&
+        existsSync(registryPath) &&
+        readFileSync(registryPath, 'utf-8').startsWith(GENERATED_REGISTRY_MARKER)) {
+        unlinkSync(registryPath);
+        deleted++;
+        log(`Deleted orphaned: ${registryPath}`);
+    }
     if ((created > 0 || updated > 0 || deleted > 0) && options.verbose !== false) {
         log(`Sync schemas: ${created} created, ${updated} updated, ${deleted} deleted`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.12.0-staging.2",
+  "version": "0.12.0-staging.4",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"
@@ -93,6 +93,7 @@
     "@fimo/agents-bundle": "workspace:*",
     "@fimo/api-contracts": "workspace:*",
     "@fimo/cli-kit": "workspace:*",
+    "@fimo/framework-detect": "workspace:*",
     "@fimo/mcp": "workspace:*",
     "@fimo/tsconfig": "workspace:*",
     "@modelcontextprotocol/sdk": "1.27.1",

package/templates/react-router/AGENTS.md

@@ -1,31 +1,33 @@
 # Fimo project
 
-This is a Fimo project — a content + media + forms + analytics platform for React websites with a CMS
+This is a Fimo project — a content + media + forms + analytics platform for web applications with a CMS
 dashboard. Fimo owns everything after the build: content, editing, environments, and hosting stay
 editable by the whole team.
 
+When asked to create or manage an agent in this project, use Fimo's agent workflow.
+
 ## Load the Fimo skills before doing Fimo work
 
-Fimo ships its skills through its CLI so they always match this project's installed version. Before
-writing schema-driven code, running CLI/deploy workflows, or migrating content, load the relevant skill:
+Before writing schema-driven code, running CLI/deploy workflows, or migrating content, load only the
+skill relevant to the task:
 
 ```bash
-npx fimo@latest skills list          # what's available
-npx fimo@latest skills get fimo-code  # writing code: schemas, forms, labels, fimo/ui
-npx fimo@latest skills get fimo-cli   # CLI + workflows: push, deploy, sync, labels, domains
+pnpm exec fimo skills get fimo-code   # match the lockfile; code + framework APIs come from this project runtime
+npx fimo@latest skills get fimo-cli   # operational workflows: push, deploy, labels, domains
 ```
 
-Add `--ref <doc>` for a skill's reference docs. Always fetch fresh from the CLI rather than trusting a
-cached copy.
+Use `npm exec fimo`, `yarn fimo`, or `bunx --no-install fimo` instead of `pnpm exec fimo` when that
+matches the project lockfile. Add `--ref <doc>` for one reference at a time. Do not load `fimo-cli` for
+a code-only task, or use `npx fimo@latest` for project-local code generation and validation.
 
 ## Critical: never hardcode user-facing things
 
 Fimo's whole point is that editors change content in the dashboard, not in code. Anything hardcoded
 breaks that. Load `fimo-code` for the exact primitives, but the rule is:
 
-- **Content** → declare a schema, render with the generated `useList()` / `useGet()` hooks + `fimo/ui`. Never `const posts = [...]` in JSX.
+- **Content** → declare a schema, use its generated client, and render with the active framework adapter. Never `const posts = [...]` in JSX.
 - **Strings** → `t('key')` + `fimo labels set`. Never `<h1>Welcome</h1>`.
-- **Media** → `<Image>` / `<Video>` from `fimo/ui`. Never `<img src>`.
+- **Media** → `<Image>` / `<Video>` from the active framework adapter. Never `<img src>` for tracked media.
 - **Forms** → the generated Zod schema + `submitX` helper. Never hand-roll fetch/validation.
 
 ## Development loop

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.12.0-staging.2",
+    "fimo": "0.12.0-staging.4",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",

package/templates/react-router/react-router.config.ts

@@ -11,7 +11,7 @@ export default {
   //   prerender: async () => (await getFimoPaths()).map((p) => p.path),
   //
   // `getFimoPaths()` expands dynamic routes (e.g. `/blog/:slug`) by fetching
-  // schema entries from the content API. See `references/setup-react-router.md`
+  // schema entries from the content API. See `references/frameworks/react-router.md`
   // in the fimo skill for the full setup pattern.
   buildDirectory: 'dist',
   // Feed Vite's dependency scanner the client entry + every route module.