@beechcms/core 0.7.0 → 0.8.1

package/dist/seed-ddl-destructive.js

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+import { junctionTableName, generateFtsTable, generateFtsTriggers } from './engine.js';
+const BRANCH_SQL_TYPE = {
+    text: 'TEXT',
+    number: 'REAL',
+    boolean: 'INTEGER',
+    date: 'INTEGER',
+    json: 'TEXT',
+    richtext: 'TEXT',
+    file: 'TEXT',
+    tags: 'TEXT',
+    relation: 'TEXT',
+    repeater: 'TEXT',
+};
+/** Branch types that receive a B-tree index in generateIndexes (used by retype to drop/recreate). */
+const INDEXABLE_TYPES = new Set(['text', 'number', 'date', 'boolean', 'relation']);
+function searchBranches(seed) {
+    return seed.branches.filter(b => (b.type === 'text' || b.type === 'richtext') && b.policies?.search !== false);
+}
+function ftsTriggerDrops(slug) {
+    return [
+        `DROP TRIGGER IF EXISTS fts_${slug}_insert;`,
+        `DROP TRIGGER IF EXISTS fts_${slug}_update;`,
+        `DROP TRIGGER IF EXISTS fts_${slug}_delete;`,
+        `DROP TABLE IF EXISTS fts_${slug};`,
+    ];
+}
+/**
+ * Ordered DROP TABLE statements for a full hard-delete of a seed's tables.
+ * Order: junction drafts → junctions → FTS triggers → FTS table → drafts → main table.
+ * All statements use IF EXISTS (idempotent).
+ */
+export function generateDropTable(seed) {
+    const stmts = [];
+    const { slug } = seed;
+    for (const branch of seed.branches) {
+        if (branch.type !== 'relation' || branch.multiple !== true)
+            continue;
+        const jt = junctionTableName(slug, branch.alias);
+        stmts.push(`DROP TABLE IF EXISTS ${jt}_drafts;`);
+        stmts.push(`DROP TABLE IF EXISTS ${jt};`);
+    }
+    stmts.push(...ftsTriggerDrops(slug));
+    stmts.push(`DROP TABLE IF EXISTS content_${slug}_drafts;`);
+    stmts.push(`DROP TABLE IF EXISTS content_${slug};`);
+    return stmts;
+}
+/**
+ * DROP COLUMN statements for a single branch (by alias).
+ * For multi-relation branches: drops the junction tables (no column on parent).
+ * For regular branches: drops from main table + drafts table (if allowDrafts).
+ * Does NOT include FTS handling — callers must prepend ftsTriggerDrops() and
+ * append planFtsRebuild() when the branch is searchable.
+ */
+export function generateDropColumn(seed, alias) {
+    const stmts = [];
+    const { slug } = seed;
+    const branch = seed.branches.find(b => b.alias === alias);
+    if (!branch)
+        throw new Error(`Branch '${alias}' not found in seed '${slug}'`);
+    if (branch.type === 'relation' && branch.multiple === true) {
+        const jt = junctionTableName(slug, alias);
+        if (seed.allowDrafts)
+            stmts.push(`DROP TABLE IF EXISTS ${jt}_drafts;`);
+        stmts.push(`DROP TABLE IF EXISTS ${jt};`);
+    }
+    else {
+        stmts.push(`ALTER TABLE content_${slug} DROP COLUMN ${alias};`);
+        if (seed.allowDrafts)
+            stmts.push(`ALTER TABLE content_${slug}_drafts DROP COLUMN ${alias};`);
+    }
+    return stmts;
+}
+/**
+ * RENAME COLUMN statements for a branch alias change.
+ * Updates main table + drafts (if allowDrafts).
+ * Does NOT handle FTS — callers must rebuild FTS separately (SQLite auto-updates
+ * trigger bodies on RENAME but the FTS virtual-table columns keep the old name).
+ */
+export function generateRenameColumn(seed, fromAlias, toAlias) {
+    const stmts = [];
+    const { slug } = seed;
+    stmts.push(`ALTER TABLE content_${slug} RENAME COLUMN ${fromAlias} TO ${toAlias};`);
+    if (seed.allowDrafts) {
+        stmts.push(`ALTER TABLE content_${slug}_drafts RENAME COLUMN ${fromAlias} TO ${toAlias};`);
+    }
+    return stmts;
+}
+/**
+ * Full FTS rebuild: drop triggers + FTS table, then recreate them, then backfill.
+ * Returns an empty array if the seed has no searchable branches.
+ * The drop steps use IF EXISTS so this is safe to call even if FTS was already dropped.
+ */
+export function planFtsRebuild(seed) {
+    const rtBranches = searchBranches(seed);
+    if (rtBranches.length === 0)
+        return [];
+    const { slug } = seed;
+    const stmts = [...ftsTriggerDrops(slug)];
+    const ftsTable = generateFtsTable(seed);
+    if (ftsTable)
+        stmts.push(ftsTable);
+    stmts.push(...generateFtsTriggers(seed));
+    const cols = rtBranches.map(b => b.alias);
+    stmts.push(`INSERT INTO fts_${slug}(entry_id, ${cols.join(', ')}) SELECT id, ${cols.join(', ')} FROM content_${slug};`);
+    return stmts;
+}
+/**
+ * Generates statements to change a branch's SQL storage type using the
+ * add-new-column / copy / drop-old / rename approach.
+ * Includes FTS rebuild statements when the branch is (or becomes) searchable.
+ * `updatedSeed` must already reflect the new type on the renamed branch.
+ */
+export function planRetypeColumn(seed, alias, newType, updatedSeed) {
+    const branch = seed.branches.find(b => b.alias === alias);
+    if (!branch)
+        throw new Error(`Branch '${alias}' not found in seed '${seed.slug}'`);
+    const { slug } = seed;
+    const newSqlType = BRANCH_SQL_TYPE[newType];
+    const tmpAlias = `${alias}_migrate`;
+    const stmts = [];
+    // Always drop FTS first to avoid "column referenced in trigger" errors on DROP COLUMN.
+    stmts.push(...ftsTriggerDrops(slug));
+    // Drop the branch index if it exists on the old column (required before DROP COLUMN).
+    if (INDEXABLE_TYPES.has(branch.type) && branch.policies?.filter !== false) {
+        stmts.push(`DROP INDEX IF EXISTS idx_${slug}_${alias};`);
+    }
+    // Main table: add migration column, copy data, drop old, rename.
+    stmts.push(`ALTER TABLE content_${slug} ADD COLUMN ${tmpAlias} ${newSqlType};`);
+    stmts.push(`UPDATE content_${slug} SET ${tmpAlias} = CAST(${alias} AS ${newSqlType});`);
+    stmts.push(`ALTER TABLE content_${slug} DROP COLUMN ${alias};`);
+    stmts.push(`ALTER TABLE content_${slug} RENAME COLUMN ${tmpAlias} TO ${alias};`);
+    // Recreate index for the renamed column if the new type warrants it.
+    if (INDEXABLE_TYPES.has(newType) && branch.policies?.filter !== false) {
+        stmts.push(`CREATE INDEX IF NOT EXISTS idx_${slug}_${alias} ON content_${slug}(${alias});`);
+    }
+    // Drafts table (no indexes to worry about).
+    if (seed.allowDrafts) {
+        stmts.push(`ALTER TABLE content_${slug}_drafts ADD COLUMN ${tmpAlias} ${newSqlType};`);
+        stmts.push(`UPDATE content_${slug}_drafts SET ${tmpAlias} = CAST(${alias} AS ${newSqlType});`);
+        stmts.push(`ALTER TABLE content_${slug}_drafts DROP COLUMN ${alias};`);
+        stmts.push(`ALTER TABLE content_${slug}_drafts RENAME COLUMN ${tmpAlias} TO ${alias};`);
+    }
+    // Rebuild FTS if the seed has searchable branches in the updated definition.
+    const rebuild = planFtsRebuild(updatedSeed);
+    stmts.push(...rebuild);
+    return { statements: stmts, ftsRebuildNeeded: rebuild.length > 0 };
+}

