fimo 0.9.0-experimental.1 → 0.9.0-experimental.11

package/dist/runtime/app/FimoProviders.js

@@ -1,5 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Suspense, useCallback, useEffect, useMemo } from 'react';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider, useQueryClient } from '@tanstack/react-query';
+import { Suspense, useCallback, useEffect, useMemo, useState } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { useLocation, useNavigate } from 'react-router';
 // @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
@@ -59,6 +60,27 @@ function PreviewBridge() {
     }, [navigate, sendRoutes, sendLocationChange]);
     return null;
 }
+/**
+ * Template projects mount their own QueryClientProvider in root.tsx, but an
+ * ADOPTED app wired straight onto FimoProviders (react-router library SPAs)
+ * has none — and the inner runtime (RefreshContentProvider, content clients)
+ * calls useQueryClient(). Mount a fallback client only when no provider
+ * exists above, so both worlds work and template caches stay untouched.
+ */
+function EnsureQueryClient({ children }) {
+    let existing = null;
+    try {
+        existing = useQueryClient();
+    }
+    catch {
+        existing = null;
+    }
+    const [fallbackClient] = useState(() => new QueryClient());
+    if (existing) {
+        return _jsx(_Fragment, { children: children });
+    }
+    return _jsx(QueryClientProvider, { client: fallbackClient, children: children });
+}
 export function FimoProviders({ children, locale }) {
     const location = useLocation();
     const localeResolution = useMemo(() => resolveFimoLocale({ pathname: location.pathname }, fimoConfig), [location.pathname]);
@@ -71,9 +93,9 @@ export function FimoProviders({ children, locale }) {
         document.documentElement.lang = toHtmlLang(activeLocale);
         document.documentElement.dir = activeDir;
     }, [activeDir, activeLocale]);
-    return (_jsx(ErrorBoundary, { FallbackComponent: AppErrorBoundary, onError: onError, children: _jsx(FimoLocaleProvider, { value: {
-                ...localeResolution,
-                locale: activeLocale,
-                dir: activeDir,
-            }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [_jsx(PreviewBridge, {}), _jsx(OptionalTracking, { routes: getDisplayRoutes() }), _jsx(Suspense, { children: children })] }) }) }) }) }) }));
+    return (_jsx(ErrorBoundary, { FallbackComponent: AppErrorBoundary, onError: onError, children: _jsx(EnsureQueryClient, { children: _jsx(FimoLocaleProvider, { value: {
+                    ...localeResolution,
+                    locale: activeLocale,
+                    dir: activeDir,
+                }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [_jsx(PreviewBridge, {}), _jsx(OptionalTracking, { routes: getDisplayRoutes() }), _jsx(Suspense, { children: children })] }) }) }) }) }) }) }));
 }

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

@@ -0,0 +1,2 @@
+export declare function BuiltWithBadge(): import("react").ReactPortal | null;
+//# sourceMappingURL=BuiltWithBadge.d.ts.map

package/dist/runtime/core/BuiltWithBadge.js

