@beechcms/core 0.8.0 → 0.9.0

package/dist/scheduler.stub.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+export class NoOpScheduler {
+    waitUntil(_promise) {
+        // intentionally empty
+    }
+}

package/dist/schema/canonical.d.ts

@@ -0,0 +1,15 @@
+import type { BeechSchemaManifest } from './manifest.types.js';
+/**
+ * Thrown when a manifest carries a value that cannot survive a JSON round-trip.
+ * Re-exported under its historical name: it is the SAME class object as
+ * `CanonicalSerializationError`, so existing `instanceof` checks keep working.
+ */
+export { CanonicalSerializationError as ManifestSerializationError } from '../common/canonical-json.js';
+/**
+ * Serializes a manifest to its canonical form: seeds sorted by slug, keys sorted, two-space
+ * indentation, trailing newline. Stable across authoring order and across key insertion order.
+ */
+export declare function toCanonicalJson(manifest: BeechSchemaManifest): string;
+/** Parses canonical JSON back into a manifest, refusing an unknown format version. */
+export declare function fromCanonicalJson(json: string): BeechSchemaManifest;
+//# sourceMappingURL=canonical.d.ts.map

package/dist/schema/canonical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonical.d.ts","sourceRoot":"","sources":["../../src/schema/canonical.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAE9D;;;;GAIG;AACH,OAAO,EAAE,2BAA2B,IAAI,0BAA0B,EAAE,MAAM,6BAA6B,CAAA;AAEvG;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CAGrE;AAED,sFAAsF;AACtF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,CASnE"}

package/dist/schema/canonical.js

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * @module schema/canonical
+ * Deterministic serialization of a manifest. The bytes produced here are the input the schema
+ * fingerprint hashes, so this format is a compatibility surface: changing it invalidates every
+ * already-published client. Treat it as frozen.
+ *
+ * The serializer itself moved to `common/canonical-json.ts` in sprint 2 so the Worker-side
+ * fingerprint can share it without importing this authoring-only module.
+ */
+import { canonicalStringify } from '../common/canonical-json.js';
+import { MANIFEST_VERSION } from './manifest.types.js';
+/**
+ * Thrown when a manifest carries a value that cannot survive a JSON round-trip.
+ * Re-exported under its historical name: it is the SAME class object as
+ * `CanonicalSerializationError`, so existing `instanceof` checks keep working.
+ */
+export { CanonicalSerializationError as ManifestSerializationError } from '../common/canonical-json.js';
+/**
+ * Serializes a manifest to its canonical form: seeds sorted by slug, keys sorted, two-space
+ * indentation, trailing newline. Stable across authoring order and across key insertion order.
+ */
+export function toCanonicalJson(manifest) {
+    const seeds = [...manifest.seeds].sort((a, b) => a.slug.localeCompare(b.slug));
+    return canonicalStringify({ version: manifest.version, seeds });
+}
+/** Parses canonical JSON back into a manifest, refusing an unknown format version. */
+export function fromCanonicalJson(json) {
+    const parsed = JSON.parse(json);
+    if (parsed.version !== MANIFEST_VERSION) {
+        throw new Error(`Unsupported manifest version ${String(parsed.version)}; this build understands ${MANIFEST_VERSION}.`);
+    }
+    if (!Array.isArray(parsed.seeds))
+        throw new Error('Manifest is missing a `seeds` array.');
+    return { version: MANIFEST_VERSION, seeds: parsed.seeds };
+}

package/dist/schema/define.d.ts

