fimo 0.8.0 → 0.9.0-experimental.1

package/dist/scripts/detect-framework.js

@@ -0,0 +1,133 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+/**
+ * Detect the framework of an existing site from its package.json and layout.
+ * Used by `fimo init` (adopt-existing-site) and the wrap migration to decide
+ * how routes are discovered and which env flavor to write.
+ */
+export function detectFramework(cwd) {
+    const pkgPath = join(cwd, 'package.json');
+    if (!existsSync(pkgPath)) {
+        return { framework: null };
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    }
+    catch {
+        return { framework: null };
+    }
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.next) {
+        const appDir = ['app', 'src/app'].find((dir) => existsSync(join(cwd, dir)));
+        const pagesDir = ['pages', 'src/pages'].find((dir) => existsSync(join(cwd, dir)));
+        return { framework: 'next', appDir, pagesDir };
+    }
+    if (deps['react-router'] || deps['@react-router/dev']) {
+        return { framework: 'react-router' };
+    }
+    if (deps['@remix-run/react']) {
+        const pagesDir = ['app/routes'].find((dir) => existsSync(join(cwd, dir)));
+        return { framework: 'remix', pagesDir };
+    }
+    if (deps.astro) {
+        const pagesDir = ['src/pages'].find((dir) => existsSync(join(cwd, dir)));
+        return { framework: 'astro', pagesDir };
+    }
+    if (deps.nuxt) {
+        // 'src/pages' covers the common custom srcDir (nuxt.config `srcDir: './src'`).
+        const pagesDir = ['pages', 'app/pages', 'src/pages'].find((dir) => existsSync(join(cwd, dir)));
+        return { framework: 'nuxt', pagesDir };
+    }
+    if (deps['@sveltejs/kit']) {
+        const pagesDir = ['src/routes'].find((dir) => existsSync(join(cwd, dir)));
+        return { framework: 'sveltekit', pagesDir };
+    }
+    if (deps.vue && deps.vite) {
+        return { framework: 'vue' };
+    }
+    if (deps.vite) {
+        // A react dependency guarantees the JSX runtime: the --apply codemod and
+        // react-router route discovery are safe. Bare vite (Solid, Preact, lit)
+        // stays hands-off.
+        return { framework: 'vite', react: Boolean(deps.react) };
+    }
+    // Known frameworks we can NAME but not wrap yet — lets `fimo init` route
+    // honestly instead of silently falling through to create-new.
+    const unsupportedByDep = [
+        ['gatsby', 'Gatsby'],
+        ['@angular/core', 'Angular'],
+        ['@docusaurus/core', 'Docusaurus'],
+        ['@11ty/eleventy', 'Eleventy'],
+    ];
+    for (const [dep, name] of unsupportedByDep) {
+        if (deps[dep]) {
+            return { framework: null, unsupported: name };
+        }
+    }
+    return { framework: null };
+}
+const WORKSPACE_SKIP = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    '.turbo',
+    '.vercel',
+    'coverage',
+]);
+/** How deep below the root the scan looks for a framework app (`apps/ui` is
+ *  depth 2, `packages/frontend/web` is depth 3). */
+const MAX_SCAN_DEPTH = 3;
+/**
+ * Find frontend apps to adopt anywhere inside a directory tree. Most real
+ * sites are monorepos where the framework app is NOT at the root and NOT
+ * necessarily under `apps/` (`frontend/`, `sites/web`, `packages/marketing`,
+ * …) — `detectFramework(root)` returns null and `fimo init` would wrongly
+ * scaffold a new project. This walks the tree up to a bounded depth, running
+ * `detectFramework` on every directory that has a package.json and pruning
+ * `node_modules`/build output, so it finds the app wherever it lives without
+ * relying on a naming convention or a workspace manifest. The root itself is
+ * excluded (the caller checks it directly); descent stops at the first
+ * framework match in a subtree (an app's own subdirs are not separate apps).
+ */
+export function findAdoptableApps(rootDir) {
+    const apps = [];
+    const walk = (dir, depth) => {
+        if (depth > MAX_SCAN_DEPTH) {
+            return;
+        }
+        if (dir !== rootDir && existsSync(join(dir, 'package.json'))) {
+            const detection = detectFramework(dir);
+            if (detection.framework) {
+                apps.push({ dir, relDir: relative(rootDir, dir), detection });
+                return; // don't descend into an app's own subtree
+            }
+        }
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory() && !WORKSPACE_SKIP.has(entry.name) && !entry.name.startsWith('.')) {
+                walk(join(dir, entry.name), depth + 1);
+            }
+        }
+    };
+    walk(rootDir, 0);
+    // Shallower + apps/-conventional first (the most likely primary site), then
+    // alphabetical — the order the interactive picker presents them in.
+    return apps.sort((a, b) => {
+        const depthA = a.relDir.split('/').length;
+        const depthB = b.relDir.split('/').length;
+        const rank = (relDir) => (relDir.startsWith('apps/') ? 0 : 1);
+        return rank(a.relDir) - rank(b.relDir) || depthA - depthB || a.relDir.localeCompare(b.relDir);
+    });
+}

