fimo 0.14.0 → 0.15.0-staging.2

package/dist/runtime/shared/local-runtime-env.js

@@ -0,0 +1,169 @@
+/**
+ * Which Fimo env a local checkout is on, and how to reach it — derived, not
+ * stored.
+ *
+ * The env is the git branch. The project id and tenant API base URL sit in
+ * `.fimo/project.json`, written once at link and never on a switch. The tenant
+ * URL for the current env is a pure function of the three, so nothing has to
+ * be rewritten when the branch changes: `git checkout` alone is a complete env
+ * switch, offline.
+ *
+ * This module only DERIVES. Precedence against explicit values is the caller's
+ * job and is the same everywhere: a variable the user (or the sandbox) already
+ * set is left alone; derivation fills the rest, one variable at a time.
+ *
+ * Shared by the CLI, `fimo/vite`, and `fimo/next/config` so the three can
+ * never disagree about which env the app is calling.
+ */
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CURRENT_PROJECT_LAYOUT, LEGACY_PROJECT_LAYOUT } from '../project-layout.js';
+import { DEFAULT_ENV, LOCAL_CONTENT_API_ENV_KEYS, buildLocalRuntimeEnv, buildTenantApiUrl, isValidEnv, } from './env-identity.js';
+/**
+ * Derive the local runtime env, or `null` when this directory is not a linked
+ * Fimo project (or the link predates `tenantApiBaseUrl` — nothing safe to
+ * derive, so nothing is).
+ */
+export function resolveLocalRuntimeEnv(options) {
+    const root = findProjectRoot(options.cwd);
+    const link = root ? readProjectLink(root) : null;
+    if (!root || !link) {
+        return null;
+    }
+    const branch = currentBranch(root);
+    const env = branch ?? DEFAULT_ENV;
+    const tenantApiUrl = buildTenantApiUrl(link.projectId, env, link.tenantApiBaseUrl);
+    return {
+        env,
+        tenantApiUrl,
+        source: branch ? 'branch' : 'fallback',
+        values: buildLocalRuntimeEnv({ tenantApiUrl, env }),
+        link,
+    };
+}
+/**
+ * The one case where "explicit wins" pins the app to the WRONG env: an
+ * explicit tenant URL that Fimo itself minted for this project (old-CLI
+ * `fimo clone` seeded the clone-time env's URL into `.env`) and that disagrees
+ * with the branch. A URL the user typed — `http://localhost:4000` — is never
+ * reported; that is the override the design exists to protect.
+ */
+export function findStaleFimoOverride(explicit, derived) {
+    for (const key of LOCAL_CONTENT_API_ENV_KEYS) {
+        const value = explicit[key];
+        if (value && value !== derived.tenantApiUrl && isFimoMintedTenantUrl(value, derived.link)) {
+            return { key, explicit: value, derived: derived.tenantApiUrl };
+        }
+    }
+    return null;
+}
+/** One message for every surface (dev-server console, `fimo checkout`) so the fix reads the same everywhere. */
+export function staleOverrideMessage(stale) {
+    return (`[fimo] An env file pins the app to ${stale.explicit} (seeded by an older CLI), ` +
+        `so it will NOT follow the git branch (${stale.derived}). ` +
+        'Run `fimo link` to remove that line, or delete it yourself.');
+}
+/** Whether `value` is a tenant URL Fimo minted for `link`'s project — for any env. */
+export function isFimoMintedTenantUrl(value, link) {
+    try {
+        const candidate = new URL(value);
+        const base = new URL(link.tenantApiBaseUrl);
+        return (candidate.protocol === base.protocol &&
+            candidate.port === base.port &&
+            candidate.hostname.startsWith(`${link.projectId}-`) &&
+            candidate.hostname.endsWith(`.${base.hostname}`));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * `.env` then `.env.local` (later wins), the way every supported framework
+ * layers them. For CLI commands, which — unlike Vite and Next — do not load
+ * these files themselves but must see the same explicit values the app will.
+ */
+export function readLocalEnvFiles(cwd) {
+    const root = findProjectRoot(cwd) ?? cwd;
+    const values = {};
+    for (const file of ['.env', '.env.local']) {
+        const filePath = path.join(root, file);
+        if (!fs.existsSync(filePath)) {
+            continue;
+        }
+        for (const line of fs.readFileSync(filePath, 'utf-8').split(/\r?\n/)) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) {
+                continue;
+            }
+            const eq = trimmed.indexOf('=');
+            if (eq <= 0) {
+                continue;
+            }
+            values[trimmed.slice(0, eq).trim()] = trimmed
+                .slice(eq + 1)
+                .trim()
+                .replace(/^['"]|['"]$/g, '');
+        }
+    }
+    return values;
+}
+/**
+ * The branch, when it names a valid env; otherwise `null` (detached HEAD, no
+ * repo, no git). Tags are deliberately ignored: the CLI maps a `release/*` tag
+ * to `prod` so `fimo status` on a checked-out release reads as read-only, but a
+ * dev server is never run to look at prod — locally you always develop toward
+ * a branch.
+ *
+ * Synchronous on purpose — this runs inside framework config hooks at startup,
+ * where a spawn of `git` is cheap and an async boundary is not always
+ * available.
+ */
+function currentBranch(root) {
+    try {
+        const branch = execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+            cwd: root,
+            stdio: ['ignore', 'pipe', 'ignore'],
+            encoding: 'utf-8',
+        }).trim();
+        return branch && branch !== 'HEAD' && isValidEnv(branch) ? branch : null;
+    }
+    catch {
+        return null;
+    }
+}
+function findProjectRoot(start) {
+    let dir = path.resolve(start);
+    for (;;) {
+        if (fs.existsSync(path.join(dir, CURRENT_PROJECT_LAYOUT.project)) ||
+            fs.existsSync(path.join(dir, LEGACY_PROJECT_LAYOUT.project))) {
+            return dir;
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return null;
+        }
+        dir = parent;
+    }
+}
+function readProjectLink(root) {
+    for (const layout of [CURRENT_PROJECT_LAYOUT, LEGACY_PROJECT_LAYOUT]) {
+        const file = path.join(root, layout.project);
+        if (!fs.existsSync(file)) {
+            continue;
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (typeof parsed.projectId === 'string' &&
+                parsed.projectId.length > 0 &&
+                typeof parsed.tenantApiBaseUrl === 'string' &&
+                parsed.tenantApiBaseUrl.length > 0) {
+                return { projectId: parsed.projectId, tenantApiBaseUrl: parsed.tenantApiBaseUrl };
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}

package/dist/runtime/{react-router → shared}/preview-location.d.ts

@@ -9,20 +9,14 @@ export interface PreviewLocationChange {
     /** Exact app location used to keep the parent's iframe URL in sync. */
     navigationPath: string;
 }
-/**
- * `ancestorOrigins[0]` identifies the immediate embedding document and stays
- * stable when the preview document itself navigates or reloads. The referrer
- * is the fallback for browsers without ancestor origins (Firefox), where it
- * can go stale after in-app navigation — which is why the runtime wrapper
- * below remembers the first successful resolution.
- */
+export interface PreviewBrowserContext {
+    readonly window: Pick<Window, 'location' | 'sessionStorage'>;
+    readonly document: Pick<Document, 'referrer'>;
+}
+/** Prefer the immediate embedding document over a potentially stale referrer. */
 export declare function resolvePreviewParentOrigin(referrer: string | undefined, ancestorOrigins: readonly string[] | undefined): string | null;
-/**
- * Resolve the parent origin for the iframe's authenticated preview channel
- * from the live browser context. Standalone app loads have no trusted parent
- * origin and must not receive query/hash-bearing location data.
- */
-export declare function getPreviewParentOrigin(): string | null;
+/** Resolve and remember the trusted Studio origin across full-page navigation. */
+export declare function getPreviewParentOrigin(browser?: PreviewBrowserContext): string | null;
 /** Keep sandbox credentials and the iframe cache-buster out of app navigation state. */
 export declare function getPreviewLocationPath(location: PreviewLocationLike): string;
 export declare function getPreviewLocationChange(location: PreviewLocationLike): PreviewLocationChange;

package/dist/runtime/{react-router → shared}/preview-location.js

@@ -13,65 +13,64 @@ const getOrigin = (value) => {
         return null;
     }
 };
-/**
- * `ancestorOrigins[0]` identifies the immediate embedding document and stays
- * stable when the preview document itself navigates or reloads. The referrer
- * is the fallback for browsers without ancestor origins (Firefox), where it
- * can go stale after in-app navigation — which is why the runtime wrapper
- * below remembers the first successful resolution.
- */
+/** Prefer the immediate embedding document over a potentially stale referrer. */
 export function resolvePreviewParentOrigin(referrer, ancestorOrigins) {
     return getOrigin(ancestorOrigins?.[0]) ?? getOrigin(referrer);
 }
-/**
- * Resolve the parent origin for the iframe's authenticated preview channel
- * from the live browser context. Standalone app loads have no trusted parent
- * origin and must not receive query/hash-bearing location data.
- */
-export function getPreviewParentOrigin() {
-    if (typeof window === 'undefined') {
+/** Resolve and remember the trusted Studio origin across full-page navigation. */
+export function getPreviewParentOrigin(browser) {
+    const browserWindow = browser?.window ?? (typeof window === 'undefined' ? undefined : window);
+    const browserDocument = browser?.document ?? (typeof document === 'undefined' ? undefined : document);
+    if (!browserWindow) {
         return null;
     }
-    const ancestorOrigin = getOrigin(window.location.ancestorOrigins?.[0]);
+    const storage = readSessionStorage(browserWindow);
+    const ancestorOrigin = getOrigin(browserWindow.location.ancestorOrigins?.[0]);
     if (ancestorOrigin) {
-        rememberPreviewParentOrigin(ancestorOrigin);
+        rememberPreviewParentOrigin(ancestorOrigin, storage);
         return ancestorOrigin;
     }
-    // The referrer becomes the previous preview URL after in-app navigation, so
-    // a remembered first resolution outranks it on reloads.
-    const rememberedOrigin = readRememberedPreviewParentOrigin();
+    const rememberedOrigin = readRememberedPreviewParentOrigin(storage);
     if (rememberedOrigin) {
         return rememberedOrigin;
     }
-    const referrerOrigin = getOrigin(typeof document === 'undefined' ? undefined : document.referrer);
+    const referrerOrigin = getOrigin(browserDocument?.referrer);
     if (referrerOrigin) {
-        rememberPreviewParentOrigin(referrerOrigin);
+        rememberPreviewParentOrigin(referrerOrigin, storage);
     }
     return referrerOrigin;
 }
-function readRememberedPreviewParentOrigin() {
+function readSessionStorage(browserWindow) {
+    try {
+        return browserWindow.sessionStorage;
+    }
+    catch {
+        return undefined;
+    }
+}
+function readRememberedPreviewParentOrigin(storage) {
     if (rememberedPreviewParentOrigin !== undefined) {
         return rememberedPreviewParentOrigin;
     }
-    if (typeof sessionStorage === 'undefined') {
+    if (!storage) {
         rememberedPreviewParentOrigin = null;
         return null;
     }
     try {
-        rememberedPreviewParentOrigin = getOrigin(sessionStorage.getItem(PREVIEW_PARENT_ORIGIN_STORAGE_KEY) ?? undefined);
+        rememberedPreviewParentOrigin = getOrigin(storage.getItem(PREVIEW_PARENT_ORIGIN_STORAGE_KEY) ?? undefined);
     }
     catch {
         rememberedPreviewParentOrigin = null;
     }
     return rememberedPreviewParentOrigin;
 }
-function rememberPreviewParentOrigin(origin) {
+function rememberPreviewParentOrigin(origin, storage) {
     rememberedPreviewParentOrigin = origin;
-    if (typeof sessionStorage === 'undefined') {
+    if (!storage) {
         return;
     }
     try {
-        sessionStorage.setItem(PREVIEW_PARENT_ORIGIN_STORAGE_KEY, origin);
+        storage.setItem(PREVIEW_PARENT_ORIGIN_STORAGE_KEY, origin);
     }
     catch {
         // Storage availability must not block the preview message channel.

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

@@ -0,0 +1,25 @@
+import type { CollectionContentCore, ContentClientConfig, ContentClientHandle, SingletonContentCore } from '../content/client/core-types.js';
+export interface SvelteKitContentClientConfig extends ContentClientConfig {
+    apiUrl: string | undefined;
+    defaultLocale?: string;
+}
+export interface SvelteKitEvent {
+    fetch: typeof globalThis.fetch;
+}
+export interface SvelteKitContentModule {
+    default: ContentClientHandle;
+}
+export type SvelteKitContentRegistry = Readonly<Record<string, SvelteKitContentModule>>;
+export interface CreateFimoOptions<TContent extends SvelteKitContentRegistry> {
+    content: TContent;
+    event: SvelteKitEvent;
+    locale?: string;
+}
+export declare function createContentClient<T extends {
+    id: string;
+}, TInput extends object>(config: SvelteKitContentClientConfig): CollectionContentCore<T, TInput>;
+export declare function createSingletonClient<T extends {
+    id: string;
+}, TInput extends object>(config: SvelteKitContentClientConfig): SingletonContentCore<T, TInput>;
+export declare function createFimo<const TContent extends SvelteKitContentRegistry>({ content, event, locale, }: CreateFimoOptions<TContent>): TContent;
+//# sourceMappingURL=content.d.ts.map

package/dist/runtime/sveltekit/content.js

@@ -0,0 +1,33 @@
+import { createServerContentClient, createServerSingletonClient } from '../content/client/server-content-client.js';
+import { createSvelteKitContentRuntime } from './runtime.js';
+const requestClientFactories = new WeakMap();
+export function createContentClient(config) {
+    const create = (requestFetch, locale) => createServerContentClient(config, createSvelteKitContentRuntime({
+        apiUrl: config.apiUrl,
+        defaultLocale: locale ?? config.defaultLocale,
+        fetch: requestFetch,
+    }));
+    const client = create(globalThis.fetch);
+    requestClientFactories.set(client, create);
+    return client;
+}
+export function createSingletonClient(config) {
+    const create = (requestFetch, locale) => createServerSingletonClient(config, createSvelteKitContentRuntime({
+        apiUrl: config.apiUrl,
+        defaultLocale: locale ?? config.defaultLocale,
+        fetch: requestFetch,
+    }));
+    const client = create(globalThis.fetch);
+    requestClientFactories.set(client, create);
+    return client;
+}
+export function createFimo({ content, event, locale, }) {
+    return Object.fromEntries(Object.entries(content).map(([key, contentModule]) => {
+        const create = requestClientFactories.get(contentModule.default);
+        if (!create) {
+            throw new Error(`Content module "${key}" was not created by fimo/sveltekit.`);
+        }
+        const client = create(event.fetch, locale);
+        return [key, { ...contentModule, ...client, default: client }];
+    }));
+}

package/dist/runtime/sveltekit/context-contract.d.ts

@@ -0,0 +1,5 @@
+import type { LabelsSnapshot } from '../labels/core.js';
+/** Shared by duplicated `fimo` package instances in the same Svelte tree. */
+export declare const LABELS_KEY: unique symbol;
+export type LabelsSource = () => LabelsSnapshot;
+//# sourceMappingURL=context-contract.d.ts.map

package/dist/runtime/sveltekit/context-contract.js

@@ -0,0 +1,2 @@
+/** Shared by duplicated `fimo` package instances in the same Svelte tree. */
+export const LABELS_KEY = Symbol.for('fimo.sveltekit.labels');

package/dist/runtime/sveltekit/context.d.ts

@@ -0,0 +1,8 @@
+import { type Labels } from '../labels/core.js';
+/**
+ * Read the labels installed by `FimoProvider`. Call it while a component
+ * initializes; the returned `t()` is usable at any time afterwards and returns
+ * a source-tracked `FimoString`, empty for keys the project has no value for.
+ */
+export declare function useLabels(): Labels;
+//# sourceMappingURL=context.d.ts.map

package/dist/runtime/sveltekit/context.js

@@ -0,0 +1,25 @@
+import { getContext } from 'svelte';
+import { createLabels } from '../labels/core.js';
+import { LABELS_KEY } from './context-contract.js';
+/**
+ * Read the labels installed by `FimoProvider`. Call it while a component
+ * initializes; the returned `t()` is usable at any time afterwards and returns
+ * a source-tracked `FimoString`, empty for keys the project has no value for.
+ */
+export function useLabels() {
+    const readSnapshot = getContext(LABELS_KEY);
+    if (!readSnapshot) {
+        throw new Error('useLabels() found no Fimo labels. Render FimoProvider with the label snapshot from your root layout load.');
+    }
+    // Every member reads the snapshot on access: binding one `createLabels` result
+    // here would freeze the labels at initialization and stop tracking `data`.
+    return {
+        get locale() {
+            return readSnapshot().locale;
+        },
+        get snapshot() {
+            return readSnapshot();
+        },
+        t: (key) => createLabels(readSnapshot()).t(key),
+    };
+}

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

@@ -0,0 +1,7 @@
+export { createContentClient, createFimo, createSingletonClient, type CreateFimoOptions, type SvelteKitContentClientConfig, type SvelteKitContentModule, type SvelteKitContentRegistry, type SvelteKitEvent, } from './content.js';
+export { useLabels } from './context.js';
+export { getLabels, type GetLabelsOptions } from './labels.js';
+export type { Labels, LabelsSnapshot } from '../labels/core.js';
+export type { CollectionContentCore as CollectionContentClient, SingletonContentCore as SingletonContentClient, } from '../content/client/core-types.js';
+export * from '../content/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/sveltekit/index.js

@@ -0,0 +1,4 @@
+export { createContentClient, createFimo, createSingletonClient, } from './content.js';
+export { useLabels } from './context.js';
+export { getLabels } from './labels.js';
+export * from '../content/index.js';

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

@@ -0,0 +1,6 @@
+export { renderRichTextHtml } from '../primitives/lib/render-rich-text.js';
+export { resolveImagePresentation, type ImageFit } from '../primitives/lib/image-optimization.js';
+export { LABELS_KEY, type LabelsSource } from './context-contract.js';
+export { connectPreview, ensurePreviewScript, sendPreviewLocation, type PreviewNavigation } from './preview.js';
+export declare function mergeSvelteImageStyle(style: string | null | undefined, objectFit: string): string;
+//# sourceMappingURL=internal.d.ts.map

package/dist/runtime/sveltekit/internal.js

@@ -0,0 +1,12 @@
+export { renderRichTextHtml } from '../primitives/lib/render-rich-text.js';
+export { resolveImagePresentation } from '../primitives/lib/image-optimization.js';
+export { LABELS_KEY } from './context-contract.js';
+export { connectPreview, ensurePreviewScript, sendPreviewLocation } from './preview.js';
+export function mergeSvelteImageStyle(style, objectFit) {
+    if (style && /(?:^|;)\s*object-fit\s*:/i.test(style)) {
+        return style;
+    }
+    const value = style?.trim() ?? '';
+    const separator = value === '' || value.endsWith(';') ? '' : ';';
+    return `${value}${separator}object-fit:${objectFit}`;
+}

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

@@ -0,0 +1,16 @@
+import type { LabelsSnapshot } from '../labels/core.js';
+import type { SvelteKitEvent } from './content.js';
+export interface GetLabelsOptions {
+    apiUrl: string | undefined;
+    event: SvelteKitEvent;
+    /** The application resolves the active locale; Fimo never infers it from the URL. */
+    locale: string;
+}
+/**
+ * Read the label dictionary for one locale through the request `fetch`.
+ *
+ * Returns plain data because SvelteKit serializes whatever a `load` returns:
+ * pass it to `FimoProvider` in a layout to expose `Label` and `useLabels()`.
+ */
+export declare function getLabels({ apiUrl, event, locale }: GetLabelsOptions): Promise<LabelsSnapshot>;
+//# sourceMappingURL=labels.d.ts.map

package/dist/runtime/sveltekit/labels.js

@@ -0,0 +1,13 @@
+import { fetchLabels } from '../labels/fetch.js';
+import { createSvelteKitContentRuntime } from './runtime.js';
+/**
+ * Read the label dictionary for one locale through the request `fetch`.
+ *
+ * Returns plain data because SvelteKit serializes whatever a `load` returns:
+ * pass it to `FimoProvider` in a layout to expose `Label` and `useLabels()`.
+ */
+export async function getLabels({ apiUrl, event, locale }) {
+    const runtime = createSvelteKitContentRuntime({ apiUrl, defaultLocale: locale, fetch: event.fetch });
+    const labels = await fetchLabels(runtime, { locale });
+    return labels.snapshot;
+}

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

@@ -0,0 +1,19 @@
+export interface PreviewNavigation {
+    /** SvelteKit `goto` — the app router stays in charge of the transition. */
+    goto: (to: string) => unknown;
+    /** SvelteKit `invalidateAll` — reruns every `load` against fresh content. */
+    invalidateAll: () => Promise<unknown>;
+}
+/** Load the platform preview script once. Empty configuration keeps preview disabled. */
+export declare function ensurePreviewScript(src: string | undefined): boolean;
+/** Report where the app is now. Studio keeps its URL and route selector in sync from this. */
+export declare function sendPreviewLocation(): void;
+/**
+ * Listen for the live Studio preview protocol and answer it with SvelteKit's
+ * own navigation APIs. Returns the disconnect function.
+ *
+ * Only messages from the established parent origin are honored. History stays
+ * native, so Studio's back/forward controls need no protocol of their own.
+ */
+export declare function connectPreview({ goto, invalidateAll }: PreviewNavigation): () => void;
+//# sourceMappingURL=preview.d.ts.map

package/dist/runtime/sveltekit/preview.js

@@ -0,0 +1,77 @@
+import { getPreviewLocationChange, getPreviewParentOrigin } from '../shared/preview-location.js';
+/** Load the platform preview script once. Empty configuration keeps preview disabled. */
+export function ensurePreviewScript(src) {
+    if (!src) {
+        return false;
+    }
+    const exists = Array.from(document.scripts).some((script) => script.getAttribute('src') === src);
+    if (!exists) {
+        const script = document.createElement('script');
+        script.src = src;
+        script.defer = true;
+        document.head.appendChild(script);
+    }
+    return true;
+}
+/** Report where the app is now. Studio keeps its URL and route selector in sync from this. */
+export function sendPreviewLocation() {
+    const parentOrigin = getPreviewParentOrigin();
+    const locationChange = getPreviewLocationChange(window.location);
+    window.parent.postMessage({
+        type: 'nav/locationChange',
+        // Query and hash state only travels to an established parent origin.
+        payload: parentOrigin ? locationChange : { path: locationChange.path },
+    }, parentOrigin ?? '*');
+}
+/** Reliable-delivery reply: the parent retries an unacknowledged message forever. */
+function acknowledge(message, result) {
+    const parentOrigin = getPreviewParentOrigin();
+    if (!message.requiresAck || typeof message.messageId !== 'string' || !parentOrigin) {
+        return;
+    }
+    window.parent.postMessage({ type: 'ack', payload: { messageId: message.messageId, ...result } }, parentOrigin);
+}
+async function refreshContent(message, invalidateAll) {
+    try {
+        await invalidateAll();
+        acknowledge(message, { ok: true });
+    }
+    catch (error) {
+        console.error(error);
+        acknowledge(message, { ok: false, error: error instanceof Error ? error.message : String(error) });
+    }
+}
+/**
+ * Listen for the live Studio preview protocol and answer it with SvelteKit's
+ * own navigation APIs. Returns the disconnect function.
+ *
+ * Only messages from the established parent origin are honored. History stays
+ * native, so Studio's back/forward controls need no protocol of their own.
+ */
+export function connectPreview({ goto, invalidateAll }) {
+    const onMessage = (event) => {
+        const parentOrigin = getPreviewParentOrigin();
+        if (event.source !== window.parent || !parentOrigin || event.origin !== parentOrigin) {
+            return;
+        }
+        const message = (event.data ?? {});
+        switch (message.type) {
+            case 'nav/navigate':
+                if (typeof message.payload?.to === 'string') {
+                    void goto(message.payload.to);
+                }
+                return;
+            case 'nav/read-routes':
+                // The app owns its route table; answer with where it actually is.
+                sendPreviewLocation();
+                return;
+            case 'content/refresh':
+                void refreshContent(message, invalidateAll);
+                return;
+        }
+    };
+    window.addEventListener('message', onMessage);
+    return () => {
+        window.removeEventListener('message', onMessage);
+    };
+}

package/dist/runtime/sveltekit/runtime.d.ts

@@ -0,0 +1,8 @@
+import { type ContentRuntime } from '../content/client/runtime.js';
+export interface SvelteKitContentRuntimeOptions {
+    apiUrl: string | undefined;
+    defaultLocale?: string;
+    fetch: typeof globalThis.fetch;
+}
+export declare function createSvelteKitContentRuntime(options: SvelteKitContentRuntimeOptions): ContentRuntime;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime/sveltekit/runtime.js

@@ -0,0 +1,17 @@
+import { requireContentApiUrl } from '../content/client/runtime.js';
+export function createSvelteKitContentRuntime(options) {
+    return {
+        apiBase() {
+            return requireContentApiUrl(options.apiUrl, 'PUBLIC_FIMO_API_URL');
+        },
+        defaultLocale() {
+            return options.defaultLocale?.trim() || 'en';
+        },
+        headers(extra) {
+            return { ...extra };
+        },
+        fetch(input, init) {
+            return options.fetch(input, init);
+        },
+    };
+}

package/dist/runtime/templates.d.ts

@@ -1,4 +1,4 @@
-export declare const TEMPLATE_FRAMEWORKS: readonly ['react-router', 'nextjs'];
+export declare const TEMPLATE_FRAMEWORKS: readonly ['react-router', 'nextjs', 'sveltekit'];
 export type TemplateFramework = (typeof TEMPLATE_FRAMEWORKS)[number];
 export declare const DEFAULT_TEMPLATE: TemplateFramework;
 /**

package/dist/runtime/templates.js

@@ -27,7 +27,7 @@ const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_ROOT = path.resolve(MODULE_DIR, '..', '..');
 const RELEASE_FILE = path.join(PACKAGE_ROOT, 'release.json');
 const PACKAGE_JSON_FILE = path.join(PACKAGE_ROOT, 'package.json');
-export const TEMPLATE_FRAMEWORKS = ['react-router', 'nextjs'];
+export const TEMPLATE_FRAMEWORKS = ['react-router', 'nextjs', 'sveltekit'];
 export const DEFAULT_TEMPLATE = 'react-router';
 /**
  * Absolute path to the requested framework's template directory.

package/dist/runtime/vite/Label.d.ts

@@ -0,0 +1,13 @@
+import type { ElementType } from 'react';
+import type { LabelProps } from '../react/primitives/contracts.js';
+export type { LabelProps } from '../react/primitives/contracts.js';
+/**
+ * Render one editable label from the Vite/React Router label context.
+ *
+ * For attributes, metadata, and composed strings, use `useLabels().t()`.
+ *
+ * @example
+ * <Label value="hero.title" as="h1" />
+ */
+export declare function Label<T extends ElementType = 'span'>({ value, ...props }: LabelProps<T>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=Label.d.ts.map

package/dist/runtime/vite/Label.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Text } from '../react/primitives/editable/Text.js';
+import { useLabels } from './translations.js';
+/**
+ * Render one editable label from the Vite/React Router label context.
+ *
+ * For attributes, metadata, and composed strings, use `useLabels().t()`.
+ *
+ * @example
+ * <Label value="hero.title" as="h1" />
+ */
+export function Label({ value, ...props }) {
+    const { t } = useLabels();
+    const textProps = { ...props, value: t(value) };
+    return _jsx(Text, { ...textProps });
+}