@@ -0,0 +1,42 @@
+import type { BeechSchemaManifest, FieldGroup, ManifestBranch, ManifestSeed } from './manifest.types.js';
+/** A field bundle, or the fields themselves, as accepted by `defineSeed`. */
+type BranchInput = ManifestBranch | FieldGroup;
+/**
+ * Declares the root manifest. Seeds are stored in authoring order here; canonical ordering is
+ * applied by `toCanonicalJson`, so a reordered manifest file produces byte-identical canonical JSON.
+ */
+export declare function defineSchema(input: {
+    seeds: ManifestSeed[];
+}): BeechSchemaManifest;
+/**
+ * Declares one content type, flattening any `defineGroup()` bundles into the branch list.
+ * Branch ORDER is preserved: it is the physical column order `planCreateSeed` will emit.
+ */
+export declare function defineSeed(input: Omit<ManifestSeed, 'branches'> & {
+    branches: BranchInput[];
+}): ManifestSeed;
+/** Declares a reusable field bundle. Expanded at author time by `defineSeed`; never persisted. */
+export declare function defineGroup(name: string, branches: ManifestBranch[]): FieldGroup;
+/**
+ * Typed field constructors. `relation` and `repeater` narrow their input because the engine treats
+ * `targetSeed` / `fields` as required for those types — making the compiler enforce what
+ * `validateSeedDefinitions` would otherwise only catch at apply time.
+ */
+export declare const defineField: {
+    readonly text: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly number: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly boolean: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly json: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly date: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly richtext: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly file: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly tags: (input: Omit<ManifestBranch, "type">) => ManifestBranch;
+    readonly relation: (input: Omit<ManifestBranch, "type" | "targetSeed"> & {
+        targetSeed: string;
+    }) => ManifestBranch;
+    readonly repeater: (input: Omit<ManifestBranch, "type" | "fields"> & {
+        fields: ManifestBranch[];
+    }) => ManifestBranch;
+};
+export {};
+//# sourceMappingURL=define.d.ts.map

package/dist/schema/define.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define.d.ts","sourceRoot":"","sources":["../../src/schema/define.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,mBAAmB,EACnB,UAAU,EACV,cAAc,EACd,YAAY,EACb,MAAM,qBAAqB,CAAA;AAE5B,6EAA6E;AAC7E,KAAK,WAAW,GAAG,cAAc,GAAG,UAAU,CAAA;AAM9C;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE;IAAE,KAAK,EAAE,YAAY,EAAE,CAAA;CAAE,GAAG,mBAAmB,CAElF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,GAAG;IAAE,QAAQ,EAAE,WAAW,EAAE,CAAA;CAAE,GAClE,YAAY,CAOd;AAED,kGAAkG;AAClG,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,EAAE,GAAG,UAAU,CAEhF;AAMD;;;;GAIG;AACH,eAAO,MAAM,WAAW;2BARP,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;6BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;8BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;2BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;2BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;+BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;2BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;2BAA7C,IAAI,CAAC,cAAc,EAAE,MAAM,CAAC,KAAG,cAAc;+BAkBnD,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,YAAY,CAAC,GAAG;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE,KAC1E,cAAc;+BAER,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,QAAQ,CAAC,GAAG;QAAE,MAAM,EAAE,cAAc,EAAE,CAAA;KAAE,KAC5E,cAAc;CACT,CAAA"}

package/dist/schema/define.js

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * @module schema/define
+ * Authoring DSL for `beech.schema.ts`. Pure, allocation-only helpers: they give the author
+ * inference and autocomplete, and they never validate, throw, or touch I/O.
+ */
+import { MANIFEST_VERSION } from './manifest.types.js';
+function isFieldGroup(input) {
+    return Array.isArray(input.branches);
+}
+/**
+ * Declares the root manifest. Seeds are stored in authoring order here; canonical ordering is
+ * applied by `toCanonicalJson`, so a reordered manifest file produces byte-identical canonical JSON.
+ */
+export function defineSchema(input) {
+    return { version: MANIFEST_VERSION, seeds: input.seeds };
+}
+/**
+ * Declares one content type, flattening any `defineGroup()` bundles into the branch list.
+ * Branch ORDER is preserved: it is the physical column order `planCreateSeed` will emit.
+ */
+export function defineSeed(input) {
+    const branches = [];
+    for (const item of input.branches) {
+        if (isFieldGroup(item))
+            branches.push(...item.branches);
+        else
+            branches.push(item);
+    }
+    return { ...input, branches };
+}
+/** Declares a reusable field bundle. Expanded at author time by `defineSeed`; never persisted. */
+export function defineGroup(name, branches) {
+    return { name, branches };
+}
+function field(type) {
+    return (input) => ({ ...input, type });
+}
+/**
+ * Typed field constructors. `relation` and `repeater` narrow their input because the engine treats
+ * `targetSeed` / `fields` as required for those types — making the compiler enforce what
+ * `validateSeedDefinitions` would otherwise only catch at apply time.
+ */
+export const defineField = {
+    text: field('text'),
+    number: field('number'),
+    boolean: field('boolean'),
+    json: field('json'),
+    date: field('date'),
+    richtext: field('richtext'),
+    file: field('file'),
+    tags: field('tags'),
+    relation: (input) => ({ ...input, type: 'relation' }),
+    repeater: (input) => ({ ...input, type: 'repeater' }),
+};