package/dist/scripts/draft-rows.d.ts

@@ -0,0 +1,19 @@
+import type { SchemaDraft } from './draft-schemas.js';
+import type { WrapScanResult } from './scan-wrappable.js';
+export interface RowsFile {
+    draftUid: string;
+    source: string;
+    references: Record<string, {
+        target?: string;
+        targets?: string[];
+        by: 'slug';
+        many?: boolean;
+    }>;
+    rows: Array<Record<string, unknown>>;
+}
+/**
+ * Stage rows for every draft. Drafts carry the inferred field types, the
+ * scan carries the raw rows (typedRows for in-code candidates; data files
+ * are re-read from disk for the full, untruncated dataset).
+ */
+export declare function writeRowsStaging(rootDir: string, scan: WrapScanResult, drafts: SchemaDraft[]): number;

package/dist/scripts/draft-rows.js

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import YAML from 'yaml';
+/**
+ * Machine-staged entry ROWS for every drafted collection: the deterministic
+ * transformation agents kept re-implementing by hand (media envelopes,
+ * richtext docs, slugs inside data), applied once by the machine. Reference
+ * fields keep their SOURCE values (slugs/names) and each file carries a
+ * references descriptor — the resolution to documentIds happens at seed
+ * time (agent-side maps today; server-side via the batch endpoint next).
+ *
+ * Output: `.fimo/migration/rows/<ProvisionalUid>.rows.json`
+ *   { draftUid, source, references: { field: { target, by, many? } }, rows }
+ *
+ * Regenerated on every migrate run; `schemas adopt-drafts` rewrites
+ * draftUid and reference targets through the same renames it applies to the
+ * schema files.
+ */
+const MEDIA_PATH = /^\/(images|img|videos|video|media|assets|files|docs|documents)\//i;
+const MEDIA_EXT = /\.(png|jpe?g|gif|webp|avif|svg|mp4|webm|mov|mp3|wav|pdf|zip|docx?)$/i;
+function toRichTextDoc(text) {
+    const paragraphs = text
+        .split(/\n\n+/)
+        .map((paragraph) => paragraph.trim())
+        .filter(Boolean);
+    return {
+        type: 'doc',
+        content: paragraphs.map((paragraph) => ({
+            type: 'paragraph',
+            content: [{ type: 'text', text: paragraph }],
+        })),
+    };
+}
+function transformValue(fieldType, value) {
+    if (value == null) {
+        return value;
+    }
+    if (fieldType === 'media' && typeof value === 'string' && (MEDIA_PATH.test(value) || MEDIA_EXT.test(value))) {
+        return { source: 'local', url: value, alt: '' };
+    }
+    if (fieldType === 'richtext' && typeof value === 'string') {
+        return toRichTextDoc(value);
+    }
+    return value;
+}
+function loadSourceRows(rootDir, source) {
+    const filePath = join(rootDir, source);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const raw = readFileSync(filePath, 'utf8');
+        const parsed = /\.ya?ml$/.test(source) ? YAML.parse(raw) : JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Stage rows for every draft. Drafts carry the inferred field types, the
+ * scan carries the raw rows (typedRows for in-code candidates; data files
+ * are re-read from disk for the full, untruncated dataset).
+ */
+export function writeRowsStaging(rootDir, scan, drafts) {
+    const rowsDir = join(rootDir, '.fimo', 'migration', 'rows');
+    rmSync(rowsDir, { recursive: true, force: true });
+    if (drafts.length === 0) {
+        return 0;
+    }
+    const bySourceLabel = new Map(drafts.map((draft) => [draft.source, draft]));
+    const provisionalByName = new Map(drafts.map((draft) => [draft.sourceName, draft.uid]));
+    const toProvisional = (name) => provisionalByName.get(name) ?? name;
+    let written = 0;
+    const stage = (draft, source, rawRows, references) => {
+        const fieldTypes = new Map(Object.entries(draft.fields).map(([name, def]) => [
+            name,
+            def && typeof def === 'object' ? (def.type ?? 'string') : 'string',
+        ]));
+        const referenceFields = new Set(references.map((reference) => reference.field));
+        const rows = rawRows.map((row) => {
+            const out = {};
+            for (const [key, value] of Object.entries(row)) {
+                // Reference values stay as SOURCE values for later resolution.
+                out[key] = referenceFields.has(key) ? value : transformValue(fieldTypes.get(key), value);
+            }
+            return out;
+        });
+        const descriptor = {};
+        for (const reference of references) {
+            const targets = reference.targets.map(toProvisional);
+            descriptor[reference.field] = {
+                ...(targets.length > 1 ? { targets } : { target: targets[0] }),
+                by: 'slug',
+                ...(reference.many ? { many: true } : {}),
+            };
+        }
+        mkdirSync(rowsDir, { recursive: true });
+        writeFileSync(join(rowsDir, `${draft.uid}.rows.json`), `${JSON.stringify({ draftUid: draft.uid, source, references: descriptor, rows }, null, 1)}\n`);
+        written += 1;
+    };
+    for (const candidate of scan.collections) {
+        const label = `${candidate.file}:${candidate.line}`;
+        const draft = bySourceLabel.get(label);
+        if (!draft || !candidate.typedRows || candidate.typedRows.length === 0) {
+            continue;
+        }
+        stage(draft, label, candidate.typedRows, (candidate.references ?? []).map((reference) => ({
+            field: reference.field,
+            targets: reference.targets,
+            many: reference.many,
+        })));
+    }
+    for (const dataFile of scan.dataFiles) {
+        const draft = bySourceLabel.get(dataFile.file);
+        if (!draft) {
+            continue;
+        }
+        // Markdown groups can't be re-read from a single path (`<dir>/*.md`) — the
+        // scanner already parsed every document into the collection's typedRows.
+        const rawRows = dataFile.kind === 'markdown'
+            ? (dataFile.collections[0]?.typedRows ?? null)
+            : loadSourceRows(rootDir, dataFile.file);
+        if (!rawRows) {
+            continue;
+        }
+        const references = dataFile.collections.flatMap((collection) => (collection.references ?? []).map((reference) => ({
+            field: reference.field,
+            targets: reference.targets,
+            many: reference.many,
+        })));
+        stage(draft, dataFile.file, rawRows, references);
+    }
+    return written;
+}

package/dist/scripts/draft-schemas.d.ts

@@ -0,0 +1,27 @@
+import type { WrapScanResult } from './scan-wrappable.js';
+/**
+ * Machine-typed schema DRAFTS for every detected collection. The forensic
+ * timeline of a real 43-minute agent migration showed ~26 minutes spent
+ * deliberating and re-probing type behavior before the first schema file
+ * appeared — while the scanner already knew every field, its sampled values,
+ * and the reference targets. This module turns that knowledge into pushable
+ * draft files so the agent's job collapses to what only an agent can do:
+ * CLASSIFY the candidate and NAME the type. Names emitted here are
+ * PROVISIONAL by contract (mechanical singular/PascalCase of the source
+ * name); the drafts never touch src/schemas — the agent reviews, renames,
+ * copies, pushes.
+ */
+export interface SchemaDraft {
+    file: string;
+    uid: string;
+    /** Original candidate/source name (pre-rename), for cross-artifact maps. */
+    sourceName: string;
+    source: string;
+    fields: Record<string, unknown>;
+}
+/**
+ * Write `.fimo/migration/schema-drafts/<Provisional>.json` (exact pushable
+ * shape) for every detected collection, plus a README stating the contract.
+ * Regenerated on every run — drafts are machine output, never hand-edited.
+ */
+export declare function writeSchemaDrafts(rootDir: string, scan: WrapScanResult): SchemaDraft[];

package/dist/scripts/draft-schemas.js

@@ -0,0 +1,188 @@
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}([T ].*)?$/;
+const MEDIA_PATH = /^\/(images|img|videos|video|media|assets|files|docs|documents)\//i;
+const MEDIA_EXT = /\.(png|jpe?g|gif|webp|avif|svg|mp4|webm|mov|mp3|wav|pdf|zip|docx?)$/i;
+function singularPascal(name) {
+    const base = name
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
+        .replace(/^(.)/, (c) => c.toUpperCase());
+    if (/ies$/i.test(base)) {
+        return base.replace(/ies$/i, 'y');
+    }
+    if (/[^aeiou](ses|xes|zes)$/i.test(base) || /(ches|shes)$/i.test(base)) {
+        // Classes -> Class, Boxes -> Box — but vowel+ses words (Releases,
+        // Cases) are plain plurals and only drop the trailing s below.
+        return base.replace(/es$/i, '');
+    }
+    if (/s$/i.test(base) && !/ss$/i.test(base)) {
+        return base.replace(/s$/i, '');
+    }
+    return base;
+}
+function inferScalarType(sampleValue, stringValues) {
+    if (typeof sampleValue === 'boolean') {
+        return { type: 'boolean' };
+    }
+    if (typeof sampleValue === 'number') {
+        return { type: 'number' };
+    }
+    const values = stringValues.length > 0 ? stringValues : typeof sampleValue === 'string' ? [sampleValue] : [];
+    if (values.length > 0) {
+        const nonEmpty = values.filter(Boolean);
+        if (nonEmpty.length > 0 && nonEmpty.every((value) => ISO_DATE.test(value))) {
+            return { type: 'date' };
+        }
+        if (nonEmpty.length > 0 && nonEmpty.every((value) => MEDIA_PATH.test(value) || MEDIA_EXT.test(value))) {
+            return { type: 'media' };
+        }
+        // Multi-paragraph prose reads as rich text; single lines stay strings.
+        if (nonEmpty.some((value) => value.includes('\n\n'))) {
+            return { type: 'richtext' };
+        }
+    }
+    return { type: 'string' };
+}
+function referenceField(reference, provisionalNames) {
+    const targets = reference.targets.map((target) => provisionalNames.get(target) ?? singularPascal(target));
+    const base = targets.length > 1 ? { type: 'reference', targets } : { type: 'reference', target: targets[0] };
+    return reference.many ? { ...base, many: true } : base;
+}
+function collectSources(scan) {
+    const sources = [];
+    for (const candidate of scan.collections) {
+        sources.push({
+            sourceName: candidate.name,
+            sourceLabel: `${candidate.file}:${candidate.line}`,
+            rowCount: candidate.count,
+            fields: candidate.fields,
+            typedSample: candidate.typedSample ?? {},
+            fieldValues: candidate.fieldValues ?? {},
+            references: candidate.references ?? [],
+            manyFields: candidate.manyFields ?? [],
+            verbatimFields: [],
+        });
+    }
+    for (const dataFile of scan.dataFiles) {
+        for (const collection of dataFile.collections) {
+            const stem = dataFile.file.replace(/^.*\//, '').replace(/\.[a-z]+$/i, '');
+            const pathName = (collection.path ?? '').replace(/^\$\.?/, '').replace(/^\.+$/, '');
+            const name = pathName || stem;
+            sources.push({
+                sourceName: name,
+                sourceLabel: dataFile.file,
+                rowCount: collection.length,
+                fields: Object.keys(collection.typedSample ?? {}),
+                typedSample: collection.typedSample ?? {},
+                fieldValues: collection.fieldValues ?? {},
+                references: collection.references ?? [],
+                manyFields: collection.manyFields ?? [],
+                verbatimFields: collection.verbatimFields ?? [],
+            });
+        }
+    }
+    return sources;
+}
+/** Compact per-field preview so classification/naming never needs the
+ *  source files: one representative value, long strings truncated. */
+function sampleFor(typedSample) {
+    const sample = {};
+    for (const [field, value] of Object.entries(typedSample)) {
+        if (typeof value === 'string' && value.length > 80) {
+            sample[field] = `${value.slice(0, 77)}…`;
+        }
+        else if (Array.isArray(value)) {
+            sample[field] = value.slice(0, 3);
+        }
+        else {
+            sample[field] = value;
+        }
+    }
+    return sample;
+}
+/**
+ * Write `.fimo/migration/schema-drafts/<Provisional>.json` (exact pushable
+ * shape) for every detected collection, plus a README stating the contract.
+ * Regenerated on every run — drafts are machine output, never hand-edited.
+ */
+export function writeSchemaDrafts(rootDir, scan) {
+    const sources = collectSources(scan);
+    const draftsDir = join(rootDir, '.fimo', 'migration', 'schema-drafts');
+    rmSync(draftsDir, { recursive: true, force: true });
+    if (sources.length === 0) {
+        return [];
+    }
+    mkdirSync(draftsDir, { recursive: true });
+    const provisionalNames = new Map();
+    for (const source of sources) {
+        provisionalNames.set(source.sourceName, singularPascal(source.sourceName));
+    }
+    const drafts = [];
+    for (const source of sources) {
+        const uid = provisionalNames.get(source.sourceName);
+        const referenceByField = new Map(source.references.map((reference) => [reference.field, reference]));
+        const fields = {};
+        // candidate.fields only lists STRING fields; booleans and numbers live
+        // in the typed sample — union both so no field is dropped.
+        const fieldNames = [...new Set([...source.fields, ...Object.keys(source.typedSample)])];
+        for (const field of fieldNames) {
+            if (field === 'slug') {
+                continue; // reserved entry metadata: set inside data on create
+            }
+            const reference = referenceByField.get(field);
+            if (reference) {
+                fields[field] = referenceField(reference, provisionalNames);
+                continue;
+            }
+            if (source.verbatimFields.includes(field)) {
+                // Markdown/MDX body: keep the raw source string so the user's own
+                // renderer still handles it — never reshape to richtext.
+                fields[field] = { type: 'string' };
+                continue;
+            }
+            if (source.manyFields.includes(field)) {
+                // String array with no reference target (a free tag list): `many` is
+                // reference-only on the server, so model it as json — the array
+                // round-trips verbatim and stays editable.
+                fields[field] = { type: 'json' };
+                continue;
+            }
+            fields[field] = inferScalarType(source.typedSample[field], source.fieldValues[field] ?? []);
+        }
+        // `source`, `rowCount`, and `sample` exist so the classify/name decision
+        // can be made from this file ALONE; adopt-drafts strips them on copy
+        // (only uid/name/fields are pushed).
+        const draft = {
+            uid,
+            name: uid,
+            source: source.sourceLabel,
+            rowCount: source.rowCount,
+            sample: sampleFor(source.typedSample),
+            fields,
+        };
+        const file = join(draftsDir, `${uid}.json`);
+        writeFileSync(file, `${JSON.stringify(draft, null, 2)}\n`);
+        drafts.push({ file, uid, sourceName: source.sourceName, source: source.sourceLabel, fields });
+    }
+    writeFileSync(join(draftsDir, 'README.md'), [
+        '# Machine-typed schema drafts (regenerated by `fimo migrate`)',
+        '',
+        'Field TYPES here are inferred from the actual source values (dates,',
+        'booleans, numbers, media paths, prose, reference targets) and are',
+        'reliable. Each draft carries its `source`, `rowCount`, and a `sample`',
+        'row — everything needed to classify and name WITHOUT opening the',
+        'source files. The NAMES are PROVISIONAL mechanical guesses — that',
+        'judgment is yours, and it is TWO commands total:',
+        '',
+        '1. `npx fimo schemas adopt-drafts --rename "Prov=Final,…" --drop "Junk,…"`',
+        '   (copies kept drafts to src/schemas, rewrites reference targets and',
+        '   staged rows files through the renames, and pushes in dependency order).',
+        '2. `npx fimo migrate seed` (seeds every staged rows file in reference',
+        '   order; the server resolves reference slugs to documentIds).',
+        '',
+        'Do not edit files in this directory: they are overwritten on every',
+        '`fimo migrate` run.',
+        '',
+    ].join('\n'));
+    return drafts;
+}

package/dist/scripts/extract-translations.js

@@ -8,6 +8,7 @@
 import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseSync } from 'oxc-parser';
