fimo 0.8.0 → 0.9.0-experimental.10

package/dist/runtime/strapi/reshape.js

@@ -0,0 +1,121 @@
+// Native `fimo/strapi` read adapter — the generic reshape from Fimo entries
+// (as `fetchEntries` returns them) into the Strapi-v5 response shape a wrapped
+// Strapi frontend's components read. Value-inspection based, so it is generic:
+// no content-type or field names are hardcoded. Relation POPULATION (turning a
+// reference handle into a nested object) is resolved one level up in the client
+// — this module reshapes a single entry's own field values.
+/** ProseMirror/TipTap doc → plain text (Strapi richtext is a string; string
+ *  consumers like read-time estimates must never receive an object). */
+function docToText(node) {
+    if (!node || typeof node !== 'object') {
+        return '';
+    }
+    const record = node;
+    if (typeof record.text === 'string') {
+        return record.text;
+    }
+    if (Array.isArray(record.content)) {
+        return record.content.map(docToText).join(' ').trim();
+    }
+    return '';
+}
+function isRichTextDoc(value) {
+    return Boolean(value) && typeof value === 'object' && value.type === 'doc';
+}
+/** A Fimo media value (seeded/loaded as `{ url, alt, width, height, … }`). */
+function isMedia(value) {
+    return (Boolean(value) &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        typeof value.url === 'string');
+}
+function reshapeMedia(value) {
+    return {
+        url: value.url,
+        alternativeText: value.alt ?? value.alternativeText ?? null,
+        ...(typeof value.width === 'number' ? { width: value.width } : {}),
+        ...(typeof value.height === 'number' ? { height: value.height } : {}),
+        ...(typeof value.name === 'string' ? { name: value.name } : {}),
+        ...(typeof value.mime === 'string' ? { mime: value.mime } : {}),
+    };
+}
+function reshapeValue(value) {
+    if (isRichTextDoc(value)) {
+        return docToText(value);
+    }
+    if (isMedia(value)) {
+        return reshapeMedia(value);
+    }
+    return value; // scalars, arrays, reference handles pass through
+}
+/** Reshape one block item: drop Fimo-internal `_key`/`_type` (exposing `_key` as
+ *  Strapi's `id`), keep everything else — `__component` passes through, nested
+ *  structural fields recurse per the manifest, leaves are value-inspected. */
+function reshapeBlockItem(item, shape) {
+    if (!item || typeof item !== 'object' || Array.isArray(item)) {
+        return {};
+    }
+    const record = item;
+    const nested = shape.variants ? (shape.variants[String(record._type)] ?? {}) : (shape.fields ?? {});
+    const out = {};
+    if (typeof record._key === 'string') {
+        out.id = record._key;
+    }
+    for (const [key, value] of Object.entries(record)) {
+        if (key === '_key' || key === '_type') {
+            continue;
+        }
+        out[key] = reshapeFieldValue(value, nested[key]);
+    }
+    return out;
+}
+/** Reshape a single field value against its manifest entry. No entry → a leaf. */
+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;
+    }
+    return items.map((item) => reshapeBlockItem(item, shape));
+}
+function reshapeEntryData(data, shapes) {
+    const out = {};
+    for (const [field, value] of Object.entries(data)) {
+        out[field] = reshapeFieldValue(value, shapes[field]);
+    }
+    return out;
+}
+/** One Fimo entry → one Strapi-v5 item (`id` + `documentId` + reshaped fields). */
+export function fimoEntryToStrapiItem(entry, shapes = {}) {
+    return { id: entry.id, documentId: entry.id, ...reshapeEntryData(entry.data, shapes) };
+}
+/** Fimo entries → a Strapi-v5 collection envelope (`{ data, meta.pagination }`). */
+export function fimoEntriesToStrapiList(entries, options = {}) {
+    const data = entries.map((entry) => fimoEntryToStrapiItem(entry, options.shapes));
+    const total = options.total ?? data.length;
+    const pageSize = options.pageSize ?? (data.length || 1);
+    return {
+        data,
+        meta: {
+            pagination: {
+                page: options.page ?? 1,
+                pageSize,
+                pageCount: pageSize > 0 ? Math.max(1, Math.ceil(total / pageSize)) : 1,
+                total,
+            },
+        },
+    };
+}
+/** Fimo entry → a Strapi-v5 single/singleton envelope (`{ data, meta }`). */
+export function fimoEntryToStrapiSingle(entry, shapes = {}) {
+    return { data: entry ? fimoEntryToStrapiItem(entry, shapes) : null, meta: {} };
+}

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