package/dist/schema/emit.d.ts

@@ -0,0 +1,14 @@
+import type { BeechSchemaManifest } from './manifest.types.js';
+/**
+ * Emits the full module source for a `beech.schema.ts`.
+ *
+ * Seeds are sorted by slug so two exports of the same database are byte-identical and a Git diff
+ * shows schema change only. `version` is NOT passed to `defineSchema` — the DSL adds it, and an
+ * excess property would fail the consumer's own typecheck.
+ *
+ * @throws CanonicalSerializationError when a seed carries a value that cannot survive a JSON
+ * round-trip. That can only happen if a non-serializable value reached the `seeds` table, which is
+ * a corrupt-state fault worth surfacing, not worth silently dropping.
+ */
+export declare function emitManifestModule(manifest: BeechSchemaManifest): string;
+//# sourceMappingURL=emit.d.ts.map

package/dist/schema/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../../src/schema/emit.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAU9D;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,CASxE"}

package/dist/schema/emit.js

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * @module schema/emit
+ * Renders a manifest as the source of a `beech.schema.ts` module — the inverse of the authoring DSL.
+ *
+ * The seed payload is embedded as the FROZEN canonical JSON literal (sprint 1's serializer), not as
+ * a tree of `defineField.*` calls. Three reasons a future reader must not "improve" this:
+ *  1. a call-tree emitter is a second serializer for the manifest shape, free to drift from
+ *     `define.ts` the moment a branch type is added;
+ *  2. the bytes here must match what `toCanonicalJson` produces, because that is what the validator
+ *     and the diff compare — one format, one producer;
+ *  3. a JSON object literal IS a valid TypeScript expression, so the emitted file typechecks in the
+ *     consumer's project with zero extra machinery.
+ *
+ * A hand-authored manifest using the full DSL round-trips through this emitter unchanged in meaning:
+ * `defineSchema`/`defineSeed`/`defineField` all erase to the same `BeechSchemaManifest`.
+ */
+import { canonicalStringify } from '../common/canonical-json.js';
+/** Header written at the top of every exported manifest. */
+const HEADER = `// Generated by \`beech schema export\` from live D1 state.\n` +
+    `//\n` +
+    `// This file is DESIRED STATE, not runtime authority: the Worker never imports it and no deploy\n` +
+    `// applies it. Edit it, review the diff in Git, then reconcile with \`beech schema plan\` /\n` +
+    `// \`beech schema apply\`. Re-export at any time to refresh the snapshot.\n`;
+/**
+ * Emits the full module source for a `beech.schema.ts`.
+ *
+ * Seeds are sorted by slug so two exports of the same database are byte-identical and a Git diff
+ * shows schema change only. `version` is NOT passed to `defineSchema` — the DSL adds it, and an
+ * excess property would fail the consumer's own typecheck.
+ *
+ * @throws CanonicalSerializationError when a seed carries a value that cannot survive a JSON
+ * round-trip. That can only happen if a non-serializable value reached the `seeds` table, which is
+ * a corrupt-state fault worth surfacing, not worth silently dropping.
+ */
+export function emitManifestModule(manifest) {
+    const seeds = [...manifest.seeds].sort((a, b) => a.slug.localeCompare(b.slug));
+    const literal = canonicalStringify({ seeds }).trimEnd();
+    return (`${HEADER}\n` +
+        `import { defineSchema } from '@beechcms/core/schema'\n\n` +
+        `export default defineSchema(${literal})\n`);
+}

package/dist/schema/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @module schema
+ * Authoring surface for `beech.schema.ts`. Imported by authoring tools and the CLI — NEVER by the
+ * Worker, which is why this module is a separate subpath and is absent from `src/index.ts`.
+ */
+export * from './manifest.types.js';
+export * from './define.js';
+export * from './canonical.js';
+export * from './manifest-seeds.js';
+export * from './manifest-validation.js';
+export * from './emit.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schema/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AAEH,cAAc,qBAAqB,CAAA;AACnC,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,qBAAqB,CAAA;AACnC,cAAc,0BAA0B,CAAA;AACxC,cAAc,WAAW,CAAA"}

package/dist/schema/index.js

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * @module schema
+ * Authoring surface for `beech.schema.ts`. Imported by authoring tools and the CLI — NEVER by the
+ * Worker, which is why this module is a separate subpath and is absent from `src/index.ts`.
+ */
+export * from './manifest.types.js';
+export * from './define.js';
+export * from './canonical.js';
+export * from './manifest-seeds.js';
+export * from './manifest-validation.js';
+export * from './emit.js';

package/dist/schema/manifest-seeds.d.ts

@@ -0,0 +1,12 @@
+import type { BeechSchemaManifest } from './manifest.types.js';
+import type { Seed } from '../engine/types.js';
+/** Manifest → engine `Seed[]`, ready for `validateSeedDefinitions` or an MCP plan candidate. */
+export declare function manifestToSeeds(manifest: BeechSchemaManifest): Seed[];
+/**
+ * Engine `Seed[]` → manifest, for a future `beech schema export`.
+ *
+ * `layout` is stripped: it is server-populated presentation state, not schema. Seeds are sorted by
+ * slug so an export is diffable; branch order is preserved because it is the physical column order.
+ */
+export declare function seedsToManifest(seeds: Seed[]): BeechSchemaManifest;
+//# sourceMappingURL=manifest-seeds.d.ts.map

package/dist/schema/manifest-seeds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-seeds.d.ts","sourceRoot":"","sources":["../../src/schema/manifest-seeds.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAgC,MAAM,qBAAqB,CAAA;AAC5F,OAAO,KAAK,EAAU,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAuBtD,gGAAgG;AAChG,wBAAgB,eAAe,CAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,EAAE,CAKrE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,mBAAmB,CAMlE"}

package/dist/schema/manifest-seeds.js

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * @module schema/manifest-seeds
+ * Bridges the manifest shape and the engine's `Seed` shape, in both directions.
+ */
+import { nextBranchId } from '../engine/seeds/seed-registry.js';
+import { MANIFEST_VERSION } from './manifest.types.js';
+/**
+ * Fills in ids for branches authored without one, in declaration order.
+ *
+ * These ids are AUTHORING-LOCAL and non-authoritative — they exist so `validateSeedDefinitions`,
+ * which fatals on a missing id, has a complete `Seed` to check. NEVER send this output to plan/apply:
+ * a minted id looks authoritative to the server and shadows the stored one. The CLI sends the raw
+ * manifest seeds instead, so `resolveCandidateIds()` matches stored ids by alias.
+ */
+function withBranchIds(branches) {
+    const accumulated = [];
+    for (const branch of branches) {
+        const resolved = {
+            ...branch,
+            id: branch.id ?? nextBranchId({ branches: accumulated }),
+            ...(branch.fields ? { fields: withBranchIds(branch.fields) } : {}),
+        };
+        accumulated.push(resolved);
+    }
+    return accumulated;
+}
+/** Manifest → engine `Seed[]`, ready for `validateSeedDefinitions` or an MCP plan candidate. */
+export function manifestToSeeds(manifest) {
+    return manifest.seeds.map((seed) => ({
+        ...seed,
+        branches: withBranchIds(seed.branches),
+    }));
+}
+/**
+ * Engine `Seed[]` → manifest, for a future `beech schema export`.
+ *
+ * `layout` is stripped: it is server-populated presentation state, not schema. Seeds are sorted by
+ * slug so an export is diffable; branch order is preserved because it is the physical column order.
+ */
+export function seedsToManifest(seeds) {
+    const sorted = [...seeds].sort((a, b) => a.slug.localeCompare(b.slug));
+    return {
+        version: MANIFEST_VERSION,
+        seeds: sorted.map(({ layout: _layout, ...seed }) => seed),
+    };
+}

package/dist/schema/manifest-validation.d.ts

@@ -0,0 +1,13 @@
+import type { SeedValidationIssue } from '../engine/seeds/seed-validation.js';
+import type { BeechSchemaManifest } from './manifest.types.js';
+/**
+ * Validates a manifest end to end:
+ *  1. format version is one this build understands;
+ *  2. every value survives canonical serialization (no callbacks or executable code persisted);
+ *  3. the derived `Seed[]` passes the engine's whole-set validation — including cross-seed relation
+ *     targets, which is exactly why this is a manifest-level and not a seed-level function.
+ *
+ * Returns issues; never throws. A caller decides whether a non-fatal issue blocks.
+ */
+export declare function validateManifest(manifest: BeechSchemaManifest): SeedValidationIssue[];
+//# sourceMappingURL=manifest-validation.d.ts.map

package/dist/schema/manifest-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-validation.d.ts","sourceRoot":"","sources":["../../src/schema/manifest-validation.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oCAAoC,CAAA;AAI7E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAE9D;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,mBAAmB,GAAG,mBAAmB,EAAE,CAqBrF"}

package/dist/schema/manifest-validation.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * @module schema/manifest-validation
+ * Whole-manifest validation. Reuses the engine's `validateSeedDefinitions` rather than
+ * reimplementing it: a manifest that passes here is a candidate set the API would also accept.
+ */
+import { validateSeedDefinitions } from '../engine/seeds/seed-validation.js';
+import { MANIFEST_VERSION } from './manifest.types.js';
+import { toCanonicalJson, ManifestSerializationError } from './canonical.js';
+import { manifestToSeeds } from './manifest-seeds.js';
+/**
+ * Validates a manifest end to end:
+ *  1. format version is one this build understands;
+ *  2. every value survives canonical serialization (no callbacks or executable code persisted);
+ *  3. the derived `Seed[]` passes the engine's whole-set validation — including cross-seed relation
+ *     targets, which is exactly why this is a manifest-level and not a seed-level function.
+ *
+ * Returns issues; never throws. A caller decides whether a non-fatal issue blocks.
+ */
+export function validateManifest(manifest) {
+    if (manifest.version !== MANIFEST_VERSION) {
+        return [{
+                slug: '*',
+                fatal: true,
+                messages: [
+                    `unsupported manifest version ${String(manifest.version)}; this build understands ${MANIFEST_VERSION}.`,
+                ],
+            }];
+    }
+    try {
+        toCanonicalJson(manifest);
+    }
+    catch (error) {
+        if (error instanceof ManifestSerializationError) {
+            return [{ slug: '*', fatal: true, messages: [error.message] }];
+        }
+        throw error;
+    }
+    return validateSeedDefinitions(manifestToSeeds(manifest));
+}

package/dist/schema/manifest.types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @module schema/manifest.types
+ * Data shapes for the `beech.schema.ts` desired-state manifest. Pure types — no runtime logic.
+ *
+ * A manifest is NOT a runtime authority: D1 remains the sole runtime source of truth. These types
+ * describe an artifact that is authored, reviewed in Git, and reconciled through an explicit
+ * plan/apply step.
+ */
+import type { Branch, Seed } from '../engine/types.js';
+/**
+ * Manifest format version. Bumped ONLY on a breaking change to the manifest shape — never on an
+ * additive field. `fromCanonicalJson` refuses any other value rather than guessing.
+ */
+export declare const MANIFEST_VERSION = 1;
+/**
+ * A field as written by hand in a manifest.
+ *
+ * `id` is optional at authoring time: nobody hand-writes `br_07`, and an author-invented id would
+ * collide with the ids the engine already minted. It is filled in by `manifestToSeeds()` purely so
+ * validation has a complete `Seed`; the AUTHORITATIVE assignment happens at plan/apply time, where
+ * `normalizeCandidate()` preserves the stored id by alias match before minting a new one.
+ * `fields` is recursive for `repeater` sub-fields, which carry the same rule.
+ */
+export type ManifestBranch = Omit<Branch, 'id' | 'fields'> & {
+    id?: string;
+    fields?: ManifestBranch[];
+};
+/**
+ * A content type as written in a manifest.
+ *
+ * `layout` is deliberately absent: it is typed `unknown`, is populated server-side by
+ * `GET /api/schema`, and is not a schema concern. Round-tripping it would make a future
+ * `beech schema diff` report permanent false drift.
+ */
+export type ManifestSeed = Omit<Seed, 'branches' | 'layout'> & {
+    branches: ManifestBranch[];
+};
+/**
+ * A reusable bundle of fields (e.g. an SEO block shared by several seeds).
+ *
+ * Author-time only: `defineSeed()` splices `branches` into the seed's own list and the group leaves
+ * ZERO trace in canonical JSON. It is a macro, not a persisted concept — there is exactly one
+ * grouping mechanism in D1, and this is not it.
+ */
+export interface FieldGroup {
+    name: string;
+    branches: ManifestBranch[];
+}
+/** The root artifact: the whole desired schema state. */
+export interface BeechSchemaManifest {
+    version: typeof MANIFEST_VERSION;
+    seeds: ManifestSeed[];
+}
+//# sourceMappingURL=manifest.types.d.ts.map

package/dist/schema/manifest.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.types.d.ts","sourceRoot":"","sources":["../../src/schema/manifest.types.ts"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAEtD;;;GAGG;AACH,eAAO,MAAM,gBAAgB,IAAI,CAAA;AAEjC;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,MAAM,EAAE,IAAI,GAAG,QAAQ,CAAC,GAAG;IAC3D,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,MAAM,CAAC,EAAE,cAAc,EAAE,CAAA;CAC1B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC,GAAG;IAC7D,QAAQ,EAAE,cAAc,EAAE,CAAA;CAC3B,CAAA;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,cAAc,EAAE,CAAA;CAC3B;AAED,yDAAyD;AACzD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,gBAAgB,CAAA;IAChC,KAAK,EAAE,YAAY,EAAE,CAAA;CACtB"}

