@beechcms/core 0.9.4 → 0.9.5

package/dist/engine/seed-types-generator.js

@@ -0,0 +1,117 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+const HEADER = '// Questo file è generato automaticamente da BeechCMS CLI. Non modificarlo direttamente.\n';
+/** System columns emitted by generateCreateTable — always present, never optional. */
+const SYSTEM_FIELDS = `  id: string\n` +
+    `  slug: string\n` +
+    `  status: 'draft' | 'review' | 'published' | 'archived'\n`;
+const SYSTEM_TIMESTAMPS = `  created_at: number\n` +
+    `  updated_at: number\n`;
+/** slug/alias → PascalCase identifier. 'blog-posts' → 'BlogPosts'. */
+export function pascalCase(input) {
+    return input
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+        .join('');
+}
+function literalUnion(options) {
+    return options.map(o => `'${o.replace(/'/g, "\\'")}'`).join(' | ');
+}
+/** Maps a single Branch to its TypeScript type expression (no optional marker). */
+export function tsTypeForBranch(branch) {
+    switch (branch.type) {
+        case 'number':
+        case 'date':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'json':
+            return 'unknown';
+        case 'text':
+        case 'richtext':
+        case 'file': {
+            const base = branch.type === 'text' && branch.options?.length
+                ? literalUnion(branch.options)
+                : 'string';
+            return branch.type === 'file' && branch.multiple ? `${base}[]` : base;
+        }
+        case 'tags': {
+            const base = branch.options?.length ? `(${literalUnion(branch.options)})` : 'string';
+            return `${base}[]`;
+        }
+        case 'relation':
+            return branch.multiple ? 'string[]' : 'string';
+        case 'repeater': {
+            const inner = (branch.fields ?? [])
+                .map(f => `${propName(f)}${optional(f)}: ${tsTypeForBranch(f)}`)
+                .join('; ');
+            return `Array<{ ${inner} }>`;
+        }
+        default: {
+            // Exhaustiveness guard — fails the build if BranchType gains a member.
+            const _never = branch.type;
+            return _never;
+        }
+    }
+}
+function optional(branch) {
+    return branch.requiredOnCreate ? '' : '?';
+}
+function propName(branch) {
+    // alias is a valid SQL column; quote only if not a plain identifier.
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(branch.alias) ? branch.alias : `'${branch.alias}'`;
+}
+/** Emits one exported interface for a single Seed. */
+export function interfaceForSeed(seed) {
+    const name = pascalCase(seed.slug);
+    const props = seed.branches
+        .map(b => `  ${propName(b)}${optional(b)}: ${tsTypeForBranch(b)}`)
+        .join('\n');
+    return (`export interface ${name} {\n` +
+        SYSTEM_FIELDS +
+        (props ? props + '\n' : '') +
+        SYSTEM_TIMESTAMPS +
+        `}\n`);
+}
+/** `v{version}:{32 hex}` — the exact shape `computeSchemaFingerprint` returns. */
+const FINGERPRINT_RE = /^v\d+:[0-9a-f]{32}$/;
+/**
+ * Pure entry point. Deterministic: sorts seeds by slug for stable diffs.
+ *
+ * The embedded fingerprint is the client's half of the drift check: `@beechcms/client` compares it
+ * against the `X-Schema-Revision` header the API returns and raises an actionable error on a
+ * mismatch, instead of trusting a stale response shape.
+ */
+export function generateSeedTypes(seeds, options = {}) {
+    const sorted = [...seeds].sort((a, b) => a.slug.localeCompare(b.slug));
+    const interfaces = sorted.map(interfaceForSeed).join('\n');
+    const registryProps = sorted
+        .map(s => `  ${propName({ alias: s.slug })}: ${pascalCase(s.slug)}`)
+        .join('\n');
+    const databaseRegistry = `export interface BeechDatabase {\n` +
+        (registryProps ? registryProps + '\n' : '') +
+        `}\n\n` +
+        `export type SeedRegistryTypes = BeechDatabase\n`;
+    return `${HEADER}\n${fingerprintBlock(options.fingerprint)}${interfaces}\n${databaseRegistry}`;
+}
+/**
+ * Emits the fingerprint constant, or nothing.
+ *
+ * The value is interpolated into source, so its shape is verified first: a fingerprint carrying a
+ * quote or a newline would emit a file that does not parse, and the failure would surface in the
+ * consumer's build rather than here.
+ */
+function fingerprintBlock(fingerprint) {
+    if (fingerprint === undefined)
+        return '';
+    if (!FINGERPRINT_RE.test(fingerprint)) {
+        throw new Error(`Refusing to embed '${fingerprint}' as a schema fingerprint: expected the v{n}:{32 hex} form produced by computeSchemaFingerprint().`);
+    }
+    return (`/**\n` +
+        ` * Schema revision these types were generated from. \`@beechcms/client\` compares it against the\n` +
+        ` * \`X-Schema-Revision\` response header; a mismatch means the backend schema moved and this file\n` +
+        ` * must be regenerated with \`beech types generate\`.\n` +
+        ` */\n` +
+        `export const SCHEMA_FINGERPRINT = '${fingerprint}'\n\n`);
+}

