@beechcms/core 0.9.0 → 0.9.1

package/dist/engine/schema-fingerprint.d.ts

@@ -1,73 +0,0 @@
-import type { Branch, Seed } from './types.js';
-/**
- * Bumped ONLY when the projection below or the canonical byte format changes — i.e. when
- * fingerprints computed by two builds are no longer comparable. It is carried in the fingerprint
- * string itself so a version skew reads as a mismatch instead of as an accidental match.
- */
-export declare const SCHEMA_FINGERPRINT_VERSION = 1;
-/** The response-shape-bearing subset of a `Branch`. */
-export interface ContractBranch {
-    alias: string;
-    type: Branch['type'];
-    format?: Branch['format'];
-    multiple?: boolean;
-    options?: string[];
-    requiredOnCreate: boolean;
-    requiredOnUpdate: boolean;
-    targetSeed?: string;
-    /** From `resolvePolicies`, so an explicitly-written default hashes like an omitted one. */
-    visibility: 'full' | 'masked' | 'hidden';
-    publicRead: boolean;
-    publicEdit: boolean;
-    minItems?: number;
-    maxItems?: number;
-    /** Present only when true: the dictionary shape is part of the public contract (`?lang=all`, writes). */
-    localized?: boolean;
-    /** Repeater sub-fields, same projection, recursively. */
-    fields?: ContractBranch[];
-}
-/** The response-shape-bearing subset of a `Seed`. */
-export interface ContractSeed {
-    slug: string;
-    displayNameAlias: string;
-    allowDrafts: boolean;
-    allowPublicRead: boolean;
-    allowPublicPost: boolean;
-    allowPublicEdit: boolean;
-    branches: ContractBranch[];
-}
-/** The exact value that gets canonicalized and hashed. */
-export interface SchemaContract {
-    fingerprintVersion: number;
-    seeds: ContractSeed[];
-}
-/**
- * Reduces seeds to what a response shape depends on.
- *
- * Deliberately EXCLUDED, and each for a reason a future reader must not "fix":
- * - `id` (`br_XX`) — a stable internal handle; it never appears in a payload, and minting order
- *   differs between an environment built by migration and one grown through the dashboard.
- * - `label`, `labelPlural`, `hint`, `dashboard`, `layout` — presentation, never response shape.
- * - `retentionDays`, `onDelete`, `policies.search|filter|sort`, `numberOptions`, `fileOptions`,
- *   `policies.classification|privacy` — behaviour and storage concerns that leave the response
- *   shape identical. (`privacy` DOES change a stored value's encoding, but the API type stays
- *   `string`; drift there is a data concern, not a type concern.)
- * - anything physical (column order, index names) — see the VETO Audit.
- *
- * Seeds are sorted by slug; BRANCH ORDER IS PRESERVED, because it is the declared field order the
- * generated types and the dashboard form both follow.
- */
-export declare function projectSchemaContract(seeds: Seed[]): SchemaContract;
-/**
- * `v{VERSION}:{32 lowercase hex}` — SHA-256 over the canonical JSON of the contract projection,
- * truncated to 128 bits.
- *
- * Truncation is deliberate: this value travels on EVERY public response as `X-Schema-Revision`,
- * and 128 bits of a SHA-256 digest carries no realistic collision risk for a value space of a few
- * hundred schema revisions. It is a revision marker, never a security token.
- *
- * Web Crypto only — the same API the Worker and Node ≥ 18 both expose, as `webhook-crypto.ts`
- * already relies on. `@beechcms/core` gains no dependency.
- */
-export declare function computeSchemaFingerprint(seeds: Seed[]): Promise<string>;
-//# sourceMappingURL=schema-fingerprint.d.ts.map