package/dist/schema/manifest.types.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+// Copyright (c) 2024–2026 Flavio De Musso
+/**
+ * Manifest format version. Bumped ONLY on a breaking change to the manifest shape — never on an
+ * additive field. `fromCanonicalJson` refuses any other value rather than guessing.
+ */
+export const MANIFEST_VERSION = 1;

package/dist/schema-mutator.d.ts

@@ -0,0 +1,26 @@
+/** 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/schema-mutator.d.ts.map

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

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

package/dist/search/search.repository.d.ts

@@ -30,15 +30,16 @@ export interface ISearchRepository {
      * Executes a UNION ALL full-text search across all FTS-enabled seed tables.
      * Returns at most options.limit + 1 rows so the caller can detect hasMore
      * without a separate count query for the cursor case.
-     * Implementations must propagate the EMPTY_QUERY error thrown by
-     * buildFtsQuery so the route handler can return an empty result set rather
-     * than a 500.
+     * A query with no usable terms (EMPTY_QUERY from buildFtsQuery) must resolve
+     * to an empty array rather than throw, so the route handler never returns a
+     * 500 for it.
      */
     search(options: SearchQueryOptions, seeds: Seed[]): Promise<SearchResultRow[]>;
     /**
      * Runs the count variant of the FTS query to support the `total` field in
      * the search response. Called in parallel with search() by the route handler
-     * with the same filter inputs but without limit/cursor.
+     * with the same filter inputs but without limit/cursor. An EMPTY_QUERY
+     * resolves to `{ total: 0 }` rather than throwing.
      */
     count(options: Omit<SearchQueryOptions, 'limit' | 'cursor'>, seeds: Seed[]): Promise<SearchCountResult>;
 }