package/dist/seed-ddl.d.ts

@@ -0,0 +1,40 @@
+import type { Seed } from './types.js';
+/**
+ * Full create-from-scratch statement set for a seed. Mirrors the CLI's buildStatements.
+ * Order: parent table → indexes → draft table → FTS table → FTS triggers →
+ * per multi-relation: junction table → junction indexes → junction draft table.
+ * Callers that create several seeds must order seeds with sortSeedsByDependencies
+ * first so relation FK targets exist.
+ */
+export declare function planCreateSeed(seed: Seed): string[];
+export interface ExtendPlan {
+    statements: string[];
+    ftsRebuildNeeded: boolean;
+}
+/**
+ * Additive extension: given the columns that already exist on content_{slug}
+ * (from PRAGMA table_info, passed in by the caller), return ONLY the statements
+ * needed to add new branches — ADD COLUMN + indexes, plus junction tables for
+ * new multi-relation branches. Never drops or renames.
+ *
+ * FTS: SQLite cannot ALTER an fts5 table's columns. If a new text/richtext
+ * searchable branch was added, ftsRebuildNeeded=true signals the caller
+ * (sprint 03) to handle it — no DROP is emitted.
+ */
+export declare function planExtendSeed(seed: Seed, existingColumns: Set<string>): ExtendPlan;
+/**
+ * Destructive FTS rebuild (sprint 06). SQLite cannot ALTER an fts5 table's
+ * columns, so when a searchable branch is added, renamed, retyped, or dropped
+ * the only correct fix is to drop and recreate the `fts_{slug}` virtual table
+ * (and its insert/update/delete triggers), then backfill from `content_{slug}`.
+ *
+ * Returns an empty array when the seed has no searchable branches — in that
+ * case the caller should instead drop any leftover FTS table via
+ * generateDropTable's FTS statements. The returned statements are destructive
+ * and must run through ISchemaMutator.execDestructive, never execDdl.
+ *
+ * Order: drop triggers → drop fts table → recreate table → recreate triggers →
+ * backfill existing rows.
+ */
+export declare function planFtsRebuild(seed: Seed): string[];
+//# sourceMappingURL=seed-ddl.d.ts.map

