fimo 0.16.0 → 0.18.0

package/dist/runtime/app/FimoProviders.js

@@ -15,6 +15,7 @@ import { ScreenshotProvider } from '../iframe/ScreenshotProvider.js';
 import { getSafePreviewNavigationPath, isPreviewRuntimeEnabled } from '../preview/bridge.js';
 import { getPreviewLocationChange, getPreviewParentOrigin } from '../preview/location.js';
 import { getActiveRouterRoutes } from '../react-router/active-routes.js';
+import { matchFimoRoute } from '../routes/contract.js';
 import { OptionalTracking } from '../t/OptionalTracking.js';
 export { getPreviewLocationChange, getPreviewLocationPath } from '../preview/location.js';
 const titleCase = (seg) => seg
@@ -45,6 +46,21 @@ function getConfigDisplayRoutes() {
 function getCanonicalRoutePath(path) {
     return resolveFimoLocale({ pathname: path }, fimoConfig).routePath;
 }
+/**
+ * The locale a pathname renders.
+ *
+ * The declared route decides it. A route that declares no `:locale` segment is
+ * app-owned and renders the default locale whatever its first segment spells,
+ * which is what stops `/fr` from switching the page to French when `fr` is
+ * really an entry slug under a top-level `/:slug` route.
+ *
+ * Only a URL that no declared route answers falls back to the compatibility
+ * prefix resolver. Existing apps can still rely on that inference while new
+ * route-owned integrations pass an explicit locale to `FimoProviders`.
+ */
+function getRouteLocale(pathname) {
+    return (matchFimoRoute(pathname, fimoConfig)?.locale ?? resolveFimoLocale({ pathname }, fimoConfig).locale);
+}
 function hasReadableFrameworkManifest(manifest) {
     return Boolean(manifest &&
         typeof manifest === 'object' &&
@@ -84,27 +100,20 @@ export function getDisplayRoutes(frameworkManifest) {
  * `nav/read-routes`) and reads routes through the `readRoutes` callback, so a
  * future non-React-Router runtime reuses it by supplying its own reader.
  */
-function PreviewBridge({ readRoutes }) {
+function PreviewBridge({ readRoutes, locale }) {
     const navigate = useNavigate();
     const location = useLocation();
-    const localeResolution = useMemo(() => resolveFimoLocale({ pathname: location.pathname }, fimoConfig), [location.pathname]);
     const sendRoutes = useCallback(() => {
         // Read at send time: the router can change its route table in place
         // during HMR, so an explicit nav/read-routes must see the current state.
         window.parent.postMessage({ type: 'nav/routes', payload: { routes: readRoutes() } }, getPreviewParentOrigin() ?? '*');
     }, [readRoutes]);
+    // `locale` is a dependency on purpose: an app that settles a new locale
+    // without moving the pathname still has to tell Studio about it.
     const sendLocationChange = useCallback(() => {
-        const locationChange = getPreviewLocationChange(location);
         const parentOrigin = getPreviewParentOrigin();
-        window.parent.postMessage({
-            type: 'nav/locationChange',
-            payload: {
-                ...(parentOrigin ? locationChange : { path: locationChange.path }),
-                routePath: localeResolution.routePath,
-                locale: localeResolution.locale,
-            },
-        }, parentOrigin ?? '*');
-    }, [location.hash, location.pathname, location.search, localeResolution.locale, localeResolution.routePath]);
+        window.parent.postMessage({ type: 'nav/locationChange', payload: getPreviewLocationChange(location, locale, parentOrigin) }, parentOrigin ?? '*');
+    }, [location.hash, location.pathname, location.search, locale]);
     useEffect(sendRoutes, [sendRoutes]);
     useEffect(sendLocationChange, [sendLocationChange]);
     useEffect(() => {
@@ -156,7 +165,9 @@ export function FimoProviders({ children, locale }) {
     const readRoutes = useCallback(() => getDisplayRoutes(frameworkContext?.manifest), [frameworkContext?.manifest]);
     const routes = readRoutes();
     const localeResolution = useMemo(() => resolveFimoLocale({ pathname: location.pathname }, fimoConfig), [location.pathname]);
-    const activeLocale = locale ?? localeResolution.locale;
+    // The app is authoritative: an explicit `locale` wins over anything Fimo can
+    // infer, and inference itself goes through the declared route contract.
+    const activeLocale = useMemo(() => locale ?? getRouteLocale(location.pathname), [locale, location.pathname]);
     const activeDir = getFimoTextDirection(activeLocale);
     // @ts-ignore - import.meta.env is provided by Vite and React Router.
     const previewEnabled = isPreviewRuntimeEnabled(import.meta.env.VITE_PREVIEW_SCRIPT_URL);
@@ -171,5 +182,5 @@ export function FimoProviders({ children, locale }) {
                     ...localeResolution,
                     locale: activeLocale,
                     dir: activeDir,
-                }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [previewEnabled ? _jsx(PreviewBridge, { readRoutes: readRoutes }) : null, _jsx(OptionalTracking, { routes: routes }), _jsx(Suspense, { children: children })] }) }) }) }) }) }) }));
+                }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [previewEnabled ? _jsx(PreviewBridge, { readRoutes: readRoutes, locale: activeLocale }) : null, _jsx(OptionalTracking, { routes: routes }), _jsx(Suspense, { children: children })] }) }) }) }) }) }) }));
 }