package/dist/search/search.repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"search.repository.d.ts","sourceRoot":"","sources":["../../src/search/search.repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAE9C,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;IAE9E;;;;OAIG;IACH,KAAK,CACH,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,CAAC,EACrD,KAAK,EAAE,IAAI,EAAE,GACZ,OAAO,CAAC,iBAAiB,CAAC,CAAA;CAC9B"}
+{"version":3,"file":"search.repository.d.ts","sourceRoot":"","sources":["../../src/search/search.repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAE9C,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACtB;AAED,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,EAAE,MAAM,GAAG,IAAI,CAAA;IACnB,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;;;OAOG;IACH,MAAM,CAAC,OAAO,EAAE,kBAAkB,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAA;IAE9E;;;;;OAKG;IACH,KAAK,CACH,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,QAAQ,CAAC,EACrD,KAAK,EAAE,IAAI,EAAE,GACZ,OAAO,CAAC,iBAAiB,CAAC,CAAA;CAC9B"}

package/dist/search/vector-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector-extractor.d.ts","sourceRoot":"","sources":["../../src/search/vector-extractor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAG9C;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,IAAI,CAc1F"}
+{"version":3,"file":"vector-extractor.d.ts","sourceRoot":"","sources":["../../src/search/vector-extractor.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAK9C;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,MAAM,GAAG,IAAI,CA4B1F"}

package/dist/search/vector-extractor.js

@@ -1,6 +1,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) 2024–2026 Flavio De Musso
-import { indexableSearchBranches } from '../engine/ddl.js';
+import { indexableSearchBranches } from '../engine/ddl/ddl.js';
+import { isLocaleDictionary, isLocalizedBranch } from '../engine/localization/localization.js';
+import { extractRichtextText } from '../engine/validation/richtext-sanitizer.js';
 /**
  * Extracts and concatenates text from all public indexable text/richtext branches of a seed.
  * Enforces privacy policies by utilizing indexableSearchBranches.
@@ -16,9 +18,28 @@ export function extractIndexableText(seed, entry) {
     const texts = [];
     for (const branch of branches) {
         const val = entry[branch.alias];
-        if (val && typeof val === 'string') {
+        if (isLocalizedBranch(branch) && isLocaleDictionary(val)) {
+            // Every language is indexed, so a query matches regardless of the language it is typed in.
+            for (const localeValue of Object.values(val)) {
+                if (typeof localeValue === 'string' && localeValue) {
+                    texts.push(localeValue);
+                }
+                else if (branch.type === 'richtext') {
+                    const text = extractRichtextText(localeValue);
+                    if (text)
+                        texts.push(text);
+                }
+            }
+        }
+        else if (typeof val === 'string' && val) {
             texts.push(val);
         }
+        else if (branch.type === 'richtext') {
+            // Deserialized richtext is always a TipTap doc object (or v1 envelope), never a string.
+            const text = extractRichtextText(val);
+            if (text)
+                texts.push(text);
+        }
     }
     const combined = texts.join(' ').trim();
     return combined.length > 0 ? combined : null;

package/dist/search/vector.repository.d.ts

@@ -4,10 +4,11 @@ export interface IVectorRepository {
     saveVector(seed: Seed, entryId: string, vector: Float32Array): Promise<void>;
     /** Removes the embedding vector (used when unpublished/deleted) */
     deleteVector(seed: Seed, entryId: string): Promise<void>;
-    /** Retrieves all vectors for a given seed to compile to R2 */
+    /** Retrieves all vectors (with entry title) for a given seed to compile to R2 */
     getAllVectors(seed: Seed): Promise<{
         entryId: string;
         vector: Float32Array;
+        title: string;
     }[]>;
 }
 //# sourceMappingURL=vector.repository.d.ts.map

