fimo 0.8.0 → 0.9.0-experimental.10

package/dist/scripts/frameworks/next/wiring.js

@@ -0,0 +1,186 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseSync } from 'oxc-parser';
+import { ensureFimoImport } from '../../apply-wrap.js';
+/**
+ * Next.js-side wrap wiring: everything the wrap migration must touch that is
+ * specific to this framework lives HERE, not in the generic flow. Mirror this
+ * module when adding a framework (see the fimo-framework-adapter skill).
+ */
+export function ensureNextWiring(cwd) {
+    const changes = [];
+    const warnings = [];
+    const configFile = ['next.config.ts', 'next.config.mjs', 'next.config.js', 'next.config.cjs']
+        .map((candidate) => path.join(cwd, candidate))
+        .find((candidate) => fs.existsSync(candidate));
+    if (configFile) {
+        const source = fs.readFileSync(configFile, 'utf8');
+        if (!source.includes('allowedDevOrigins')) {
+            // The three mainstream config shapes: a named object binding, a direct
+            // `export default {` literal, and CJS `module.exports = {`.
+            let patched = source.replace(/(const\s+nextConfig[^=]*=\s*\{)/, `$1\n  allowedDevOrigins: ['*.preview.fimo.ai'],`);
+            if (patched === source) {
+                patched = source.replace(/((?:export\s+default|module\.exports\s*=)\s*\{)/, `$1\n  allowedDevOrigins: ['*.preview.fimo.ai'],\n`);
+            }
+            if (patched !== source) {
+                fs.writeFileSync(configFile, patched);
+                changes.push(`added allowedDevOrigins to ${path.basename(configFile)}`);
+            }
+            else {
+                warnings.push(`Could not patch ${path.basename(configFile)} automatically — add: allowedDevOrigins: ['*.preview.fimo.ai']`);
+            }
+        }
+    }
+    else {
+        warnings.push("No next.config found — create one with: allowedDevOrigins: ['*.preview.fimo.ai']");
+    }
+    return { changes, warnings };
+}
+function findFirst(node, predicate) {
+    if (!node || typeof node !== 'object') {
+        return null;
+    }
+    if (predicate(node)) {
+        return node;
+    }
+    for (const value of Object.values(node)) {
+        if (Array.isArray(value)) {
+            for (const entry of value) {
+                const found = findFirst(entry, predicate);
+                if (found) {
+                    return found;
+                }
+            }
+        }
+        else if (value && typeof value === 'object') {
+            const found = findFirst(value, predicate);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return null;
+}
+const jsxName = (element) => element?.openingElement?.name?.name;
+/**
+ * Candidate app-router root-layout files: the direct `<appDir>/layout.*` plus,
+ * for i18n apps that place the `<html>` layout under a dynamic segment
+ * (next-intl's `app/[locale]/layout.tsx`), any `<appDir>/[segment]/layout.*`.
+ * Existing files only, in resolution order.
+ */
+export function nextRootLayoutFiles(cwd, appDir) {
+    const names = ['layout.tsx', 'layout.jsx', 'layout.js'];
+    const dirs = [path.join(cwd, appDir)];
+    try {
+        for (const entry of fs.readdirSync(path.join(cwd, appDir), { withFileTypes: true })) {
+            if (entry.isDirectory() && entry.name.startsWith('[') && entry.name.endsWith(']')) {
+                dirs.push(path.join(cwd, appDir, entry.name));
+            }
+        }
+    }
+    catch {
+        // appDir missing — no candidates
+    }
+    return dirs.flatMap((dir) => names.map((name) => path.join(dir, name))).filter((file) => fs.existsSync(file));
+}
+/**
+ * Wire the app-router root layout deterministically: imports, async default
+ * export, loader calls, `<FimoNextScripts />` in head, and `{children}`
+ * wrapped in `<FimoNextProviders>`. Only the provably safe shape is touched —
+ * one default-exported function whose JSX returns `<html>…<body>` with a
+ * `{children}` expression somewhere inside body (create-next-app and its
+ * variants). Anything else bails with the reason, and the agent prompt keeps
+ * the manual recipe.
+ */
+export function ensureNextLayoutWiring(cwd, detection) {
+    if (!detection.appDir) {
+        return {
+            changes: [],
+            warnings: ['Root wiring not applied: pages-router project (no app directory) — wire pages/_app manually.'],
+            wired: false,
+        };
+    }
+    const candidates = nextRootLayoutFiles(cwd, detection.appDir);
+    // Already wired anywhere — an agent may have mounted the [locale] layout by hand.
+    if (candidates.some((file) => fs.readFileSync(file, 'utf8').includes('FimoNextProviders'))) {
+        return { changes: [], warnings: [], wired: true };
+    }
+    // The real root layout is the one that returns <html> (next-intl puts it under
+    // app/[locale]/); fall back to the first candidate for the bail message.
+    const layoutFile = candidates.find((file) => fs.readFileSync(file, 'utf8').includes('<html')) ?? candidates[0];
+    const rel = layoutFile ? path.relative(cwd, layoutFile) : `${detection.appDir}/layout.tsx`;
+    const bail = (reason) => ({
+        changes: [],
+        warnings: [`Root wiring not applied: ${reason} — follow the layout recipe in the agent prompt (${rel}).`],
+        wired: false,
+    });
+    if (!layoutFile) {
+        return bail('no root layout file found');
+    }
+    const code = fs.readFileSync(layoutFile, 'utf8');
+    let program;
+    try {
+        program = parseSync(layoutFile, code).program;
+    }
+    catch {
+        return bail('root layout could not be parsed');
+    }
+    const exportDefault = (program.body ?? []).find((node) => node.type === 'ExportDefaultDeclaration');
+    if (!exportDefault || exportDefault.declaration?.type !== 'FunctionDeclaration') {
+        return bail('the default export is not a plain function declaration');
+    }
+    const layoutFn = exportDefault.declaration;
+    const body = layoutFn.body;
+    if (!body || (body.type !== 'FunctionBody' && body.type !== 'BlockStatement')) {
+        return bail('the layout function has no block body');
+    }
+    const html = findFirst(body, (node) => node?.type === 'JSXElement' && jsxName(node) === 'html');
+    if (!html) {
+        return bail('the layout does not return an <html> element');
+    }
+    const htmlBody = (html.children ?? []).find((child) => child?.type === 'JSXElement' && jsxName(child) === 'body');
+    if (!htmlBody) {
+        return bail('no <body> element found under <html>');
+    }
+    const childrenExpr = findFirst(htmlBody, (node) => node?.type === 'JSXExpressionContainer' &&
+        node.expression?.type === 'Identifier' &&
+        node.expression?.name === 'children');
+    if (!childrenExpr) {
+        return bail('no {children} expression found inside <body>');
+    }
+    const edits = [];
+    if (!layoutFn.async) {
+        edits.push({ start: layoutFn.start, end: layoutFn.start, replacement: 'async ' });
+    }
+    edits.push({
+        start: body.start + 1,
+        end: body.start + 1,
+        replacement: '\n  const config = loadFimoConfig();\n  const labels = await loadFimoLabels();\n',
+    });
+    edits.push({
+        start: childrenExpr.start,
+        end: childrenExpr.end,
+        replacement: `<FimoNextProviders config={config} labels={labels}>${code.slice(childrenExpr.start, childrenExpr.end)}</FimoNextProviders>`,
+    });
+    const head = (html.children ?? []).find((child) => child?.type === 'JSXElement' && jsxName(child) === 'head');
+    if (head) {
+        const at = head.openingElement.end;
+        edits.push({ start: at, end: at, replacement: '<FimoNextScripts />' });
+    }
+    else {
+        const at = html.openingElement.end;
+        edits.push({
+            start: at,
+            end: at,
+            replacement: '\n      <head>\n        <FimoNextScripts />\n      </head>',
+        });
+    }
+    let next = code;
+    for (const edit of edits.sort((a, b) => b.start - a.start)) {
+        next = next.slice(0, edit.start) + edit.replacement + next.slice(edit.end);
+    }
+    next = ensureFimoImport(next, ['FimoNextProviders', 'FimoNextScripts'], 'fimo/next');
+    next = ensureFimoImport(next, ['loadFimoConfig', 'loadFimoLabels'], 'fimo/next/server');
+    fs.writeFileSync(layoutFile, next);
+    return { changes: [`wired Fimo providers into ${rel}`], warnings: [], wired: true };
+}

package/dist/scripts/frameworks/nuxt/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
+export declare function discoverNuxtRoutes(pagesDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/nuxt/routes.js

@@ -0,0 +1,38 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { pushRoute, toSegment } from '../discovered-route.js';
+/** Nuxt file-based routes under pages/ (index.vue maps to the dir path). */
+export function discoverNuxtRoutes(pagesDir) {
+    const routes = [];
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            let isDir = false;
+            try {
+                isDir = statSync(full).isDirectory();
+            }
+            catch {
+                continue;
+            }
+            if (isDir) {
+                walk(full, [...segments, toSegment(entry)]);
+                continue;
+            }
+            if (!entry.endsWith('.vue')) {
+                continue;
+            }
+            const base = entry.replace(/\.vue$/, '');
+            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)], full);
+        }
+    };
+    walk(pagesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/nuxt/template-style.d.ts

@@ -0,0 +1,9 @@
+import type { TemplateWrapStyle } from '../../apply-wrap-templates.js';
+/**
+ * Nuxt template wraps: the useFimoT composable is client-safe (fimo/nuxt
+ * never pulls server loaders into the bundle) and transfers the dictionary
+ * through the Nuxt payload, so a single `<script setup>` line wires a file.
+ * Options-API scripts have no safe injection point (top-level await needs
+ * setup) — those files stay agent work.
+ */
+export declare const nuxtTemplateWrapStyle: TemplateWrapStyle;

package/dist/scripts/frameworks/nuxt/template-style.js

@@ -0,0 +1,27 @@
+/**
+ * Nuxt template wraps: the useFimoT composable is client-safe (fimo/nuxt
+ * never pulls server loaders into the bundle) and transfers the dictionary
+ * through the Nuxt payload, so a single `<script setup>` line wires a file.
+ * Options-API scripts have no safe injection point (top-level await needs
+ * setup) — those files stay agent work.
+ */
+export const nuxtTemplateWrapStyle = {
+    ext: '.vue',
+    head: "import { useFimoT } from 'fimo/nuxt'\nconst t = await useFimoT()",
+    headMarker: /useFimoT/,
+    open: '{{ t(',
+    close: ') }}',
+    injectHead: (code, head) => {
+        // An SFC may carry BOTH <script> and <script setup>: target the setup
+        // block specifically (top-level await is only legal there).
+        const setup = code.match(/<script[^>]*\bsetup\b[^>]*>\r?\n?/);
+        if (setup && setup.index !== undefined) {
+            const at = setup.index + setup[0].length;
+            return `${code.slice(0, at)}${head}\n${code.slice(at)}`;
+        }
+        if (/<script\b/.test(code)) {
+            return null;
+        }
+        return `<script setup>\n${head}\n</script>\n\n${code}`;
+    },
+};

package/dist/scripts/frameworks/remix/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** Remix v2 flat routes under app/routes: dots are slashes, $param is dynamic. */
+export declare function discoverRemixRoutes(routesDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/remix/routes.js

@@ -0,0 +1,36 @@
+import { readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { pushRoute } from '../discovered-route.js';
+const FILE_EXT = /\.(tsx|jsx|ts|js|mdx)$/;
+/** Remix v2 flat routes under app/routes: dots are slashes, $param is dynamic. */
+export function discoverRemixRoutes(routesDir) {
+    const routes = [];
+    let entries;
+    try {
+        entries = readdirSync(routesDir);
+    }
+    catch {
+        return routes;
+    }
+    for (const entry of entries) {
+        if (!FILE_EXT.test(entry)) {
+            continue;
+        }
+        const base = entry.replace(FILE_EXT, '');
+        if (base === '_index') {
+            pushRoute(routes, [], join(routesDir, entry));
+            continue;
+        }
+        // Pathless layout segments start with _ ; trailing ._index maps to the parent.
+        const parts = base
+            .replace(/\._index$/, '')
+            .split('.')
+            .filter((seg) => !seg.startsWith('_'))
+            .map((seg) => (seg.startsWith('$') ? `:${seg.slice(1) || 'splat'}` : seg));
+        if (parts.length > 0) {
+            pushRoute(routes, parts, join(routesDir, entry));
+        }
+    }
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/support.d.ts

@@ -0,0 +1,75 @@
+import type { FrameworkDetection } from '../detect-framework.js';
+/**
+ * A host dependency the wrap gates on, with the floor Fimo's runtime requires.
+ * The floor is honest to the API surface the in-tree runtime actually uses —
+ * React frameworks gate on `react` 18 (the runtime touches `useSyncExternalStore`),
+ * Vue/Svelte/Astro on their own framework floor. The version gate is what turns
+ * an unsupported host into one actionable sentence instead of an npm `ERESOLVE`
+ * or an install-then-crash.
+ */
+export interface SupportCheck {
+    pkg: string;
+    /** Floor, `X.Y.Z`. */
+    min: string;
+    label: string;
+    /** Why this floor exists — shown to the user. */
+    reason: string;
+    /** One actionable next step — shown as the error hint. */
+    remedy: string;
+}
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export declare function supportChecksFor(detection: Pick<FrameworkDetection, 'framework' | 'react'>): SupportCheck[];
+interface ParsedVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    /** The original spec, for display. */
+    raw: string;
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export declare function parseVersionFloor(spec: string): ParsedVersion | null;
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export declare function readHostVersion(cwd: string, pkg: string): ParsedVersion | null;
+export interface HostSupportViolation {
+    subject: string;
+    /** The version we found on the host. */
+    found: string;
+    /** The floor Fimo requires. */
+    min: string;
+    /** Headline sentence for the error message. */
+    headline: string;
+    /** Actionable next step for the error hint. */
+    remedy: string;
+}
+export interface HostSupportResult {
+    ok: boolean;
+    violations: HostSupportViolation[];
+    /** Versions read successfully — for the summary line ("React 18.3.1"). */
+    detected: Array<{
+        label: string;
+        version: string;
+    }>;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export declare function checkHostSupport(cwd: string, detection: Pick<FrameworkDetection, 'framework' | 'react'>): HostSupportResult;
+export {};

package/dist/scripts/frameworks/support.js

@@ -0,0 +1,165 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const REACT_CHECK = {
+    pkg: 'react',
+    min: '18.0.0',
+    label: 'React',
+    reason: "Fimo's inline-editing runtime uses React 18 APIs (useSyncExternalStore).",
+    remedy: 'Upgrade React to 18 or newer. The content still migrates on older React; only inline editing needs 18+.',
+};
+/**
+ * The runtime-floor checks for a detected framework. React-based frameworks all
+ * gate on `react`; the template frameworks gate on their own package. Frameworks
+ * with no runtime coupling (or none detected) return [] — nothing to gate.
+ */
+export function supportChecksFor(detection) {
+    switch (detection.framework) {
+        case 'next':
+        case 'remix':
+        case 'react-router':
+            return [REACT_CHECK];
+        case 'vite':
+            return detection.react ? [REACT_CHECK] : [];
+        case 'nuxt':
+            return [
+                {
+                    pkg: 'nuxt',
+                    min: '3.0.0',
+                    label: 'Nuxt',
+                    reason: 'Fimo supports Nuxt 3+ (Vue 3). Nuxt 2 is end-of-life.',
+                    remedy: 'Upgrade to Nuxt 3 or newer.',
+                },
+            ];
+        case 'vue':
+            return [
+                {
+                    pkg: 'vue',
+                    min: '3.0.0',
+                    label: 'Vue',
+                    reason: 'Fimo supports Vue 3+. Vue 2 is end-of-life.',
+                    remedy: 'Upgrade to Vue 3 or newer.',
+                },
+            ];
+        case 'astro':
+            return [
+                {
+                    pkg: 'astro',
+                    min: '4.0.0',
+                    label: 'Astro',
+                    reason: 'Fimo supports Astro 4+.',
+                    remedy: 'Upgrade Astro to 4 or newer.',
+                },
+            ];
+        case 'sveltekit':
+            return [
+                {
+                    pkg: '@sveltejs/kit',
+                    min: '2.0.0',
+                    label: 'SvelteKit',
+                    reason: 'Fimo supports SvelteKit 2+.',
+                    remedy: 'Upgrade @sveltejs/kit to 2 or newer.',
+                },
+            ];
+        default:
+            return [];
+    }
+}
+/**
+ * The lowest concrete version a spec implies. Handles the shapes seen in real
+ * package.json / installed manifests: `^18.2.0`, `~3.4`, `>=2.0.0`, `18 || 19`,
+ * `18.3.1`, ` >= 14.0.0 `, bare `18`. Returns null for anything without a
+ * numeric floor (`latest`, `*`, `workspace:*`, `catalog:`, a git/file url) — we
+ * never gate on a version we cannot read.
+ */
+export function parseVersionFloor(spec) {
+    if (!spec) {
+        return null;
+    }
+    // A `||` union — the floor is the lowest branch, i.e. the first token.
+    const first = spec.split('||')[0];
+    const match = first.match(/(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: match[2] ? Number(match[2]) : 0,
+        patch: match[3] ? Number(match[3]) : 0,
+        raw: spec.trim(),
+    };
+}
+function isBelowFloor(found, min) {
+    const floor = parseVersionFloor(min);
+    if (!floor) {
+        return false;
+    }
+    if (found.major !== floor.major) {
+        return found.major < floor.major;
+    }
+    if (found.minor !== floor.minor) {
+        return found.minor < floor.minor;
+    }
+    return found.patch < floor.patch;
+}
+/**
+ * The host's version of `pkg`. Prefers the INSTALLED manifest
+ * (`node_modules/<pkg>/package.json`) — the ground truth of what will run —
+ * and falls back to the declared range floor in the host package.json (a fresh
+ * clone before install). Returns null when neither is readable.
+ */
+export function readHostVersion(cwd, pkg) {
+    const installed = join(cwd, 'node_modules', pkg, 'package.json');
+    if (existsSync(installed)) {
+        try {
+            const version = JSON.parse(readFileSync(installed, 'utf8')).version;
+            const parsed = parseVersionFloor(String(version));
+            if (parsed) {
+                return parsed;
+            }
+        }
+        catch {
+            // fall through to the declared range
+        }
+    }
+    const rootPkg = join(cwd, 'package.json');
+    if (existsSync(rootPkg)) {
+        try {
+            const pkgJson = JSON.parse(readFileSync(rootPkg, 'utf8'));
+            const spec = { ...pkgJson.dependencies, ...pkgJson.devDependencies }[pkg];
+            if (spec) {
+                return parseVersionFloor(String(spec));
+            }
+        }
+        catch {
+            // unreadable — nothing to gate on
+        }
+    }
+    return null;
+}
+/**
+ * Gate the wrap on the host's framework/runtime versions. Silent for supported
+ * hosts (the common case); returns one violation per below-floor dependency so
+ * the caller can stop with a clear message. A version we cannot read is never a
+ * violation — the peer range and the install still catch a genuinely absent dep.
+ */
+export function checkHostSupport(cwd, detection) {
+    const violations = [];
+    const detected = [];
+    for (const check of supportChecksFor(detection)) {
+        const found = readHostVersion(cwd, check.pkg);
+        if (!found) {
+            continue;
+        }
+        detected.push({ label: check.label, version: found.raw });
+        if (isBelowFloor(found, check.min)) {
+            violations.push({
+                subject: check.label,
+                found: found.raw,
+                min: check.min,
+                headline: `${check.label} ${found.raw} is below Fimo's floor of ${check.label} ${check.min}. ${check.reason}`,
+                remedy: check.remedy,
+            });
+        }
+    }
+    return { ok: violations.length === 0, violations, detected };
+}

package/dist/scripts/frameworks/sveltekit/routes.d.ts

@@ -0,0 +1,3 @@
+import type { DiscoveredRoute } from '../next/routes.js';
+/** SvelteKit routes: every directory under src/routes holding a +page file. */
+export declare function discoverSvelteKitRoutes(routesDir: string): DiscoveredRoute[];

package/dist/scripts/frameworks/sveltekit/routes.js

@@ -0,0 +1,35 @@
+import { readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { pushRoute, toSegment } from '../discovered-route.js';
+/** SvelteKit routes: every directory under src/routes holding a +page file. */
+export function discoverSvelteKitRoutes(routesDir) {
+    const routes = [];
+    const walk = (dir, segments) => {
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        const pageFile = entries.find((entry) => /^\+page\.(svelte|md)$/.test(entry));
+        if (pageFile) {
+            // Route groups (parens) are layout-only segments.
+            pushRoute(routes, segments.filter((seg) => !seg.startsWith('(')), join(dir, pageFile));
+        }
+        for (const entry of entries) {
+            const full = join(dir, entry);
+            try {
+                if (statSync(full).isDirectory()) {
+                    walk(full, [...segments, toSegment(entry)]);
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+    };
+    walk(routesDir, []);
+    routes.sort((a, b) => a.path.localeCompare(b.path));
+    return routes;
+}

package/dist/scripts/frameworks/sveltekit/template-style.d.ts

@@ -0,0 +1,9 @@
+import { type TemplateWrapStyle } from '../../apply-wrap-templates.js';
+/**
+ * SvelteKit template wraps. The t binding is deliberately a mode-agnostic
+ * `const` — a `$derived` flips a legacy component into runes mode (breaking
+ * its own `$:` statements) and a `$:` reactive runs after init (arrays built
+ * at init see undefined). Labels only change with a reload in edit mode,
+ * which the wrap contract accepts.
+ */
+export declare const svelteTemplateWrapStyle: TemplateWrapStyle;

package/dist/scripts/frameworks/sveltekit/template-style.js

@@ -0,0 +1,54 @@
+import { existsSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { injectIntoInstanceScript } from '../../apply-wrap-templates.js';
+import { slugify } from '../../apply-wrap.js';
+/**
+ * SvelteKit template wraps. The t binding is deliberately a mode-agnostic
+ * `const` — a `$derived` flips a legacy component into runes mode (breaking
+ * its own `$:` statements) and a `$:` reactive runs after init (arrays built
+ * at init see undefined). Labels only change with a reload in edit mode,
+ * which the wrap contract accepts.
+ */
+export const svelteTemplateWrapStyle = {
+    ext: '.svelte',
+    head: "import { page } from '$app/stores';\n\timport { makeFimoT } from 'fimo/svelte';\n\tconst t = makeFimoT($page.data.fimoLabels);",
+    headMarker: /makeFimoT/,
+    open: '{t(',
+    close: ')}',
+    injectHead: (code, head) => injectIntoInstanceScript(code, head, '<script>'),
+    // Route-convention filenames carry no meaning: scope +page/+layout keys by
+    // their route directory (src/routes/pricing/+page.svelte -> "pricing").
+    fileScope: (file) => {
+        const stem = basename(file).replace(/\.svelte$/, '');
+        if (!stem.startsWith('+')) {
+            return null;
+        }
+        const dir = basename(dirname(file));
+        if (!dir || dir === 'routes' || dir === 'src') {
+            return stem === '+layout' ? 'layout' : 'home';
+        }
+        return slugify(dir) || 'home';
+    },
+    // The store form reads $page.data.fimoLabels: wire the root server load
+    // once when the project has none. An existing +layout.server.* is agent
+    // work (merging into a user load function is judgment, and until then the
+    // inline fallbacks keep rendering identical).
+    ensureWiring: (rootDir) => {
+        const routesDir = join(rootDir, 'src', 'routes');
+        const existing = ['+layout.server.js', '+layout.server.ts'].some((name) => existsSync(join(routesDir, name)));
+        if (existing || !existsSync(routesDir)) {
+            return [];
+        }
+        const layoutPath = join(routesDir, '+layout.server.js');
+        writeFileSync(layoutPath, [
+            "import { loadFimoLabels } from 'fimo/svelte/server';",
+            '',
+            'export const load = async () => {',
+            '\tconst labels = await loadFimoLabels();',
+            '\treturn { fimoLabels: labels.dictionaries[labels.defaultLocale] ?? {} };',
+            '};',
+            '',
+        ].join('\n'));
+        return ['src/routes/+layout.server.js'];
+    },
+};