fimo 0.14.0 → 0.15.0-staging.2

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

@@ -1,5 +1,5 @@
 import React from 'react';
-export { getPreviewLocationChange, getPreviewLocationPath } from '../react-router/preview-location.js';
+export { getPreviewLocationChange, getPreviewLocationPath } from '../preview/location.js';
 export interface ParamInfo {
     schema: string;
     queryField: string;

package/dist/runtime/app/FimoProviders.js

@@ -12,10 +12,11 @@ import { ViteLifecycles } from '../core/ViteLifecycles.js';
 import { FimoLocaleProvider } from '../i18n/FimoLocaleContext.js';
 import { getFimoTextDirection, resolveFimoLocale, toHtmlLang } from '../i18n/locale.js';
 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 { getPreviewLocationChange, getPreviewParentOrigin, } from '../react-router/preview-location.js';
 import { OptionalTracking } from '../t/OptionalTracking.js';
-export { getPreviewLocationChange, getPreviewLocationPath } from '../react-router/preview-location.js';
+export { getPreviewLocationChange, getPreviewLocationPath } from '../preview/location.js';
 const titleCase = (seg) => seg
     .replace(/[_-]+/g, ' ')
     .replace(/([a-z])([A-Z])/g, '$1 $2')
@@ -116,8 +117,11 @@ function PreviewBridge({ readRoutes }) {
             const payload = event.data?.payload;
             switch (type) {
                 case 'nav/navigate':
-                    if (payload?.to) {
-                        navigate(payload.to);
+                    {
+                        const target = getSafePreviewNavigationPath(payload?.to, window.location.origin);
+                        if (target) {
+                            navigate(target);
+                        }
                     }
                     return;
                 case 'nav/read-routes':
@@ -154,6 +158,8 @@ export function FimoProviders({ children, locale }) {
     const localeResolution = useMemo(() => resolveFimoLocale({ pathname: location.pathname }, fimoConfig), [location.pathname]);
     const activeLocale = locale ?? localeResolution.locale;
     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);
     useEffect(() => {
         if (typeof document === 'undefined') {
             return;
@@ -165,5 +171,5 @@ export function FimoProviders({ children, locale }) {
                     ...localeResolution,
                     locale: activeLocale,
                     dir: activeDir,
-                }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [_jsx(PreviewBridge, { readRoutes: readRoutes }), _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 }) : null, _jsx(OptionalTracking, { routes: routes }), _jsx(Suspense, { children: children })] }) }) }) }) }) }) }));
 }

package/dist/runtime/astro/internal.d.ts

@@ -0,0 +1,6 @@
+export { renderRichTextHtml } from './render-rich-text.js';
+export { resolveImagePresentation, type ImageFit } from '../primitives/lib/image-optimization.js';
+export { connectAstroPreview, type AstroPreviewOptions } from './preview.js';
+type AstroImageStyle = string | Record<string, unknown> | undefined;
+export declare function mergeAstroImageStyle(style: AstroImageStyle, objectFit: string): AstroImageStyle;
+//# sourceMappingURL=internal.d.ts.map

package/dist/runtime/astro/internal.js

@@ -0,0 +1,16 @@
+export { renderRichTextHtml } from './render-rich-text.js';
+export { resolveImagePresentation } from '../primitives/lib/image-optimization.js';
+export { connectAstroPreview } from './preview.js';
+export function mergeAstroImageStyle(style, objectFit) {
+    if (typeof style === 'string') {
+        if (/(?:^|;)\s*object-fit\s*:/i.test(style)) {
+            return style;
+        }
+        const separator = style.trim() === '' || style.trimEnd().endsWith(';') ? '' : ';';
+        return `${style}${separator}object-fit:${objectFit}`;
+    }
+    if (style && ('objectFit' in style || 'object-fit' in style)) {
+        return style;
+    }
+    return { ...style, objectFit };
+}

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