package/dist/search/vector.repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vector.repository.d.ts","sourceRoot":"","sources":["../../src/search/vector.repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAE9C,MAAM,WAAW,iBAAiB;IAChC,yDAAyD;IACzD,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5E,mEAAmE;IACnE,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAExD,8DAA8D;IAC9D,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAE,EAAE,CAAC,CAAA;CAChF"}
+{"version":3,"file":"vector.repository.d.ts","sourceRoot":"","sources":["../../src/search/vector.repository.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AAE9C,MAAM,WAAW,iBAAiB;IAChC,yDAAyD;IACzD,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5E,mEAAmE;IACnE,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAExD,iFAAiF;IACjF,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC,CAAA;CAC/F"}

package/dist/security/time-trap-token.repository.d.ts

@@ -1,8 +1,10 @@
 export interface ITimeTrapTokenRepository {
-    /** Checks if a time-trap token hash has already been consumed. */
+    /** Cheap, non-atomic pre-check used only to fail fast before expensive validation. */
     isTokenUsed(tokenHash: string): Promise<boolean>;
-    /** Marks a time-trap token hash as consumed with an expiration timestamp. */
-    markTokenUsed(tokenHash: string, usedAt: number, expiresAt: number): Promise<void>;
+    /** Atomically claims a token hash as consumed. Returns false if it was already claimed. */
+    claimToken(tokenHash: string, usedAt: number, expiresAt: number): Promise<boolean>;
+    /** Releases a previously claimed token hash, allowing retry after a failed content creation. */
+    releaseToken(tokenHash: string): Promise<void>;
     /** Cleans up expired token entries. */
     cleanup(nowSeconds: number): Promise<void>;
 }

package/dist/security/time-trap-token.repository.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"time-trap-token.repository.d.ts","sourceRoot":"","sources":["../../src/security/time-trap-token.repository.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,wBAAwB;IACvC,kEAAkE;IAClE,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAChD,6EAA6E;IAC7E,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClF,uCAAuC;IACvC,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3C"}
+{"version":3,"file":"time-trap-token.repository.d.ts","sourceRoot":"","sources":["../../src/security/time-trap-token.repository.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,wBAAwB;IACvC,sFAAsF;IACtF,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAChD,2FAA2F;IAC3F,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAClF,gGAAgG;IAChG,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9C,uCAAuC;IACvC,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC3C"}