@@ -0,0 +1,3 @@
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/svelte/index.js

@@ -0,0 +1,7 @@
+// fimo/svelte — CLIENT-SAFE surface for .svelte components (they hydrate:
+// importing the server barrel here pulls node builtins into the client
+// bundle, the exact class the Nuxt dogfood broke on). Server loaders live in
+// fimo/svelte/server, called from +layout.server.ts / +page.server.ts —
+// SvelteKit's own server-only convention.
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';

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

@@ -0,0 +1,3 @@
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/svelte/server.js

@@ -0,0 +1,6 @@
+// fimo/svelte/server — SvelteKit adapter, server surface. The loaders are
+// framework-neutral (SvelteKit needs no React): call them in server-side code
+// (frontmatter / load functions / useAsyncData) and render values with the
+// DOM attribute helpers so edit mode can select the elements.
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';

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

@@ -0,0 +1,3 @@
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/vue/index.js

@@ -0,0 +1,5 @@
+// fimo/vue — CLIENT-SAFE surface for Vue SFCs (same rule as fimo/svelte:
+// never re-export the server barrel from a surface component code imports).
+// Server loaders live in fimo/vue/server.
+export { fimoLabelAttrs, fimoMediaAttrs, FIMO_SOURCE_ATTR } from '../wrapped/dom.js';
+export { makeFimoT } from '../shared/labels-t.pure.js';

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

@@ -0,0 +1,3 @@
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/vue/server.js

@@ -0,0 +1,6 @@
+// fimo/vue/server — Vue adapter, server surface. The loaders are
+// framework-neutral (Vue needs no React): call them in server-side code
+// (frontmatter / load functions / useAsyncData) and render values with the
+// DOM attribute helpers so edit mode can select the elements.
+export * from '../wrapped/server.js';
+export { fimoLabelAttrs, fimoMediaAttrs } from '../wrapped/dom.js';

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

@@ -0,0 +1,17 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+type FimoFileLinkProps = Omit<ComponentPropsWithoutRef<'a'>, 'id'> & {
+    /** WrappedMedia entry key, e.g. `home.whitepaper`. Seeded at migration time. */
+    id: string;
+    children?: ReactNode;
+};
+/**
+ * Wraps a hardcoded file link (pdf, zip, ...) so the file becomes replaceable
+ * in Fimo. The original `href` stays in code as the fallback:
+ *
+ *   <FimoFileLink id="home.whitepaper" href="/whitepaper.pdf">
+ *     <FimoText id="home.whitepaper.cta">Download the whitepaper</FimoText>
+ *   </FimoFileLink>
+ */
+export declare function FimoFileLink({ id, href, children, ...props }: FimoFileLinkProps): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FimoFileLink.d.ts.map

package/dist/runtime/wrapped/FimoFileLink.js

@@ -0,0 +1,19 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { FIMO_SOURCE } from '../primitives/lib/index.js';
+import { useWrappedMedia } from './WrappedContentContext.js';
+/**
+ * Wraps a hardcoded file link (pdf, zip, ...) so the file becomes replaceable
+ * in Fimo. The original `href` stays in code as the fallback:
+ *
+ *   <FimoFileLink id="home.whitepaper" href="/whitepaper.pdf">
+ *     <FimoText id="home.whitepaper.cta">Download the whitepaper</FimoText>
+ *   </FimoFileLink>
+ */
+export function FimoFileLink({ id, href, children, ...props }) {
+    const media = useWrappedMedia(id);
+    if (media) {
+        return (_jsx("a", { href: media.url, "data-fimo-source": media[FIMO_SOURCE], ...props, children: children }));
+    }
+    return (_jsx("a", { href: href, ...props, children: children }));
+}

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