+import { collectScopedBindings, isFunctionLike, resolveScopedKey } from './i18n-namespace.js';
 function findReactFiles(dir, files = []) {
     if (!existsSync(dir)) {
         return files;
@@ -34,17 +35,21 @@ function extractFromFile(filePath) {
         const code = readFileSync(filePath, 'utf-8');
         const result = parseSync(filePath, code);
         const ast = result.program;
-        function visit(node) {
+        function visit(node, scopes) {
             if (!node || typeof node !== 'object') {
                 return;
             }
-            if (node.type === 'CallExpression') {
-                const callee = node.callee;
-                if (callee?.type === 'Identifier' && callee?.name === 't') {
-                    const args = node.arguments || [];
-                    const firstArg = args[0];
-                    if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
-                        const key = firstArg.value;
+            // A function introduces a new scope layer with its `useTranslations`
+            // bindings; nested calls resolve innermost-first.
+            const childScopes = isFunctionLike(node) ? [...scopes, collectScopedBindings(node)] : scopes;
+            if (node.type === 'CallExpression' && node.callee?.type === 'Identifier') {
+                const name = node.callee.name;
+                const firstArg = (node.arguments ?? [])[0];
+                if (firstArg?.type === 'Literal' && typeof firstArg.value === 'string') {
+                    const { key, scoped, unresolvable } = resolveScopedKey(name, firstArg.value, childScopes);
+                    // A namespace-scoped var (any name) OR a bare Fimo `t(...)`. A passed-in
+                    // param `t` is unresolvable (the caller owns the namespace) — skip it.
+                    if (!unresolvable && (scoped || name === 't')) {
                         declarations.push({ key, file: filePath });
                     }
                 }
@@ -53,15 +58,15 @@ function extractFromFile(filePath) {
                 const child = node[key];
                 if (Array.isArray(child)) {
                     for (const item of child) {
-                        visit(item);
+                        visit(item, childScopes);
                     }
                 }
                 else if (typeof child === 'object' && child !== null) {
-                    visit(child);
+                    visit(child, childScopes);
                 }
             }
         }
-        visit(ast);
+        visit(ast, []);
     }
     catch (error) {
         console.error(`Failed to parse ${filePath}:`, error);

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

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

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

@@ -0,0 +1,55 @@
+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 PAGE_EXT = /\.(astro|md|mdx|html)$/;
+const toSegment = (name) => name.replace(/^\[\.\.\.(.+)\]$/, ':$1').replace(/^\[(.+)\]$/, ':$1');
+/** Astro file-based routes under src/pages (index files map to the dir path). */
+export function discoverAstroRoutes(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 (!PAGE_EXT.test(entry) || entry.startsWith('_')) {
+                continue;
+            }
+            const base = entry.replace(PAGE_EXT, '');
+            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/astro/template-style.d.ts

@@ -0,0 +1,7 @@
+import type { TemplateWrapStyle } from '../../apply-wrap-templates.js';
+/**
+ * Astro template wraps: t() resolves in the frontmatter (server-only, so the
+ * server barrel is safe to import there), values interpolate as {t(...)}.
+ * Files without a frontmatter fence get one — Astro allows an empty fence.
+ */
+export declare const astroTemplateWrapStyle: TemplateWrapStyle;

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

@@ -0,0 +1,19 @@
+/**
+ * Astro template wraps: t() resolves in the frontmatter (server-only, so the
+ * server barrel is safe to import there), values interpolate as {t(...)}.
+ * Files without a frontmatter fence get one — Astro allows an empty fence.
+ */
+export const astroTemplateWrapStyle = {
+    ext: '.astro',
+    head: 'import { loadFimoT } from "fimo/astro/server";\nconst t = await loadFimoT();',
+    headMarker: /loadFimoT/,
+    open: '{t(',
+    close: ')}',
+    injectHead: (code, head) => {
+        const fence = code.match(/^---\r?\n/);
+        if (fence) {
+            return `${code.slice(0, fence[0].length)}${head}\n${code.slice(fence[0].length)}`;
+        }
+        return `---\n${head}\n---\n${code}`;
+    },
+};