@@ -0,0 +1,68 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from 'react';
+import { createPortal } from 'react-dom';
+const STORAGE_KEY = 'fimoBadgeDismissed';
+export function BuiltWithBadge() {
+    const hideFimoBadge = __FIMO_HIDE_BADGE__;
+    const [visible, setVisible] = useState(false);
+    useEffect(() => {
+        try {
+            const dismissed = sessionStorage.getItem(STORAGE_KEY) === 'true';
+            setVisible(!dismissed);
+        }
+        catch {
+            setVisible(true);
+        }
+    }, []);
+    if (hideFimoBadge) {
+        return null;
+    } // hide fimo badge config
+    // @ts-ignore
+    if (!import.meta.env.PROD) {
+        return null;
+    } // only show in prod
+    if (!visible) {
+        return null;
+    }
+    if (typeof document === 'undefined') {
+        return null;
+    }
+    return createPortal(_jsx("div", { style: {
+            position: 'fixed',
+            right: '16px',
+            bottom: '16px',
+            zIndex: 100000,
+            margin: 0,
+        }, children: _jsxs("div", { style: {
+                display: 'flex',
+                alignItems: 'center',
+                gap: '8px',
+                borderRadius: '9999px',
+                color: '#fff',
+                boxShadow: '0 12px 30px rgba(0, 0, 0, 0.35)',
+                padding: '8px 12px',
+                fontSize: '12px',
+                lineHeight: 1.2,
+                backgroundColor: 'rgba(0, 0, 0, 0.9)',
+                fontFamily: 'ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, sans-serif',
+            }, children: [_jsxs("a", { href: "https://fimo.ai", target: "_blank", rel: "noopener noreferrer", style: {
+                        display: 'inline-flex',
+                        alignItems: 'center',
+                        gap: '8px',
+                        color: '#fff',
+                        textDecoration: 'none',
+                    }, children: [_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "18", height: "18", viewBox: "0 0 24 12", fill: "none", children: _jsx("path", { d: "M22.8569 4.85715H14.9866L15.9132 3.58186C16.5027 2.77062 17.4534 2.28627 18.4561 2.28627H22.8569C23.4882 2.28627 23.9999 1.7745 23.9999 1.14328C23.9999 0.512061 23.4884 0 22.8569 0H18.4561C16.7239 0 15.082 0.836671 14.0639 2.23798L12.1611 4.85715H6.9979C5.2657 4.85715 3.62379 5.69382 2.60567 7.09513L0.360255 10.1852C-0.0109321 10.6958 0.10251 11.4108 0.613142 11.7817C0.816023 11.9291 1.05119 12 1.28408 12C1.63755 12 1.98616 11.8366 2.20962 11.5288L4.45474 8.43872C5.04424 7.62748 5.99493 7.14314 6.99762 7.14314H10.5L8.28977 10.1852C7.91858 10.6958 8.03203 11.4108 8.54266 11.7817C8.74554 11.9291 8.98071 12 9.2136 12C9.56707 12 9.91568 11.8366 10.1391 11.5288L12.3843 8.43872C12.9738 7.62748 13.9244 7.14314 14.9271 7.14314H22.8566C23.4879 7.14314 23.9996 6.63136 23.9996 6.00014C23.9996 5.36893 23.4879 4.85715 22.8566 4.85715H22.8569Z", fill: "white" }) }), _jsx("span", { style: { fontWeight: 600 }, children: "Built with Fimo" })] }), _jsx("button", { "aria-label": "Dismiss badge", style: {
+                        color: '#ddd',
+                        background: 'transparent',
+                        cursor: 'pointer',
+                        border: 'none',
+                        padding: 0,
+                        lineHeight: 0,
+                    }, onClick: () => {
+                        try {
+                            sessionStorage.setItem(STORAGE_KEY, 'true');
+                        }
+                        catch { }
+                        setVisible(false);
+                    }, type: "button", children: _jsxs("svg", { xmlns: "http://www.w3.org/2000/svg", width: 14, height: 14, viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: 2, strokeLinecap: "round", strokeLinejoin: "round", "aria-hidden": true, children: [_jsx("path", { d: "M18 6 6 18" }), _jsx("path", { d: "m6 6 12 12" })] }) })] }) }), document.body);
+}

package/dist/runtime/primitives/components/RichText.d.ts

@@ -3,7 +3,11 @@ import { type FimoRichText, type FimoRichTextComponents } from '../lib/index.js'
 type RichTextProps = {
     value: FimoRichText;
     components?: FimoRichTextComponents;
+    /** Wrapper element. Use `span` when the block sits inside phrasing
+     *  content (a `<p>`): a div there is invalid HTML — the browser closes
+     *  the paragraph early and React trashes the hydrated tree. */
+    as?: 'div' | 'span';
 } & Omit<ComponentPropsWithoutRef<'div'>, 'children'>;
-export declare function RichText({ value, components, ...props }: RichTextProps): import("react/jsx-runtime").JSX.Element;
+export declare function RichText({ value, components, as: Wrapper, ...props }: RichTextProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=RichText.d.ts.map

package/dist/runtime/primitives/components/RichText.js

@@ -128,8 +128,8 @@ function renderNode(node, components, key) {
     }
     return _jsx(Fragment, { children: children }, key);
 }