@@ -0,0 +1,14 @@
+import { type ComponentPropsWithoutRef } from 'react';
+type FimoMediaImageProps = Omit<ComponentPropsWithoutRef<'img'>, 'id' | 'children'> & {
+    /** WrappedMedia entry key, e.g. `home.hero.image`. Seeded at migration time. */
+    id: string;
+};
+/**
+ * Wraps a hardcoded image so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaImage id="home.hero.image" src="/images/dashboard.png" alt="Dashboard" width={1200} height={630} />
+ */
+export declare function FimoMediaImage({ id, src, alt, ...props }: FimoMediaImageProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=FimoMediaImage.d.ts.map

package/dist/runtime/wrapped/FimoMediaImage.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Image } from '../primitives/components/Image.js';
+import { useWrappedMedia } from './WrappedContentContext.js';
+/**
+ * Wraps a hardcoded image so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaImage id="home.hero.image" src="/images/dashboard.png" alt="Dashboard" width={1200} height={630} />
+ */
+export function FimoMediaImage({ id, src, alt, ...props }) {
+    const media = useWrappedMedia(id);
+    if (media) {
+        return _jsx(Image, { value: media, alt: alt, ...props });
+    }
+    if (!src) {
+        return null;
+    }
+    return _jsx("img", { src: src, alt: alt, ...props });
+}

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

@@ -0,0 +1,14 @@
+import { type ComponentPropsWithoutRef } from 'react';
+type FimoMediaVideoProps = Omit<ComponentPropsWithoutRef<'video'>, 'id' | 'children'> & {
+    /** WrappedMedia entry key, e.g. `home.demo.video`. Seeded at migration time. */
+    id: string;
+};
+/**
+ * Wraps a hardcoded video so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaVideo id="home.demo.video" src="/demo.mp4" autoPlay muted loop />
+ */
+export declare function FimoMediaVideo({ id, src, autoPlay, loop, muted, playsInline, ...props }: FimoMediaVideoProps): import("react/jsx-runtime").JSX.Element | null;
+export {};
+//# sourceMappingURL=FimoMediaVideo.d.ts.map

package/dist/runtime/wrapped/FimoMediaVideo.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Video } from '../primitives/components/Video.js';
+import { useWrappedMedia } from './WrappedContentContext.js';
+/**
+ * Wraps a hardcoded video so it becomes replaceable in Fimo. The original
+ * `src` stays in code as the fallback until the WrappedMedia entry resolves:
+ *
+ *   <FimoMediaVideo id="home.demo.video" src="/demo.mp4" autoPlay muted loop />
+ */
+export function FimoMediaVideo({ id, src, autoPlay, loop, muted, playsInline, ...props }) {
+    const media = useWrappedMedia(id);
+    if (media) {
+        return _jsx(Video, { value: media, autoPlay: autoPlay, loop: loop, muted: muted, playsInline: playsInline, ...props });
+    }
+    if (!src) {
+        return null;
+    }
+    return _jsx("video", { src: src, autoPlay: autoPlay, loop: loop, muted: muted, playsInline: playsInline, ...props });
+}

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

@@ -0,0 +1,26 @@
+import { type ReactNode } from 'react';
+import { type FimoRichTextComponents } from '../primitives/lib/index.js';
+interface FimoRichTextBlockProps {
+    /** WrappedRichText entry key, e.g. `home.hero.subtitle`. Seeded at migration time. */
+    id: string;
+    /** The original formatted markup — rendered when the entry is absent. */
+    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
+ * editable with marks in Fimo. Seeding converts the original markup to
+ * TipTap JSON; the renderer emits the same tags back. The original JSX
+ * stays in code as the fallback:
+ *
+ *   <FimoRichTextBlock id="home.hero.subtitle">
+ *     <p>We help teams <strong>ship faster</strong> and <em>stay safe</em>.</p>
+ *   </FimoRichTextBlock>
+ */
+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

@@ -0,0 +1,22 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { RichText } from '../primitives/components/RichText.js';
+import { FimoRichText } from '../primitives/lib/index.js';
+import { useWrappedRichText } from './WrappedContentContext.js';
+/**
+ * Wraps formatted text (bold, italic, underline, links) so it becomes
+ * editable with marks in Fimo. Seeding converts the original markup to
+ * TipTap JSON; the renderer emits the same tags back. The original JSX
+ * stays in code as the fallback:
+ *
+ *   <FimoRichTextBlock id="home.hero.subtitle">
+ *     <p>We help teams <strong>ship faster</strong> and <em>stay safe</em>.</p>
+ *   </FimoRichTextBlock>
+ */
+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, as: as }));
+}

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

