fimo 0.9.0-experimental.1 → 0.9.0

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

@@ -1,54 +0,0 @@
-import { readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-function pushRoute(routes, parts) {
-    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
-    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-    routes.push({
-        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-        path: routePath,
-        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
-    });
-}
-const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
-/** 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)]);
-        }
-    };
-    walk(pagesDir, []);
-    routes.sort((a, b) => a.path.localeCompare(b.path));
-    return routes;
-}

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

@@ -1,9 +0,0 @@
-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

@@ -1,27 +0,0 @@
-/**
- * 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

@@ -1,3 +0,0 @@
-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

@@ -1,50 +0,0 @@
-import { readdirSync } from 'node:fs';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-function pushRoute(routes, parts) {
-    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
-    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-    routes.push({
-        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-        path: routePath,
-        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
-    });
-}
-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, []);
-            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);
-        }
-    }
-    routes.sort((a, b) => a.path.localeCompare(b.path));
-    return routes;
-}

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

@@ -1,75 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,50 +0,0 @@
-import { readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-function pushRoute(routes, parts) {
-    const routePath = `/${parts.join('/')}`.replace(/\/+/g, '/');
-    const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-    routes.push({
-        id: routePath === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-        path: routePath,
-        label: routePath === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? routePath),
-    });
-}
-const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
-/** 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;
-        }
-        if (entries.some((entry) => /^\+page\.(svelte|md)$/.test(entry))) {
-            // Route groups (parens) are layout-only segments.
-            pushRoute(routes, segments.filter((seg) => !seg.startsWith('(')));
-        }
-        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

@@ -1,9 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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'];
-    },
-};

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

@@ -1,15 +0,0 @@
-import type { DiscoveredRoute } from '../next/routes.js';
-/**
- * Route discovery for Vite React SPAs: there is no file convention, so the
- * routes live in react-router code. v1 reads LITERAL, ABSOLUTE paths from the
- * two mainstream declaration shapes —
- *
- *   <Route path="/pricing" element={…} />          (JSX tree)
- *   createBrowserRouter([{ path: '/pricing', … }])  (object form)
- *
- * — in files that import react-router. Relative child paths and index routes
- * need the router's nesting semantics to resolve; they (and `*` wildcards)
- * stay out of v1: the fimo-config route registry accepts manual entries for
- * anything the scan cannot see, and scanned routes only ever ADD to it.
- */
-export declare function discoverReactRouterDomRoutes(rootDir: string): DiscoveredRoute[];

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

@@ -1,93 +0,0 @@
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-const titleCase = (seg) => seg
-    .replace(/[_\-]+/g, ' ')
-    .replace(/([a-z])([A-Z])/g, '$1 $2')
-    .split(/\s+/)
-    .filter(Boolean)
-    .map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase())
-    .join(' ');
-const ROUTE_SOURCE = /\.(tsx|jsx|ts|js)$/;
-const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', '.git']);
-/**
- * Route discovery for Vite React SPAs: there is no file convention, so the
- * routes live in react-router code. v1 reads LITERAL, ABSOLUTE paths from the
- * two mainstream declaration shapes —
- *
- *   <Route path="/pricing" element={…} />          (JSX tree)
- *   createBrowserRouter([{ path: '/pricing', … }])  (object form)
- *
- * — in files that import react-router. Relative child paths and index routes
- * need the router's nesting semantics to resolve; they (and `*` wildcards)
- * stay out of v1: the fimo-config route registry accepts manual entries for
- * anything the scan cannot see, and scanned routes only ever ADD to it.
- */
-export function discoverReactRouterDomRoutes(rootDir) {
-    const srcDir = join(rootDir, 'src');
-    const files = [];
-    const walk = (dir) => {
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (SKIP_DIRS.has(entry)) {
-                continue;
-            }
-            const full = join(dir, entry);
-            let isDir = false;
-            try {
-                isDir = statSync(full).isDirectory();
-            }
-            catch {
-                continue;
-            }
-            if (isDir) {
-                walk(full);
-            }
-            else if (ROUTE_SOURCE.test(entry)) {
-                files.push(full);
-            }
-        }
-    };
-    walk(srcDir);
-    const routes = new Map();
-    for (const file of files) {
-        let code;
-        try {
-            code = readFileSync(file, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        if (!/from\s+['"]react-router(?:-dom)?['"]/.test(code)) {
-            continue;
-        }
-        const paths = [
-            ...[...code.matchAll(/<Route\b[^>]*\bpath\s*=\s*(?:"([^"]+)"|'([^']+)'|\{\s*(?:"([^"]+)"|'([^']+)')\s*\})/g)],
-            ...[...code.matchAll(/\bpath\s*:\s*(?:"([^"]+)"|'([^']+)')/g)],
-        ]
-            .map((match) => match.slice(1).find(Boolean))
-            .filter((path) => typeof path === 'string');
-        for (const raw of paths) {
-            if (!raw.startsWith('/') || raw.includes('*')) {
-                continue;
-            }
-            const path = raw !== '/' && raw.endsWith('/') ? raw.slice(0, -1) : raw;
-            if (routes.has(path)) {
-                continue;
-            }
-            const parts = path.split('/').filter(Boolean);
-            const lastStatic = [...parts].reverse().find((part) => !part.startsWith(':'));
-            routes.set(path, {
-                id: path === '/' ? 'home' : parts.map((part) => part.replace(/^:/, '')).join('-'),
-                path,
-                label: path === '/' ? 'Home' : titleCase(lastStatic ?? parts[parts.length - 1] ?? path),
-            });
-        }
-    }
-    return [...routes.values()].sort((a, b) => a.path.localeCompare(b.path));
-}

package/dist/scripts/frameworks/vite/wiring.d.ts

@@ -1,10 +0,0 @@
-import type { RootWiringResult } from '../next/wiring.js';
-/**
- * Vite React SPA root wiring: wrap the root render argument with
- * `FimoSpaProviders` (client-side label fetch; inline fallbacks until it
- * resolves) and import the project's fimo-config.json. Only the mainstream
- * entry shape is touched — a `createRoot(…).render(<JSX/>)` (or legacy
- * `ReactDOM.render(<JSX/>, …)`) call whose first argument is a JSX element.
- * Anything else bails with the reason and stays agent work via the recipe.
- */
-export declare function ensureSpaEntryWiring(cwd: string): RootWiringResult;