package/dist/seed-ddl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-ddl.d.ts","sourceRoot":"","sources":["../src/seed-ddl.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AActC;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAanD;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,eAAe,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,UAAU,CAqBnF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CA0BnD"}

package/dist/seed-ddl.js

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+import { generateCreateTable, generateDraftTable, generateIndexes, generateFtsTable, generateFtsTriggers, generateAddColumn, generateJunctionTable, generateJunctionIndexes, generateJunctionDraftTable, indexableSearchBranches, } from './engine.js';
+/**
+ * Full create-from-scratch statement set for a seed. Mirrors the CLI's buildStatements.
+ * Order: parent table → indexes → draft table → FTS table → FTS triggers →
+ * per multi-relation: junction table → junction indexes → junction draft table.
+ * Callers that create several seeds must order seeds with sortSeedsByDependencies
+ * first so relation FK targets exist.
+ */
+export function planCreateSeed(seed) {
+    const stmts = [generateCreateTable(seed), ...generateIndexes(seed)];
+    const draft = generateDraftTable(seed);
+    if (draft)
+        stmts.push(draft);
+    const fts = generateFtsTable(seed);
+    if (fts)
+        stmts.push(fts, ...generateFtsTriggers(seed));
+    for (const branch of seed.branches) {
+        if (branch.type !== 'relation' || branch.multiple !== true)
+            continue;
+        stmts.push(generateJunctionTable(seed, branch), ...generateJunctionIndexes(seed, branch));
+        const dj = generateJunctionDraftTable(seed, branch);
+        if (dj)
+            stmts.push(dj);
+    }
+    return stmts;
+}
+/**
+ * Additive extension: given the columns that already exist on content_{slug}
+ * (from PRAGMA table_info, passed in by the caller), return ONLY the statements
+ * needed to add new branches — ADD COLUMN + indexes, plus junction tables for
+ * new multi-relation branches. Never drops or renames.
+ *
+ * FTS: SQLite cannot ALTER an fts5 table's columns. If a new text/richtext
+ * searchable branch was added, ftsRebuildNeeded=true signals the caller
+ * (sprint 03) to handle it — no DROP is emitted.
+ */
+export function planExtendSeed(seed, existingColumns) {
+    const statements = [];
+    let ftsRebuildNeeded = false;
+    for (const branch of seed.branches) {
+        if (branch.type === 'relation' && branch.multiple === true) {
+            // junction table is CREATE IF NOT EXISTS — safe to re-emit
+            statements.push(generateJunctionTable(seed, branch), ...generateJunctionIndexes(seed, branch));
+            const dj = generateJunctionDraftTable(seed, branch);
+            if (dj)
+                statements.push(dj);
+            continue;
+        }
+        if (existingColumns.has(branch.alias))
+            continue;
+        statements.push(generateAddColumn(seed, branch));
+        if ((branch.type === 'text' || branch.type === 'richtext') && branch.policies?.search !== false) {
+            ftsRebuildNeeded = true;
+        }
+    }
+    // CREATE INDEX IF NOT EXISTS — idempotent, safe to re-run
+    statements.push(...generateIndexes(seed));
+    return { statements, ftsRebuildNeeded };
+}
+/**
+ * Destructive FTS rebuild (sprint 06). SQLite cannot ALTER an fts5 table's
+ * columns, so when a searchable branch is added, renamed, retyped, or dropped
+ * the only correct fix is to drop and recreate the `fts_{slug}` virtual table
+ * (and its insert/update/delete triggers), then backfill from `content_{slug}`.
+ *
+ * Returns an empty array when the seed has no searchable branches — in that
+ * case the caller should instead drop any leftover FTS table via
+ * generateDropTable's FTS statements. The returned statements are destructive
+ * and must run through ISchemaMutator.execDestructive, never execDdl.
+ *
+ * Order: drop triggers → drop fts table → recreate table → recreate triggers →
+ * backfill existing rows.
+ */
+export function planFtsRebuild(seed) {
+    const branches = indexableSearchBranches(seed);
+    if (branches.length === 0)
+        return [];
+    const slug = seed.slug;
+    const ftsTable = `fts_${slug}`;
+    const contentTable = `content_${slug}`;
+    const cols = branches.map(b => b.alias);
+    const ftsTableDdl = generateFtsTable(seed);
+    const triggers = generateFtsTriggers(seed);
+    // generateFtsTable/Triggers return non-null here (branches.length > 0 checked).
+    if (!ftsTableDdl)
+        return [];
+    const ftsColList = ['entry_id', ...cols].join(', ');
+    const selectList = ['id', ...cols].join(', ');
+    return [
+        `DROP TRIGGER IF EXISTS fts_${slug}_insert;`,
+        `DROP TRIGGER IF EXISTS fts_${slug}_update;`,
+        `DROP TRIGGER IF EXISTS fts_${slug}_delete;`,
+        `DROP TABLE IF EXISTS ${ftsTable};`,
+        ftsTableDdl,
+        ...triggers,
+        `INSERT INTO ${ftsTable}(${ftsColList}) SELECT ${selectList} FROM ${contentTable};`,
+    ];
+}

