fimo 0.9.0-experimental.10 → 0.9.0-experimental.12

package/dist/scripts/detect-framework.js

@@ -1,5 +1,11 @@
 import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join, relative } from 'node:path';
+/** A Vite SPA declares its entry with a root `index.html`; a library that only
+ *  bundles with Vite has none. This is what separates a deployable SITE from a
+ *  package that merely depends on react-router / vite / vue. */
+function hasHtmlEntry(cwd) {
+    return existsSync(join(cwd, 'index.html'));
+}
 /**
  * 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
@@ -29,7 +35,16 @@ export function detectFramework(cwd) {
         const pagesDir = ['pages', 'src/pages'].find((dir) => existsSync(join(cwd, dir)));
         return { framework: 'next', appDir, pagesDir };
     }
-    if (deps['react-router'] || deps['@react-router/dev']) {
+    // A react-router SITE is either framework mode (`@react-router/dev`) or a Vite
+    // SPA (an `index.html` entry). The `react-router` RUNTIME lib alone is a
+    // LIBRARY signal — the CLI, component libs and the `fimo/react-router` adapter
+    // all depend on it without being a site — so it must be paired with an app
+    // entry, or every workspace package reads as react-router (the monorepo picker
+    // bug: apps/cli mislabeled and offered as "your site").
+    if (deps['@react-router/dev']) {
+        return { framework: 'react-router' };
+    }
+    if (deps['react-router'] && hasHtmlEntry(cwd)) {
         return { framework: 'react-router' };
     }
     if (deps['@remix-run/react']) {
@@ -49,13 +64,15 @@ export function detectFramework(cwd) {
         const pagesDir = ['src/routes'].find((dir) => existsSync(join(cwd, dir)));
         return { framework: 'sveltekit', pagesDir };
     }
-    if (deps.vue && deps.vite) {
+    if (deps.vue && deps.vite && hasHtmlEntry(cwd)) {
         return { framework: 'vue' };
     }
-    if (deps.vite) {
+    if (deps.vite && hasHtmlEntry(cwd)) {
         // 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.
+        // stays hands-off. Vite is also just a build tool libraries use, so an
+        // app entry (index.html) is required — a lib that bundles with Vite is not
+        // a site.
         return { framework: 'vite', react: Boolean(deps.react) };
     }
     // Known frameworks we can NAME but not wrap yet — lets `fimo init` route
@@ -86,6 +103,37 @@ const WORKSPACE_SKIP = new Set([
     '.vercel',
     'coverage',
 ]);
+/**
+ * Directory names that hold NON-site packages — fixtures, examples, evals,
+ * scaffolding templates, internal tooling. Pruned from the picker so a
+ * monorepo's real sites aren't buried under dozens of candidates (the Fimo
+ * workspace surfaced 22, mostly `evals/*`, their `_references/*` mirrors, and
+ * `tools/*`). Generic monorepo conventions, not a project-specific list.
+ * Auto-discovery only: `fimo init <path>` still adopts any explicit directory.
+ */
+const NON_SITE_DIRS = new Set([
+    'examples',
+    'example',
+    'fixtures',
+    '__fixtures__',
+    '__tests__',
+    'test',
+    'tests',
+    'e2e',
+    'evals',
+    'eval',
+    'benchmarks',
+    'bench',
+    'demo',
+    'demos',
+    'sandbox',
+    'sandboxes',
+    'playground',
+    'tools',
+    'scripts',
+    'templates',
+    'template',
+]);
 /** 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;
@@ -122,7 +170,13 @@ export function findAdoptableApps(rootDir) {
             return;
         }
         for (const entry of entries) {
-            if (entry.isDirectory() && !WORKSPACE_SKIP.has(entry.name) && !entry.name.startsWith('.')) {
+            if (entry.isDirectory() &&
+                !WORKSPACE_SKIP.has(entry.name) &&
+                !NON_SITE_DIRS.has(entry.name.toLowerCase()) &&
+                // `.`-prefixed (dotdirs) and `_`-prefixed (internal / `_references`
+                // reference mirrors) are never the user's deployable site.
+                !entry.name.startsWith('.') &&
+                !entry.name.startsWith('_')) {
                 walk(join(dir, entry.name), depth + 1);
             }
         }

package/dist/scripts/routes/page-structure.d.ts

@@ -34,6 +34,11 @@ export interface PageSectionDraft {
     /** The same file drafts on several pages — chrome. Model it ONCE as a
      *  Single Type, never as a per-page block. */
     shared?: boolean;
