fimo 0.9.0-experimental.7 → 0.9.0-experimental.8

package/dist/runtime/app/FimoProviders.js

@@ -1,5 +1,6 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Suspense, useCallback, useEffect, useMemo } from 'react';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { QueryClient, QueryClientProvider, useQueryClient } from '@tanstack/react-query';
+import { Suspense, useCallback, useEffect, useMemo, useState } from 'react';
 import { ErrorBoundary } from 'react-error-boundary';
 import { useLocation, useNavigate } from 'react-router';
 // @ts-ignore - virtual module provided by fimoConfigPlugin in fimo/vite
@@ -59,6 +60,27 @@ function PreviewBridge() {
     }, [navigate, sendRoutes, sendLocationChange]);
     return null;
 }
+/**
+ * Template projects mount their own QueryClientProvider in root.tsx, but an
+ * ADOPTED app wired straight onto FimoProviders (react-router library SPAs)
+ * has none — and the inner runtime (RefreshContentProvider, content clients)
+ * calls useQueryClient(). Mount a fallback client only when no provider
+ * exists above, so both worlds work and template caches stay untouched.
+ */
+function EnsureQueryClient({ children }) {
+    let existing = null;
+    try {
+        existing = useQueryClient();
+    }
+    catch {
+        existing = null;
+    }
+    const [fallbackClient] = useState(() => new QueryClient());
+    if (existing) {
+        return _jsx(_Fragment, { children: children });
+    }
+    return _jsx(QueryClientProvider, { client: fallbackClient, children: children });
+}
 export function FimoProviders({ children, locale }) {
     const location = useLocation();
     const localeResolution = useMemo(() => resolveFimoLocale({ pathname: location.pathname }, fimoConfig), [location.pathname]);
@@ -71,9 +93,9 @@ export function FimoProviders({ children, locale }) {
         document.documentElement.lang = toHtmlLang(activeLocale);
         document.documentElement.dir = activeDir;
     }, [activeDir, activeLocale]);
-    return (_jsx(ErrorBoundary, { FallbackComponent: AppErrorBoundary, onError: onError, children: _jsx(FimoLocaleProvider, { value: {
-                ...localeResolution,
-                locale: activeLocale,
-                dir: activeDir,
-            }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [_jsx(PreviewBridge, {}), _jsx(OptionalTracking, { routes: getDisplayRoutes() }), _jsx(Suspense, { children: children })] }) }) }) }) }) }));
+    return (_jsx(ErrorBoundary, { FallbackComponent: AppErrorBoundary, onError: onError, children: _jsx(EnsureQueryClient, { children: _jsx(FimoLocaleProvider, { value: {
+                    ...localeResolution,
+                    locale: activeLocale,
+                    dir: activeDir,
+                }, children: _jsx(DataSourcesProvider, { children: _jsx(ScreenshotProvider, { children: _jsx(ViteLifecycles, { children: _jsxs(RefreshContentProvider, { children: [_jsx(PreviewBridge, {}), _jsx(OptionalTracking, { routes: getDisplayRoutes() }), _jsx(Suspense, { children: children })] }) }) }) }) }) }) }));
 }

package/dist/runtime/react/FimoSpaProviders.js

@@ -3,6 +3,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useState } from 'react';
 import { getFimoDefaultLocale, getFimoLocales } from '../i18n/locale.js';
 import { fetchLabelBundle, serializeBundle } from '../shared/labels-fetch.pure.js';