package/dist/engine/schema-fingerprint.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-fingerprint.d.ts","sourceRoot":"","sources":["../../src/engine/schema-fingerprint.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAE9C;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,IAAI,CAAA;AAE3C,uDAAuD;AACvD,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;IACzB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,gBAAgB,EAAE,OAAO,CAAA;IACzB,gBAAgB,EAAE,OAAO,CAAA;IACzB,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,2FAA2F;IAC3F,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,QAAQ,CAAA;IACxC,UAAU,EAAE,OAAO,CAAA;IACnB,UAAU,EAAE,OAAO,CAAA;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,yGAAyG;IACzG,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,yDAAyD;IACzD,MAAM,CAAC,EAAE,cAAc,EAAE,CAAA;CAC1B;AAED,qDAAqD;AACrD,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,gBAAgB,EAAE,MAAM,CAAA;IACxB,WAAW,EAAE,OAAO,CAAA;IACpB,eAAe,EAAE,OAAO,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;IACxB,eAAe,EAAE,OAAO,CAAA;IACxB,QAAQ,EAAE,cAAc,EAAE,CAAA;CAC3B;AAED,0DAA0D;AAC1D,MAAM,WAAW,cAAc;IAC7B,kBAAkB,EAAE,MAAM,CAAA;IAC1B,KAAK,EAAE,YAAY,EAAE,CAAA;CACtB;AAyBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,cAAc,CAenE;AAMD;;;;;;;;;;GAUG;AACH,wBAAsB,wBAAwB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAI7E"}

package/dist/engine/schema-fingerprint.js

