fimo 0.14.0 → 0.15.0-staging.2

package/assets/sveltekit/components/Json.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+  import type { HTMLAttributes, SvelteHTMLElements } from 'svelte/elements';
+
+  import { getFimoSource } from 'fimo/sveltekit';
+
+  type Props = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    value: unknown;
+    as?: keyof SvelteHTMLElements;
+    [key: string]: unknown;
+  };
+
+  let { value, as = 'span', ...props }: Props = $props();
+  const source = $derived(getFimoSource(value));
+</script>
+
+{#if value != null}
+  <svelte:element this={as} {...props} data-fimo-source={source}>{JSON.stringify(value)}</svelte:element>
+{/if}

package/assets/sveltekit/components/Label.svelte

@@ -0,0 +1,16 @@
+<script lang="ts">
+  import { useLabels } from 'fimo/sveltekit';
+  import type { ComponentProps } from 'svelte';
+
+  import Text from './Text.svelte';
+
+  type Props = Omit<ComponentProps<typeof Text>, 'value'> & {
+    value: string;
+  };
+
+  let { value, ...props }: Props = $props();
+  const labels = useLabels();
+  const label = $derived(labels.t(value));
+</script>
+
+<Text {...props} value={label} />

package/assets/sveltekit/components/Number.svelte

@@ -0,0 +1,21 @@
+<script lang="ts">
+  import type { HTMLAttributes, SvelteHTMLElements } from 'svelte/elements';
+
+  // Content numbers stay plain JS numbers (there is no FimoNumber wrapper), so
+  // this primitive has no source to expose: it formats for display only and is
+  // not editable in the preview.
+  type Props = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    value: number | null | undefined;
+    as?: keyof SvelteHTMLElements;
+    locale?: string;
+    options?: Intl.NumberFormatOptions;
+    [key: string]: unknown;
+  };
+
+  let { value, as = 'span', locale, options, ...props }: Props = $props();
+  const rendered = $derived(value != null && !Number.isNaN(value) ? value.toLocaleString(locale, options) : null);
+</script>
+
+{#if rendered != null}
+  <svelte:element this={as} {...props}>{rendered}</svelte:element>
+{/if}

package/assets/sveltekit/components/RichText.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">
+  import type { HTMLAttributes } from 'svelte/elements';
+
+  import type { FimoRichText } from 'fimo/sveltekit';
+  import { getFimoSource } from 'fimo/sveltekit';
+  import { renderRichTextHtml } from 'fimo/sveltekit/internal';
+
+  type Props = Omit<HTMLAttributes<HTMLDivElement>, 'children'> & {
+    value: FimoRichText | null | undefined;
+  };
+
+  let { value, ...props }: Props = $props();
+  const source = $derived(getFimoSource(value));
+  const html = $derived(renderRichTextHtml(value?.content));
+</script>
+
+{#if value}
+  <div {...props} data-fimo-source={source} data-fimo-richtext="">{@html html}</div>
+{/if}

package/assets/sveltekit/components/Text.svelte

@@ -0,0 +1,30 @@
+<script lang="ts">
+  import type { HTMLAttributes, SvelteHTMLElements } from 'svelte/elements';
+
+  import type { FimoString } from 'fimo/sveltekit';
+  import { getFimoParts, getFimoSource } from 'fimo/sveltekit';
+
+  type Props = Omit<HTMLAttributes<HTMLElement>, 'children'> & {
+    value: FimoString | string | null | undefined;
+    as?: keyof SvelteHTMLElements;
+    [key: string]: unknown;
+  };
+
+  let { value, as = 'span', ...props }: Props = $props();
+  const parts = $derived(getFimoParts(value));
+  const source = $derived(getFimoSource(value));
+</script>
+
+<svelte:element this={as} {...props} data-fimo-source={source}>
+  {#if parts && parts.length > 1}
+    {#each parts as part}
+      {#if part.source}
+        <span data-fimo-source={part.source}>{part.text}</span>
+      {:else}
+        {part.text}
+      {/if}
+    {/each}
+  {:else}
+    {String(value ?? '')}
+  {/if}
+</svelte:element>

package/assets/sveltekit/components/Video.svelte

@@ -0,0 +1,37 @@
+<script lang="ts">
+  import type { HTMLVideoAttributes } from 'svelte/elements';
+
+  import type { FimoMedia } from 'fimo/sveltekit';
+  import { getFimoSource } from 'fimo/sveltekit';
+
+  type Props = Omit<HTMLVideoAttributes, 'src' | 'width' | 'height' | 'children'> & {
+    value: FimoMedia | null | undefined;
+    overrideSrc?: string;
+  };
+
+  let {
+    value,
+    overrideSrc,
+    autoplay = true,
+    loop = true,
+    muted = true,
+    playsinline = true,
+    ...props
+  }: Props = $props();
+  const source = $derived(getFimoSource(value));
+</script>
+
+{#if value}
+  <!-- svelte-ignore a11y_media_has_caption -->
+  <video
+    {...props}
+    src={overrideSrc ?? value.url}
+    width={value.width}
+    height={value.height}
+    {autoplay}
+    {loop}
+    {muted}
+    {playsinline}
+    data-fimo-source={source}
+  ></video>
+{/if}

package/assets/sveltekit/components/index.d.ts

@@ -0,0 +1,10 @@
+export { default as Boolean } from './Boolean.svelte';
+export { default as Date } from './Date.svelte';
+export { default as FimoProvider } from './FimoProvider.svelte';
+export { default as Image } from './Image.svelte';
+export { default as Json } from './Json.svelte';
+export { default as Label } from './Label.svelte';
+export { default as Number } from './Number.svelte';
+export { default as RichText } from './RichText.svelte';
+export { default as Text } from './Text.svelte';
+export { default as Video } from './Video.svelte';

package/assets/sveltekit/components/index.js

@@ -0,0 +1,10 @@
+export { default as Boolean } from './Boolean.svelte';
+export { default as Date } from './Date.svelte';
+export { default as FimoProvider } from './FimoProvider.svelte';
+export { default as Image } from './Image.svelte';
+export { default as Json } from './Json.svelte';
+export { default as Label } from './Label.svelte';
+export { default as Number } from './Number.svelte';
+export { default as RichText } from './RichText.svelte';
+export { default as Text } from './Text.svelte';
+export { default as Video } from './Video.svelte';

package/dist/build/astro/config.d.ts

@@ -0,0 +1,4 @@
+import type { AstroIntegration } from 'astro';
+/** Connect an Astro app to Fimo preview and hosted server rendering. */
+export declare function fimo(): AstroIntegration;
+//# sourceMappingURL=config.d.ts.map

package/dist/build/astro/config.js

@@ -0,0 +1,64 @@
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import astroHostingAdapter from '@astrojs/vercel';
+import { getConfigPreviewRoutes } from '../../runtime/preview/routes.js';
+import { getConfigServer } from '../../runtime/shared/fimo-config.server.js';
+import runtimeEnvPlugin from '../vite/plugins/runtime-env.js';
+const require = createRequire(import.meta.url);
+const astroHostingEntrypoint = require.resolve('@astrojs/vercel/entrypoint');
+function serializeForModule(value) {
+    return (JSON.stringify(value) ?? 'undefined')
+        .replaceAll('<', '\\u003c')
+        .replaceAll('\u2028', '\\u2028')
+        .replaceAll('\u2029', '\\u2029');
+}
+function createFimoHostingAdapter() {
+    const adapter = astroHostingAdapter();
+    const configDone = adapter.hooks['astro:config:done'];
+    if (configDone) {
+        adapter.hooks['astro:config:done'] = (options) => {
+            configDone({
+                ...options,
+                setAdapter: (resolvedAdapter) => options.setAdapter({
+                    ...resolvedAdapter,
+                    serverEntrypoint: astroHostingEntrypoint,
+                }),
+            });
+        };
+    }
+    return adapter;
+}
+/** Connect an Astro app to Fimo preview and hosted server rendering. */
+export function fimo() {
+    return {
+        name: 'fimo:astro',
+        hooks: {
+            'astro:config:setup': ({ config, injectScript, updateConfig }) => {
+                const hasVercelAdapter = config.integrations?.some((integration) => integration.name === '@astrojs/vercel' || integration.name.startsWith('@astrojs/vercel/'));
+                if (config.output === 'server' && !config.adapter && !hasVercelAdapter) {
+                    // Astro copies config.adapter into its adapter lifecycle before setup
+                    // hooks run. Registering the same object as an integration ensures
+                    // its config:done hook calls setAdapter for the server build.
+                    const adapter = createFimoHostingAdapter();
+                    updateConfig({ adapter, integrations: [adapter] });
+                }
+                // Astro is Vite underneath: the same plugin that points a Vite app at
+                // the git branch's env does it here, exposing `PUBLIC_FIMO_API_URL`.
+                // `as never` sidesteps a TS "excessive stack depth" on Astro's
+                // DeepPartial<AstroConfig> vs Vite's Plugin type; the shape is the
+                // documented `updateConfig({ vite: { plugins } })`.
+                updateConfig({ vite: { plugins: [runtimeEnvPlugin()] } });
+                const fimoConfig = getConfigServer(fileURLToPath(config.root));
+                const routes = getConfigPreviewRoutes(fimoConfig);
+                injectScript('page', [
+                    "import { connectAstroPreview } from 'fimo/astro/internal';",
+                    'connectAstroPreview({',
+                    '  previewScriptUrl: import.meta.env.PUBLIC_FIMO_PREVIEW_SCRIPT_URL,',
+                    `  routes: ${serializeForModule(routes)},`,
+                    `  i18n: ${serializeForModule(fimoConfig.i18n)},`,
+                    '});',
+                ].join('\n'));
+            },
+        },
+    };
+}

package/dist/build/next/config.js

@@ -1,3 +1,4 @@
+import { findStaleFimoOverride, resolveLocalRuntimeEnv, staleOverrideMessage, } from '../../runtime/shared/local-runtime-env.js';
 const NEXT_DEVELOPMENT_PHASE = 'phase-development-server';
 const PREVIEW_ORIGINS_ENV = 'FIMO_PREVIEW_ALLOWED_ORIGINS';
 function readPreviewOrigins() {
@@ -20,6 +21,21 @@ export function withFimo(applicationConfig) {
         if (phase !== NEXT_DEVELOPMENT_PHASE) {
             return config;
         }
+        // Next has already loaded `.env*` into `process.env` by the time this runs,
+        // so "unset" here means neither the platform, the shell, nor the user's own
+        // env files supplied it — only then does the git branch decide, per key.
+        const derived = resolveLocalRuntimeEnv({ cwd: process.cwd() });
+        if (derived) {
+            const stale = findStaleFimoOverride(process.env, derived);
+            if (stale) {
+                console.warn(staleOverrideMessage(stale));
+            }
+            for (const [key, value] of Object.entries(derived.values)) {
+                if (!process.env[key]) {
+                    process.env[key] = value;
+                }
+            }
+        }
         const previewOrigins = readPreviewOrigins();
         if (previewOrigins.length === 0) {
             return config;

package/dist/build/sveltekit/config.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Configure a SvelteKit project for Fimo hosting without exposing the hosting
+ * provider in the generated application.
+ */
+export declare function fimo(): import("@sveltejs/kit").Adapter;
+//# sourceMappingURL=config.d.ts.map

package/dist/build/sveltekit/config.js

@@ -0,0 +1,8 @@
+import adapter from '@sveltejs/adapter-vercel';
+/**
+ * Configure a SvelteKit project for Fimo hosting without exposing the hosting
+ * provider in the generated application.
+ */
+export function fimo() {
+    return adapter({ runtime: 'nodejs24.x' });
+}

package/dist/build/sveltekit/data-id.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'vite';
+export default function svelteDataIdPlugin(): Plugin;
+//# sourceMappingURL=data-id.d.ts.map

package/dist/build/sveltekit/data-id.js

@@ -0,0 +1,171 @@
+import { createRequire } from 'node:module';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getLineColumn } from '../vite/plugins/data-id.js';
+// Native DOM elements are always taggable. Fimo's editable primitives are the
+// only component exception: they forward arbitrary element attributes to the
+// native element they render, so tagging them gives Studio the precise source
+// location without leaking data-fimo-id props into arbitrary user components.
+const TAGGABLE_ELEMENT_TYPES = new Set(['RegularElement', 'SvelteElement']);
+const FIMO_PRIMITIVE_EXPORTS = new Set(['Text', 'Image', 'RichText']);
+const FIMO_COMPONENTS_MODULE = 'fimo/sveltekit/components';
+const EXCLUDED_ID_SEGMENTS = ['/node_modules/', '/.svelte-kit/', 'components/ui/', '.fimo/ui/'];
+export default function svelteDataIdPlugin() {
+    let config;
+    let compilerLoad;
+    // Svelte is owned by the consuming app, never by fimo: resolve the compiler
+    // from the project root so tagging parses with the exact Svelte version
+    // that later compiles the file.
+    function loadCompiler() {
+        compilerLoad ??= (async () => {
+            try {
+                const projectRequire = createRequire(join(config.root, 'package.json'));
+                const compilerUrl = pathToFileURL(projectRequire.resolve('svelte/compiler')).href;
+                // The require condition can point at a CJS bundle; depending on the
+                // named-export lexer, `parse` may only be reachable via `default`.
+                const imported = (await import(compilerUrl));
+                const compiler = typeof imported.parse === 'function' ? imported : imported.default;
+                if (typeof compiler?.parse !== 'function') {
+                    throw new Error('svelte/compiler does not expose parse()');
+                }
+                return compiler;
+            }
+            catch (error) {
+                config.logger.warn(`[fimo] data-fimo-id tagging disabled: svelte/compiler is not resolvable from ${config.root} (${String(error)})`);
+                return null;
+            }
+        })();
+        return compilerLoad;
+    }
+    return {
+        name: 'vite-plugin-svelte-data-id',
+        enforce: 'pre',
+        configResolved(resolvedConfig) {
+            config = resolvedConfig;
+        },
+        async transform(code, id) {
+            if (config.command === 'build') {
+                return null;
+            }
+            // Query'd sub-requests (`+page.svelte?svelte&type=style…`) carry
+            // compiled non-Svelte content and never end with `.svelte`.
+            if (!id.endsWith('.svelte')) {
+                return null;
+            }
+            if (EXCLUDED_ID_SEGMENTS.some((segment) => id.includes(segment))) {
+                return null;
+            }
+            const compiler = await loadCompiler();
+            if (!compiler) {
+                return null;
+            }
+            let parsed;
+            try {
+                parsed = compiler.parse(code, { modern: true });
+            }
+            catch {
+                // Invalid Svelte: leave the file untouched so vite-plugin-svelte
+                // reports the real syntax error against the original source.
+                return null;
+            }
+            const relativePath = id.startsWith(`${config.root}/`) ? id.slice(config.root.length + 1) : id;
+            const insertions = [];
+            const primitiveComponents = collectFimoPrimitiveComponents(parsed.instance, parsed.module);
+            collectInsertions(parsed.fragment, code, relativePath, primitiveComponents, insertions);
+            if (insertions.length === 0) {
+                return null;
+            }
+            insertions.sort((a, b) => b.offset - a.offset);
+            let transformed = code;
+            for (const insertion of insertions) {
+                transformed = transformed.slice(0, insertion.offset) + insertion.value + transformed.slice(insertion.offset);
+            }
+            return { code: transformed, map: null };
+        },
+    };
+}
+function collectInsertions(node, code, relativePath, primitiveComponents, insertions) {
+    if (!node || typeof node !== 'object') {
+        return;
+    }
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            collectInsertions(item, code, relativePath, primitiveComponents, insertions);
+        }
+        return;
+    }
+    const element = node;
+    if (typeof element.type === 'string' &&
+        (TAGGABLE_ELEMENT_TYPES.has(element.type) ||
+            (element.type === 'Component' && typeof element.name === 'string' && primitiveComponents.has(element.name))) &&
+        typeof element.start === 'number' &&
+        typeof element.name === 'string' &&
+        !hasExplicitId(element.attributes)) {
+        const { line, column } = getLineColumn(code, element.start);
+        insertions.push({
+            // `start` points at `<`, so this lands right after the tag name — also
+            // valid for `<svelte:element>`, whose `name` is the literal pseudo-tag.
+            offset: element.start + 1 + element.name.length,
+            value: ` data-fimo-id="${relativePath}#${line}-${column}"`,
+        });
+    }
+    for (const [key, child] of Object.entries(node)) {
+        // `metadata` is compiler-internal bookkeeping and may hold
+        // back-references; `parent` would make the walk cyclic.
+        if (key === 'parent' || key === 'metadata') {
+            continue;
+        }
+        collectInsertions(child, code, relativePath, primitiveComponents, insertions);
+    }
+}
+function collectFimoPrimitiveComponents(...instances) {
+    const names = new Set();
+    for (const instance of instances) {
+        if (!instance || typeof instance !== 'object') {
+            continue;
+        }
+        const content = instance.content;
+        if (!content || typeof content !== 'object') {
+            continue;
+        }
+        const body = content.body;
+        if (!Array.isArray(body)) {
+            continue;
+        }
+        for (const statement of body) {
+            if (!statement || typeof statement !== 'object') {
+                continue;
+            }
+            const declaration = statement;
+            const source = declaration.source;
+            if (declaration.type !== 'ImportDeclaration' || source?.value !== FIMO_COMPONENTS_MODULE) {
+                continue;
+            }
+            if (!Array.isArray(declaration.specifiers)) {
+                continue;
+            }
+            for (const specifier of declaration.specifiers) {
+                if (!specifier || typeof specifier !== 'object') {
+                    continue;
+                }
+                const imported = specifier;
+                if (imported.type === 'ImportSpecifier' &&
+                    typeof imported.imported?.name === 'string' &&
+                    FIMO_PRIMITIVE_EXPORTS.has(imported.imported.name) &&
+                    typeof imported.local?.name === 'string') {
+                    names.add(imported.local.name);
+                }
+            }
+        }
+    }
+    return names;
+}
+function hasExplicitId(attributes) {
+    if (!Array.isArray(attributes)) {
+        return false;
+    }
+    return attributes.some((attribute) => {
+        const attr = attribute;
+        return attr.type === 'Attribute' && attr.name === 'data-fimo-id';
+    });
+}

package/dist/build/sveltekit/vite.d.ts

@@ -0,0 +1,13 @@
+import type { PluginOption } from 'vite';
+/**
+ * Narrow SvelteKit build connector. Points the dev server at the git branch's
+ * Fimo env (`PUBLIC_FIMO_API_URL`, `FIMO_ENV`), and tags native Svelte
+ * template elements with deterministic `data-fimo-id="<path>#<line>-<column>"`
+ * attributes during `vite dev` so the Fimo preview can map DOM nodes back to
+ * source. Explicit `data-fimo-id` attributes are preserved and production
+ * builds are untouched.
+ *
+ * Usage in the app's vite.config.ts: `plugins: [fimo(), sveltekit()]`.
+ */
+export declare function fimo(): PluginOption[];
+//# sourceMappingURL=vite.d.ts.map

package/dist/build/sveltekit/vite.js

@@ -0,0 +1,15 @@
+import runtimeEnvPlugin from '../vite/plugins/runtime-env.js';
+import svelteDataIdPlugin from './data-id.js';
+/**
+ * Narrow SvelteKit build connector. Points the dev server at the git branch's
+ * Fimo env (`PUBLIC_FIMO_API_URL`, `FIMO_ENV`), and tags native Svelte
+ * template elements with deterministic `data-fimo-id="<path>#<line>-<column>"`
+ * attributes during `vite dev` so the Fimo preview can map DOM nodes back to
+ * source. Explicit `data-fimo-id` attributes are preserved and production
+ * builds are untouched.
+ *
+ * Usage in the app's vite.config.ts: `plugins: [fimo(), sveltekit()]`.
+ */
+export function fimo() {
+    return [runtimeEnvPlugin(), svelteDataIdPlugin()];
+}

package/dist/build/vite/index.js

@@ -5,6 +5,7 @@ import dataIdPlugin from './plugins/data-id.js';
 import fimoConfigPlugin from './plugins/fimo-config.js';
 import overlayPlugin from './plugins/overlay.js';
 import robotsPlugin from './plugins/robots.js';
+import runtimeEnvPlugin from './plugins/runtime-env.js';
 import seoPlugin from './plugins/seo.js';
 import serverConfigPlugin from './plugins/server-config.js';
 import sitemapPlugin from './plugins/sitemap.js';
@@ -137,6 +138,7 @@ function bundleFimoIntoSsrPlugin() {
 // NOTE: dataIdPlugin must run before anything else to capture valid line numbers.
 export function fimo(opts = {}) {
     const plugins = [
+        runtimeEnvPlugin(),
         bundleFimoIntoSsrPlugin(),
         contentSyncPlugin(),
         serverConfigPlugin(),

package/dist/build/vite/plugins/data-id.d.ts

@@ -1,3 +1,12 @@
 import type { Plugin } from 'vite';
 export default function dataIdPlugin(): Plugin;
+/**
+ * 1-based line and 0-based column of `offset` in `code`. Shared with the
+ * SvelteKit data-id plugin: both derive the stable `<path>#<line>-<column>`
+ * id from it, so the convention must not change independently.
+ */
+export declare function getLineColumn(code: string, offset: number): {
+    line: number;
+    column: number;
+};
 //# sourceMappingURL=data-id.d.ts.map

package/dist/build/vite/plugins/data-id.js

@@ -78,7 +78,12 @@ export default function dataIdPlugin() {
         },
     };
 }
-function getLineColumn(code, offset) {
+/**
+ * 1-based line and 0-based column of `offset` in `code`. Shared with the
+ * SvelteKit data-id plugin: both derive the stable `<path>#<line>-<column>`
+ * id from it, so the convention must not change independently.
+ */
+export function getLineColumn(code, offset) {
     let line = 1;
     let column = 0;
     for (let i = 0; i < offset && i < code.length; i++) {

package/dist/build/vite/plugins/runtime-env.d.ts

@@ -0,0 +1,21 @@
+import { type Plugin } from 'vite';
+/**
+ * Point the app at the Fimo env of the current git branch.
+ *
+ * One rule, per variable: anything already set — by the process env (sandbox,
+ * shell) or the user's own `.env*` files, read through Vite's `loadEnv` — is
+ * left alone; derivation fills only what is missing. A value a user wrote by
+ * hand is an override, and this plugin must never win over it.
+ *
+ * Two injection paths, both needed:
+ * - `process.env`, so Vite's own `VITE_*` exposure, `loadEnv`, and server-side
+ *   code (`getFimoPaths`, SSR) all see the value.
+ * - `define` for the two keys the browser bundle reads. Fimo's own template
+ *   `define`s them from `loadEnv` at user-config time — before any plugin can
+ *   run — which yields `undefined` on a bare checkout; a plugin's `define`
+ *   merges over the user's, so this is what makes the client see the derived
+ *   URL. Only for keys nothing else set, so the user's own `define` stays
+ *   authoritative.
+ */
+export default function runtimeEnvPlugin(): Plugin;
+//# sourceMappingURL=runtime-env.d.ts.map

package/dist/build/vite/plugins/runtime-env.js

@@ -0,0 +1,68 @@
+import { loadEnv } from 'vite';
+import { findStaleFimoOverride, resolveLocalRuntimeEnv, staleOverrideMessage, } from '../../../runtime/shared/local-runtime-env.js';
+/**
+ * Point the app at the Fimo env of the current git branch.
+ *
+ * One rule, per variable: anything already set — by the process env (sandbox,
+ * shell) or the user's own `.env*` files, read through Vite's `loadEnv` — is
+ * left alone; derivation fills only what is missing. A value a user wrote by
+ * hand is an override, and this plugin must never win over it.
+ *
+ * Two injection paths, both needed:
+ * - `process.env`, so Vite's own `VITE_*` exposure, `loadEnv`, and server-side
+ *   code (`getFimoPaths`, SSR) all see the value.
+ * - `define` for the two keys the browser bundle reads. Fimo's own template
+ *   `define`s them from `loadEnv` at user-config time — before any plugin can
+ *   run — which yields `undefined` on a bare checkout; a plugin's `define`
+ *   merges over the user's, so this is what makes the client see the derived
+ *   URL. Only for keys nothing else set, so the user's own `define` stays
+ *   authoritative.
+ */
+export default function runtimeEnvPlugin() {
+    return {
+        name: 'fimo:runtime-env',
+        enforce: 'pre',
+        config: {
+            // `order: 'pre'` on the HOOK, not just `enforce: 'pre'` on the plugin.
+            // Vite sorts every hook by its own `order` first and plugin position
+            // second, so a plugin-level `enforce` alone does not beat another
+            // plugin's `order: 'pre'` hook. SvelteKit's config hook declares exactly
+            // that and snapshots the environment through `loadEnv` — without this,
+            // it captures the env before this plugin fills it and `$env/dynamic/public`
+            // comes back empty. Astro hides the same bug because it reads
+            // `import.meta.env`, which `define` patches at transform time.
+            order: 'pre',
+            handler(config, { command, mode }) {
+                // Production builds get their env from the platform. Only a local dev
+                // server has a git branch worth deriving from.
+                if (command !== 'serve') {
+                    return;
+                }
+                const cwd = config.root ?? process.cwd();
+                const derived = resolveLocalRuntimeEnv({ cwd });
+                if (!derived) {
+                    return;
+                }
+                const explicit = { ...loadEnv(mode, config.envDir ?? cwd, ''), ...process.env };
+                const stale = findStaleFimoOverride(explicit, derived);
+                if (stale) {
+                    console.warn(staleOverrideMessage(stale));
+                }
+                // Decide what is missing BEFORE writing to process.env, or the define
+                // step below would see the values this loop just set.
+                const missing = Object.entries(derived.values).filter(([key]) => !explicit[key]);
+                for (const [key, value] of missing) {
+                    process.env[key] = value;
+                }
+                // `define` EVERY derived key, not a hand-picked subset. Vite only exposes
+                // `envPrefix` matches on `import.meta.env`, so an unprefixed key set on
+                // `process.env` is invisible to code that reads `import.meta.env` — which
+                // is how Astro's server runtime reads `FIMO_CONTENT_API_URL`. A curated
+                // list silently misses whichever framework reads a key that is not on it.
+                // Every value here is a public tenant URL or an env name; none is secret.
+                const define = Object.fromEntries(missing.map(([key, value]) => [`import.meta.env.${key}`, JSON.stringify(value)]));
+                return Object.keys(define).length > 0 ? { define } : undefined;
+            },
+        },
+    };
+}

package/dist/cli/bundle.json

@@ -1,7 +1,7 @@
 {
   "bundled": true,
   "bundler": "esbuild",
-  "bundledAt": "2026-08-14T12:10:52.606Z",
+  "bundledAt": "2026-08-16T19:27:18.832Z",
   "cliVersion": "0.14.0",
   "external": [
     "oxc-parser",