+import { fetchWrappedContent } from '../wrapped/content-fetch.pure.js';
 import { WrappedProviders } from '../wrapped/WrappedProviders.js';
 /** Browser-safe stable signature (labelSignature uses Buffer, server-only). */
 function bundleSignature(bundle) {
@@ -34,6 +35,7 @@ function bundleSignature(bundle) {
  */
 export function FimoSpaProviders({ config, apiUrl, previewScriptUrl, media, richText, locale, children, }) {
     const [labels, setLabels] = useState(undefined);
+    const [content, setContent] = useState(undefined);
     useEffect(() => {
         if (!apiUrl) {
             return;
@@ -49,15 +51,30 @@ export function FimoSpaProviders({ config, apiUrl, previewScriptUrl, media, rich
             .catch(() => {
             // Unreachable API: keep rendering the inline fallbacks.
         });
+        // Wrapped rich text and media live in the plumbing types — without this
+        // fetch a client-rendered app only ever shows their inline fallbacks
+        // and Studio edits to them render nowhere.
+        fetchWrappedContent(apiUrl)
+            .then((fetched) => {
+            if (!cancelled) {
+                setContent(fetched);
+            }
+        })
+            .catch(() => {
+            // Unreachable API: keep rendering the inline fallbacks.
+        });
         return () => {
             cancelled = true;
         };
     }, [apiUrl, config]);
+    // Explicitly-passed maps win over the fetched ones (caller override).
+    const mergedMedia = useMemo(() => (content?.media || media ? { ...(content?.media ?? {}), ...(media ?? {}) } : undefined), [content?.media, media]);
+    const mergedRichText = useMemo(() => (content?.richText || richText ? { ...(content?.richText ?? {}), ...(richText ?? {}) } : undefined), [content?.richText, richText]);
     const navigation = useMemo(() => ({
         pathname: typeof window !== 'undefined' ? window.location.pathname : null,
         navigate: (to) => {
             window.location.assign(to);
         },
     }), []);
-    return (_jsxs(WrappedProviders, { config: config, labels: labels, media: media, richText: richText, locale: locale, navigation: navigation, children: [previewScriptUrl ? _jsx("script", { type: "module", src: previewScriptUrl }) : null, children] }));
+    return (_jsxs(WrappedProviders, { config: config, labels: labels, media: mergedMedia, richText: mergedRichText, locale: locale, navigation: navigation, children: [previewScriptUrl ? _jsx("script", { type: "module", src: previewScriptUrl }) : null, children] }));
 }

package/dist/runtime/wrapped/content-fetch.pure.d.ts

@@ -0,0 +1,20 @@
+import type { WrappedMediaEntry, WrappedRichTextEntry } from './WrappedContentContext.js';
+export interface WrappedEntryRow {
+    id: string;
+    data: Record<string, unknown>;
+}
+/** Every published row of a content type, paginated to the end. Returns []
+ *  when the API is unreachable so wrapped sites keep their fallbacks. */
+export declare function fetchAllWrappedRows(apiUrl: string, typeName: string): Promise<WrappedEntryRow[]>;
+/** WrappedMedia rows → key → media entry (the FimoMediaImage/Video id map). */
+export declare function mapWrappedMedia(rows: WrappedEntryRow[]): Record<string, WrappedMediaEntry>;
+/** WrappedRichText rows → key → TipTap content (the FimoRichTextBlock map). */
+export declare function mapWrappedRichText(rows: WrappedEntryRow[]): Record<string, WrappedRichTextEntry>;
+export interface WrappedContent {
+    media: Record<string, WrappedMediaEntry>;
+    richText: Record<string, WrappedRichTextEntry>;
+}
+/** Both plumbing maps in one round: what a client-rendered wrapped app needs
+ *  so Studio edits to rich text and media are LIVE, not fallback-only. */
+export declare function fetchWrappedContent(apiUrl: string): Promise<WrappedContent>;
+//# sourceMappingURL=content-fetch.pure.d.ts.map

package/dist/runtime/wrapped/content-fetch.pure.js

@@ -0,0 +1,106 @@
+// Wrapped-content fetching, PURE core: fetch/URL/AbortController only — no
+// node builtins, importable from client-bundled code (the SPA provider) and
+// from the server loaders alike. The plumbing types (WrappedRichText,
+// WrappedMedia) hold ALL of a site's wrapped rich text and media, so the
+// fetch PAGINATES to the end — the tenant API caps limit at 100 and a real
+// site exceeds it (the Fimo site carries 147 rich-text entries).
+import { fetchWithTimeout } from '../shared/labels-fetch.pure.js';
+const PAGE_LIMIT = 100;
+const MAX_ROWS = 5000;
+function readString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function readNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+/** Every published row of a content type, paginated to the end. Returns []
+ *  when the API is unreachable so wrapped sites keep their fallbacks. */
+export async function fetchAllWrappedRows(apiUrl, typeName) {
+    const rows = [];
+    try {
+        for (let offset = 0; offset < MAX_ROWS; offset += PAGE_LIMIT) {
+            const url = new URL(`/entries/${typeName}`, apiUrl);
+            url.searchParams.set('limit', String(PAGE_LIMIT));
+            url.searchParams.set('offset', String(offset));
+            const response = await fetchWithTimeout(url, 4000);
+            if (!response.ok) {
+                break;
+            }
+            const body = (await response.json());
+            const page = Array.isArray(body.data) ? body.data : [];
+            for (const row of page) {
+                if (!row || typeof row !== 'object') {
+                    continue;
+                }
+                const record = row;
+                const id = String(record.id ?? record.documentId ?? '');
+                if (id.length === 0) {
+                    continue;
+                }
+                rows.push({
+                    id,
+                    data: (record.data && typeof record.data === 'object' ? record.data : record),
+                });
+            }
+            const hasMore = body.meta?.hasMore === true || page.length === PAGE_LIMIT;
+            if (!hasMore) {
+                break;
+            }
+        }
+    }
+    catch {
+        // Unreachable API mid-pagination: return what we have (possibly []).
+    }
+    return rows;
+}
+/** WrappedMedia rows → key → media entry (the FimoMediaImage/Video id map). */
+export function mapWrappedMedia(rows) {
+    const map = {};
+    for (const entry of rows) {
+        const key = readString(entry.data.key) ?? readString(entry.data.slug);
+        const asset = entry.data.image;
+        if (!key || !asset || typeof asset !== 'object') {
+            continue;
+        }
+        const assetRecord = asset;
+        const url = readString(assetRecord.url);
+        if (!url) {
+            continue;
+        }
+        map[key] = {
+            url,
+            alt: readString(assetRecord.alt) ?? readString(entry.data.alt),
+            name: readString(assetRecord.name),
+            mime: readString(assetRecord.mime) ?? readString(assetRecord.mimeType),
+            width: readNumber(assetRecord.width),
+            height: readNumber(assetRecord.height),
+            source: `WrappedMedia.${entry.id}.image`,
+        };
+    }
+    return map;
+}
+/** WrappedRichText rows → key → TipTap content (the FimoRichTextBlock map). */
+export function mapWrappedRichText(rows) {
+    const map = {};
+    for (const entry of rows) {
+        const key = readString(entry.data.key) ?? readString(entry.data.slug);
+        const body = entry.data.body;
+        if (!key || !body || typeof body !== 'object') {
+            continue;
+        }
+        map[key] = {
+            content: body,
+            source: `WrappedRichText.${entry.id}.body`,
+        };
+    }
+    return map;
+}
+/** Both plumbing maps in one round: what a client-rendered wrapped app needs
+ *  so Studio edits to rich text and media are LIVE, not fallback-only. */
+export async function fetchWrappedContent(apiUrl) {
+    const [mediaRows, richTextRows] = await Promise.all([
+        fetchAllWrappedRows(apiUrl, 'WrappedMedia'),
+        fetchAllWrappedRows(apiUrl, 'WrappedRichText'),
+    ]);
+    return { media: mapWrappedMedia(mediaRows), richText: mapWrappedRichText(richTextRows) };
+}

package/dist/runtime/wrapped/server.d.ts

@@ -39,12 +39,15 @@ export declare function fetchEntries(typeName: string, options?: FimoServerOptio
 /**
  * Load the WrappedMedia entries (key → media) seeded by the wrap migration.
  * Each entry has a `key` (the FimoMediaImage/Video/FileLink id) and an
- * asset-typed `image` field.
+ * asset-typed `image` field. Paginates to the end — a site's wrapped media
+ * routinely exceeds one API page.
  */
 export declare function loadWrappedMedia(options?: FimoServerOptions): Promise<Record<string, WrappedMediaEntry>>;
 /**
  * Load the WrappedRichText entries (key → TipTap JSON) seeded by the wrap
- * migration for formatted text (bold/italic/underline/links).
+ * migration for formatted text (bold/italic/underline/links). Paginates to
+ * the end — the Fimo site alone carries 147 entries against a 20-row API
+ * default page.
  */
 export declare function loadWrappedRichText(options?: FimoServerOptions): Promise<Record<string, WrappedRichTextEntry>>;
 /**

package/dist/runtime/wrapped/server.js

@@ -5,6 +5,7 @@
 import { getConfigServer } from '../shared/fimo-config.server.js';
 import { deepMergeMessages, unflattenMessages } from '../shared/i18n-messages.js';
 import { fetchLabelDictionary, fetchWithTimeout, labelSignature, loadLabelBundle, readProjectEnv, resolveTenantApiUrl, } from '../shared/labels-fetch.server.js';
+import { fetchAllWrappedRows, mapWrappedMedia, mapWrappedRichText } from './content-fetch.pure.js';
 export function loadFimoConfig(rootDir = process.cwd()) {
     return getConfigServer(rootDir);
 }
@@ -72,62 +73,31 @@ export async function fetchEntries(typeName, options = {}) {
         return [];
     }
 }
-function readString(value) {
-    return typeof value === 'string' && value.length > 0 ? value : undefined;
-}
-function readNumber(value) {
-    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
-}
 /**
  * Load the WrappedMedia entries (key → media) seeded by the wrap migration.
  * Each entry has a `key` (the FimoMediaImage/Video/FileLink id) and an
- * asset-typed `image` field.
+ * asset-typed `image` field. Paginates to the end — a site's wrapped media
+ * routinely exceeds one API page.
  */
 export async function loadWrappedMedia(options = {}) {
-    const entries = await fetchEntries('WrappedMedia', options);
-    const map = {};
-    for (const entry of entries) {
-        const key = readString(entry.data.key) ?? readString(entry.data.slug);
-        const asset = entry.data.image;
-        if (!key || !asset || typeof asset !== 'object') {
-            continue;
-        }
-        const assetRecord = asset;
-        const url = readString(assetRecord.url);
-        if (!url) {
-            continue;
-        }
-        map[key] = {
-            url,
-            alt: readString(assetRecord.alt) ?? readString(entry.data.alt),
-            name: readString(assetRecord.name),
-            mime: readString(assetRecord.mime) ?? readString(assetRecord.mimeType),
-            width: readNumber(assetRecord.width),
-            height: readNumber(assetRecord.height),
-            source: `WrappedMedia.${entry.id}.image`,
-        };
-    }
-    return map;
+    const apiUrl = await resolveApiUrl(options);
+    if (!apiUrl) {
+        return {};
+    }
+    return mapWrappedMedia(await fetchAllWrappedRows(apiUrl, 'WrappedMedia'));
 }
 /**
  * Load the WrappedRichText entries (key → TipTap JSON) seeded by the wrap
- * migration for formatted text (bold/italic/underline/links).
+ * migration for formatted text (bold/italic/underline/links). Paginates to
+ * the end — the Fimo site alone carries 147 entries against a 20-row API
+ * default page.
  */
 export async function loadWrappedRichText(options = {}) {
-    const entries = await fetchEntries('WrappedRichText', options);
-    const map = {};
-    for (const entry of entries) {
-        const key = readString(entry.data.key) ?? readString(entry.data.slug);
-        const body = entry.data.body;
-        if (!key || !body || typeof body !== 'object') {
-            continue;
-        }
-        map[key] = {
-            content: body,
-            source: `WrappedRichText.${entry.id}.body`,
-        };
+    const apiUrl = await resolveApiUrl(options);
+    if (!apiUrl) {
+        return {};
     }
-    return map;
+    return mapWrappedRichText(await fetchAllWrappedRows(apiUrl, 'WrappedRichText'));
 }
 /** Key fields tried, in order, to align a source row with its Fimo entry. */
 const COLLECTION_KEY_FIELDS = ['slug', 'id', 'key', 'name', 'title', 'question'];

package/dist/scripts/apply-wrap-templates.js

@@ -66,7 +66,7 @@ export function applyTemplateWrapToFile(code, style, items, allocator) {
             continue;
         }
         const collapsed = match[2].replace(/\s+/g, ' ').trim();
-        const id = allocator.allocate(scope || 'shared', slugify(collapsed));
+        const id = allocator.allocate(scope || 'shared', slugify(decodeJsxEntities(collapsed)));
         const escaped = collapsed.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
         const replacement = `>${match[1]}${style.open}"${id}", "${escaped}"${style.close}${match[3]}<`;
         next = next.slice(0, match.index) + replacement + next.slice(match.index + match[0].length);

package/dist/scripts/apply-wrap.js

@@ -33,10 +33,27 @@ const JSX_ENTITIES = {
     ''': "'",
     ' ': ' ',
     '©': '©',
+    '®': '®',
+    '™': '™',
+    '°': '°',
+    '·': '·',
+    '•': '•',
+    '…': '…',
+    '—': '—',
+    '–': '–',
+    '‘': '‘',
+    '’': '’',
+    '“': '“',
+    '”': '”',
+    '«': '«',
+    '»': '»',
+    '×': '×',
+    '→': '→',
+    '←': '←',
 };
 export function decodeJsxEntities(text) {
     return text
-        .replace(/&(amp|lt|gt|quot|apos|nbsp|copy);/g, (entity) => JSX_ENTITIES[entity] ?? entity)
+        .replace(/&(amp|lt|gt|quot|apos|nbsp|copy|reg|trade|deg|middot|bull|hellip|mdash|ndash|lsquo|rsquo|ldquo|rdquo|laquo|raquo|times|rarr|larr);/g, (entity) => JSX_ENTITIES[entity] ?? entity)
         .replace(/&#(\d+);/g, (_, code) => String.fromCodePoint(Number(code)))
         .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCodePoint(parseInt(code, 16)));
 }
@@ -62,7 +79,12 @@ export function keyScope(file) {
     return slugify(stem) || 'shared';
 }
 export function slugify(text) {
+    // camelCase boundaries become segments BEFORE lowercasing, so component
+    // file names keep their word structure (AgentStrip.tsx → agent-strip.*)
+    // and every humanized display of the key reads like the component name.
     return collapse(text)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
         .toLowerCase()
         .normalize('NFD')
         .replace(/[̀-ͯ]/g, '')
@@ -154,7 +176,9 @@ export function applyWrapToFile(code, items, allocator, importModule = 'fimo/nex
             }
             const lead = raw.slice(0, raw.indexOf(core));
             const trail = raw.slice(raw.indexOf(core) + core.length);
-            const id = allocator.allocate(scope, slugify(core));
+            // Slug from the DECODED text — "'" must never leak "apos" into a
+            // key ("today-apos-s-total" read "Today Apos S Total" in the Studio).
+            const id = allocator.allocate(scope, slugify(decodeJsxEntities(core)));
             edits.push({
                 start: span.start,
                 end: span.end,

package/dist/scripts/cms/strapi/wiring.js

@@ -35,7 +35,7 @@ const SINGLETONS = [${singletons.map((name) => `'${name}'`).join(', ')}];
 
 // Structural field shapes (single components read as objects; block items and
 // dynamic zones reshape into the Strapi shape the components expect).
-const FIELD_SHAPES = ${fieldShapes};
+const FIELD_SHAPES = ${fieldShapes} as const;
 
 export const fimoStrapiFetch = createFimoStrapiFetch({
   types: TYPES,

package/dist/scripts/detect-framework.js

@@ -18,6 +18,12 @@ export function detectFramework(cwd) {
         return { framework: null };
     }
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    // A CMS backend is never an adoptable frontend — Strapi 5 ships vite+react
+    // devDeps for its admin panel, which the bare-vite fallback would match
+    // (the sandbox/website monorepo suggested `fimo init apps/strapi`).
+    if (deps['@strapi/strapi']) {
+        return { framework: null };
+    }
     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)));

package/dist/scripts/draft-rows.js

@@ -1,6 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import YAML from 'yaml';
+import { slugify } from './apply-wrap.js';
+/** Display fields tried, in order, when deriving a human entry slug. */
+const DISPLAY_SLUG_FIELDS = ['title', 'name', 'question', 'q', 'label', 'heading'];
 /**
  * Machine-staged entry ROWS for every drafted collection: the deterministic
  * transformation agents kept re-implementing by hand (media envelopes,
@@ -71,6 +74,20 @@ export function writeRowsStaging(rootDir, scan, drafts) {
     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;
+    // Types other rows REFERENCE resolve by slug server-side — their slugs must
+    // stay whatever identity the source carries. Every other type gets a HUMAN
+    // slug derived from its display field (never `faq-item-<hash>`).
+    const referencedUids = new Set();
+    for (const draft of drafts) {
+        for (const def of Object.values(draft.fields)) {
+            const field = def;
+            if (field?.type === 'reference') {
+                for (const target of field.targets ?? (field.target ? [field.target] : [])) {
+                    referencedUids.add(target);
+                }
+            }
+        }
+    }
     let written = 0;
     const stage = (draft, source, rawRows, references) => {
         const fieldTypes = new Map(Object.entries(draft.fields).map(([name, def]) => [
@@ -78,12 +95,31 @@ export function writeRowsStaging(rootDir, scan, drafts) {
             def && typeof def === 'object' ? (def.type ?? 'string') : 'string',
         ]));
         const referenceFields = new Set(references.map((reference) => reference.field));
+        const usedSlugs = new Set();
         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);
             }
+            if (typeof out.slug === 'string' && out.slug) {
+                usedSlugs.add(out.slug);
+            }
+            else if (!referencedUids.has(draft.uid)) {
+                // Human slug from the display field ("who-is-behind-fimo", never
+                // "faq-item-<hash>"). Referenced types keep their source identity —
+                // the server resolves references by target slug.
+                const display = DISPLAY_SLUG_FIELDS.map((field) => row[field]).find((candidate) => typeof candidate === 'string' && candidate.trim().length > 0);
+                const base = display ? slugify(display) : '';
+                if (base) {
+                    let candidate = base;
+                    for (let counter = 2; usedSlugs.has(candidate); counter++) {
+                        candidate = `${base}-${counter}`;
+                    }
+                    usedSlugs.add(candidate);
+                    out.slug = candidate;
+                }
+            }
             return out;
         });
         const descriptor = {};

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

@@ -1,23 +1,7 @@
 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),
-    });
-}
+import { pushRoute, toSegment } from '../discovered-route.js';
 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 = [];
@@ -46,7 +30,7 @@ export function discoverAstroRoutes(pagesDir) {
                 continue;
             }
             const base = entry.replace(PAGE_EXT, '');
-            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)]);
+            pushRoute(routes, base === 'index' ? segments : [...segments, toSegment(base)], full);
         }
     };
     walk(pagesDir, []);

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

@@ -1,5 +1,6 @@
 import type { TemplateWrapStyle } from '../apply-wrap-templates.js';
 import type { FrameworkDetection } from '../detect-framework.js';
+import { type RouteFileResolution, type RouteLike } from '../routes/module-resolve.js';
 import { type CollectionRewireResult } from './next/rewire.js';
 import { type DiscoveredRoute } from './next/routes.js';
 import { type RootWiringResult } from './next/wiring.js';
@@ -31,14 +32,26 @@ export declare function frameworkJsxWrapperModule(detection: Pick<FrameworkDetec
  * server data path there is no deterministic t() wiring to inject.
  */
 export declare function frameworkTemplateWrapStyle(framework: string | null | undefined): TemplateWrapStyle | null;
+export declare function frameworkRouteFiles(framework: string | null): ((cwd: string, routes: Record<string, RouteLike>) => RouteFileResolution[]) | null;
+export interface SectionStyle {
+    /** Module extensions a section import may resolve to. */
+    extensions: string[];
+    /** Wrapped-key scope for a component file (must match the wrap codemod's
+     *  own scoping so drafted sections join their staged keys). */
+    fileScope: (relFile: string) => string;
+    /** Directories tried for auto-imported components (Nuxt convention) when
+     *  a section tag has no import statement. */
+    fallbackComponentDirs: string[];
+}
 /**
- * The one-time root-wiring codemod for frameworks whose providers mount in a
- * single well-known file (Next.js app router: the root layout; Vite React
- * SPA: the entry). Runs during --apply, AFTER the baseline capture — the
- * pre-wrap dev-server boot must not require the fimo package, and providers
- * are render-transparent so the parity check stays clean. Template
- * frameworks wire through their TemplateWrapStyle.ensureWiring hooks instead.
+ * How to read a page's SECTION STRUCTURE for this framework — the seam the
+ * page-structure drafter builds on. Template frameworks share the ES-import
+ * + capitalized-tag shape, differing only in extensions and key scoping.
  */
+export declare function frameworkSectionStyle(framework: string | null): SectionStyle;
+/** Client-rendered frameworks: no server pass — reads happen in the browser
+ *  (the prompt's collection recipe and the SPA providers key off this). */
+export declare function isClientRenderedFramework(framework: string | null | undefined): boolean;
 export declare function frameworkRootWiring(detection: Pick<FrameworkDetection, 'framework' | 'react' | 'appDir'>): ((cwd: string) => RootWiringResult) | null;
 /**
  * Collection-page rewiring: pages that render a machine-staged collection get