@@ -1,97 +0,0 @@
-// SPDX-License-Identifier: MIT
-// Copyright (c) 2024–2026 Flavio De Musso
-/**
- * @module engine/schema-fingerprint
- * A deterministic name for "the shape this API answers in".
- *
- * Computed from live seed definitions (`introspectSeedDefinitions`), embedded in generated client
- * types at build time (sprint 3), returned on every public response as `X-Schema-Revision`
- * (sprint 4), and compared by the client at request time (sprint 5). Both ends MUST compute it
- * with this function — two implementations would be free to disagree, and a drift detector whose
- * ends disagree is worse than none.
- *
- * What is hashed is a CONTRACT PROJECTION, not the whole seed definition: labels, hints, dashboard
- * icons and layout cannot change a single response byte, and hashing them would fire a hard
- * `BeechProblem` in someone else's production client over a typo fix.
- */
-import { canonicalStringify } from '../common/canonical-json.js';
-import { resolvePolicies } from './policies.js';
-/**
- * Bumped ONLY when the projection below or the canonical byte format changes — i.e. when
- * fingerprints computed by two builds are no longer comparable. It is carried in the fingerprint
- * string itself so a version skew reads as a mismatch instead of as an accidental match.
- */
-export const SCHEMA_FINGERPRINT_VERSION = 1;
-function projectBranch(branch) {
-    const policies = resolvePolicies(branch);
-    return {
-        alias: branch.alias,
-        type: branch.type,
-        ...(branch.format !== undefined ? { format: branch.format } : {}),
-        ...(branch.multiple !== undefined ? { multiple: branch.multiple } : {}),
-        // Option order is the contract: it is the order a select renders and a union type lists.
-        ...(branch.options !== undefined ? { options: [...branch.options] } : {}),
-        requiredOnCreate: branch.requiredOnCreate ?? false,
-        requiredOnUpdate: branch.requiredOnUpdate ?? false,
-        ...(branch.targetSeed !== undefined ? { targetSeed: branch.targetSeed } : {}),
-        visibility: policies.visibility,
-        publicRead: policies.public,
-        publicEdit: policies.publicEdit,
-        ...(branch.minItems !== undefined ? { minItems: branch.minItems } : {}),
-        ...(branch.maxItems !== undefined ? { maxItems: branch.maxItems } : {}),
-        // Spread only when true so every schema without localized branches keeps its fingerprint.
-        ...(branch.localized === true ? { localized: true } : {}),
-        ...(branch.fields ? { fields: branch.fields.map(projectBranch) } : {}),
-    };
-}
-/**
- * Reduces seeds to what a response shape depends on.
- *
- * Deliberately EXCLUDED, and each for a reason a future reader must not "fix":
- * - `id` (`br_XX`) — a stable internal handle; it never appears in a payload, and minting order
- *   differs between an environment built by migration and one grown through the dashboard.
- * - `label`, `labelPlural`, `hint`, `dashboard`, `layout` — presentation, never response shape.
- * - `retentionDays`, `onDelete`, `policies.search|filter|sort`, `numberOptions`, `fileOptions`,
- *   `policies.classification|privacy` — behaviour and storage concerns that leave the response
- *   shape identical. (`privacy` DOES change a stored value's encoding, but the API type stays
- *   `string`; drift there is a data concern, not a type concern.)
- * - anything physical (column order, index names) — see the VETO Audit.
- *
- * Seeds are sorted by slug; BRANCH ORDER IS PRESERVED, because it is the declared field order the
- * generated types and the dashboard form both follow.
- */
-export function projectSchemaContract(seeds) {
-    return {
-        fingerprintVersion: SCHEMA_FINGERPRINT_VERSION,
-        seeds: [...seeds]
-            .sort((a, b) => a.slug.localeCompare(b.slug))
-            .map(seed => ({
-            slug: seed.slug,
-            displayNameAlias: seed.displayNameAlias,
-            allowDrafts: seed.allowDrafts ?? false,
-            allowPublicRead: seed.allowPublicRead ?? false,
-            allowPublicPost: seed.allowPublicPost ?? false,
-            allowPublicEdit: seed.allowPublicEdit ?? false,
-            branches: seed.branches.map(projectBranch),
-        })),
-    };
-}
-function toHex(buffer) {
-    return Array.from(new Uint8Array(buffer), byte => byte.toString(16).padStart(2, '0')).join('');
-}
-/**
- * `v{VERSION}:{32 lowercase hex}` — SHA-256 over the canonical JSON of the contract projection,
- * truncated to 128 bits.
- *
- * Truncation is deliberate: this value travels on EVERY public response as `X-Schema-Revision`,
- * and 128 bits of a SHA-256 digest carries no realistic collision risk for a value space of a few
- * hundred schema revisions. It is a revision marker, never a security token.
- *
- * Web Crypto only — the same API the Worker and Node ≥ 18 both expose, as `webhook-crypto.ts`
- * already relies on. `@beechcms/core` gains no dependency.
- */
-export async function computeSchemaFingerprint(seeds) {
-    const bytes = new TextEncoder().encode(canonicalStringify(projectSchemaContract(seeds)));
-    const digest = await crypto.subtle.digest('SHA-256', bytes);
-    return `v${SCHEMA_FINGERPRINT_VERSION}:${toHex(digest).slice(0, 32)}`;
-}

package/dist/engine/schema-mutator.d.ts

@@ -1,26 +0,0 @@
-/** Executes additive schema DDL against the live database and introspects columns.
- *  Implemented by D1SchemaMutator in apps/api/src/shared/schema-mutator.d1.ts.
- *  This is the ONLY sanctioned channel for runtime DDL — handlers never touch env.DB. */
-export interface ISchemaMutator {
-    /** Column names currently on a table, or null if the table does not exist. */
-    getColumns(table: string): Promise<Set<string> | null>;
-    /** Runs the given DDL statements in order as a single D1 batch.
-     *  All statements must be additive (CREATE … IF NOT EXISTS / ALTER … ADD COLUMN /
-     *  CREATE INDEX IF NOT EXISTS). Throws on the first failing statement. */
-    execDdl(statements: string[]): Promise<void>;
-    /** `DROP TABLE IF EXISTS {table}`. */
-    dropTable(table: string): Promise<void>;
-    /** `ALTER TABLE {table} DROP COLUMN {column}`. */
-    dropColumn(table: string, column: string): Promise<void>;
-    /** `ALTER TABLE {table} RENAME COLUMN {from} TO {to}`. */
-    renameColumn(table: string, from: string, to: string): Promise<void>;
-    /** Runs a multi-statement destructive batch atomically (FTS rebuild,
-     *  type-change column rebuild, full type drop). The caller assembles the
-     *  statements; the impl validates identifiers and runs them as one D1 batch. */
-    execDestructive(statements: string[]): Promise<void>;
-    /** Reads all rows from a table for the specified columns only.
-     *  Used before DROP TABLE to collect R2 keys for media cleanup.
-     *  All identifiers are validated against `^[A-Za-z0-9_]+$`. */
-    fetchRows(table: string, columns: string[]): Promise<Record<string, unknown>[]>;
-}
-//# sourceMappingURL=schema-mutator.d.ts.map