@@ -0,0 +1,14 @@
+import type { PreviewRoute } from '../preview/routes.js';
+import type { FimoI18nConfig } from '../shared/fimo-config.types.js';
+export interface AstroPreviewOptions {
+    readonly previewScriptUrl: string | undefined;
+    readonly routes: PreviewRoute[];
+    readonly i18n?: FimoI18nConfig;
+}
+export interface AstroPreviewBrowser {
+    readonly window: Window;
+    readonly document: Document;
+}
+/** Connect an Astro document to Studio without taking ownership of Astro routing. */
+export declare function connectAstroPreview(options: AstroPreviewOptions, browser?: AstroPreviewBrowser | undefined): () => void;
+//# sourceMappingURL=preview.d.ts.map

package/dist/runtime/astro/preview.js

@@ -0,0 +1,103 @@
+import { resolveFimoLocale } from '../i18n/locale.js';
+import { getSafePreviewNavigationPath, isPreviewRuntimeEnabled } from '../preview/bridge.js';
+import { 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__';
+/**
+ * Internal signal the injected preview bundle listens for on `document`.
+ *
+ * ClientRouter replaces `<body>` and rewrites the `<html>` attributes in place,
+ * so the overlay ends up detached and everything bound to those nodes stale.
+ * Translating that here keeps Astro's lifecycle out of the shared bundle, which
+ * knows only this event name. Frameworks that keep the document mounted never
+ * emit it. Keep in sync with `packages/preview/src/documentChange.ts`.
+ */
+const FIMO_DOCUMENT_CHANGE_EVENT = 'fimo:document-change';
+function currentBrowser() {
+    return typeof window === 'undefined' || typeof document === 'undefined' ? undefined : { window, document };
+}
+function loadPreviewScript(browserDocument, previewScriptUrl) {
+    if (browserDocument.querySelector('script[data-fimo-preview-script]')) {
+        return;
+    }
+    const script = browserDocument.createElement('script');
+    script.src = previewScriptUrl;
+    script.defer = true;
+    script.dataset.fimoPreviewScript = '';
+    browserDocument.head.append(script);
+}
+/** Connect an Astro document to Studio without taking ownership of Astro routing. */
+export function connectAstroPreview(options, browser = currentBrowser()) {
+    if (!browser) {
+        return () => undefined;
+    }
+    if (!isPreviewRuntimeEnabled(options.previewScriptUrl)) {
+        return () => undefined;
+    }
+    const connectedWindow = browser.window;
+    connectedWindow[CONNECTION_KEY]?.();
+    loadPreviewScript(browser.document, options.previewScriptUrl);
+    const parentOrigin = getPreviewParentOrigin(browser);
+    const postToStudio = (message) => browser.window.parent.postMessage(message, parentOrigin ?? '*');
+    const sendRoutes = () => {
+        postToStudio({ type: 'nav/routes', payload: { routes: options.routes } });
+    };
+    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,
+            },
+        });
+    };
+    const announceDocumentChange = () => {
+        browser.document.dispatchEvent(new Event(FIMO_DOCUMENT_CHANGE_EVENT));
+    };
+    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) {
+                browser.window.location.assign(target);
+            }
+            return;
+        }
+        if (event.data?.type === 'content/refresh') {
+            if (event.data?.requiresAck && typeof event.data?.messageId === 'string') {
+                postToStudio({ type: 'ack', payload: { messageId: event.data.messageId, ok: true } });
+            }
+            browser.window.setTimeout(() => browser.window.location.reload(), 0);
+            return;
+        }
+        if (event.data?.type === 'nav/read-routes') {
+            sendRoutes();
+            sendLocation();
+        }
+    };
+    browser.window.addEventListener('message', handleMessage);
+    browser.window.addEventListener('popstate', sendLocation);
+    browser.window.addEventListener('hashchange', sendLocation);
+    browser.document.addEventListener(ASTRO_PAGE_LOAD_EVENT, sendLocation);
+    browser.document.addEventListener(ASTRO_AFTER_SWAP_EVENT, announceDocumentChange);
+    sendRoutes();
+    sendLocation();
+    const disconnect = () => {
+        browser.window.removeEventListener('message', handleMessage);
+        browser.window.removeEventListener('popstate', sendLocation);
+        browser.window.removeEventListener('hashchange', sendLocation);
+        browser.document.removeEventListener(ASTRO_PAGE_LOAD_EVENT, sendLocation);
+        browser.document.removeEventListener(ASTRO_AFTER_SWAP_EVENT, announceDocumentChange);
+        if (connectedWindow[CONNECTION_KEY] === disconnect) {
+            delete connectedWindow[CONNECTION_KEY];
+        }
+    };
+    connectedWindow[CONNECTION_KEY] = disconnect;
+    return disconnect;
+}