package/dist/engine/seed-validation.d.ts

@@ -0,0 +1,30 @@
+import type { Seed } from './types.js';
+/**
+ * Allowed charset for a branch alias. An alias becomes a raw SQL column name in
+ * CREATE TABLE / ADD COLUMN / CREATE INDEX and in SELECT/WHERE/ORDER BY clauses
+ * (see engine.ts), so it MUST be restricted to a safe identifier charset to
+ * prevent DDL/query injection. Exported so the seeds API rename route reuses the
+ * exact same guard — do not inline a divergent copy.
+ */
+export declare const BRANCH_ALIAS_RE: RegExp;
+/**
+ * Allowed charset for a seed slug identifier.
+ * Must consist solely of lowercase ASCII letters, digits, and underscores.
+ * Exported so route handlers and validation functions reuse the exact same guard.
+ */
+export declare const SEED_SLUG_RE: RegExp;
+export declare const SLUG_RE: RegExp;
+export interface SeedValidationIssue {
+    slug: string;
+    messages: string[];
+    fatal: boolean;
+}
+/**
+ * Pure, console-free, throw-free validation of a seed set.
+ * The single seed being created/edited should be validated in the context of
+ * the full active set: call validateSeedDefinitions([...otherActiveSeeds, edited]).
+ */
+export declare function validateSeedDefinitions(seeds: Seed[]): SeedValidationIssue[];
+/** Convenience: true iff no fatal issues. */
+export declare function isSeedSetValid(seeds: Seed[]): boolean;
+//# sourceMappingURL=seed-validation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"seed-validation.d.ts","sourceRoot":"","sources":["../../src/engine/seed-validation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAQtC;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,QAAyB,CAAA;AAErD;;;;GAIG;AACH,eAAO,MAAM,YAAY,QAAiB,CAAA;AAC1C,eAAO,MAAM,OAAO,QAAe,CAAA;AAGnC,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,EAAE,OAAO,CAAA;CACf;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,mBAAmB,EAAE,CA6T5E;AAED,6CAA6C;AAC7C,wBAAgB,cAAc,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAErD"}

package/dist/engine/seed-validation.js