package/dist/engine/schema-mutator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"schema-mutator.d.ts","sourceRoot":"","sources":["../../src/engine/schema-mutator.ts"],"names":[],"mappings":"AAGA;;yFAEyF;AACzF,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,CAAA;IACtD;;8EAE0E;IAC1E,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAS5C,sCAAsC;IACtC,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACvC,kDAAkD;IAClD,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxD,0DAA0D;IAC1D,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACpE;;oFAEgF;IAChF,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEpD;;mEAE+D;IAC/D,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,CAAA;CAChF"}

package/dist/engine/schema-mutator.js

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

package/dist/engine/seed-ddl-destructive.d.ts

@@ -1,40 +0,0 @@
-import type { Seed, BranchType } from './types.js';
-/**
- * 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 declare function generateDropTable(seed: Seed): string[];
-/**
- * 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 declare function generateDropColumn(seed: Seed, alias: string): string[];
-/**
- * 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 declare function generateRenameColumn(seed: Seed, fromAlias: string, toAlias: string): string[];
-/**
- * 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 declare function planFtsRebuild(seed: Seed): string[];
-export interface RetypeColumnPlan {
-    statements: string[];
-    ftsRebuildNeeded: boolean;
-}
-/**
- * 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 declare function planRetypeColumn(seed: Seed, alias: string, newType: BranchType, updatedSeed: Seed): RetypeColumnPlan;
-//# sourceMappingURL=seed-ddl-destructive.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"seed-ddl-destructive.d.ts","sourceRoot":"","sources":["../../src/engine/seed-ddl-destructive.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAU,UAAU,EAAE,MAAM,YAAY,CAAA;AAkC1D;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAgBtD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAgBtE;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ7F;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE,CAiBnD;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,gBAAgB,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,UAAU,EACnB,WAAW,EAAE,IAAI,GAChB,gBAAgB,CAyClB"}

package/dist/engine/seed-ddl-destructive.js

@@ -1,149 +0,0 @@
-// 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/engine/seed-ddl.d.ts

@@ -1,40 +0,0 @@
-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/engine/seed-ddl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"seed-ddl.d.ts","sourceRoot":"","sources":["../../src/engine/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/engine/seed-ddl.js

@@ -1,100 +0,0 @@
-// 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/engine/seed-registry.d.ts

@@ -1,71 +0,0 @@
-import type { Seed, Branch } from './types.js';
-export interface ISeedRegistry {
-    /**
-     * Returns all seeds as a flat array, preserving insertion order.
-     * Decouples callers from the internal storage shape so the registry
-     * implementation can change without touching every route handler.
-     */
-    all(): Seed[];
-    /**
-     * Returns the seed with the given slug, or null if not found.
-     * Provides a single lookup point that can be overridden in tests
-     * without rebuilding the full registry object.
-     */
-    get(slug: string): Seed | null;
-    /**
-     * Returns seeds that are visible in the dashboard sidebar.
-     * A seed is visible when dashboard.hidden is not explicitly true.
-     * Eliminates the seeds.filter(s => !s.dashboard?.hidden) pattern
-     * that would otherwise be duplicated across route handlers.
-     */
-    visibleInDashboard(): Seed[];
-    /**
-     * Returns seeds that have allowPublicRead enabled.
-     * Eliminates the seeds.filter(s => s.allowPublicRead) pattern.
-     */
-    publicReadable(): Seed[];
-    /**
-     * Returns seeds that have the draft workflow enabled.
-     * Eliminates the seeds.filter(s => s.allowDrafts) pattern.
-     */
-    draftEnabled(): Seed[];
-}
-export declare class SeedRegistry implements ISeedRegistry {
-    private readonly seedMap;
-    private readonly orderedSeeds;
-    constructor(seeds: Seed[]);
-    all(): Seed[];
-    get(slug: string): Seed | null;
-    visibleInDashboard(): Seed[];
-    publicReadable(): Seed[];
-    draftEnabled(): Seed[];
-}
-/**
- * Named subclass of SeedRegistry for use in test suites.
- * Gives tests a semantic name without requiring any dependency on factory.ts.
- */
-export declare class InMemorySeedRegistry extends SeedRegistry {
-}
-/** Finds a branch by its stable id within a Seed. Returns null if not found. */
-export declare function findBranchById(seed: Seed, id: string): Branch | null;
-/**
- * Returns the next free branch id for a seed in the form `br_NN` (zero-padded to 2,
- * growing as needed). Scans existing ids, never reuses a number already present —
- * even if a branch was removed, its id is not recycled (ids must be globally stable
- * for the life of the seed so layouts/automations/FTS triggers never collide).
- */
-export declare function nextBranchId(seed: Pick<Seed, 'branches'>): string;
-/**
- * Returns the input seeds reordered so that every seed appears AFTER all the
- * seeds it depends on (its `relation` branch targets). Pure function — does
- * not read from any global registry.
- *
- * Uses Kahn's algorithm (BFS on in-degree) for cycle detection and topological
- * ordering. Sprint 3 (CLI / migration runner) consumes this to create tables in
- * the correct order without disabling SQLite FK constraints.
- *
- * @throws {Error} When a relation targets an unknown slug not in `seeds`.
- * @throws {Error} When a cyclic dependency is detected, listing involved slugs.
- */
-export declare function sortSeedsByDependencies(seeds: ReadonlyArray<Seed>): Seed[];
-//# sourceMappingURL=seed-registry.d.ts.map