package/dist/runtime/astro/render-rich-text.d.ts

@@ -0,0 +1,2 @@
+export { renderRichTextHtml } from '../primitives/lib/render-rich-text.js';
+//# sourceMappingURL=render-rich-text.d.ts.map

package/dist/runtime/astro/render-rich-text.js

@@ -0,0 +1 @@
+export { renderRichTextHtml } from '../primitives/lib/render-rich-text.js';

package/dist/runtime/astro/server-runtime.d.ts

@@ -0,0 +1,3 @@
+import { type ContentRuntime } from '../content/client/runtime.js';
+export declare const astroServerContentRuntime: ContentRuntime;
+//# sourceMappingURL=server-runtime.d.ts.map

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

@@ -0,0 +1,20 @@
+import { requireContentApiUrl } from '../content/client/runtime.js';
+export const astroServerContentRuntime = {
+    apiBase() {
+        return requireContentApiUrl(import.meta.env.FIMO_CONTENT_API_URL, 'FIMO_CONTENT_API_URL');
+    },
+    defaultLocale() {
+        return import.meta.env.FIMO_DEFAULT_LOCALE?.trim() || undefined;
+    },
+    headers(extra) {
+        const headers = { ...extra };
+        const env = import.meta.env.FIMO_ENV?.trim();
+        if (env) {
+            headers['X-Fimo-Env'] = env;
+        }
+        return headers;
+    },
+    fetch(input, init) {
+        return globalThis.fetch(input, init);
+    },
+};

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

@@ -0,0 +1,15 @@
+import type { CollectionContentCore, ContentClientConfig, SingletonContentCore } from '../content/client/core-types.js';
+import { type GetLabelsOptions } from '../labels/fetch.js';
+export declare function createContentClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig): CollectionContentCore<T, TInput>;
+export declare function createSingletonClient<T extends {
+    id: string;
+}, TInput extends object>(config: ContentClientConfig): SingletonContentCore<T, TInput>;
+export declare function getLabels(options?: GetLabelsOptions): Promise<import("./server.js").Labels>;
+export { fimo } from '../primitives/lib/template.js';
+export type { CollectionContentCore as CollectionContentClient, SingletonContentCore as SingletonContentClient, } from '../content/client/core-types.js';
+export type { GetLabelsOptions } from '../labels/fetch.js';
+export type { Labels, LabelsSnapshot } from '../labels/core.js';
+export * from '../content/index.js';
+//# sourceMappingURL=server.d.ts.map

package/dist/runtime/astro/server.js

@@ -0,0 +1,14 @@
+import { createServerContentClient, createServerSingletonClient } from '../content/client/server-content-client.js';
+import { fetchLabels } from '../labels/fetch.js';
+import { astroServerContentRuntime } from './server-runtime.js';
+export function createContentClient(config) {
+    return createServerContentClient(config, astroServerContentRuntime);
+}
+export function createSingletonClient(config) {
+    return createServerSingletonClient(config, astroServerContentRuntime);
+}
+export function getLabels(options) {
+    return fetchLabels(astroServerContentRuntime, options);
+}
+export { fimo } from '../primitives/lib/template.js';
+export * from '../content/index.js';

package/dist/runtime/content/client/collection-core.d.ts

@@ -1,22 +1,7 @@
 import type { Fields, Populate, Query } from '../../primitives/lib/query.js';
+import type { CollectionContentCore, ContentClientConfig, ContentReadOptions } from './core-types.js';
 import type { ContentRuntime } from './runtime.js';