package/dist/seed-layout.d.ts

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import type { Seed, Branch } from './types.js';
+export declare const kanbanViewConfigSchema: z.ZodObject<{
+    axisBranchId: z.ZodNullable<z.ZodString>;
+    sort: z.ZodNullable<z.ZodObject<{
+        branchId: z.ZodString;
+        dir: z.ZodEnum<{
+            ASC: "ASC";
+            DESC: "DESC";
+        }>;
+    }, z.core.$strip>>;
+    hiddenColumnValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    collapsedColumnValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type KanbanViewConfig = z.infer<typeof kanbanViewConfigSchema>;
+export declare const seedViewConfigSchema: z.ZodObject<{
+    kanban: z.ZodOptional<z.ZodObject<{
+        axisBranchId: z.ZodNullable<z.ZodString>;
+        sort: z.ZodNullable<z.ZodObject<{
+            branchId: z.ZodString;
+            dir: z.ZodEnum<{
+                ASC: "ASC";
+                DESC: "DESC";
+            }>;
+        }, z.core.$strip>>;
+        hiddenColumnValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        collapsedColumnValues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type SeedViewConfig = z.infer<typeof seedViewConfigSchema>;
+/** Reference to a Seed branch by its stable id (e.g. 'br_03').
+ *  Aliases can be renamed — ids cannot. When the id does not match any
+ *  branch on the Seed at read time, the field is silently stripped (auto-cleanup). */
+export interface LayoutField {
+    branchId: string;
+}
+export interface LayoutColumn {
+    id: string;
+    fields: LayoutField[];
+}
+export interface LayoutSection {
+    id: string;
+    label?: string;
+    hideLabel?: boolean;
+    hideBorder?: boolean;
+    collapsible?: boolean;
+    /** Max 4 columns. Enforced by validator. */
+    columns: LayoutColumn[];
+}
+export interface LayoutTab {
+    id: string;
+    label: string;
+    sections: LayoutSection[];
+}
+export interface FormLayout {
+    /** Format version — bump when introducing breaking changes. */
+    version: 1;
+    tabs: LayoutTab[];
+}
+/** Branch types that must occupy a section alone, full width. */
+export declare const FULL_WIDTH_BRANCH_TYPES: Set<import("./types.js").BranchType>;
+/** Returns true when a branch is a gallery (file + multiple/asset-list). */
+export declare function isGalleryBranch(branch: Branch): boolean;
+/** Branch types currently unsupported in the Layout Builder. */
+export declare const UNSUPPORTED_BRANCH_TYPES: Set<import("./types.js").BranchType>;
+/** Aliases that are NEVER included in the editor form (handled by other UI). */
+export declare const SYSTEM_ALIASES: Set<string>;
+/** True when the branch is eligible to appear in the layout at all. */
+export declare function isLayoutableBranch(branch: Branch): boolean;
+/** True when the branch must occupy a dedicated full-width section. */
+export declare function isFullWidthBranch(branch: Branch): boolean;
+/** Branches considered SEO fields. Matches the existing rule in entry-editor.tsx. */
+export declare function isSeoBranch(branch: Branch): boolean;
+export declare const layoutFieldSchema: z.ZodObject<{
+    branchId: z.ZodString;
+}, z.core.$strip>;
+export declare const layoutColumnSchema: z.ZodObject<{
+    id: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        branchId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const layoutSectionSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    hideLabel: z.ZodOptional<z.ZodBoolean>;
+    hideBorder: z.ZodOptional<z.ZodBoolean>;
+    collapsible: z.ZodOptional<z.ZodBoolean>;
+    columns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        fields: z.ZodArray<z.ZodObject<{
+            branchId: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const layoutTabSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    sections: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        hideLabel: z.ZodOptional<z.ZodBoolean>;
+        hideBorder: z.ZodOptional<z.ZodBoolean>;
+        collapsible: z.ZodOptional<z.ZodBoolean>;
+        columns: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            fields: z.ZodArray<z.ZodObject<{
+                branchId: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const formLayoutSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    tabs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        sections: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            hideLabel: z.ZodOptional<z.ZodBoolean>;
+            hideBorder: z.ZodOptional<z.ZodBoolean>;
+            collapsible: z.ZodOptional<z.ZodBoolean>;
+            columns: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                fields: z.ZodArray<z.ZodObject<{
+                    branchId: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare function generateDefaultLayout(seed: Seed, opts?: {
+    newId: () => string;
+}): FormLayout;
+export type ValidateLayoutResult = {
+    ok: true;
+    cleaned: FormLayout;
+} | {
+    ok: false;
+    errors: string[];
+    cleaned: FormLayout;
+};
+export declare function validateLayoutAgainstSeed(layout: FormLayout, seed: Seed): ValidateLayoutResult;
+//# sourceMappingURL=seed-layout.d.ts.map

package/dist/seed-layout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-layout.d.ts","sourceRoot":"","sources":["../src/seed-layout.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAO9C,eAAO,MAAM,sBAAsB;;;;;;;;;;;iBAKjC,CAAA;AACF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAErE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;iBAEjB,CAAA;AAChB,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAMjE;;sFAEsF;AACtF,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,WAAW,EAAE,CAAA;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,4CAA4C;IAC5C,OAAO,EAAE,YAAY,EAAE,CAAA;CACxB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,aAAa,EAAE,CAAA;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,+DAA+D;IAC/D,OAAO,EAAE,CAAC,CAAA;IACV,IAAI,EAAE,SAAS,EAAE,CAAA;CAClB;AAMD,iEAAiE;AACjE,eAAO,MAAM,uBAAuB,sCAAwC,CAAA;AAE5E,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAGvD;AAED,gEAAgE;AAChE,eAAO,MAAM,wBAAwB,sCAAoC,CAAA;AAEzE,gFAAgF;AAChF,eAAO,MAAM,cAAc,aAEzB,CAAA;AAEF,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED,uEAAuE;AACvE,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD;AAED,qFAAqF;AACrF,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnD;AAMD,eAAO,MAAM,iBAAiB;;iBAAgE,CAAA;AAC9F,eAAO,MAAM,kBAAkB;;;;;iBAG7B,CAAA;AACF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;iBAO9B,CAAA;AACF,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;iBAI1B,CAAA;AACF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAG3B,CAAA;AAiDF,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,IAAI,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,MAAM,CAAA;CAAE,GAC7B,UAAU,CAmBZ;AAMD,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,GACjC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,UAAU,CAAA;CAAE,CAAA;AAExD,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,UAAU,EAClB,IAAI,EAAE,IAAI,GACT,oBAAoB,CAiEtB"}

package/dist/seed-layout.js

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+import { z } from 'zod';
+import { findBranchById } from './seed-registry.js';
+// ---------------------------------------------------------------------------
+// View config — per-seed, per-view dashboard preferences (KB-S02)
+// ---------------------------------------------------------------------------
+export const kanbanViewConfigSchema = z.object({
+    axisBranchId: z.string().nullable(),
+    sort: z.object({ branchId: z.string(), dir: z.enum(['ASC', 'DESC']) }).nullable(),
+    hiddenColumnValues: z.array(z.string()).optional(),
+    collapsedColumnValues: z.array(z.string()).optional(),
+});
+export const seedViewConfigSchema = z.object({
+    kanban: kanbanViewConfigSchema.optional(),
+}).passthrough();
+// ---------------------------------------------------------------------------
+// Branch-type rules used by both the default generator and the validator.
+// ---------------------------------------------------------------------------
+/** Branch types that must occupy a section alone, full width. */
+export const FULL_WIDTH_BRANCH_TYPES = new Set(['richtext']);
+/** Returns true when a branch is a gallery (file + multiple/asset-list). */
+export function isGalleryBranch(branch) {
+    return branch.type === 'file'
+        && (branch.multiple === true || branch.format === 'asset-list');
+}
+/** Branch types currently unsupported in the Layout Builder. */
+export const UNSUPPORTED_BRANCH_TYPES = new Set(['json']);
+/** Aliases that are NEVER included in the editor form (handled by other UI). */
+export const SYSTEM_ALIASES = new Set([
+    'id', 'slug', 'status', 'created_at', 'updated_at',
+]);
+/** True when the branch is eligible to appear in the layout at all. */
+export function isLayoutableBranch(branch) {
+    if (SYSTEM_ALIASES.has(branch.alias))
+        return false;
+    if (branch.policies?.visibility === 'hidden')
+        return false;
+    if (UNSUPPORTED_BRANCH_TYPES.has(branch.type))
+        return false;
+    return true;
+}
+/** True when the branch must occupy a dedicated full-width section. */
+export function isFullWidthBranch(branch) {
+    return FULL_WIDTH_BRANCH_TYPES.has(branch.type) || isGalleryBranch(branch);
+}
+/** Branches considered SEO fields. Matches the existing rule in entry-editor.tsx. */
+export function isSeoBranch(branch) {
+    return branch.alias.startsWith('meta');
+}
+// ---------------------------------------------------------------------------
+// Zod schema for shape validation
+// ---------------------------------------------------------------------------
+export const layoutFieldSchema = z.object({ branchId: z.string().regex(/^br_[A-Za-z0-9]+$/) });
+export const layoutColumnSchema = z.object({
+    id: z.string().min(1),
+    fields: z.array(layoutFieldSchema),
+});
+export const layoutSectionSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().optional(),
+    hideLabel: z.boolean().optional(),
+    hideBorder: z.boolean().optional(),
+    collapsible: z.boolean().optional(),
+    columns: z.array(layoutColumnSchema).min(1).max(4),
+});
+export const layoutTabSchema = z.object({
+    id: z.string().min(1),
+    label: z.string().min(1).max(60),
+    sections: z.array(layoutSectionSchema).min(1),
+});
+export const formLayoutSchema = z.object({
+    version: z.literal(1),
+    tabs: z.array(layoutTabSchema).min(1).max(8),
+});
+// ---------------------------------------------------------------------------
+// Default layout generator
+// ---------------------------------------------------------------------------
+const DEFAULT_COLUMNS_PER_SECTION = 3;
+const defaultIdFactory = () => crypto.randomUUID();
+function buildSectionsForBranches(branches, newId) {
+    const sections = [];
+    let currentColumns = [];
+    function flushCompact() {
+        if (currentColumns.length === 0)
+            return;
+        sections.push({ id: newId(), columns: currentColumns });
+        currentColumns = [];
+    }
+    for (const branch of branches) {
+        if (isFullWidthBranch(branch)) {
+            flushCompact();
+            sections.push({
+                id: newId(),
+                label: branch.label,
+                hideLabel: true,
+                columns: [{ id: newId(), fields: [{ branchId: branch.id }] }],
+            });
+        }
+        else {
+            currentColumns.push({ id: newId(), fields: [{ branchId: branch.id }] });
+            if (currentColumns.length >= DEFAULT_COLUMNS_PER_SECTION) {
+                flushCompact();
+            }
+        }
+    }
+    flushCompact();
+    if (sections.length === 0) {
+        sections.push({ id: newId(), columns: [{ id: newId(), fields: [] }] });
+    }
+    return sections;
+}
+export function generateDefaultLayout(seed, opts) {
+    const newId = opts?.newId ?? defaultIdFactory;
+    const layoutable = seed.branches.filter(isLayoutableBranch);
+    const seo = layoutable.filter(isSeoBranch);
+    const main = layoutable.filter((b) => !isSeoBranch(b));
+    const dataTab = {
+        id: newId(),
+        label: 'Data',
+        sections: buildSectionsForBranches(main, newId),
+    };
+    const seoTab = {
+        id: newId(),
+        label: 'SEO',
+        sections: buildSectionsForBranches(seo, newId),
+    };
+    return { version: 1, tabs: [dataTab, seoTab] };
+}
+export function validateLayoutAgainstSeed(layout, seed) {
+    // Gracefully handle undefined/null layout, or missing tabs (e.g. from {} placeholder)
+    if (!layout || !Array.isArray(layout.tabs)) {
+        const defaultLayout = generateDefaultLayout(seed);
+        return {
+            ok: false,
+            errors: ['Invalid layout structure: missing tabs'],
+            cleaned: defaultLayout,
+        };
+    }
+    const errors = [];
+    const seenBranchIds = new Set();
+    const cleanedTabs = (layout.tabs ?? []).map((tab) => ({
+        ...tab,
+        sections: (tab?.sections ?? []).map((section) => ({
+            ...section,
+            columns: (section?.columns ?? []).map((col) => ({
+                ...col,
+                fields: (col?.fields ?? []).filter((f) => {
+                    if (!f || typeof f !== 'object' || !('branchId' in f))
+                        return false;
+                    const branch = findBranchById(seed, f.branchId);
+                    if (!branch)
+                        return false;
+                    if (UNSUPPORTED_BRANCH_TYPES.has(branch.type) || SYSTEM_ALIASES.has(branch.alias))
+                        return false;
+                    return true;
+                }),
+            })),
+        })),
+    }));
+    // Duplicate and full-width constraint checks on cleaned layout
+    for (const tab of cleanedTabs) {
+        for (const section of tab.sections ?? []) {
+            const fieldsInSection = [];
+            for (const col of section.columns ?? []) {
+                for (const f of col.fields ?? []) {
+                    const branch = findBranchById(seed, f.branchId);
+                    if (!branch)
+                        continue;
+                    if (seenBranchIds.has(f.branchId)) {
+                        errors.push(`Branch '${branch.alias}' (id=${f.branchId}) appears more than once in the layout.`);
+                    }
+                    else {
+                        seenBranchIds.add(f.branchId);
+                        fieldsInSection.push(branch);
+                    }
+                }
+            }
+            // Full-width branches must occupy a dedicated section
+            const fullWidthInSection = fieldsInSection.filter(isFullWidthBranch);
+            if (fullWidthInSection.length > 0 && fieldsInSection.length > fullWidthInSection.length) {
+                for (const fw of fullWidthInSection) {
+                    errors.push(`Branch '${fw.alias}' (type=${fw.type}) must occupy a dedicated section and cannot share it with other fields.`);
+                }
+            }
+        }
+    }
+    const cleaned = { ...layout, tabs: cleanedTabs };
+    if (errors.length > 0)
+        return { ok: false, errors, cleaned };
+    return { ok: true, cleaned };
+}

package/dist/seed-layout.repository.d.ts

@@ -0,0 +1,22 @@
+import type { FormLayout, SeedViewConfig } from './seed-layout.js';
+export interface SeedLayoutRecord {
+    slug: string;
+    layout: FormLayout;
+    updatedAt: number;
+    updatedBy: string;
+}
+export interface ISeedLayoutRepository {
+    /** Return the stored layout for a seed, or null if none was ever saved. */
+    get(slug: string): Promise<SeedLayoutRecord | null>;
+    /** Return all stored layouts, keyed by slug — used by GET /api/schema to enrich. */
+    getAllAsMap(): Promise<Map<string, FormLayout>>;
+    /** Upsert. `updatedBy` is the writer's user id. */
+    upsert(slug: string, layout: FormLayout, updatedBy: string): Promise<void>;
+    /** Remove the stored row — used by the "Reset" action. */
+    remove(slug: string): Promise<void>;
+    /** Return the per-view config blob for a seed, or null if none was stored. */
+    getViewConfig(slug: string): Promise<SeedViewConfig | null>;
+    /** Upsert the per-view config for a seed. */
+    setViewConfig(slug: string, config: SeedViewConfig, updatedBy: string): Promise<void>;
+}
+//# sourceMappingURL=seed-layout.repository.d.ts.map

package/dist/seed-layout.repository.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seed-layout.repository.d.ts","sourceRoot":"","sources":["../src/seed-layout.repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAElE,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,UAAU,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,WAAW,qBAAqB;IACpC,2EAA2E;IAC3E,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,GAAG,IAAI,CAAC,CAAA;IACnD,oFAAoF;IACpF,WAAW,IAAI,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAA;IAC/C,mDAAmD;IACnD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1E,0DAA0D;IAC1D,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,8EAA8E;IAC9E,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IAC3D,6CAA6C;IAC7C,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACtF"}

package/dist/seed-layout.repository.js

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+export {};