@@ -0,0 +1,329 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+import { AUTOMATION_RESERVED_WORDS } from '../automations/automations-grammar-words.js';
+import { SYSTEM_COLUMNS } from './ddl.js';
+import { sortSeedsByDependencies } from './seed-registry.js';
+import { SQL_RESERVED_WORDS } from './sql-reserved-words.js';
+const BRANCH_ID_RE = /^br_[A-Za-z0-9]+$/;
+/**
+ * Allowed charset for a branch alias. An alias becomes a raw SQL column name in
+ * CREATE TABLE / ADD COLUMN / CREATE INDEX and in SELECT/WHERE/ORDER BY clauses
+ * (see engine.ts), so it MUST be restricted to a safe identifier charset to
+ * prevent DDL/query injection. Exported so the seeds API rename route reuses the
+ * exact same guard — do not inline a divergent copy.
+ */
+export const BRANCH_ALIAS_RE = /^[a-z][a-zA-Z0-9_]*$/;
+/**
+ * Allowed charset for a seed slug identifier.
+ * Must consist solely of lowercase ASCII letters, digits, and underscores.
+ * Exported so route handlers and validation functions reuse the exact same guard.
+ */
+export const SEED_SLUG_RE = /^[a-z0-9_]+$/;
+export const SLUG_RE = SEED_SLUG_RE;
+/**
+ * Pure, console-free, throw-free validation of a seed set.
+ * The single seed being created/edited should be validated in the context of
+ * the full active set: call validateSeedDefinitions([...otherActiveSeeds, edited]).
+ */
+export function validateSeedDefinitions(seeds) {
+    const result = [];
+    // ── Fatal 1: unknown relation targets ────────────────────────────────────
+    const slugSet = new Set(seeds.map(s => s.slug));
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.type === 'relation' && branch.targetSeed) {
+                if (!slugSet.has(branch.targetSeed)) {
+                    messages.push(`branch '${branch.alias}' targets unknown seed '${branch.targetSeed}'`);
+                }
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 2: multi-relation with SET NULL ────────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.type === 'relation' && branch.multiple === true && branch.onDelete === 'SET NULL') {
+                messages.push(`Branch '${branch.alias}': multi-relations cannot use ON DELETE SET NULL. ` +
+                    `Use 'CASCADE' or 'RESTRICT'.`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 3: junction table name collisions / length ─────────────────────
+    {
+        const junctionNames = new Set();
+        for (const seed of seeds) {
+            const messages = [];
+            for (const branch of seed.branches) {
+                if (branch.type !== 'relation' || branch.multiple !== true)
+                    continue;
+                const name = `rel_${seed.slug}_${branch.alias}`;
+                if (name.length > 256) {
+                    messages.push(`Junction table name '${name}' exceeds 256 characters (${name.length})`);
+                }
+                if (junctionNames.has(name)) {
+                    messages.push(`Junction table name collision: '${name}' already used by another seed/branch`);
+                }
+                junctionNames.add(name);
+            }
+            if (messages.length > 0)
+                result.push({ slug: seed.slug, messages, fatal: true });
+        }
+    }
+    // ── Fatal 4: dependency cycles ────────────────────────────────────────────
+    const hasUnknownTargets = result.some(e => e.fatal);
+    if (!hasUnknownTargets) {
+        try {
+            sortSeedsByDependencies(seeds);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const cycleMatch = msg.match(/Cyclic dependency detected among seeds: (.*)/);
+            if (cycleMatch) {
+                const cycleSlugs = cycleMatch[1].split(', ');
+                for (const slug of cycleSlugs) {
+                    result.push({ slug, messages: [msg], fatal: true });
+                }
+            }
+            else {
+                result.push({ slug: '<graph>', messages: [msg], fatal: true });
+            }
+        }
+    }
+    // ── Fatal 5: branch id format / uniqueness ───────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        const idsInSeed = new Set();
+        for (const branch of seed.branches) {
+            if (!branch.id || !BRANCH_ID_RE.test(branch.id)) {
+                messages.push(`branch '${branch.alias}' has invalid id '${branch.id}'. Expected format ^br_[A-Za-z0-9]+$.`);
+            }
+            else if (idsInSeed.has(branch.id)) {
+                messages.push(`duplicate branch id '${branch.id}'`);
+            }
+            if (branch.id)
+                idsInSeed.add(branch.id);
+            // Alias becomes a raw SQL column name — reject anything outside the safe
+            // identifier charset before it can reach DDL/query string interpolation.
+            if (typeof branch.alias !== 'string' || !BRANCH_ALIAS_RE.test(branch.alias)) {
+                messages.push(`branch alias '${branch.alias}' is invalid. Expected format ${BRANCH_ALIAS_RE.source} ` +
+                    `(lowercase letter followed by alphanumeric characters or underscores).`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 6: reserved aliases ─────────────────────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (SYSTEM_COLUMNS.has(branch.alias)) {
+                messages.push(`branch '${branch.alias}' collides with reserved system column. ` +
+                    `System columns (id, slug, status, created_at, updated_at) cannot be used as branch aliases.`);
+            }
+            else if (AUTOMATION_RESERVED_WORDS.has(branch.alias)) {
+                messages.push(`branch '${branch.alias}' uses reserved alias. ` +
+                    `This word is used by the automation template grammar.`);
+            }
+            else if (SQL_RESERVED_WORDS.has(branch.alias.toLowerCase())) {
+                messages.push(`branch '${branch.alias}' uses SQL reserved keyword. ` +
+                    `Please pick a different alias to prevent database errors.`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 10: repeater sub-field constraints ─────────────────────────────
+    {
+        const REPEATER_DISALLOWED_SUBTYPES = new Set(['repeater', 'relation', 'file']);
+        for (const seed of seeds) {
+            const messages = [];
+            for (const branch of seed.branches) {
+                if (branch.type !== 'repeater')
+                    continue;
+                const subIds = new Set();
+                const subAliases = new Set();
+                for (const sub of branch.fields ?? []) {
+                    if (REPEATER_DISALLOWED_SUBTYPES.has(sub.type)) {
+                        messages.push(`branch '${branch.alias}': sub-field '${sub.alias}' has disallowed type '${sub.type}'. ` +
+                            `Repeater sub-fields cannot be 'repeater', 'relation', or 'file' in v1.`);
+                    }
+                    if (!sub.id || !BRANCH_ID_RE.test(sub.id)) {
+                        messages.push(`branch '${branch.alias}': sub-field '${sub.alias}' has invalid id '${sub.id}'. ` +
+                            `Expected format ^br_[A-Za-z0-9]+$.`);
+                    }
+                    else if (subIds.has(sub.id)) {
+                        messages.push(`branch '${branch.alias}': duplicate sub-field id '${sub.id}'`);
+                    }
+                    if (sub.id)
+                        subIds.add(sub.id);
+                    if (typeof sub.alias !== 'string' || !BRANCH_ALIAS_RE.test(sub.alias)) {
+                        messages.push(`branch '${branch.alias}': sub-field alias '${sub.alias}' is invalid. ` +
+                            `Expected format ${BRANCH_ALIAS_RE.source}.`);
+                    }
+                    else if (subAliases.has(sub.alias)) {
+                        messages.push(`branch '${branch.alias}': duplicate sub-field alias '${sub.alias}'`);
+                    }
+                    subAliases.add(sub.alias);
+                }
+            }
+            if (messages.length > 0)
+                result.push({ slug: seed.slug, messages, fatal: true });
+        }
+    }
+    // ── Warning 7: duplicate slug ─────────────────────────────────────────────
+    {
+        const slugsSeen = new Set();
+        for (const seed of seeds) {
+            const messages = [];
+            if (slugsSeen.has(seed.slug)) {
+                messages.push(`duplicate slug "${seed.slug}" — each seed must have a unique slug`);
+            }
+            slugsSeen.add(seed.slug);
+            if (messages.length > 0)
+                result.push({ slug: seed.slug, messages, fatal: false });
+        }
+    }
+    // ── Warning 8: duplicate branch alias within a seed ───────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        const aliasesSeen = new Set();
+        for (const branch of seed.branches) {
+            if (aliasesSeen.has(branch.alias)) {
+                messages.push(`duplicate branch alias "${branch.alias}"`);
+            }
+            aliasesSeen.add(branch.alias);
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: false });
+    }
+    // ── Warning 9: displayNameAlias not in branches ───────────────────────────
+    for (const seed of seeds) {
+        const allAliases = new Set(seed.branches.map(b => b.alias));
+        if (!allAliases.has(seed.displayNameAlias)) {
+            result.push({
+                slug: seed.slug,
+                messages: [`displayNameAlias "${seed.displayNameAlias}" not found in branches`],
+                fatal: false,
+            });
+        }
+    }
+    // ── Fatal 11 / Warning 10: repeater cardinality bounds ───────────────────
+    {
+        for (const seed of seeds) {
+            const fatals = [];
+            const warnings = [];
+            for (const branch of seed.branches) {
+                const hasBounds = branch.minItems !== undefined || branch.maxItems !== undefined;
+                if (!hasBounds)
+                    continue;
+                if (branch.type !== 'repeater') {
+                    warnings.push(`branch '${branch.alias}': minItems/maxItems are ignored on type ` +
+                        `'${branch.type}' (repeater-only).`);
+                    continue;
+                }
+                for (const [key, val] of [['minItems', branch.minItems], ['maxItems', branch.maxItems]]) {
+                    if (val !== undefined && (!Number.isInteger(val) || val < 0)) {
+                        fatals.push(`branch '${branch.alias}': ${key} must be a non-negative integer (got ${val}).`);
+                    }
+                }
+                if (Number.isInteger(branch.minItems) && Number.isInteger(branch.maxItems) &&
+                    branch.minItems > branch.maxItems) {
+                    fatals.push(`branch '${branch.alias}': minItems (${branch.minItems}) must be <= maxItems (${branch.maxItems}).`);
+                }
+            }
+            if (fatals.length > 0)
+                result.push({ slug: seed.slug, messages: fatals, fatal: true });
+            if (warnings.length > 0)
+                result.push({ slug: seed.slug, messages: warnings, fatal: false });
+        }
+    }
+    // ── Fatal 12: displayNameAlias format validation ───────────────────────────
+    for (const seed of seeds) {
+        if (typeof seed.displayNameAlias !== 'string' || !BRANCH_ALIAS_RE.test(seed.displayNameAlias)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `displayNameAlias '${seed.displayNameAlias}' is invalid. Expected format ${BRANCH_ALIAS_RE.source} ` +
+                        `(lowercase letter followed by alphanumeric characters or underscores).`,
+                ],
+                fatal: true,
+            });
+        }
+        else if (SYSTEM_COLUMNS.has(seed.displayNameAlias)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `displayNameAlias '${seed.displayNameAlias}' collides with reserved system column. ` +
+                        `System columns (id, slug, status, created_at, updated_at) cannot be used as displayNameAlias.`,
+                ],
+                fatal: true,
+            });
+        }
+        else if (SQL_RESERVED_WORDS.has(seed.displayNameAlias.toLowerCase())) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `displayNameAlias '${seed.displayNameAlias}' uses SQL reserved keyword. ` +
+                        `Please pick a different alias to prevent database errors.`,
+                ],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 13: retentionDays validation ─────────────────────────────────────
+    for (const seed of seeds) {
+        if (seed.retentionDays !== undefined && (!Number.isInteger(seed.retentionDays) || seed.retentionDays <= 0)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `retentionDays must be a positive integer >= 1 (got ${seed.retentionDays}).`,
+                ],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 14: publicEdit validation ─────────────────────────────────────────
+    for (const seed of seeds) {
+        const messages = [];
+        for (const branch of seed.branches) {
+            if (branch.policies?.publicEdit !== undefined && typeof branch.policies.publicEdit !== 'boolean') {
+                messages.push(`branch '${branch.alias}': policies.publicEdit must be a boolean`);
+            }
+        }
+        if (messages.length > 0)
+            result.push({ slug: seed.slug, messages, fatal: true });
+    }
+    // ── Fatal 15: seed slug format validation ─────────────────────────────────
+    for (const seed of seeds) {
+        if (typeof seed.slug !== 'string' || !SEED_SLUG_RE.test(seed.slug)) {
+            result.push({
+                slug: seed.slug,
+                messages: [
+                    `slug '${seed.slug}' is invalid. Expected format ${SEED_SLUG_RE.source} ` +
+                        `(lowercase letters, numbers, and underscores only).`,
+                ],
+                fatal: true,
+            });
+        }
+    }
+    // ── Fatal 16: softDelete type validation ────────────────────────────────────
+    for (const seed of seeds) {
+        if (seed.softDelete !== undefined && typeof seed.softDelete !== 'boolean') {
+            result.push({
+                slug: seed.slug,
+                messages: [`softDelete must be a boolean (got ${typeof seed.softDelete}).`],
+                fatal: true,
+            });
+        }
+    }
+    return result;
+}
+/** Convenience: true iff no fatal issues. */
+export function isSeedSetValid(seeds) {
+    return validateSeedDefinitions(seeds).every(i => !i.fatal);
+}