-export function RichText({ value, components, ...props }) {
+export function RichText({ value, components, as: Wrapper = 'div', ...props }) {
     const source = value[FIMO_SOURCE];
     const { value: liveContent, ref } = useFimoLiveValue(value.content);
-    return (_jsx("div", { ref: ref, ...props, "data-fimo-source": source, "data-fimo-richtext": "", children: renderNode(liveContent, components, 0) }));
+    return (_jsx(Wrapper, { ref: ref, ...props, "data-fimo-source": source, "data-fimo-richtext": "", children: renderNode(liveContent, components, 0) }));
 }

package/dist/runtime/react/FimoSpaProviders.js

@@ -1,18 +1,11 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
 import { getFimoDefaultLocale, getFimoLocales } from '../i18n/locale.js';
-import { fetchLabelBundle, serializeBundle } from '../shared/labels-fetch.pure.js';
+import { fetchLabelBundle } from '../shared/labels-fetch.pure.js';
+import { fetchWrappedContent } from '../wrapped/content-fetch.pure.js';
 import { WrappedProviders } from '../wrapped/WrappedProviders.js';
-/** Browser-safe stable signature (labelSignature uses Buffer, server-only). */
-function bundleSignature(bundle) {
-    const serialized = serializeBundle(bundle);
-    let hash = 5381;
-    for (let i = 0; i < serialized.length; i++) {
-        hash = ((hash << 5) + hash + serialized.charCodeAt(i)) | 0;
-    }
-    return `spa-${hash}`;
-}
+import { readInitialSpaContent, spaBundleSignature, writeSpaContentCache } from './spa-content-cache.js';
 /**
  * Fimo providers for wrapped CLIENT-RENDERED React apps (Vite SPAs). There is
  * no server pass to load labels in, so this adapter fetches the dictionary in
@@ -33,31 +26,97 @@ function bundleSignature(bundle) {
  * router without depending on one.
  */
 export function FimoSpaProviders({ config, apiUrl, previewScriptUrl, media, richText, locale, children, }) {
-    const [labels, setLabels] = useState(undefined);
+    // Synchronous first paint: baked SSG payload or the last visit's cached
+    // one renders IMMEDIATELY (the SDK owns rendering — no fallback flash
+    // while the network round-trips); the fetches below revalidate it.
+    const initial = useMemo(() => readInitialSpaContent(apiUrl), [apiUrl]);
+    const [labels, setLabels] = useState(initial?.labels ?? undefined);
+    const [content, setContent] = useState(initial?.content ?? undefined);
+    const latestRef = useRef({
+        labels: initial?.labels ?? undefined,
+        content: initial?.content ?? undefined,
+    });
     useEffect(() => {
         if (!apiUrl) {
             return;
         }
-        let cancelled = false;
-        const defaultLocale = getFimoDefaultLocale(config);
-        fetchLabelBundle(apiUrl, getFimoLocales(config), defaultLocale)
-            .then((bundle) => {
-            if (!cancelled) {
-                setLabels({ ...bundle, signature: bundleSignature(bundle) });
+        let disposed = false;
+        const persist = () => {
+            writeSpaContentCache(apiUrl, { labels: latestRef.current.labels, content: latestRef.current.content });
+        };
+        const revalidate = () => {
+            const defaultLocale = getFimoDefaultLocale(config);
+            fetchLabelBundle(apiUrl, getFimoLocales(config), defaultLocale)
+                .then((bundle) => {
+                if (!disposed) {
+                    const next = { ...bundle, signature: spaBundleSignature(bundle) };
+                    latestRef.current.labels = next;
+                    setLabels(next);
+                    persist();
+                }
+            })
+                .catch(() => {
+                // Unreachable API: keep rendering the cached/baked values or fallbacks.
+            });
+            // Wrapped rich text and media live in the plumbing types — without this
+            // fetch a client-rendered app only ever shows their inline fallbacks
+            // and Studio edits to them render nowhere.
+            fetchWrappedContent(apiUrl)
+                .then((fetched) => {
+                if (!disposed) {
+                    latestRef.current.content = fetched;
+                    setContent(fetched);
+                    persist();
+                }
+            })
+                .catch(() => {
+                // Unreachable API: keep rendering the cached/baked values or fallbacks.
+            });
+        };
+        revalidate();
+        // Live updates, no refresh needed:
+        // 1. Inside the Fimo Studio preview, every save posts
+        //    `{ type: 'content/refresh' }` into the iframe — refetch on the spot
+        //    (same contract the template runtime's RefreshContentProvider uses).
+        // 2. In a plain tab, coming back to the site (alt-tab from the Studio)
+        //    revalidates on focus/visibility — edits appear without a reload.
+        let lastRun = Date.now();
+        const throttledRevalidate = () => {
+            if (Date.now() - lastRun < 1500) {
+                return;
+            }
+            lastRun = Date.now();
+            revalidate();
+        };
+        const onMessage = (event) => {
+            if (event.data?.type === 'content/refresh') {
+                lastRun = Date.now();
+                revalidate();
+            }
+        };
+        const onVisibility = () => {
+            if (document.visibilityState === 'visible') {
+                throttledRevalidate();
             }
-        })
-            .catch(() => {
-            // Unreachable API: keep rendering the inline fallbacks.
-        });
+        };
+        window.addEventListener('message', onMessage);
+        window.addEventListener('focus', throttledRevalidate);
+        document.addEventListener('visibilitychange', onVisibility);
         return () => {
-            cancelled = true;
+            disposed = true;
+            window.removeEventListener('message', onMessage);
+            window.removeEventListener('focus', throttledRevalidate);
+            document.removeEventListener('visibilitychange', onVisibility);
         };
     }, [apiUrl, config]);
+    // Explicitly-passed maps win over the fetched ones (caller override).
+    const mergedMedia = useMemo(() => (content?.media || media ? { ...(content?.media ?? {}), ...(media ?? {}) } : undefined), [content?.media, media]);
+    const mergedRichText = useMemo(() => (content?.richText || richText ? { ...(content?.richText ?? {}), ...(richText ?? {}) } : undefined), [content?.richText, richText]);
     const navigation = useMemo(() => ({
         pathname: typeof window !== 'undefined' ? window.location.pathname : null,
         navigate: (to) => {
             window.location.assign(to);
         },
     }), []);
-    return (_jsxs(WrappedProviders, { config: config, labels: labels, media: media, richText: richText, locale: locale, navigation: navigation, children: [previewScriptUrl ? _jsx("script", { type: "module", src: previewScriptUrl }) : null, children] }));
+    return (_jsxs(WrappedProviders, { config: config, labels: labels, media: mergedMedia, richText: mergedRichText, locale: locale, navigation: navigation, children: [previewScriptUrl ? _jsx("script", { type: "module", src: previewScriptUrl }) : null, children] }));
 }

package/dist/runtime/react/index.d.ts

@@ -30,4 +30,6 @@ export type { FimoLocaleResolution } from '../i18n/locale.js';
 export { getDisplayRoutes } from '../shared/display-routes.js';
 export type { DisplayRoute, ParamInfo } from '../shared/display-routes.js';
 export type { FimoConfig, FimoRouteConfig, FimoSEO } from '../shared/fimo-config.types.js';
+export { fetchFimoSpaContent, serializeFimoSpaContent } from './spa-content-cache.js';
+export type { SpaContentPayload } from './spa-content-cache.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/runtime/react/index.js

@@ -37,3 +37,4 @@ export { FimoLocaleProvider, useLocale } from '../i18n/FimoLocaleContext.js';
 export { getFimoDefaultLocale, getFimoLocales, getFimoTextDirection, localizeFimoPath, resolveFimoLocale, toHtmlLang, } from '../i18n/locale.js';
 // Config + routes
 export { getDisplayRoutes } from '../shared/display-routes.js';
+export { fetchFimoSpaContent, serializeFimoSpaContent } from './spa-content-cache.js';

package/dist/runtime/react/spa-content-cache.d.ts

@@ -0,0 +1,38 @@
+import type { FimoConfig } from '../shared/fimo-config.types.js';
+import { type LabelBundle } from '../shared/labels-fetch.pure.js';
+import { type WrappedContent } from '../wrapped/content-fetch.pure.js';
+import type { WrappedLabels } from '../wrapped/WrappedProviders.js';
+/**
+ * Instant first paint for client-rendered wrapped apps: the SDK controls
+ * rendering, so it never has to flash fallbacks while the network round
+ * trips. Two synchronous sources, in priority order:
+ *
+ * 1. `window.__FIMO_CONTENT__` — baked by the site's SSG/prerender step
+ *    (`serializeFimoSpaContent`), zero flash even on the first ever visit;
+ * 2. the last fetched payload cached in localStorage — instant from the
+ *    second visit on, revalidated in the background (stale-while-revalidate).
+ */
+export interface SpaContentPayload {
+    labels?: WrappedLabels;
+    content?: WrappedContent;
+}
+declare global {
+    interface Window {
+        __FIMO_CONTENT__?: SpaContentPayload;
+    }
+}
+export declare function readInitialSpaContent(apiUrl: string | undefined): SpaContentPayload | null;
+export declare function writeSpaContentCache(apiUrl: string, payload: SpaContentPayload): void;
+/** Browser-safe stable signature (labelSignature uses Buffer, server-only). */
+export declare function spaBundleSignature(bundle: LabelBundle): string;
+/**
+ * Build-time half of the bake: fetch the exact payload the provider's
+ * background revalidation produces (labels with the same signature shape,
+ * wrapped rich text + media), ready for `serializeFimoSpaContent`. Runs
+ * anywhere `fetch` exists — an SSG/prerender node script included.
+ */
+export declare function fetchFimoSpaContent(apiUrl: string, config: FimoConfig): Promise<SpaContentPayload>;
+/** SSG helper: a script tag baking the payload into prerendered HTML so the
+ *  provider hydrates it synchronously — zero content flash. */
+export declare function serializeFimoSpaContent(payload: SpaContentPayload): string;
+//# sourceMappingURL=spa-content-cache.d.ts.map

package/dist/runtime/react/spa-content-cache.js

@@ -0,0 +1,64 @@
+import { getFimoDefaultLocale, getFimoLocales } from '../i18n/locale.js';
+import { fetchLabelBundle, serializeBundle } from '../shared/labels-fetch.pure.js';
+import { fetchWrappedContent } from '../wrapped/content-fetch.pure.js';
+const CACHE_PREFIX = 'fimo:spa-content:';
+export function readInitialSpaContent(apiUrl) {
+    if (typeof window === 'undefined') {
+        return null;
+    }
+    if (window.__FIMO_CONTENT__ && typeof window.__FIMO_CONTENT__ === 'object') {
+        return window.__FIMO_CONTENT__;
+    }
+    if (!apiUrl) {
+        return null;
+    }
+    try {
+        const raw = window.localStorage.getItem(CACHE_PREFIX + apiUrl);
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeSpaContentCache(apiUrl, payload) {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    try {
+        window.localStorage.setItem(CACHE_PREFIX + apiUrl, JSON.stringify(payload));
+    }
+    catch {
+        // Quota/private mode: the cache is an optimization, never a requirement.
+    }
+}
+/** Browser-safe stable signature (labelSignature uses Buffer, server-only). */
+export function spaBundleSignature(bundle) {
+    const serialized = serializeBundle(bundle);
+    let hash = 5381;
+    for (let i = 0; i < serialized.length; i++) {
+        hash = ((hash << 5) + hash + serialized.charCodeAt(i)) | 0;
+    }
+    return `spa-${hash}`;
+}
+/**
+ * Build-time half of the bake: fetch the exact payload the provider's
+ * background revalidation produces (labels with the same signature shape,
+ * wrapped rich text + media), ready for `serializeFimoSpaContent`. Runs
+ * anywhere `fetch` exists — an SSG/prerender node script included.
+ */
+export async function fetchFimoSpaContent(apiUrl, config) {
+    const [labels, content] = await Promise.all([
+        fetchLabelBundle(apiUrl, getFimoLocales(config), getFimoDefaultLocale(config)).then((bundle) => ({
+            ...bundle,
+            signature: spaBundleSignature(bundle),
+        })),
+        fetchWrappedContent(apiUrl),
+    ]);
+    return { labels, content };
+}
+/** SSG helper: a script tag baking the payload into prerendered HTML so the
+ *  provider hydrates it synchronously — zero content flash. */
+export function serializeFimoSpaContent(payload) {
+    const json = JSON.stringify(payload).replace(/</g, '\\u003c');
+    return `<script>window.__FIMO_CONTENT__=${json}</script>`;
+}

package/dist/runtime/seo/neutral.d.ts

@@ -0,0 +1,22 @@
+import type { FimoSEO } from '../shared/fimo-config.types.js';
+/**
+ * The framework-neutral `fimo/seo` surface: pure per-page SEO resolution over
+ * the page registry (`fimo-config.json#routes`), with no framework adapter,
+ * no vite virtual module, and no React. Every framework's injection recipe
+ * (Next `generateMetadata`, an Astro head component, a SvelteKit load) calls
+ * `getFimoSeoForPath` server-side and maps the result to its own head API.
+ * SEO stays wired only when the project owner explicitly opted into
+ * Fimo-managed SEO — the migration never wires it by default.
+ */
+export { resolveSeoForPath } from './resolver.js';
+export type { FimoSEO, RouteSEO } from '../shared/fimo-config.types.js';
+export interface GetFimoSeoOptions {
+    /** Project root holding fimo-config.json (default: process.cwd()). */
+    rootDir?: string;
+    /** Instance data for `{{variable}}` templates in route-level SEO (e.g. the
+     *  entry rendered by a dynamic page: `{ "blog-post": entry }`). */
+    routeData?: Record<string, unknown>;
+}
+/** Resolve the SEO values for one page path from the page registry on disk. */
+export declare function getFimoSeoForPath(pathname: string, options?: GetFimoSeoOptions): FimoSEO | undefined;
+//# sourceMappingURL=neutral.d.ts.map

package/dist/runtime/seo/neutral.js

@@ -0,0 +1,17 @@
+import { getConfigServer } from '../shared/fimo-config.server.js';
+import { resolveSeoForPath } from './resolver.js';
+/**
+ * The framework-neutral `fimo/seo` surface: pure per-page SEO resolution over
+ * the page registry (`fimo-config.json#routes`), with no framework adapter,
+ * no vite virtual module, and no React. Every framework's injection recipe
+ * (Next `generateMetadata`, an Astro head component, a SvelteKit load) calls
+ * `getFimoSeoForPath` server-side and maps the result to its own head API.
+ * SEO stays wired only when the project owner explicitly opted into
+ * Fimo-managed SEO — the migration never wires it by default.
+ */
+export { resolveSeoForPath } from './resolver.js';
+/** Resolve the SEO values for one page path from the page registry on disk. */
+export function getFimoSeoForPath(pathname, options = {}) {
+    const config = getConfigServer(options.rootDir ?? process.cwd());
+    return resolveSeoForPath(pathname, config, options.routeData);
+}

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

@@ -4,5 +4,4 @@ import type { FimoConfig } from './fimo-config.types.js';
  * Reads JSON directly to avoid virtual module issues during config loading.
  */
 export declare function getConfigServer(rootDir: string): FimoConfig;
-export declare function getConfigVersion(rootDir: string): number;
 //# sourceMappingURL=fimo-config.server.d.ts.map

package/dist/runtime/shared/fimo-config.server.js

@@ -2,7 +2,6 @@ import { readFileSync } from 'fs';
 import { resolve } from 'path';
 // Matches the template's fimo-config.json (`version: "4"`) and the agents
 // workspace default — the fallback when a config omits the field.
-const LATEST_TEMPLATE_VERSION = 4;
 const defaultConfig = {
     seo: undefined,
 };
@@ -27,15 +26,3 @@ export function getConfigServer(rootDir) {
         return defaultConfig;
     }
 }
-export function getConfigVersion(rootDir) {
-    try {
-        const configPath = resolve(rootDir, 'fimo-config.json');
-        const content = readFileSync(configPath, 'utf-8');
-        const raw = JSON.parse(content);
-        const parsed = Number.parseInt(String(raw.version ?? LATEST_TEMPLATE_VERSION), 10);
-        return Number.isFinite(parsed) && parsed > 0 ? parsed : LATEST_TEMPLATE_VERSION;
-    }
-    catch {
-        return LATEST_TEMPLATE_VERSION;
-    }
-}

package/dist/runtime/strapi/client.js

@@ -57,15 +57,40 @@ export function parseStrapiUrl(rawUrl, apiPrefix = '/api') {
         where: Object.keys(where).length > 0 ? where : undefined,
     };
 }
+const isDev = () => typeof process !== 'undefined' && process.env != null && process.env.NODE_ENV !== 'production';
 /** Build a `fetch`-compatible function that serves scaffolded content from Fimo. */
 export function createFimoStrapiFetch(options, realFetch = fetch) {
     const singletons = new Set(options.singletons ?? []);
     const read = { apiUrl: options.apiUrl, rootDir: options.rootDir };
+    // Lowercased type-name index, used only to flag a *near-miss* fallthrough: a
+    // path segment that looks like a scaffolded type but doesn't match a TYPES key
+    // (the classic singular-vs-plural keying bug). Genuinely foreign paths
+    // (`/api/upload/files`) don't match and stay silent.
+    const typeNamesLower = new Set(Object.values(options.types).map((name) => name.toLowerCase()));
+    const warnedPaths = new Set();
+    const warnNearMiss = (segment) => {
+        if (!isDev() || warnedPaths.has(segment)) {
+            return;
+        }
+        const seg = segment.toLowerCase();
+        const nearMiss = typeNamesLower.has(seg) ||
+            typeNamesLower.has(seg.replace(/s$/, '')) ||
+            typeNamesLower.has(seg.replace(/ies$/, 'y'));
+        if (nearMiss) {
+            warnedPaths.add(segment);
+            console.warn(`[fimo/strapi] /api/${segment} looks like a scaffolded type but is not in the type map — ` +
+                `this read fell through to the live CMS. If a single type reads empty, its map key is likely ` +
+                `plural where the fetch is singular (regenerate with \`fimo migrate --scaffold-cms\`).`);
+        }
+    };
     return (async (input, init) => {
         const rawUrl = typeof input === 'string' ? input : input instanceof URL ? input.href : input.url;
         const parsed = parseStrapiUrl(rawUrl ?? '', options.apiPrefix);
         const typeName = parsed ? options.types[parsed.pluralName] : undefined;
         if (!parsed || !typeName) {
+            if (parsed) {
+                warnNearMiss(parsed.pluralName);
+            }
             return realFetch(input, init); // not a mapped content read → real CMS
         }
         const entries = await fetchEntries(typeName, {
@@ -73,11 +98,29 @@ export function createFimoStrapiFetch(options, realFetch = fetch) {
             ...(parsed.where ? { where: parsed.where } : {}),
             ...(parsed.pageSize ? { limit: parsed.pageSize } : {}),
         });
+        const shapes = options.fieldShapes?.[typeName];
+        const single = Boolean(parsed.documentId) || singletons.has(typeName);
         if (entries.length === 0) {
+            // A FILTERED miss on a type Fimo owns (it has entries) answers with the
+            // honest empty envelope — the document just doesn't exist. Falling
+            // through here would leak every unknown-slug read (404s included) to the
+            // old CMS: dead-CMS timeouts, and content resurrection when it's alive.
+            if (parsed.where || parsed.documentId) {
+                const any = await fetchEntries(typeName, { ...read, limit: 1 });
+                if (any.length > 0) {
+                    // Canonical Strapi shapes: collection miss → 200 `{data: []}`,
+                    // document miss → 404 with the Strapi error body.
+                    const empty = single
+                        ? { data: null, error: { status: 404, name: 'NotFoundError', message: 'Not Found', details: {} } }
+                        : fimoEntriesToStrapiList([], { pageSize: parsed.pageSize, total: 0, shapes });
+                    return new Response(JSON.stringify(empty), {
+                        status: single ? 404 : 200,
+                        headers: { 'content-type': 'application/json' },
+                    });
+                }
+            }
             return realFetch(input, init); // nothing scaffolded → fall back to the CMS
         }
-        const shapes = options.fieldShapes?.[typeName];
-        const single = Boolean(parsed.documentId) || singletons.has(typeName);
         const payload = single
             ? fimoEntryToStrapiSingle(parsed.documentId ? (entries.find((e) => e.id === parsed.documentId) ?? entries[0]) : entries[0], shapes)
             : fimoEntriesToStrapiList(entries, { pageSize: parsed.pageSize, total: entries.length, shapes });

package/dist/runtime/strapi/reshape.d.ts

@@ -17,15 +17,19 @@ export interface StrapiSingleEnvelope {
 }
 /**
  * The field-shape manifest, baked into the generated `fimo-strapi.ts` by the
- * migration. It carries ONLY the structural (blocks) fields — a Fimo blocks
- * value is always an array, but a Strapi single component reads as an object, so
- * the reshape needs to know which array to unwrap. Leaf fields (scalars, media,
- * richtext, references) never appear here; they are handled by value-inspection.
+ * migration. It carries the structural (blocks) fields — a Fimo blocks value
+ * is always an array, but a Strapi single component reads as an object, so
+ * the reshape needs to know which array to unwrap — plus to-many relations
+ * ('many-ref'), whose array invariant value-inspection cannot hold on its
+ * own. Other leaf fields (scalars, media, richtext, single references) never
+ * appear here; they are handled by value-inspection.
  * Kept in sync with `computeFieldShapes` in `scripts/cms/strapi/shapes.ts`.
  */
 export interface BlockFieldShape {
-    /** 'single' → unwrap the one-item array to an object; 'list' → keep the array. */
-    readonly kind: 'single' | 'list';
+    /** 'single' → unwrap the one-item array to an object; 'list' → keep the
+     *  array; 'many-ref' → a to-many relation, coerced to an array whatever
+     *  arrives (a frontend iterating a oneToMany 500s on a stray object). */
+    readonly kind: 'single' | 'list' | 'many-ref';
     /** Nested structural shapes for a fixed-shape block (single/repeatable component). */
     readonly fields?: FieldShapes;
     /** Per-variant nested shapes for a dynamic zone, keyed by variant uid (`_type`). */

package/dist/runtime/strapi/reshape.js

@@ -74,6 +74,13 @@ function reshapeFieldValue(value, shape) {
     if (!shape) {
         return reshapeValue(value);
     }
+    if (shape.kind === 'many-ref') {
+        // Array invariant for to-many relations: null/undefined → [], a stray
+        // single handle → [handle]. Items are leaves (populated relation objects
+        // or reference handles), never block items.
+        const items = Array.isArray(value) ? value : value == null ? [] : [value];
+        return items.map(reshapeValue);
+    }
     const items = Array.isArray(value) ? value : [];
     if (shape.kind === 'single') {
         return items.length > 0 ? reshapeBlockItem(items[0], shape) : null;

package/dist/runtime/wrapped/FimoRichTextBlock.d.ts

@@ -7,6 +7,9 @@ interface FimoRichTextBlockProps {
     children?: ReactNode;
     components?: FimoRichTextComponents;
     className?: string;
+    /** Wrapper element — `span` when the block sits inside a `<p>` (a div
+     *  there is invalid HTML and breaks hydration). */
+    as?: 'div' | 'span';
 }
 /**
  * Wraps formatted text (bold, italic, underline, links) so it becomes
@@ -18,6 +21,6 @@ interface FimoRichTextBlockProps {
  *     <p>We help teams <strong>ship faster</strong> and <em>stay safe</em>.</p>
  *   </FimoRichTextBlock>
  */
-export declare function FimoRichTextBlock({ id, children, components, className }: FimoRichTextBlockProps): import("react/jsx-runtime").JSX.Element;
+export declare function FimoRichTextBlock({ id, children, components, className, as }: FimoRichTextBlockProps): import("react/jsx-runtime").JSX.Element;
 export {};
 //# sourceMappingURL=FimoRichTextBlock.d.ts.map

package/dist/runtime/wrapped/FimoRichTextBlock.js

@@ -13,10 +13,10 @@ import { useWrappedRichText } from './WrappedContentContext.js';
  *     <p>We help teams <strong>ship faster</strong> and <em>stay safe</em>.</p>
  *   </FimoRichTextBlock>
  */
-export function FimoRichTextBlock({ id, children, components, className }) {
+export function FimoRichTextBlock({ id, children, components, className, as }) {
     const entry = useWrappedRichText(id);
     if (!entry) {
         return _jsx(_Fragment, { children: children });
     }
-    return (_jsx(RichText, { value: new FimoRichText(entry.content, entry.source), components: components, className: className }));
+    return (_jsx(RichText, { value: new FimoRichText(entry.content, entry.source), components: components, className: className, as: as }));
 }