@@ -0,0 +1,22 @@
+import { type ComponentPropsWithoutRef, type ElementType } from 'react';
+type FimoTextProps<T extends ElementType = 'span'> = {
+    /** Label key, e.g. `home.hero.title`. Seeded at migration time. */
+    id: string;
+    /** The original hardcoded string — rendered when the key has no value. */
+    children?: string;
+    as?: T;
+} & Omit<ComponentPropsWithoutRef<T>, 'id' | 'as' | 'children'>;
+/**
+ * Wraps a hardcoded string so it becomes editable in Fimo. The original
+ * string stays in code as the fallback:
+ *
+ *   <h1><FimoText id="home.hero.title">Ship your site in hours</FimoText></h1>
+ *
+ * For attribute strings use the two-argument label function instead:
+ *
+ *   const { t } = useLabels();
+ *   <input placeholder={String(t('home.newsletter.placeholder', 'Your work email'))} />
+ */
+export declare function FimoText<T extends ElementType = 'span'>({ id, children, as, ...props }: FimoTextProps<T>): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=FimoText.d.ts.map

package/dist/runtime/wrapped/FimoText.js

@@ -0,0 +1,20 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from '../primitives/components/Text.js';
+import { useLabels } from '../primitives/labels-hook.js';
+/**
+ * Wraps a hardcoded string so it becomes editable in Fimo. The original
+ * string stays in code as the fallback:
+ *
+ *   <h1><FimoText id="home.hero.title">Ship your site in hours</FimoText></h1>
+ *
+ * For attribute strings use the two-argument label function instead:
+ *
+ *   const { t } = useLabels();
+ *   <input placeholder={String(t('home.newsletter.placeholder', 'Your work email'))} />
+ */
+export function FimoText({ id, children, as, ...props }) {
+    const { t } = useLabels();
+    const textProps = { value: t(id, children), as, ...props };
+    return _jsx(Text, { ...textProps });
+}

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