package/dist/engine/seeds.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Seed Registry: configurazione degli schemi di contenuto.
+ * In v0.4.0 ogni Seed genera una tabella `content_{slug}` con colonne reali.
+ * `branch.alias` è il nome della colonna SQL.
+ */
+import type { Seed } from './types.js';
+/**
+ * Registro globale dei Seed.
+ * In produzione, questo viene popolato dalle definizioni dell'utente.
+ */
+export declare const SEED_REGISTRY: Record<string, Seed>;
+/**
+ * Registra un set di Seed nel registro globale.
+ */
+export declare function registerSeeds(seeds: Seed[]): void;
+/**
+ * Ritorna il Seed per lo slug dato, o null se non esiste.
+ */
+export declare function getSeed(slug: string): Seed | null;
+//# sourceMappingURL=seeds.d.ts.map

package/dist/engine/seeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"seeds.d.ts","sourceRoot":"","sources":["../../src/engine/seeds.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AAEtC;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,IAAI,CAAM,CAAA;AAErD;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,IAAI,EAAE,QAI1C;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAEjD"}

package/dist/engine/seeds.js

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * Registro globale dei Seed.
+ * In produzione, questo viene popolato dalle definizioni dell'utente.
+ */
+export const SEED_REGISTRY = {};
+/**
+ * Registra un set di Seed nel registro globale.
+ */
+export function registerSeeds(seeds) {
+    seeds.forEach(seed => {
+        SEED_REGISTRY[seed.slug] = seed;
+    });
+}
+/**
+ * Ritorna il Seed per lo slug dato, o null se non esiste.
+ */
+export function getSeed(slug) {
+    return SEED_REGISTRY[slug] ?? null;
+}

package/dist/engine/serialize.d.ts

@@ -0,0 +1,20 @@
+import type { Branch } from './types.js';
+/**
+ * Serializes a value for writing to the DB.
+ * boolean → 0/1 | date → Unix timestamp | json/tags/richtext/repeater → JSON string
+ *
+ * @param branch The branch definition.
+ * @param value The value to serialize.
+ * @returns The serialized DB value (string, number, or null).
+ */
+export declare function serializeForDb(branch: Branch, value: unknown): string | number | null;
+/**
+ * Deserializes a value read from the DB to its API/JS representation.
+ * 0/1 → boolean | Unix timestamp → ISO 8601 | JSON string → object/array
+ *
+ * @param branch The branch definition.
+ * @param value The raw database value.
+ * @returns The deserialized value.
+ */
+export declare function deserializeFromDb(branch: Branch, value: unknown): unknown;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/engine/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/engine/serialize.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,MAAM,EAOP,MAAM,YAAY,CAAC;AAmEpB;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,CAsCrF;AAGD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAmCzE"}