-import type { CollectionPage, ContentClientConfig, ContentModuleMeta, ContentReadOptions, ContentResult } from './types.js';
-export interface CollectionContentCore<T extends {
-    id: string;
-}, TInput extends object> {
-    readonly meta: ContentModuleMeta;
-    wrapWithSource(entry: Record<string, any>): T;
-    getById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
-    getBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
-    getByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
-    list<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<CollectionPage<ContentResult<T, TFields, TPopulate>>>;
-    get<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<ContentResult<T, TFields, TPopulate>[]>;
-    create(payload: TInput): Promise<T>;
-    update(id: string, payload: Partial<TInput>): Promise<T>;
-    remove(id: string, options?: {
-        locale?: string;
-    }): Promise<void>;
-}
+export type { CollectionContentCore } from './core-types.js';
 export interface CollectionCoreState<T extends {
     id: string;
 }, TInput extends object> {

package/dist/runtime/content/client/collection-core.js

@@ -7,15 +7,19 @@ export function createCollectionContentCore(config, runtime) {
         throw new Error(`Schema "${info.uid}" is a Single — use createSingletonClient instead.`);
     }
     validateReferences(info, references);
-    const defaultLocale = runtime.defaultLocale();
+    const requestDefaultLocale = runtime.defaultLocale();
     const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
     const self = { wrapWithSource, meta };
     const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
     function wrapWithSource(entry) {
-        return wrapEntry(info, entry, { alwaysIncludeLocale: true, defaultLocale, resolve });
+        return wrapEntry(info, entry, {
+            alwaysIncludeLocale: true,
+            defaultLocale: requestDefaultLocale ?? 'en',
+            resolve,
+        });
     }
     function readPath(url, options) {
-        return buildReadPath(url, readCollectionLocale(options, defaultLocale), options.populate, options.localeFallbacks);
+        return buildReadPath(url, readCollectionLocale(options, requestDefaultLocale), options.populate, options.localeFallbacks);
     }
     async function getById(id, options = {}) {
         const response = await runtime.fetch(`${runtime.apiBase()}${readPath(`/entries/${info.uid}/${id}`, options)}`, {
@@ -69,7 +73,10 @@ export function createCollectionContentCore(config, runtime) {
         if (where && Object.keys(where).length > 0) {
             query.set('where', JSON.stringify(where));
         }
-        query.set('locale', readCollectionLocale({ locale: requestedLocale }, defaultLocale));
+        const locale = readCollectionLocale({ locale: requestedLocale }, requestDefaultLocale);
+        if (locale) {
+            query.set('locale', locale);
+        }
         return query.toString();
     }
     async function list(params = {}) {
@@ -96,7 +103,7 @@ export function createCollectionContentCore(config, runtime) {
     }
     async function create(payload) {
         const localizedPayload = info.localized
-            ? withMutationLocale(payload, readCollectionLocale({}, defaultLocale))
+            ? withMutationLocale(payload, readCollectionLocale({}, requestDefaultLocale))
             : payload;
         const response = await runtime.fetch(`${runtime.apiBase()}/entries/${info.uid}`, {
             method: 'POST',
@@ -111,7 +118,7 @@ export function createCollectionContentCore(config, runtime) {
     }
     async function update(id, payload) {
         const write = splitWritePayload(payload);
-        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale({ locale: write.locale }, defaultLocale), undefined);
+        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale({ locale: write.locale }, requestDefaultLocale), undefined);
         const response = await runtime.fetch(`${runtime.apiBase()}${url}`, {
             method: 'PUT',
             headers: runtime.headers({ 'Content-Type': 'application/json' }),
@@ -124,7 +131,7 @@ export function createCollectionContentCore(config, runtime) {
         return wrapWithSource(body.data);
     }
     async function remove(id, options = {}) {
-        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale(options, defaultLocale), undefined);
+        const url = buildReadPath(`/entries/${info.uid}/${id}`, readCollectionLocale(options, requestDefaultLocale), undefined);
         const response = await runtime.fetch(`${runtime.apiBase()}${url}`, {
             method: 'DELETE',
             headers: runtime.headers(),
@@ -143,7 +150,7 @@ export function createCollectionContentCore(config, runtime) {
     };
     return {
         client: { meta, wrapWithSource, getById, getBySlug, getByField, list, get, create, update, remove },
-        defaultLocale,
+        defaultLocale: requestDefaultLocale ?? 'en',
         queryKeys,
     };
 }

package/dist/runtime/content/client/core-types.d.ts

@@ -0,0 +1,96 @@
+import type { Fields, Populate, PopulatedResult, ProjectedWithPopulate, Query } from '../../primitives/lib/query.js';
+export type ContentResult<T extends {
+    id: string;
+}, TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined> = ProjectedWithPopulate<PopulatedResult<T, TPopulate> & {
+    id: string;
+}, TFields, TPopulate>;
+export interface ContentSchemaField {
+    type?: string;
+    required?: boolean;
+    default?: unknown;
+    multiple?: boolean;
+    many?: boolean;
+    target?: string;
+    targets?: readonly string[];
+    min?: number;
+    max?: number;
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+    schema?: {
+        fields: Readonly<Record<string, ContentSchemaField>>;
+    } | {
+        oneOf: readonly {
+            uid: string;
+            label: string;
+            description?: string;
+            fields: Readonly<Record<string, ContentSchemaField>>;
+        }[];
+    };
+}
+export interface ContentSchema {
+    uid: string;
+    name?: string;
+    isSingleton?: boolean;
+    i18n?: {
+        enabled?: boolean;
+    };
+    fields?: Readonly<Record<string, ContentSchemaField>>;
+}
+export interface ContentModuleMeta {
+    readonly uid: string;
+    readonly pascal: string;
+    readonly localized: boolean;
+}
+export interface ContentClientHandle {
+    wrapWithSource: (entry: Record<string, any>) => unknown;
+    meta: ContentModuleMeta;
+}
+export type ContentModuleRef = ContentClientHandle | {
+    default: ContentClientHandle;
+};
+export interface ContentClientConfig {
+    schema: ContentSchema;
+    references?: Readonly<Record<string, ContentModuleRef>>;
+}
+export interface ContentReadOptions<TPopulate> {
+    locale?: string;
+    populate?: TPopulate;
+    localeFallbacks?: boolean;
+}
+export interface CollectionPageInfo {
+    readonly limit: number;
+    readonly offset: number;
+    readonly total: number;
+    readonly hasMore: boolean;
+    readonly nextOffset: number | null;
+}
+export interface CollectionPage<TItem> {
+    readonly items: TItem[];
+    readonly pageInfo: CollectionPageInfo;
+}
+export interface CollectionContentCore<T extends {
+    id: string;
+}, TInput extends object> {
+    readonly meta: ContentModuleMeta;
+    wrapWithSource(entry: Record<string, any>): T;
+    getById<TPopulate extends Populate<T> | undefined = undefined>(id: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
+    getBySlug<TPopulate extends Populate<T> | undefined = undefined>(slug: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
+    getByField<TPopulate extends Populate<T> | undefined = undefined>(fieldName: string, value: string, options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate> | null>;
+    list<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<CollectionPage<ContentResult<T, TFields, TPopulate>>>;
+    get<TFields extends Fields<T> | undefined = undefined, TPopulate extends Populate<T> | undefined = undefined>(params?: Query<T, TFields, TPopulate>): Promise<ContentResult<T, TFields, TPopulate>[]>;
+    create(payload: TInput): Promise<T>;
+    update(id: string, payload: Partial<TInput>): Promise<T>;
+    remove(id: string, options?: {
+        locale?: string;
+    }): Promise<void>;
+}
+export interface SingletonContentCore<T extends {
+    id: string;
+}, TInput extends object> {
+    readonly meta: ContentModuleMeta;
+    wrapWithSource(entry: Record<string, any>): T;
+    get<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
+    update(payload: Partial<TInput>): Promise<T>;
+}
+//# sourceMappingURL=core-types.d.ts.map

package/dist/runtime/content/client/core-types.js

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

package/dist/runtime/content/client/internal.d.ts

@@ -1,4 +1,4 @@
-import type { ContentClientHandle, ContentModuleRef, ContentSchema, ContentSchemaField } from './types.js';
+import type { ContentClientHandle, ContentModuleRef, ContentSchema, ContentSchemaField } from './core-types.js';
 export interface InterpretedSchema {
     uid: string;
     pascal: string;
@@ -13,7 +13,7 @@ interface LocaleReadOptions {
     locale?: string;
     populate?: string | readonly string[];
 }
-export declare function readCollectionLocale(options: LocaleReadOptions, fallbackLocale?: string): string;
+export declare function readCollectionLocale(options: LocaleReadOptions, fallbackLocale?: string): string | undefined;
 export declare function readSingletonLocale(options: LocaleReadOptions, ownerUsesLocale: boolean, localizedReferenceFields: ReadonlySet<string>, fallbackLocale?: string): string | undefined;
 export declare function buildReadPath(url: string, locale: string | undefined, populate: string | readonly string[] | undefined, localeFallbacks?: boolean): string;
 export declare function splitWritePayload(payload: Record<string, unknown>): {
@@ -21,8 +21,8 @@ export declare function splitWritePayload(payload: Record<string, unknown>): {
     locale?: string;
     documentId?: string;
 };
-export declare function withMutationLocale<T extends object>(payload: T, activeLocale: string): T & {
-    locale: string;
+export declare function withMutationLocale<T extends object>(payload: T, activeLocale?: string): T & {
+    locale?: string;
 };
 type ReferenceResolver = (uid: string) => ContentClientHandle | undefined;
 /**

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

@@ -45,10 +45,10 @@ function populateFields(populate) {
     }
     return typeof populate === 'string' ? [populate] : [...populate];
 }
-export function readCollectionLocale(options, fallbackLocale = 'en') {
+export function readCollectionLocale(options, fallbackLocale) {
     return options.locale ?? fallbackLocale;
 }
-export function readSingletonLocale(options, ownerUsesLocale, localizedReferenceFields, fallbackLocale = 'en') {
+export function readSingletonLocale(options, ownerUsesLocale, localizedReferenceFields, fallbackLocale) {
     const populatesLocalizedTarget = populateFields(options.populate).some((field) => localizedReferenceFields.has(field));
     return ownerUsesLocale || populatesLocalizedTarget ? (options.locale ?? fallbackLocale) : undefined;
 }
@@ -80,7 +80,8 @@ export function splitWritePayload(payload) {
 }
 export function withMutationLocale(payload, activeLocale) {
     const locale = payload.locale;
-    return { ...payload, locale: locale ?? activeLocale };
+    const resolvedLocale = locale ?? activeLocale;
+    return resolvedLocale ? { ...payload, locale: resolvedLocale } : payload;
 }
 function isPopulatedEntry(value) {
     if (value == null || typeof value !== 'object') {

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

@@ -1,6 +1,6 @@
 export interface ContentRuntime {
     apiBase(): string;
-    defaultLocale(): string;
+    defaultLocale(): string | undefined;
     headers(extra?: Record<string, string>): Record<string, string>;
     fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
 }

package/dist/runtime/content/client/server-content-client.d.ts

@@ -1,9 +1,9 @@
+import type { CollectionContentCore, ContentClientConfig, SingletonContentCore } from './core-types.js';
 import type { ContentRuntime } from './runtime.js';
-import type { CollectionContentClient, ContentClientConfig, SingletonContentClient } from './types.js';
 export declare function createServerContentClient<T extends {
     id: string;
-}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): CollectionContentClient<T, TInput>;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): CollectionContentCore<T, TInput>;
 export declare function createServerSingletonClient<T extends {
     id: string;
-}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): SingletonContentClient<T, TInput>;
+}, TInput extends object>(config: ContentClientConfig, runtime: ContentRuntime): SingletonContentCore<T, TInput>;
 //# sourceMappingURL=server-content-client.d.ts.map

package/dist/runtime/content/client/server-content-client.js

@@ -1,35 +1,8 @@
 import { createCollectionContentCore } from './collection-core.js';
 import { createSingletonContentCore } from './singleton-core.js';
-function clientHook(name) {
-    return () => {
-        throw new Error(`${name} is a Client Component hook. Call it only below a "use client" boundary.`);
-    };
-}
 export function createServerContentClient(config, runtime) {
-    const { client } = createCollectionContentCore(config, runtime);
-    return {
-        ...client,
-        useGetById: clientHook('useGetById'),
-        useGetBySlug: clientHook('useGetBySlug'),
-        useGetByField: clientHook('useGetByField'),
-        useGet: clientHook('useGet'),
-        useList: clientHook('useList'),
-        useInfiniteList: clientHook('useInfiniteList'),
-        useSuspenseGetById: clientHook('useSuspenseGetById'),
-        useSuspenseGetBySlug: clientHook('useSuspenseGetBySlug'),
-        useSuspenseGetByField: clientHook('useSuspenseGetByField'),
-        useSuspenseGet: clientHook('useSuspenseGet'),
-        useCreate: clientHook('useCreate'),
-        useUpdate: clientHook('useUpdate'),
-        useRemove: clientHook('useRemove'),
-    };
+    return createCollectionContentCore(config, runtime).client;
 }
 export function createServerSingletonClient(config, runtime) {
-    const { client } = createSingletonContentCore(config, runtime);
-    return {
-        ...client,
-        useGet: clientHook('useGet'),
-        useSuspenseGet: clientHook('useSuspenseGet'),
-        useUpdate: clientHook('useUpdate'),
-    };
+    return createSingletonContentCore(config, runtime).client;
 }

package/dist/runtime/content/client/singleton-core.d.ts

@@ -1,14 +1,7 @@
 import type { Populate } from '../../primitives/lib/query.js';
+import type { ContentClientConfig, ContentReadOptions, SingletonContentCore } from './core-types.js';
 import type { ContentRuntime } from './runtime.js';
-import type { ContentClientConfig, ContentModuleMeta, ContentReadOptions, ContentResult } from './types.js';
-export interface SingletonContentCore<T extends {
-    id: string;
-}, TInput extends object> {
-    readonly meta: ContentModuleMeta;
-    wrapWithSource(entry: Record<string, any>): T;
-    get<TPopulate extends Populate<T> | undefined = undefined>(options?: ContentReadOptions<TPopulate>): Promise<ContentResult<T, undefined, TPopulate>>;
-    update(payload: Partial<TInput>): Promise<T>;
-}
+export type { SingletonContentCore } from './core-types.js';
 export interface SingletonCoreState<T extends {
     id: string;
 }, TInput extends object> {

package/dist/runtime/content/client/singleton-core.js

@@ -6,7 +6,7 @@ export function createSingletonContentCore(config, runtime) {
         throw new Error(`Schema "${info.uid}" is a collection — use createContentClient instead.`);
     }
     validateReferences(info, references);
-    const defaultLocale = runtime.defaultLocale();
+    const requestDefaultLocale = runtime.defaultLocale();
     const meta = { uid: info.uid, pascal: info.pascal, localized: info.localized };
     const self = { wrapWithSource, meta };
     const resolve = (uid) => uid === info.uid ? self : resolveClientHandle(references[uid]);
@@ -31,11 +31,11 @@ export function createSingletonContentCore(config, runtime) {
     function wrapWithSource(entry) {
         return wrapEntry(info, entry, {
             alwaysIncludeLocale: info.localized,
-            defaultLocale,
+            defaultLocale: requestDefaultLocale ?? 'en',
             resolve,
         });
     }
-    function localize(options, fallbackLocale = defaultLocale) {
+    function localize(options, fallbackLocale = requestDefaultLocale) {
         return readSingletonLocale(options, info.localized, getLocalizedReferenceFields(), fallbackLocale);
     }
     function readPath(url, options) {
@@ -69,5 +69,10 @@ export function createSingletonContentCore(config, runtime) {
         root: [info.pascal],
         document: (options = {}) => [info.pascal, 'document', options.locale, options.populate],
     };
-    return { client: { meta, wrapWithSource, get, update }, defaultLocale, localize, queryKeys };
+    return {
+        client: { meta, wrapWithSource, get, update },
+        defaultLocale: requestDefaultLocale ?? 'en',
+        localize,
+        queryKeys,
+    };
 }