package/dist/runtime/app/prefetch.d.ts

@@ -1,7 +1,9 @@
 export declare function resolveFimoLocaleForUrl(url: string): import("./index.js").FimoLocaleResolution;
 /**
  * Fetch route data for SEO meta resolution.
- * Only fetches data for detail pages (routes with `params` in .fimo/config.json).
+ *
+ * Only entry params are fetched: a locale param is resolved from the URL and
+ * never corresponds to a CMS schema, so it must not produce a request.
  */
 export declare function resolveMetaEntries(url: string): Promise<Record<string, unknown> | undefined>;
 //# sourceMappingURL=prefetch.d.ts.map

package/dist/runtime/app/prefetch.js

@@ -1,57 +1,15 @@
 // @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
 import fimoConfig from 'virtual:fimo-config';
 import { resolveFimoLocale } from '../i18n/locale.js';
-/**
- * Match a concrete URL against the routes in .fimo/config.json.
- * Returns the matching route config or null.
- */
-function matchRoute(url) {
-    const config = fimoConfig;
-    const localeResolution = resolveFimoLocale(url, config);
-    const pathname = localeResolution.routePath;
-    const routes = config.routes ?? {};
-    for (const [id, config] of Object.entries(routes)) {
-        if (!config.path) {
-            continue;
-        }
-        const patternSegments = config.path.split('/').filter(Boolean);
-        const urlSegments = pathname.split('/').filter(Boolean);
-        if (patternSegments.length !== urlSegments.length) {
-            continue;
-        }
-        const paramValues = {};
-        let match = true;
-        for (let i = 0; i < patternSegments.length; i++) {
-            const pattern = patternSegments[i];
-            const value = urlSegments[i];
-            if (pattern.startsWith(':')) {
-                paramValues[pattern.slice(1)] = value;
-            }
-            else if (pattern !== value) {
-                match = false;
-                break;
-            }
-        }
-        if (match) {
-            return { id, config, paramValues };
-        }
-    }
-    // Handle index route
-    if (pathname === '/' || pathname === '') {
-        for (const [id, config] of Object.entries(routes)) {
-            if (config.path === '/') {
-                return { id, config, paramValues: {} };
-            }
-        }
-    }
-    return null;
-}
+import { matchFimoRoute } from '../routes/contract.js';
 export function resolveFimoLocaleForUrl(url) {
     return resolveFimoLocale(url, fimoConfig);
 }
 /**
  * Fetch route data for SEO meta resolution.
- * Only fetches data for detail pages (routes with `params` in .fimo/config.json).
+ *
+ * Only entry params are fetched: a locale param is resolved from the URL and
+ * never corresponds to a CMS schema, so it must not produce a request.
  */
 export async function resolveMetaEntries(url) {
     // @ts-ignore – import.meta.env is a Vite feature, replaced at build time for both client and SSR
@@ -59,24 +17,22 @@ export async function resolveMetaEntries(url) {
     if (!base) {
         return undefined;
     }
-    const localeResolution = resolveFimoLocaleForUrl(url);
-    const route = matchRoute(url);
-    if (!route?.config.params) {
+    const match = matchFimoRoute(url, fimoConfig);
+    if (!match || match.contract.entryParams.length === 0) {
         return undefined;
     }
     const data = {};
-    await Promise.all(Object.entries(route.config.params).map(async ([paramName, paramInfo]) => {
-        const value = route.paramValues[paramName];
+    await Promise.all(match.contract.entryParams.map(async (param) => {
+        const value = match.entryParams[param.name];
         if (!value) {
             return;
         }
-        const { schema, queryField } = paramInfo;
-        const entryUrl = new URL(`${base}/entries/${schema}/field/${encodeURIComponent(queryField)}/${encodeURIComponent(value)}`);
-        entryUrl.searchParams.set('locale', localeResolution.locale);
+        const entryUrl = new URL(`${base}/entries/${param.schema}/field/${encodeURIComponent(param.queryField)}/${encodeURIComponent(value)}`);
+        entryUrl.searchParams.set('locale', match.locale);
         const res = await fetch(entryUrl);
         if (res.ok) {
             const json = await res.json();
-            data[paramName] = json.data;
+            data[param.name] = json.data;
         }
     }));
     return Object.keys(data).length > 0 ? data : undefined;

package/dist/runtime/astro/preview.js

@@ -1,6 +1,6 @@
-import { resolveFimoLocale } from '../i18n/locale.js';
+import { getFimoDefaultLocale } from '../i18n/locale.js';
 import { getSafePreviewNavigationPath, isPreviewRuntimeEnabled } from '../preview/bridge.js';
-import { getPreviewLocationChange, getPreviewParentOrigin } from '../preview/location.js';
+import { getDocumentLocale, getPreviewLocationChange, getPreviewParentOrigin } from '../preview/location.js';
 const ASTRO_PAGE_LOAD_EVENT = 'astro:page-load';
 const ASTRO_AFTER_SWAP_EVENT = 'astro:after-swap';
 const CONNECTION_KEY = '__fimoAstroPreviewDisconnect__';
@@ -43,16 +43,14 @@ export function connectAstroPreview(options, browser = currentBrowser()) {
     const sendRoutes = () => {
         postToStudio({ type: 'nav/routes', payload: { routes: options.routes } });
     };
+    // Astro settles the locale server-side and renders it into `<html lang>`, so
+    // reading it back reports the locale the document is actually showing rather
+    // than one inferred from the URL. `astro:page-load` fires after a ClientRouter
+    // swap as well, which is what keeps this correct across in-place navigation.
     const sendLocation = () => {
-        const location = getPreviewLocationChange(browser.window.location);
-        const locale = resolveFimoLocale({ pathname: browser.window.location.pathname }, { i18n: options.i18n });
         postToStudio({
             type: 'nav/locationChange',
-            payload: {
-                ...(parentOrigin ? location : { path: location.path }),
-                routePath: locale.routePath,
-                locale: browser.document.documentElement.lang || locale.locale,
-            },
+            payload: getPreviewLocationChange(browser.window.location, getDocumentLocale(browser.document, getFimoDefaultLocale({ i18n: options.i18n })), parentOrigin),
         });
     };
     const announceDocumentChange = () => {

package/dist/runtime/content/client/internal.js

@@ -203,6 +203,7 @@ function wrapField(field, value, source, resolve) {
         case 'string':
         case 'text':
         case 'date':
+        case 'datetime':
             return value != null ? new FimoString(String(value), source) : value;
         case 'richtext':
             return value != null ? new FimoRichText(value, source) : value;

package/dist/runtime/i18n/locale.d.ts

@@ -16,6 +16,10 @@ export interface FimoLocaleRequestLike {
 export declare function getFimoDefaultLocale(config: Pick<FimoConfig, 'i18n'> | undefined): string;
 export declare function getFimoLocales(config: Pick<FimoConfig, 'i18n'> | undefined): string[];
 export declare function resolveFimoLocale(requestLike: string | URL | FimoLocaleRequestLike, config: Pick<FimoConfig, 'i18n'> | undefined): FimoLocaleResolution;
+/**
+ * Rewrite a path so it renders in `locale`. The default locale is always
+ * unprefixed — `/en/pricing` is not a path Fimo produces or recognizes.
+ */
 export declare function localizeFimoPath(path: string, locale: string, config: Pick<FimoConfig, 'i18n'> | undefined): string;
 export declare function getFimoTextDirection(locale: string): 'ltr' | 'rtl';
 export declare function toHtmlLang(locale: string): string;

package/dist/runtime/i18n/locale.js

@@ -16,12 +16,14 @@ export function resolveFimoLocale(requestLike, config) {
     const pathname = normalizePathname(readPathname(requestLike));
     const defaultLocale = getFimoDefaultLocale(config);
     const locales = getFimoLocales(config);
-    const routing = config?.i18n?.routing;
-    const strategy = routing?.strategy ?? 'path-prefix';
-    const prefixDefaultLocale = routing?.prefixDefaultLocale === true;
+    // New route-owned projects do not need this setting. Keep reading it for
+    // older apps whose provider or navigation still relies on global prefixes.
+    const strategy = config?.i18n?.routing?.strategy ?? 'path-prefix';
     if (strategy === 'path-prefix') {
         const [firstSegment, ...rest] = pathname.split('/').filter(Boolean);
-        if (firstSegment && locales.includes(firstSegment)) {
+        // The default locale has no prefixed form, so a leading `/en` is an
+        // ordinary route segment rather than a locale marker.
+        if (firstSegment && firstSegment !== defaultLocale && locales.includes(firstSegment)) {
             const routePath = normalizePathname(`/${rest.join('/')}`);
             return {
                 locale: firstSegment,
@@ -30,7 +32,7 @@ export function resolveFimoLocale(requestLike, config) {
                 pathname,
                 routePath,
                 prefix: firstSegment,
-                isDefaultLocale: firstSegment === defaultLocale,
+                isDefaultLocale: false,
                 dir: getFimoTextDirection(firstSegment),
             };
         }
@@ -40,7 +42,7 @@ export function resolveFimoLocale(requestLike, config) {
             locales,
             pathname,
             routePath: pathname,
-            prefix: prefixDefaultLocale ? defaultLocale : null,
+            prefix: null,
             isDefaultLocale: true,
             dir: getFimoTextDirection(defaultLocale),
         };
@@ -56,16 +58,14 @@ export function resolveFimoLocale(requestLike, config) {
         dir: getFimoTextDirection(defaultLocale),
     };
 }
+/**
+ * Rewrite a path so it renders in `locale`. The default locale is always
+ * unprefixed — `/en/pricing` is not a path Fimo produces or recognizes.
+ */
 export function localizeFimoPath(path, locale, config) {
     const routePath = resolveFimoLocale(path, config).routePath;
-    const defaultLocale = getFimoDefaultLocale(config);
-    const routing = config?.i18n?.routing;
-    const strategy = routing?.strategy ?? 'path-prefix';
-    const prefixDefaultLocale = routing?.prefixDefaultLocale === true;
-    if (strategy !== 'path-prefix') {
-        return routePath;
-    }
-    if (locale === defaultLocale && !prefixDefaultLocale) {
+    const strategy = config?.i18n?.routing?.strategy ?? 'path-prefix';
+    if (strategy !== 'path-prefix' || locale === getFimoDefaultLocale(config)) {
         return routePath;
     }
     return normalizePathname(`/${locale}${routePath === '/' ? '' : routePath}`);

package/dist/runtime/next/client-runtime.js

@@ -4,7 +4,11 @@ export const nextClientContentRuntime = {
         return requireContentApiUrl(process.env.NEXT_PUBLIC_FIMO_API_URL, 'NEXT_PUBLIC_FIMO_API_URL');
     },
     defaultLocale() {
-        return process.env.NEXT_PUBLIC_FIMO_DEFAULT_LOCALE?.trim() || 'en';
+        // The application resolves locale from its own configuration and routes and
+        // passes it through `FimoProvider`. `undefined` leaves `locale` off the
+        // request so the API answers with the project default; an environment
+        // variable must never become the project's source of truth for it.
+        return undefined;
     },
     headers(extra) {
         const headers = { ...extra };

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

@@ -13,6 +13,7 @@ export type { CollectionContentCore, CollectionPage, CollectionPageInfo, Content
 export { FIMO_PARTS, FIMO_SOURCE, FimoBoolean, FimoDate, FimoMedia, FimoRichText, FimoString, getFimoParts, getFimoSource, hasFimoSource, isFimoDate, isFimoString, } from '../content/index.js';
 export { Boolean } from '../react/primitives/editable/Boolean.js';
 export { Date } from '../react/primitives/editable/Date.js';
+export { DateTime } from '../react/primitives/editable/DateTime.js';
 export { Image } from '../react/primitives/editable/Image.js';
 export { Json } from '../react/primitives/editable/Json.js';
 export { RichText } from '../react/primitives/editable/RichText.js';
@@ -21,7 +22,7 @@ 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, FimoRichTextContent, FimoSource, NullOnlyOps, NumberOps, Populate, Populated, PopulatedResult, Projected, ProjectedWithPopulate, Query, ReferenceField, ReferenceMap, ScalarOps, Sort, SortField, StringOps, Where, WithReferences, } from '../content/index.js';
 export type { FimoRichTextComponents, FimoRichTextMarkProps, FimoRichTextNodeProps, } from '../react/primitives/contracts.js';
-export { FimoProvider, useLabels } from './provider.js';
-export type { FimoProviderProps } from './provider.js';
+export { FimoPreviewBridge, FimoProvider, useLabels } from './provider.js';
+export type { FimoPreviewBridgeProps, FimoProviderProps } from './provider.js';
 export type { Labels, LabelsSnapshot } from '../labels/core.js';
 //# sourceMappingURL=client.d.ts.map

package/dist/runtime/next/client.js

@@ -15,10 +15,11 @@ export { createContentCore, createSingletonCore } from '../content/index.js';
 export { FIMO_PARTS, FIMO_SOURCE, FimoBoolean, FimoDate, FimoMedia, FimoRichText, FimoString, getFimoParts, getFimoSource, hasFimoSource, isFimoDate, isFimoString, } from '../content/index.js';
 export { Boolean } from '../react/primitives/editable/Boolean.js';
 export { Date } from '../react/primitives/editable/Date.js';
+export { DateTime } from '../react/primitives/editable/DateTime.js';
 export { Image } from '../react/primitives/editable/Image.js';
 export { Json } from '../react/primitives/editable/Json.js';
 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 { FimoProvider, useLabels } from './provider.js';
+export { FimoPreviewBridge, FimoProvider, useLabels } from './provider.js';

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

@@ -1,7 +1,7 @@
 import { type GetLabelsOptions } from '../labels/fetch.js';
 /**
- * Read the labels for an application-resolved locale. When omitted, locale
- * comes from the runtime's default-locale variable.
+ * Read the labels for an application-resolved locale. When omitted, the request
+ * carries no locale and the Fimo API answers with the project default locale.
  */
 export declare function getLabels(options?: GetLabelsOptions): Promise<import("./client.js").Labels>;
 //# sourceMappingURL=labels.d.ts.map

package/dist/runtime/next/labels.js

@@ -1,8 +1,8 @@
 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 the runtime's default-locale variable.
+ * Read the labels for an application-resolved locale. When omitted, the request
+ * carries no locale and the Fimo API answers with the project default locale.
  */
 export function getLabels(options) {
     return fetchLabels(nextServerContentRuntime, options);

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

@@ -0,0 +1,13 @@
+interface NextPreviewBrowser {
+    readonly window: Pick<Window, 'addEventListener' | 'location' | 'parent' | 'removeEventListener' | 'sessionStorage'>;
+    readonly document: Pick<Document, 'referrer'>;
+}
+type NextPreviewConnection = {
+    readonly locale: string;
+    readonly navigate: (to: string) => unknown;
+    readonly pathname: string;
+    readonly previewScriptUrl: string | undefined;
+};
+export declare function connectNextPreview({ locale, navigate, pathname, previewScriptUrl }: NextPreviewConnection, browser?: NextPreviewBrowser): () => void;
+export {};
+//# sourceMappingURL=preview.d.ts.map

package/dist/runtime/next/preview.js

@@ -0,0 +1,34 @@
+import { getSafePreviewNavigationPath, isPreviewRuntimeEnabled } from '../preview/bridge.js';
+import { getPreviewLocationChange, getPreviewParentOrigin } from '../preview/location.js';
+export function connectNextPreview({ locale, navigate, pathname, previewScriptUrl }, browser = { window, document }) {
+    if (!isPreviewRuntimeEnabled(previewScriptUrl)) {
+        return () => undefined;
+    }
+    const parentOrigin = getPreviewParentOrigin(browser);
+    const sendLocationChange = () => {
+        browser.window.parent.postMessage({
+            type: 'nav/locationChange',
+            payload: getPreviewLocationChange({ pathname, search: browser.window.location.search, hash: browser.window.location.hash }, locale, parentOrigin),
+        }, parentOrigin ?? '*');
+    };
+    const handleMessage = (event) => {
+        if (event.source !== browser.window.parent || !parentOrigin || event.origin !== parentOrigin) {
+            return;
+        }
+        if (event.data?.type === 'nav/navigate') {
+            const target = getSafePreviewNavigationPath(event.data?.payload?.to, browser.window.location.origin);
+            if (target) {
+                navigate(target);
+            }
+            return;
+        }
+        if (event.data?.type === 'nav/read-routes') {
+            sendLocationChange();
+        }
+    };
+    browser.window.addEventListener('message', handleMessage);
+    sendLocationChange();
+    return () => {
+        browser.window.removeEventListener('message', handleMessage);
+    };
+}

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

@@ -2,6 +2,8 @@ import { type ElementType } from 'react';
 import type { BooleanProps, DateProps, ImageProps, JsonProps, RichTextProps, VideoProps } from '../../react/primitives/contracts.js';
 export declare function Boolean<T extends ElementType = 'span'>({ value, as, children, ...props }: BooleanProps<T>): import("react/jsx-runtime").JSX.Element | null;
 export declare function Date({ value, ...props }: DateProps): import("react/jsx-runtime").JSX.Element | null;
+/** Renders a `datetime` field: the `dateTime` attribute keeps the whole instant. */
+export declare function DateTime({ value, ...props }: DateProps): import("react/jsx-runtime").JSX.Element | null;
 export declare function Image(props: ImageProps): import("react/jsx-runtime").JSX.Element | null;
 export declare function Json<T extends ElementType = 'span'>({ value, as, children, ...props }: JsonProps<T>): import("react/jsx-runtime").JSX.Element | null;
 export declare function RichText({ value, components, ...props }: RichTextProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/runtime/next/primitives/server.js

@@ -19,6 +19,14 @@ export function Date({ value, ...props }) {
     const source = typeof value === 'object' && FIMO_SOURCE in value ? (value[FIMO_SOURCE] ?? undefined) : undefined;
     return _jsx(DateRenderer, { ...props, value: value, source: source });
 }
+/** Renders a `datetime` field: the `dateTime` attribute keeps the whole instant. */
+export function DateTime({ value, ...props }) {
+    if (!value) {
+        return null;
+    }
+    const source = typeof value === 'object' && FIMO_SOURCE in value ? (value[FIMO_SOURCE] ?? undefined) : undefined;
+    return _jsx(DateRenderer, { ...props, value: value, source: source, precision: "instant" });
+}
 export function Image(props) {
     if (!props.value) {
         return null;

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

@@ -8,6 +8,11 @@ export interface FimoProviderProps {
     queryClient?: QueryClient;
 }
 export declare function FimoProvider({ children, labels, locale, queryClient }: FimoProviderProps): import("react/jsx-runtime").JSX.Element;
+export interface FimoPreviewBridgeProps {
+    readonly navigate: (to: string) => unknown;
+    readonly pathname: string;
+}
+export declare function FimoPreviewBridge({ navigate, pathname }: FimoPreviewBridgeProps): ReactNode;
 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,9 +1,16 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { createContext, useContext, useMemo, useState } from 'react';
+import { createContext, useContext, useEffect, useMemo, useState } from 'react';
 import { createLabels } from '../labels/core.js';
-import { nextClientContentRuntime } from './client-runtime.js';
+import { connectNextPreview } from './preview.js';
+/**
+ * Last resort when an application renders `FimoProvider` without a locale and
+ * without labels. The project's default locale lives in
+ * `.fimo/config.json#i18n.defaultLocale`, which the application reads and passes
+ * in; no environment variable participates.
+ */
+const UNRESOLVED_LOCALE = 'en';
 const FimoNextContext = createContext({});
 export function FimoProvider({ children, labels, locale, queryClient }) {
     const [client] = useState(() => queryClient ?? new QueryClient());
@@ -11,13 +18,20 @@ export function FimoProvider({ children, labels, locale, queryClient }) {
     const value = useMemo(() => ({ labels, locale: activeLocale }), [activeLocale, labels]);
     return (_jsx(FimoNextContext.Provider, { value: value, children: _jsx(QueryClientProvider, { client: client, children: children }) }));
 }
+export function FimoPreviewBridge({ navigate, pathname }) {
+    const context = useContext(FimoNextContext);
+    const locale = context.locale ?? UNRESOLVED_LOCALE;
+    const previewScriptUrl = process.env.NEXT_PUBLIC_FIMO_PREVIEW_SCRIPT_URL;
+    useEffect(() => connectNextPreview({ locale, navigate, pathname, previewScriptUrl }), [locale, navigate, pathname, previewScriptUrl]);
+    return null;
+}
 export function useNextContentLocale(requestedLocale, defaultLocale) {
     const context = useContext(FimoNextContext);
     return requestedLocale ?? context.locale ?? defaultLocale;
 }
 export function useLabels() {
     const context = useContext(FimoNextContext);
-    const locale = context.locale ?? nextClientContentRuntime.defaultLocale() ?? 'en';
+    const locale = context.locale ?? UNRESOLVED_LOCALE;
     const snapshot = context.labels?.locale === locale
         ? context.labels
         : { locale, labels: {}, updatedAt: null };

package/dist/runtime/next/server-runtime.js

@@ -4,7 +4,10 @@ export const nextServerContentRuntime = {
         return requireContentApiUrl(process.env.FIMO_CONTENT_API_URL, 'FIMO_CONTENT_API_URL');
     },
     defaultLocale() {
-        return process.env.FIMO_DEFAULT_LOCALE?.trim() || undefined;
+        // `undefined` leaves `locale` off the request so the tenant API answers with
+        // the project default declared in `.fimo/config.json#i18n.defaultLocale`.
+        // Route-resolved locales reach Fimo through `createFimo`/`getLabels`.
+        return undefined;
     },
     headers(extra) {
         const headers = { ...extra };

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

@@ -1,7 +1,7 @@
 import type { CollectionContentCore, ContentClientConfig, SingletonContentCore } from '../content/client/core-types.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 { Boolean, Date, DateTime, 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';

package/dist/runtime/next/server.js

@@ -3,7 +3,7 @@ import { createFormClient } from '../forms/index.js';
 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 { Boolean, Date, DateTime, Image, Json, RichText, Video } from './primitives/server.js';
 export { createFimo } from './facade.js';
 export { getLabels } from './labels.js';
 export function createContentClient(config) {

package/dist/runtime/paths/get-fimo-paths.d.ts

@@ -5,11 +5,12 @@ import type { FimoPath, GetFimoPathsOptions } from './types.js';
  * robots.txt, or any per-route logic.
  *
  * - Static paths in config: emitted as-is.
- * - Dynamic paths (with `:slug`-style params): expanded by fetching schema
- *   entries from `VITE_API_URL`. One returned entry per dynamic expansion.
- * - With `i18n.routing.strategy: "path-prefix"`, paths are emitted for every
- *   configured locale: default locale unprefixed by default, non-default
- *   locales prefixed (`/es/...`). The app router still needs matching routes.
+ * - Dynamic paths (with `:slug`-style entry params): expanded by fetching
+ *   schema entries from `VITE_API_URL`. One returned entry per expansion.
+ * - Locales come from the route contract, not from the project locale list: a
+ *   route is emitted once per locale only when its path declares a `:locale`
+ *   segment. The default locale is always unprefixed. A route without a
+ *   `:locale` segment yields exactly one default-locale path.
  * - Pure-string return shape (`p.path`) is suitable for RR's `prerender`.
  *
  * If no API URL is set, dynamic routes are skipped with a console warning.