+    /** The page component's OWN inline content (hero, stats, FAQ rendered
+     *  directly in the page file, not in an imported child). It aggregates
+     *  several on-page sections, so it is exempt from illustration detection
+     *  (its many short labels are real content, not a UI mock). */
+    pageOwn?: boolean;
 }
 export interface PageStructureDraft {
     pageId: string;
@@ -68,5 +73,91 @@ export interface PageSingleDraft {
     pageId: string;
     schema: Record<string, unknown>;
     document: Record<string, unknown>;
+    /** Section components left OUT of the single because they read as
+     *  illustrations/product demos, not editable content — the agent confirms
+     *  each is decorative (exempts it) or pulls it back into the model. */
+    illustrations?: string[];
 }
-export declare function buildPageSingleDraft(draft: PageStructureDraft, labelValues: Record<string, string>): PageSingleDraft | null;
+/**
+ * A section whose visible text is a DENSE PILE of copy strings reads as an
+ * ILLUSTRATION / product demo (a fake dashboard, a device mockup, an animated
+ * terminal), not editable content — e.g. a UI mock with 75 strings (column
+ * headers, buttons, status chips, plus a little fake body prose). Modeling
+ * that as 75 CMS fields is noise that makes a page uneditable.
+ *
+ * The primary signal is SIZE (framework-neutral: no real editable section has
+ * 30+ flat sibling copy fields — real content is small or structured into
+ * collections). A section that is SUBSTANTIALLY prose is exempt (an article /
+ * legal page is content, however long). For a medium pile (8-29 strings) the
+ * component NAME must corroborate. Conservative by design — a false positive
+ * silently drops editable content, so the caller SURFACES the flag for the
+ * agent to confirm rather than deleting it silently.
+ */
+export declare function isIllustrationSection(section: PageSectionDraft, labelValues: Record<string, string>): boolean;
+export declare function buildPageSingleDraft(draft: PageStructureDraft, labelValues: Record<string, string>, contentConfirmed?: ReadonlySet<string>): PageSingleDraft | null;
+/**
+ * The machine-built Single Type for a shared chrome section (header, footer,
+ * nav, cookie banner): its structure AND content are identical on every page,
+ * so it is modeled ONCE and referenced. `markSharedSections` flags these; today
+ * `buildPageSingleDraft` just SKIPS them, so they die as orphan flat labels —
+ * this builds the Single the agent pushes instead.
+ */
+export interface SharedSingleDraft {
+    uid: string;
+    component: string;
+    file: string;
+    schema: Record<string, unknown>;
+    document: Record<string, unknown>;
+}
+/**
+ * One Single Type per unique shared chrome section (deduped by
+ * `(file, component)` — the same header on N pages is ONE Single). Reuses
+ * `sectionBlock` so a header's nav/logo/labels become real fields; a section
+ * that yields no fields (a pure decorative wrapper) is skipped rather than
+ * emitting an empty Single.
+ */
+export declare function buildSharedSingleDrafts(drafts: PageStructureDraft[], labelValues: Record<string, string>): SharedSingleDraft[];
+/**
+ * A section the detector reads as an illustration/product-demo, with enough
+ * context for the human to confirm in a glance: WHERE it lives (`file`,
+ * `component`), WHAT strings it holds (`labelKeys` + a few `samples`). The
+ * interview turns each into an `IllustrationDecisionRecord`; keyed by
+ * `(file, component)` so the decision survives the agent's rename pass.
+ */
+export interface IllustrationCandidate {
+    file: string;
+    component: string;
+    labelKeys: string[];
+    samples: string[];
+}
+/**
+ * Every section (top-level or nested) the illustration detector flags across
+ * the page-structure drafts, deduped by `(file, component)` — the same file
+ * rendered on several pages is one candidate, one question. Rich payload, not
+ * just a name: the caller relays it to the human and, on `drop`, exempts the
+ * `labelKeys` from the coverage/parity gates.
+ */
+export declare function collectIllustrationCandidates(drafts: PageStructureDraft[], labelValues: Record<string, string>): IllustrationCandidate[];
+/**
+ * A section the structural detector left as a page-local block (a default
+ * Component) but whose content model is genuinely in question: its component
+ * renders on 2+ pages, so the owner may know it is actually the SAME content
+ * everywhere (a Single Type) or a repeated managed entry (a Collection Type) —
+ * a call `markSharedSections` cannot make when the copies live in different
+ * files. Single-page sections are unambiguously Components and never surface.
+ */
+export interface ContentModelCandidate {
+    file: string;
+    component: string;
+    /** How many page drafts render this component — the ambiguity signal. */
+    pages: number;
+    samples: string[];
+}
+/**
+ * The content-model classification candidates: non-shared, non-illustration
+ * sections whose component appears across 2+ page drafts. Deduped by
+ * `(file, component)`; the interview asks which are Single Types / Collection
+ * Types and leaves the rest as Components. Shared chrome (auto Single Type) and
+ * detected collections (auto Collection Type) never reach here.
+ */
+export declare function collectContentModelCandidates(drafts: PageStructureDraft[], labelValues: Record<string, string>, contentConfirmed?: ReadonlySet<string>): ContentModelCandidate[];

package/dist/scripts/routes/page-structure.js

@@ -1,8 +1,13 @@
 import { readFileSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { basename, join, relative } from 'node:path';
 import { frameworkSectionStyle } from '../frameworks/discover.js';
 import { componentImports, resolveModuleFile, resolveRouteFiles } from './label-prefixes.js';
-const MAX_SECTION_DEPTH = 3;
+// How deep the section recursion nests components into blocks. The platform
+// caps structured-content nesting at 7 and the page Single wraps each top
+// section as a block (one level), so 6 keeps the deepest child inside the
+// limit while mirroring real page-builders that nest 5-6 deep (a features
+// grid → groups → cards → …). Was 3, which flattened deep structure.
+const MAX_SECTION_DEPTH = 6;
 const MAX_DRAFT_ROWS = 50;
 const pascal = (value) => value
     .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
@@ -91,6 +96,30 @@ function draftChildSections(context, file, depth) {
     }
     return sections;
 }
+/**
+ * The page component's OWN inline content — hero copy, stats, an inline FAQ —
+ * lives under the page FILE's label prefix and is never an imported child, so
+ * `draftChildSections` skips it and it strands as orphan flat labels. Draft it
+ * as ONE section (its detected collections + labels, NO child recursion — the
+ * imported children are already separate top-level sections). Marked `pageOwn`
+ * so illustration detection doesn't mistake its many short labels for a mock.
+ */
+function draftPageOwnSection(context, file) {
+    const rel = relative(context.cwd, file);
+    const prefix = context.style.fileScope(rel);
+    const labelKeys = context.keysByPrefix.get(prefix) ?? [];
+    const collections = (context.collectionsByFile.get(rel) ?? []).map((candidate) => ({
+        name: candidate.name,
+        fields: candidate.fields,
+        count: candidate.count,
+        ...(candidate.typedRows ? { rows: candidate.typedRows.slice(0, MAX_DRAFT_ROWS) } : {}),
+    }));
+    if (labelKeys.length === 0 && collections.length === 0) {
+        return null;
+    }
+    const component = pascal(basename(rel).replace(/\.\w+$/, ''));
+    return { key: camel(component), component, file: rel, prefix, labelKeys, collections, pageOwn: true };
+}
 export function draftPageStructures(args) {
     const { cwd, framework, routes, collections } = args;
     const keysByPrefix = new Map();
@@ -109,8 +138,13 @@ export function draftPageStructures(args) {
     const drafts = [];
     for (const { routeId, file } of resolveRouteFiles(cwd, framework, routes)) {
         const context = { cwd, style, keysByPrefix, collectionsByFile, visited: new Set([file]) };
-        const sections = draftChildSections(context, file, 1);
-        if (sections.length > 1) {
+        const childSections = draftChildSections(context, file, 1);
+        const ownSection = draftPageOwnSection(context, file);
+        const sections = ownSection ? [ownSection, ...childSections] : childSections;
+        // buildPageSingleDraft's `totalFields >= 3` is the real triviality filter,
+        // so drafting any page with content (>= 1 section) is safe — and it is what
+        // lets an inline-only page (all content in the page file) get a Single.
+        if (sections.length >= 1) {
             drafts.push({ pageId: routeId, single: pascal(routeId), sections });
         }
     }
@@ -149,11 +183,94 @@ export function countDraftSections(draft) {
 }
 const labelFieldName = (key) => camel(key.split('.').pop() ?? key);
 const scalarType = (value) => value.length > 80 || value.includes('\n') ? 'text' : 'string';
-function sectionBlock(section, labelValues) {
+/** Names that corroborate (never trigger alone) an illustration/demo. */
+const ILLUSTRATION_NAME = /mock|demo|preview|illustration|visual|showcase|diagram|orbit|screenshot|animation|graphic|dashboard|widget|figure/i;
+/** A section with this many flat sibling copy strings is a dump, not content:
+ *  real editable sections stay small (a hero has ~3 fields, a card ~3), and
+ *  genuinely repeated content is a collection/block, not N sibling labels. A
+ *  UI mock reproduced in code (a fake dashboard, a device frame, a terminal
+ *  demo) is the usual culprit — one carried 75 strings in the wild. */
+const ILLUSTRATION_DENSE = 30;
+const ILLUSTRATION_MIN_LABELS = 8;
+const wordCount = (value) => value.trim().split(/\s+/).filter(Boolean).length;
+/** Editable prose: a heading + paragraph section has some; a UI-chrome dump
+ *  (a product mock's nav/table/button strings) is mostly tiny fragments. */
+const looksLikeProse = (value) => {
+    const words = wordCount(value);
+    return words >= 8 || (words >= 5 && /[.!?]/.test(value.trim()));
+};
+/**
+ * A section whose visible text is a DENSE PILE of copy strings reads as an
+ * ILLUSTRATION / product demo (a fake dashboard, a device mockup, an animated
+ * terminal), not editable content — e.g. a UI mock with 75 strings (column
+ * headers, buttons, status chips, plus a little fake body prose). Modeling
+ * that as 75 CMS fields is noise that makes a page uneditable.
+ *
+ * The primary signal is SIZE (framework-neutral: no real editable section has
+ * 30+ flat sibling copy fields — real content is small or structured into
+ * collections). A section that is SUBSTANTIALLY prose is exempt (an article /
+ * legal page is content, however long). For a medium pile (8-29 strings) the
+ * component NAME must corroborate. Conservative by design — a false positive
+ * silently drops editable content, so the caller SURFACES the flag for the
+ * agent to confirm rather than deleting it silently.
+ */
+export function isIllustrationSection(section, labelValues) {
+    // The page's own aggregate content is many sections at once, not a single
+    // component's UI mock — never read it as an illustration.
+    if (section.pageOwn) {
+        return false;
+    }
+    const values = section.labelKeys.map((key) => labelValues[key] ?? '').filter((value) => value.trim().length > 0);
+    if (values.length < ILLUSTRATION_MIN_LABELS) {
+        return false;
+    }
+    // Substantially prose → a text/article/legal section, not a UI dump.
+    const proseRatio = values.filter(looksLikeProse).length / values.length;
+    if (proseRatio > 0.4) {
+        return false;
+    }
+    // A dense pile is a dump on size alone — the confident trigger.
+    if (values.length >= ILLUSTRATION_DENSE) {
+        return true;
+    }
+    // Medium pile: only when the component name says mock/demo AND it is mostly
+    // tiny fragments — keeps the false-positive rate near zero.
+    const shortRatio = values.filter((value) => wordCount(value) <= 3).length / values.length;
+    return ILLUSTRATION_NAME.test(section.component) && shortRatio >= 0.7;
+}
+const sectionIdentity = (section) => `${section.file}::${section.component}`;
+/**
+ * A section reads as an illustration to leave OUT of the model — UNLESS the
+ * owner confirmed in the interview that it IS editable content
+ * (`wrap.illustrations` disposition `content`, passed as `contentConfirmed`).
+ * That override is the whole point of asking, so it must beat the detector.
+ */
+function isDroppableIllustration(section, labelValues, contentConfirmed) {
+    return isIllustrationSection(section, labelValues) && !contentConfirmed.has(sectionIdentity(section));
+}
+function sectionBlock(section, labelValues, illustrations, contentConfirmed) {
     const fields = {};
     const value = {};
     let fieldCount = 0;
+    // Partition the section's labels: a key with a nested path
+    // (`<prefix>.<group>.<item>.<field>`) is a COLLECTION encoded in the label
+    // keys (`ecosystem-items.github.name`, `…react.name`, …). Flattening it by
+    // last segment would collapse every item to one `name` field and silently
+    // drop the rest — group it into a repeatable block. Single-segment keys stay
+    // scalar fields.
+    const groups = new Map();
+    const relOf = (key) => key.startsWith(`${section.prefix}.`) ? key.slice(section.prefix.length + 1) : key;
     for (const key of section.labelKeys) {
+        const parts = relOf(key).split('.');
+        if (parts.length >= 3) {
+            const [group, item, ...fieldParts] = parts;
+            const itemMap = groups.get(group) ?? new Map();
+            const itemFields = itemMap.get(item) ?? {};
+            itemFields[camel(fieldParts.join('-'))] = labelValues[key] ?? '';
+            itemMap.set(item, itemFields);
+            groups.set(group, itemMap);
+            continue;
+        }
         const name = labelFieldName(key);
         if (fields[name]) {
             continue;
@@ -163,6 +280,21 @@ function sectionBlock(section, labelValues) {
         value[name] = labelValue;
         fieldCount += 1;
     }
+    for (const [group, itemMap] of groups) {
+        const name = camel(group);
+        if (fields[name]) {
+            continue;
+        }
+        const itemFields = {};
+        for (const itemValue of itemMap.values()) {
+            for (const fieldName of Object.keys(itemValue)) {
+                itemFields[fieldName] = { type: 'string' };
+            }
+        }
+        fields[name] = { type: 'blocks', schema: { fields: itemFields } };
+        value[name] = [...itemMap.values()];
+        fieldCount += 1;
+    }
     for (const collection of section.collections) {
         const name = camel(collection.name);
         if (fields[name]) {
@@ -192,7 +324,11 @@ function sectionBlock(section, labelValues) {
         if (child.shared) {
             continue;
         }
-        const block = sectionBlock(child, labelValues);
+        if (isDroppableIllustration(child, labelValues, contentConfirmed)) {
+            illustrations.push(child.component);
+            continue;
+        }
+        const block = sectionBlock(child, labelValues, illustrations, contentConfirmed);
         if (!block || fields[child.key]) {
             continue;
         }
@@ -205,15 +341,24 @@ function sectionBlock(section, labelValues) {
     }
     return { fields, value, fieldCount };
 }
-export function buildPageSingleDraft(draft, labelValues) {
+export function buildPageSingleDraft(draft, labelValues, contentConfirmed = new Set()) {
     const fields = {};
     const document = {};
+    const illustrations = [];
     let totalFields = 0;
     for (const section of draft.sections) {
         if (section.shared || fields[section.key]) {
             continue;
         }
-        const block = sectionBlock(section, labelValues);
+        // Illustration/demo sections (a product mock's UI-chrome strings) are noise
+        // in a CMS — leave them out of the single. Surfaced, never silently lost.
+        // The interview's `content` override folds one back in (from the next run,
+        // once the decision is recorded — singles are built before the interview).
+        if (isDroppableIllustration(section, labelValues, contentConfirmed)) {
+            illustrations.push(section.component);
+            continue;
+        }
+        const block = sectionBlock(section, labelValues, illustrations, contentConfirmed);
         if (!block) {
             continue;
         }
@@ -230,5 +375,123 @@ export function buildPageSingleDraft(draft, labelValues) {
         pageId: draft.pageId,
         schema: { uid: draft.single, name: draft.single, isSingleton: true, fields },
         document,
+        ...(illustrations.length > 0 ? { illustrations: [...new Set(illustrations)] } : {}),
+    };
+}
+/**
+ * One Single Type per unique shared chrome section (deduped by
+ * `(file, component)` — the same header on N pages is ONE Single). Reuses
+ * `sectionBlock` so a header's nav/logo/labels become real fields; a section
+ * that yields no fields (a pure decorative wrapper) is skipped rather than
+ * emitting an empty Single.
+ */
+export function buildSharedSingleDrafts(drafts, labelValues) {
+    const byIdentity = new Map();
+    const walk = (sections) => {
+        for (const section of sections) {
+            if (section.shared) {
+                const identity = `${section.file}::${section.component}`;
+                if (!byIdentity.has(identity)) {
+                    const block = sectionBlock(section, labelValues, [], new Set());
+                    if (block && Object.keys(block.fields).length > 0) {
+                        const uid = pascal(section.component);
+                        byIdentity.set(identity, {
+                            uid,
+                            component: section.component,
+                            file: section.file,
+                            schema: { uid, name: uid, isSingleton: true, fields: block.fields },
+                            document: block.value,
+                        });
+                    }
+                }
+                // A shared section owns its whole subtree — don't descend for more.
+                continue;
+            }
+            walk(section.children ?? []);
+        }
+    };
+    for (const draft of drafts) {
+        walk(draft.sections);
+    }
+    return [...byIdentity.values()];
+}
+/** How many sample strings a candidate carries so a human can judge in 3s. */
+const SECTION_SAMPLE_COUNT = 6;
+const sectionSamples = (section, labelValues) => section.labelKeys
+    .map((key) => labelValues[key] ?? '')
+    .filter((value) => value.trim().length > 0)
+    .slice(0, SECTION_SAMPLE_COUNT);
+/**
+ * Every section (top-level or nested) the illustration detector flags across
+ * the page-structure drafts, deduped by `(file, component)` — the same file
+ * rendered on several pages is one candidate, one question. Rich payload, not
+ * just a name: the caller relays it to the human and, on `drop`, exempts the
+ * `labelKeys` from the coverage/parity gates.
+ */
+export function collectIllustrationCandidates(drafts, labelValues) {
+    const byIdentity = new Map();
+    const walk = (sections) => {
+        for (const section of sections) {
+            if (isIllustrationSection(section, labelValues)) {
+                const identity = `${section.file}::${section.component}`;
+                if (!byIdentity.has(identity)) {
+                    byIdentity.set(identity, {
+                        file: section.file,
+                        component: section.component,
+                        labelKeys: [...section.labelKeys],
+                        samples: sectionSamples(section, labelValues),
+                    });
+                }
+            }
+            walk(section.children ?? []);
+        }
     };
+    for (const draft of drafts) {
+        walk(draft.sections);
+    }
+    return [...byIdentity.values()];
+}
+/**
+ * The content-model classification candidates: non-shared, non-illustration
+ * sections whose component appears across 2+ page drafts. Deduped by
+ * `(file, component)`; the interview asks which are Single Types / Collection
+ * Types and leaves the rest as Components. Shared chrome (auto Single Type) and
+ * detected collections (auto Collection Type) never reach here.
+ */
+export function collectContentModelCandidates(drafts, labelValues, contentConfirmed = new Set()) {
+    const eligible = (section) => !section.shared && !isDroppableIllustration(section, labelValues, contentConfirmed);
+    const pagesByComponent = new Map();
+    const count = (pageId, sections) => {
+        for (const section of sections) {
+            if (eligible(section)) {
+                pagesByComponent.set(section.component, (pagesByComponent.get(section.component) ?? new Set()).add(pageId));
+            }
+            count(pageId, section.children ?? []);
+        }
+    };
+    for (const draft of drafts) {
+        count(draft.pageId, draft.sections);
+    }
+    const byIdentity = new Map();
+    const collect = (sections) => {
+        for (const section of sections) {
+            const pages = pagesByComponent.get(section.component)?.size ?? 0;
+            if (eligible(section) && pages >= 2) {
+                const identity = `${section.file}::${section.component}`;
+                if (!byIdentity.has(identity)) {
+                    byIdentity.set(identity, {
+                        file: section.file,
+                        component: section.component,
+                        pages,
+                        samples: sectionSamples(section, labelValues),
+                    });
+                }
+            }
+            collect(section.children ?? []);
+        }
+    };
+    for (const draft of drafts) {
+        collect(draft.sections);
+    }
+    return [...byIdentity.values()];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fimo",
-  "version": "0.9.0-experimental.10",
+  "version": "0.9.0-experimental.12",
   "description": "Fimo CLI - create, deploy, and manage Fimo projects",
   "bin": {
     "fimo": "dist/cli/index.js"

package/templates/react-router/package.json

@@ -21,7 +21,7 @@
     "cmdk": "^1.1.1",
     "date-fns": "^4.1.0",
     "embla-carousel-react": "^8.6.0",
-    "fimo": "0.9.0-experimental.10",
+    "fimo": "0.9.0-experimental.12",
     "input-otp": "^1.4.2",
     "isbot": "^5",
     "lucide-react": "^0.577.0",