package/dist/engine/seed-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"seed-registry.d.ts","sourceRoot":"","sources":["../../src/engine/seed-registry.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AAI9C,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,GAAG,IAAI,IAAI,EAAE,CAAA;IAEb;;;;OAIG;IACH,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAAA;IAE9B;;;;;OAKG;IACH,kBAAkB,IAAI,IAAI,EAAE,CAAA;IAE5B;;;OAGG;IACH,cAAc,IAAI,IAAI,EAAE,CAAA;IAExB;;;OAGG;IACH,YAAY,IAAI,IAAI,EAAE,CAAA;CACvB;AAID,qBAAa,YAAa,YAAW,aAAa;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAmB;IAC3C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAQ;IAErC,YAAY,KAAK,EAAE,IAAI,EAAE,EAgCxB;IAED,GAAG,IAAI,IAAI,EAAE,CAEZ;IAED,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAE7B;IAED,kBAAkB,IAAI,IAAI,EAAE,CAE3B;IAED,cAAc,IAAI,IAAI,EAAE,CAEvB;IAED,YAAY,IAAI,IAAI,EAAE,CAErB;CACF;AAED;;;GAGG;AACH,qBAAa,oBAAqB,SAAQ,YAAY;CAAG;AAEzD,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,MAAM,CAQjE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,aAAa,CAAC,IAAI,CAAC,GAAG,IAAI,EAAE,CA0F1E"}