@@ -0,0 +1,28 @@
+import React from 'react';
+import { FIMO_SOURCE, FimoMedia, type FimoRichTextContent } from '../primitives/lib/index.js';
+export interface WrappedMediaEntry {
+    url: string;
+    alt?: string;
+    name?: string;
+    mime?: string;
+    width?: number;
+    height?: number;
+    /** data-fimo-source path, e.g. `WrappedMedia.<entryId>.image` */
+    source: string;
+}
+export interface WrappedRichTextEntry {
+    content: FimoRichTextContent;
+    /** data-fimo-source path, e.g. `WrappedRichText.<entryId>.body` */
+    source: string;
+}
+export interface WrappedContentValue {
+    media: Record<string, WrappedMediaEntry>;
+    richText: Record<string, WrappedRichTextEntry>;
+}
+export declare function WrappedContentProvider({ media, richText, children, }: Partial<WrappedContentValue> & {
+    children?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useWrappedMedia(id: string): FimoMedia | null;
+export declare function useWrappedRichText(id: string): WrappedRichTextEntry | null;
+export { FIMO_SOURCE };
+//# sourceMappingURL=WrappedContentContext.d.ts.map

package/dist/runtime/wrapped/WrappedContentContext.js

@@ -0,0 +1,30 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { FIMO_SOURCE, FimoMedia } from '../primitives/lib/index.js';
+const emptyValue = { media: {}, richText: {} };
+const WrappedContentContext = createContext(emptyValue);
+export function WrappedContentProvider({ media, richText, children, }) {
+    const value = useMemo(() => ({ media: media ?? {}, richText: richText ?? {} }), [media, richText]);
+    return _jsx(WrappedContentContext.Provider, { value: value, children: children });
+}
+export function useWrappedMedia(id) {
+    const { media } = useContext(WrappedContentContext);
+    const entry = media[id];
+    if (!entry) {
+        return null;
+    }
+    return new FimoMedia({
+        url: entry.url,
+        alt: entry.alt ?? '',
+        name: entry.name ?? id,
+        mime: entry.mime ?? '',
+        width: entry.width,
+        height: entry.height,
+    }, entry.source);
+}
+export function useWrappedRichText(id) {
+    const { richText } = useContext(WrappedContentContext);
+    return richText[id] ?? null;
+}
+export { FIMO_SOURCE };

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

@@ -0,0 +1,33 @@
+import React from 'react';
+import type { FimoConfig } from '../shared/fimo-config.types.js';
+import { type WrappedMediaEntry, type WrappedRichTextEntry } from './WrappedContentContext.js';
+export interface WrappedLabels {
+    dictionaries: Record<string, Record<string, string>>;
+    defaultLocale: string;
+    locales?: string[];
+    updatedAt?: string | null;
+    signature: string;
+}
+/** Framework navigation adapter: the ONLY thing an adapter must supply. */
+export interface WrappedNavigation {
+    pathname: string | null;
+    navigate: (to: string) => void;
+}
+export interface WrappedProvidersProps {
+    config: FimoConfig;
+    labels?: WrappedLabels;
+    media?: Record<string, WrappedMediaEntry>;
+    richText?: Record<string, WrappedRichTextEntry>;
+    locale?: string;
+    navigation: WrappedNavigation;
+    children?: React.ReactNode;
+}
+/**
+ * Framework-neutral providers for WRAPPED (adopted) apps. Adapters
+ * (fimo/next, fimo/remix, ...) supply only the navigation hooks; everything
+ * else — label hydration, locale resolution, preview bridge, error boundary —
+ * is shared. Content arrives as serializable props from the wrapped server
+ * loaders.
+ */
+export declare function WrappedProviders({ config, labels, media, richText, locale, navigation, children }: WrappedProvidersProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=WrappedProviders.d.ts.map

package/dist/runtime/wrapped/WrappedProviders.js

@@ -0,0 +1,101 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { Suspense, useCallback, useEffect, useMemo, useState } from 'react';
+import { ErrorBoundary } from 'react-error-boundary';
+import { DataSourcesProvider } from '../content/DataSourcesProvider.js';
+import { AppErrorBoundary, onError } from '../core/AppErrorBoundary.js';
+import { FimoLocaleProvider } from '../i18n/FimoLocaleContext.js';
+import { getFimoTextDirection, resolveFimoLocale, toHtmlLang } from '../i18n/locale.js';
+import { ScreenshotProvider } from '../iframe/ScreenshotProvider.js';
+import { hydrateLabels } from '../primitives/labels-store.js';
+import { getDisplayRoutes } from '../shared/display-routes.js';
+import { WrappedContentProvider } from './WrappedContentContext.js';
+function toLabelState(labels) {
+    return {
+        dictionaries: labels.dictionaries,
+        defaultLocale: labels.defaultLocale,
+        signature: labels.signature,
+        updatedAt: labels.updatedAt ?? null,
+    };
+}
+function PreviewBridge({ config, navigation }) {
+    const { pathname, navigate } = navigation;
+    const localeResolution = useMemo(() => resolveFimoLocale({ pathname: pathname ?? undefined }, config), [pathname, config]);
+    const sendRoutes = useCallback(() => {
+        window.parent.postMessage({ type: 'nav/routes', payload: { routes: getDisplayRoutes(config) } }, '*');
+    }, [config]);
+    const sendLocationChange = useCallback(() => {
+        window.parent.postMessage({
+            type: 'nav/locationChange',
+            payload: {
+                path: pathname,
+                routePath: localeResolution.routePath,
+                locale: localeResolution.locale,
+            },
+        }, '*');
+    }, [pathname, localeResolution.locale, localeResolution.routePath]);
+    useEffect(sendRoutes, [sendRoutes]);
+    useEffect(sendLocationChange, [sendLocationChange]);
+    useEffect(() => {
+        const handleMessage = (event) => {
+            const type = event.data?.type;
+            const payload = event.data?.payload;
+            switch (type) {
+                case 'nav/navigate':
+                    if (payload?.to) {
+                        navigate(payload.to);
+                    }
+                    return;
+                case 'nav/read-routes':
+                    sendRoutes();
+                    sendLocationChange();
+                    return;
+            }
+        };
+        window.addEventListener('message', handleMessage);
+        return () => {
+            window.removeEventListener('message', handleMessage);
+        };
+    }, [navigate, sendRoutes, sendLocationChange]);
+    return null;
+}
+/**
+ * Framework-neutral providers for WRAPPED (adopted) apps. Adapters
+ * (fimo/next, fimo/remix, ...) supply only the navigation hooks; everything
+ * else — label hydration, locale resolution, preview bridge, error boundary —
+ * is shared. Content arrives as serializable props from the wrapped server
+ * loaders.
+ */
+export function WrappedProviders({ config, labels, media, richText, locale, navigation, children }) {
+    // Wrapped apps have no QueryClientProvider of their own; ScreenshotProvider
+    // (and future data-refresh machinery) need one, so the adapter owns it.
+    const [queryClient] = useState(() => new QueryClient());
+    useState(() => {
+        if (labels) {
+            hydrateLabels(toLabelState(labels));
+        }
+        return null;
+    });
+    useEffect(() => {
+        if (labels) {
+            hydrateLabels(toLabelState(labels));
+        }
+    }, [labels]);
+    const pathname = navigation.pathname;
+    const localeResolution = useMemo(() => resolveFimoLocale({ pathname: pathname ?? undefined }, config), [pathname, config]);
+    const activeLocale = locale ?? localeResolution.locale;
+    const activeDir = getFimoTextDirection(activeLocale);
+    useEffect(() => {
+        if (typeof document === 'undefined') {
+            return;
+        }
+        document.documentElement.lang = toHtmlLang(activeLocale);
+        document.documentElement.dir = activeDir;
+    }, [activeDir, activeLocale]);
+    return (_jsx(ErrorBoundary, { FallbackComponent: AppErrorBoundary, onError: onError, children: _jsx(QueryClientProvider, { client: queryClient, children: _jsx(FimoLocaleProvider, { value: {
+                    ...localeResolution,
+                    locale: activeLocale,
+                    dir: activeDir,
+                }, children: _jsx(WrappedContentProvider, { media: media, richText: richText, children: _jsx(DataSourcesProvider, { children: _jsxs(ScreenshotProvider, { children: [_jsx(PreviewBridge, { config: config, navigation: navigation }), _jsx(Suspense, { children: children })] }) }) }) }) }) }));
+}

package/dist/runtime/wrapped/content-fetch.pure.d.ts

@@ -0,0 +1,20 @@
+import type { WrappedMediaEntry, WrappedRichTextEntry } from './WrappedContentContext.js';
+export interface WrappedEntryRow {
+    id: string;
+    data: Record<string, unknown>;
+}
+/** Every published row of a content type, paginated to the end. Returns []
+ *  when the API is unreachable so wrapped sites keep their fallbacks. */
+export declare function fetchAllWrappedRows(apiUrl: string, typeName: string): Promise<WrappedEntryRow[]>;
+/** WrappedMedia rows → key → media entry (the FimoMediaImage/Video id map). */
+export declare function mapWrappedMedia(rows: WrappedEntryRow[]): Record<string, WrappedMediaEntry>;
+/** WrappedRichText rows → key → TipTap content (the FimoRichTextBlock map). */
+export declare function mapWrappedRichText(rows: WrappedEntryRow[]): Record<string, WrappedRichTextEntry>;
+export interface WrappedContent {
+    media: Record<string, WrappedMediaEntry>;
+    richText: Record<string, WrappedRichTextEntry>;
+}
+/** Both plumbing maps in one round: what a client-rendered wrapped app needs
+ *  so Studio edits to rich text and media are LIVE, not fallback-only. */
+export declare function fetchWrappedContent(apiUrl: string): Promise<WrappedContent>;
+//# sourceMappingURL=content-fetch.pure.d.ts.map