@abraca/schema 2.3.0

package/dist/abracadabra-schema.esm.js

@@ -0,0 +1,781 @@
+import { z } from "zod";
+
+//#region packages/schema/src/crdt.ts
+/** Y.Text marker. Reads as opaque CRDT — schema does not validate the contents. */
+function ytext() {
+	return z.custom(() => true).meta({ crdt: "ytext" });
+}
+/** Y.Array<T> marker. Element schema is preserved in metadata for codegen. */
+function yarray(element) {
+	return z.custom(() => true).meta({
+		crdt: "yarray",
+		element
+	});
+}
+/** Y.Map<T> marker. Value schema is preserved in metadata for codegen. */
+function ymap(value) {
+	return z.custom(() => true).meta({
+		crdt: "ymap",
+		element: value
+	});
+}
+/** Inspect a Zod schema for a CRDT marker. Returns undefined for non-CRDT schemas. */
+function crdtMetaOf(schema) {
+	const meta = schema.meta();
+	if (meta && typeof meta.crdt === "string") return meta;
+}
+
+//#endregion
+//#region packages/schema/src/types/universal.ts
+/**
+* Universal meta keys that may appear on any typed root.
+*
+* Mirrors the canonical list in `page-type-guidelines.md` §4.5 plus the
+* three cross-cutting cover keys (`coverUploadId`/`coverDocId`/
+* `coverMimeType`). Every key is optional. Per-type schemas merge this
+* object via `UniversalMeta.extend({ ... })`.
+*
+* Descendant-only keys (cell formatting, geo, dashboard layout, spatial
+* transforms, EXIF media metadata, etc.) are deliberately excluded —
+* descendants are untyped and unvalidated by the registry, so those
+* keys flow through the untyped meta path without per-type constraints.
+*/
+const hexColor = z.string().regex(/^#[0-9a-fA-F]{6}$/);
+const hhmm = z.string().regex(/^[0-2]\d:[0-5]\d$/);
+const UniversalMeta = z.strictObject({
+	color: hexColor.optional(),
+	icon: z.string().optional(),
+	datetimeStart: z.iso.datetime().optional(),
+	datetimeEnd: z.iso.datetime().optional(),
+	allDay: z.boolean().optional(),
+	dateStart: z.iso.date().optional(),
+	dateEnd: z.iso.date().optional(),
+	timeStart: hhmm.optional(),
+	timeEnd: hhmm.optional(),
+	tags: z.array(z.string()).optional(),
+	checked: z.boolean().optional(),
+	priority: z.number().int().min(0).max(4).optional(),
+	status: z.string().optional(),
+	rating: z.number().min(0).max(5).optional(),
+	url: z.string().optional(),
+	email: z.string().optional(),
+	phone: z.string().optional(),
+	number: z.number().optional(),
+	unit: z.string().optional(),
+	subtitle: z.string().optional(),
+	note: z.string().optional(),
+	taskProgress: z.number().min(0).max(100).optional(),
+	assignedTo: z.string().optional(),
+	coverUploadId: z.string().optional(),
+	coverDocId: z.string().optional(),
+	coverMimeType: z.string().optional(),
+	__schemaVersion: z.number().int().min(1).optional()
+});
+
+//#endregion
+//#region packages/schema/src/query.ts
+/**
+* V2 query layer — predicate AST.
+*
+* Mirrors InstantDB / Prisma `where` shapes: column → predicate pairs
+* composed with boolean AND/OR/NOT. The Rust compiler at
+* `crates/abracadabra/src/query.rs` walks the same shape and emits
+* indexed SQL against `doc_meta_index`.
+*
+* Columns are restricted to the universal-meta projection: `priority`,
+* `dateStart`, `dateEnd`, `tags`, `status`, `assignedTo`. Anything else
+* is rejected. Adding a column requires both:
+*   1. A new column on `doc_meta_index` (migration in `abracadabra-rs`)
+*   2. A new entry in `META_COLUMNS` below
+*
+* The schema is intentionally narrow — only the operators the v2 query
+* layer can actually execute against indexed columns are accepted. New
+* operators require server changes; the schema is the contract.
+*/
+/**
+* Whitelisted indexed columns on `doc_meta_index`. Adding to this list
+* requires a parallel migration on the server. Order is the canonical
+* documentation order — not enforced.
+*/
+const META_COLUMNS = [
+	"priority",
+	"dateStart",
+	"dateEnd",
+	"tags",
+	"status",
+	"assignedTo"
+];
+z.enum(META_COLUMNS);
+const ScalarValue = z.union([
+	z.string(),
+	z.number(),
+	z.boolean(),
+	z.null()
+]);
+/**
+* Numeric / lexicographic comparison operators. Apply to integer
+* (`priority`), date (`dateStart`, `dateEnd`), and string
+* (`status`, `assignedTo`) columns. Strings compare lexicographically
+* — useful for date filtering on the SQLite path where dates are TEXT.
+*/
+const RangeOps = z.strictObject({
+	eq: ScalarValue.optional(),
+	neq: ScalarValue.optional(),
+	gt: ScalarValue.optional(),
+	gte: ScalarValue.optional(),
+	lt: ScalarValue.optional(),
+	lte: ScalarValue.optional(),
+	in: z.array(ScalarValue).optional(),
+	between: z.tuple([ScalarValue, ScalarValue]).optional()
+});
+/**
+* Operators for the `tags` column. `tags` is a JSON array.
+* `contains: "x"` matches when the array includes the string `x`.
+* `containsAll: ["x","y"]` requires all listed tags to be present.
+* `containsAny: ["x","y"]` requires at least one.
+*/
+const TagOps = z.strictObject({
+	contains: z.string().optional(),
+	containsAll: z.array(z.string()).optional(),
+	containsAny: z.array(z.string()).optional(),
+	isEmpty: z.boolean().optional()
+});
+/** Per-column predicate. `null` => column IS NULL. */
+const ColumnPredicate = z.union([
+	ScalarValue,
+	RangeOps,
+	TagOps
+]);
+const WhereClauseSchema = z.lazy(() => z.strictObject({
+	AND: z.array(WhereClauseSchema).optional(),
+	OR: z.array(WhereClauseSchema).optional(),
+	NOT: WhereClauseSchema.optional(),
+	priority: ColumnPredicate.optional(),
+	dateStart: ColumnPredicate.optional(),
+	dateEnd: ColumnPredicate.optional(),
+	tags: ColumnPredicate.optional(),
+	status: ColumnPredicate.optional(),
+	assignedTo: ColumnPredicate.optional()
+}));
+/**
+* Parse + normalise a raw `where` object. Returns a discriminated
+* result so call sites can render server-friendly error messages on
+* the wire.
+*/
+function parseWhereClause(raw) {
+	const parsed = WhereClauseSchema.safeParse(raw);
+	if (parsed.success) return {
+		ok: true,
+		value: parsed.data
+	};
+	return {
+		ok: false,
+		errors: parsed.error.issues.map((i) => ({
+			path: i.path,
+			message: i.message
+		}))
+	};
+}
+
+//#endregion
+//#region packages/schema/src/types/doc.ts
+/**
+* `doc` — the default rich-text page type. Body is a TipTap-backed
+* `Y.Text`; descendants are untyped tree entries.
+*/
+const DocMeta = UniversalMeta;
+const Doc = defineDocType({
+	name: "doc",
+	version: 1,
+	meta: DocMeta,
+	body: ytext()
+});
+const docSchema = defineSchema({ types: [Doc] });
+
+//#endregion
+//#region packages/schema/src/types/prose.ts
+/**
+* `prose` — long-form prose with serif typography. Same body shape as
+* `doc` (Y.Text TipTap content); descendants are untyped.
+*/
+const ProseMeta = UniversalMeta;
+const Prose = defineDocType({
+	name: "prose",
+	version: 1,
+	meta: ProseMeta,
+	body: ytext()
+});
+const proseSchema = defineSchema({ types: [Prose] });
+
+//#endregion
+//#region packages/schema/src/types/kanban.ts
+/**
+* `kanban` — drag-and-drop board. Direct children are columns;
+* grandchildren are cards. Both descendants are untyped tree entries
+* — only the board itself carries `type: "kanban"` and the per-board
+* view-config keys below.
+*/
+const KanbanMeta = UniversalMeta.extend({
+	kanbanColumnWidth: z.enum([
+		"narrow",
+		"default",
+		"wide"
+	]).optional(),
+	kanbanShowIcon: z.boolean().optional(),
+	kanbanShowTags: z.boolean().optional(),
+	kanbanShowPriority: z.boolean().optional(),
+	kanbanShowDueDate: z.boolean().optional(),
+	kanbanShowCover: z.boolean().optional()
+});
+const Kanban = defineDocType({
+	name: "kanban",
+	version: 1,
+	meta: KanbanMeta
+});
+const kanbanSchema = defineSchema({ types: [Kanban] });
+
+//#endregion
+//#region packages/schema/src/types/gallery.ts
+/**
+* `gallery` — visual grid of items with rich content. Direct children
+* are items (untyped tree entries).
+*/
+const GalleryMeta = UniversalMeta.extend({
+	galleryColumns: z.number().int().min(1).max(6).optional(),
+	galleryAspect: z.enum([
+		"square",
+		"4:3",
+		"3:2",
+		"16:9",
+		"free"
+	]).optional(),
+	galleryCardStyle: z.enum([
+		"default",
+		"compact",
+		"detailed"
+	]).optional(),
+	galleryShowLabels: z.boolean().optional(),
+	gallerySortBy: z.enum([
+		"manual",
+		"date",
+		"name",
+		"rating"
+	]).optional()
+});
+const Gallery = defineDocType({
+	name: "gallery",
+	version: 1,
+	meta: GalleryMeta
+});
+const gallerySchema = defineSchema({ types: [Gallery] });
+
+//#endregion
+//#region packages/schema/src/types/table.ts
+/**
+* `table` — collaborative spreadsheet. Direct children are columns;
+* grandchildren are positional cells (row N = Nth child of each
+* column). Descendants are untyped.
+*/
+const TableMeta = UniversalMeta.extend({
+	tableMode: z.enum(["hierarchy", "flat"]).optional(),
+	tableSortDir: z.enum(["asc", "desc"]).optional()
+});
+const Table = defineDocType({
+	name: "table",
+	version: 1,
+	meta: TableMeta
+});
+const tableSchema = defineSchema({ types: [Table] });
+
+//#endregion
+//#region packages/schema/src/types/outline.ts
+/**
+* `outline` — hierarchical outline with keyboard navigation. Unlimited
+* descendant nesting; all descendants are untyped.
+*/
+const OutlineMeta = UniversalMeta;
+const Outline = defineDocType({
+	name: "outline",
+	version: 1,
+	meta: OutlineMeta
+});
+const outlineSchema = defineSchema({ types: [Outline] });
+
+//#endregion
+//#region packages/schema/src/types/checklist.ts
+/**
+* `checklist` — collaborative checklist with sub-tasks and due dates.
+* Unlimited descendant nesting; all descendants are untyped (per-task
+* `checked` / `priority` / `dateEnd` flow through universal keys).
+*/
+const ChecklistMeta = UniversalMeta.extend({
+	checklistFilter: z.enum([
+		"all",
+		"active",
+		"completed"
+	]).optional(),
+	checklistSort: z.enum([
+		"manual",
+		"priority",
+		"due"
+	]).optional()
+});
+const Checklist = defineDocType({
+	name: "checklist",
+	version: 1,
+	meta: ChecklistMeta
+});
+const checklistSchema = defineSchema({ types: [Checklist] });
+
+//#endregion
+//#region packages/schema/src/types/graph.ts
+/**
+* `graph` — force-directed knowledge graph rendering. Descendants are
+* untyped (per-node `graphX` / `graphY` / `graphPinned` are written to
+* descendant meta but not validated by the registry).
+*/
+const GraphMeta = UniversalMeta.extend({ showRefEdges: z.boolean().optional() });
+const Graph = defineDocType({
+	name: "graph",
+	version: 1,
+	meta: GraphMeta
+});
+const graphSchema = defineSchema({ types: [Graph] });
+
+//#endregion
+//#region packages/schema/src/types/timeline.ts
+/**
+* `timeline` — Gantt-style project timeline. Direct children are epics;
+* grandchildren are tasks (both untyped). Per-bar `dateStart` /
+* `dateEnd` / `taskProgress` / `color` use universal keys.
+*/
+const TimelineMeta = UniversalMeta;
+const Timeline = defineDocType({
+	name: "timeline",
+	version: 1,
+	meta: TimelineMeta
+});
+const timelineSchema = defineSchema({ types: [Timeline] });
+
+//#endregion
+//#region packages/schema/src/types/calendar.ts
+/**
+* `calendar` — event calendar with month/week/day views. Direct
+* children are events (untyped); per-event `datetimeStart` /
+* `datetimeEnd` / `allDay` / `color` use universal keys.
+*/
+const CalendarMeta = UniversalMeta.extend({
+	calendarWeekStart: z.enum(["sun", "mon"]).optional(),
+	calendarView: z.enum([
+		"month",
+		"week",
+		"day"
+	]).optional(),
+	calendarShowWeekNumbers: z.boolean().optional()
+});
+const Calendar = defineDocType({
+	name: "calendar",
+	version: 1,
+	meta: CalendarMeta
+});
+const calendarSchema = defineSchema({ types: [Calendar] });
+
+//#endregion
+//#region packages/schema/src/types/map.ts
+/**
+* `map` — collaborative world map. Direct children are markers / lines
+* / measure entries (untyped, distinguished by descendant `geoType`
+* key flowing through the untyped meta path).
+*/
+const MapMeta = UniversalMeta.extend({ mapShowLabels: z.boolean().optional() });
+const MapDocType = defineDocType({
+	name: "map",
+	version: 1,
+	meta: MapMeta
+});
+const mapSchema = defineSchema({ types: [MapDocType] });
+
+//#endregion
+//#region packages/schema/src/types/dashboard.ts
+/**
+* `dashboard` — arranges documents as draggable icons / widgets.
+* Descendants are untyped; per-item `desk*` layout keys flow through
+* the untyped meta path.
+*/
+const DashboardMeta = UniversalMeta;
+const Dashboard = defineDocType({
+	name: "dashboard",
+	version: 1,
+	meta: DashboardMeta
+});
+const dashboardSchema = defineSchema({ types: [Dashboard] });
+
+//#endregion
+//#region packages/schema/src/types/chart.ts
+/**
+* `chart` — manual data points or aggregation over document trees.
+* Direct children are data points (untyped); per-point `number` /
+* `color` / `tags` use universal keys.
+*/
+const ChartMeta = UniversalMeta.extend({
+	chartType: z.enum([
+		"bar",
+		"stacked bar",
+		"line",
+		"donut",
+		"treemap"
+	]).optional(),
+	chartMetric: z.enum([
+		"value",
+		"type",
+		"tag",
+		"status",
+		"priority",
+		"activity",
+		"completion"
+	]).optional(),
+	chartColorScheme: z.enum([
+		"default",
+		"warm",
+		"cool",
+		"mono"
+	]).optional(),
+	chartLimit: z.number().int().min(3).max(30).optional(),
+	chartShowLegend: z.boolean().optional(),
+	chartShowValues: z.boolean().optional()
+});
+const Chart = defineDocType({
+	name: "chart",
+	version: 1,
+	meta: ChartMeta
+});
+const chartSchema = defineSchema({ types: [Chart] });
+
+//#endregion
+//#region packages/schema/src/types/sheets.ts
+/**
+* `sheets` — spreadsheet with formulas + formatting. Direct children
+* are columns; grandchildren are positional cells (both untyped).
+* Per-cell `formula` / `bold` / `bgColor` / `numberFormat` etc. flow
+* through the untyped meta path.
+*/
+const SheetsMeta = UniversalMeta.extend({
+	sheetsDefaultColWidth: z.number().min(40).max(500).optional(),
+	sheetsDefaultRowHeight: z.number().min(20).max(100).optional(),
+	sheetsShowGridlines: z.boolean().optional()
+});
+const Sheets = defineDocType({
+	name: "sheets",
+	version: 1,
+	meta: SheetsMeta
+});
+const sheetsSchema = defineSchema({ types: [Sheets] });
+
+//#endregion
+//#region packages/schema/src/types/slides.ts
+/**
+* `slides` — two-axis presentation. Direct children are slides;
+* grandchildren are sub-slides (both untyped); per-slide
+* `slidesTransition` / `color` flow through the universal/untyped
+* paths.
+*/
+const SlidesMeta = UniversalMeta.extend({ slidesTheme: z.enum(["dark", "light"]).optional() });
+const Slides = defineDocType({
+	name: "slides",
+	version: 1,
+	meta: SlidesMeta
+});
+const slidesSchema = defineSchema({ types: [Slides] });
+
+//#endregion
+//#region packages/schema/src/types/overview.ts
+/**
+* `overview` — space home: activity, people, stats. Descendants are
+* regular pages; no overview-specific config keys today.
+*/
+const OverviewMeta = UniversalMeta;
+const Overview = defineDocType({
+	name: "overview",
+	version: 1,
+	meta: OverviewMeta
+});
+const overviewSchema = defineSchema({ types: [Overview] });
+
+//#endregion
+//#region packages/schema/src/manifest/plugin-manifest.ts
+/**
+* Runtime validation schema for plugin manifests (manifest v1).
+*
+* The TypeScript types live in `@abraca/plugin/src/manifest.ts` and stay
+* pure — `@abraca/plugin` itself ships zero schemas per `feedback_schema_free_core`.
+* This file is the opt-in Zod validator used by:
+*
+* - the registry server's submission pipeline (verifies submitted manifests
+*   before storing the artifact)
+* - the `@abraca/plugin-cli` `validate` command (local pre-submit linting)
+* - hosts (`cou-shell`, `@abraca/nuxt`) before instantiating an external
+*   plugin, when they want runtime validation in addition to the
+*   compile-time `PluginManifest` typing.
+*
+* The inferred shape is asserted to be structurally identical to
+* `PluginManifest` from `@abraca/plugin` via `_check` type aliases below —
+* if either side drifts, the typecheck fails.
+*/
+/**
+* Capabilities with no dynamic suffix. Anything outside this set and the two
+* prefix families (`network[:*]`, `page-type:<slug>`) is rejected.
+*
+* Encoded as a regex pattern (not a `.refine()` callback) so the
+* Zod-to-JSON-Schema codegen captures it — otherwise the registry server's
+* Rust validator would have to re-implement the vocabulary in parallel.
+*/
+const CAPABILITY_PATTERN = "^(fs:read|fs:write|clipboard:read|clipboard:write|doc-read|doc-write|awareness|server-runner|command-palette|toolbar|bubble-menu|slash-command|drag-handle|chat:send|chat:read|notifications:show|network|network:\\S+|page-type:[a-z][a-z0-9-]*)$";
+const PluginCapabilitySchema = z.string().regex(new RegExp(CAPABILITY_PATTERN), { message: "unknown plugin capability — see PluginCapability in @abraca/plugin" }).transform((s) => s);
+/** Lowercase-kebab slug. Starts with a letter; no consecutive dashes; no trailing dash. */
+const PluginIdSchema = z.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, "id must be lowercase-kebab (e.g. 'spatial', 'plugin-coder', 'my-2nd-plugin')");
+/**
+* Strict semver `MAJOR.MINOR.PATCH` with optional pre-release / build metadata.
+* Reference: https://semver.org/spec/v2.0.0.html#backusnaur-form-grammar-for-valid-semver-versions
+*/
+const SemverSchema = z.string().regex(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/, "version must be valid semver (e.g. '1.2.3', '0.1.0-alpha.1')");
+/**
+* Loose semver range — accepts `^1.2.3`, `~1.2`, `>=1.0 <2`, `1.x`, etc.
+* Not parsed here; the registry server runs `semver.validRange` for strict
+* validation. We just guard against obvious junk.
+*/
+const SemverRangeSchema = z.string().min(1).max(80).regex(/^[\d.xX*~^<>=|\s&,a-zA-Z+-]+$/, "invalid semver range");
+/** `sha256-<64 hex chars>`. */
+const IntegritySchema = z.string().regex(/^sha256-[0-9a-f]{64}$/, "integrity must be 'sha256-' + 64 lowercase hex chars");
+/** Relative POSIX path. No `..` segments, no absolute, no protocols. */
+const RelativePathSchema = z.string().min(1).max(256).refine((p) => !p.startsWith("/") && !/^[a-z]+:\/\//i.test(p) && !p.split("/").includes(".."), "must be a relative path with no '..' segments");
+const PluginManifestAuthorSchema = z.object({
+	github: z.string().min(1).max(64).optional(),
+	name: z.string().min(1).max(120).optional(),
+	url: z.string().url().max(512).optional(),
+	email: z.string().email().max(254).optional()
+});
+const PluginPricingSchema = z.enum([
+	"free",
+	"optional",
+	"paid"
+]);
+const PluginVersionStatusSchema = z.enum([
+	"live",
+	"pending",
+	"rejected",
+	"superseded"
+]);
+const PluginManifestContributesSchema = z.object({
+	pageTypes: z.array(z.string().min(1)).readonly().optional(),
+	extensions: z.array(z.string().min(1)).readonly().optional(),
+	awarenessFields: z.array(z.string().min(1)).readonly().optional(),
+	serverRunners: z.array(z.string().min(1)).readonly().optional(),
+	commands: z.array(z.string().min(1)).readonly().optional(),
+	settingsPanels: z.array(z.string().min(1)).readonly().optional()
+});
+const PluginManifestSchema = z.object({
+	manifestVersion: z.literal(1),
+	id: PluginIdSchema,
+	name: z.string().min(1).max(80).optional(),
+	version: SemverSchema,
+	author: PluginManifestAuthorSchema,
+	license: z.string().min(1).max(80),
+	description: z.string().min(1).max(280),
+	readme: z.string().max(1e5).optional(),
+	homepage: z.string().url().max(512).optional(),
+	repository: z.string().min(3).max(512).optional(),
+	minAbracadabraVersion: SemverRangeSchema.optional(),
+	entry: RelativePathSchema,
+	integrity: IntegritySchema,
+	pricing: PluginPricingSchema.optional(),
+	screenshots: z.array(RelativePathSchema).max(20).readonly().optional(),
+	categories: z.array(z.string().min(1).max(40)).max(10).readonly().optional(),
+	capabilities: z.object({
+		required: z.array(PluginCapabilitySchema).readonly(),
+		optional: z.array(PluginCapabilitySchema).readonly().optional()
+	}),
+	contributes: PluginManifestContributesSchema.optional(),
+	peerDeps: z.record(z.string(), SemverRangeSchema).optional()
+});
+/**
+* Parse and validate a manifest. Always returns a result object — never
+* throws. Useful for surface UIs (the registry submission flow, the CLI's
+* `validate` command) that want to render every issue at once.
+*/
+function validatePluginManifest(value) {
+	const parsed = PluginManifestSchema.safeParse(value);
+	if (parsed.success) return {
+		ok: true,
+		value: parsed.data
+	};
+	return {
+		ok: false,
+		errors: parsed.error.issues.map((i) => ({
+			path: i.path,
+			message: i.message,
+			code: i.code
+		}))
+	};
+}
+
+//#endregion
+//#region packages/schema/src/index.ts
+/**
+* Declare a doc-type. The returned value carries enough type information for
+* downstream codegen and is a `DocType` once registered.
+*/
+function defineDocType(spec) {
+	return {
+		...spec,
+		__resolved: true
+	};
+}
+/** Reference another doc-type by name. Resolution happens in {@link defineSchema}. */
+function ref(name) {
+	return { __ref: name };
+}
+/**
+* Build a registry from a list of doc-types. Validates that all `ref(...)`
+* targets exist; throws on dangling references.
+*
+* The returned registry carries a phantom `__metaMap` witness inferred from
+* `spec`, so call sites like `provider.docs(schema).get("kanban", id)`
+* see fully-typed meta even though the registry's runtime shape is generic.
+*/
+function defineSchema(spec) {
+	const types = /* @__PURE__ */ new Map();
+	for (const t of spec.types) {
+		if (types.has(t.name)) throw new Error(`Duplicate doc-type name: ${t.name}`);
+		types.set(t.name, t);
+	}
+	for (const t of spec.types) for (const child of t.children ?? []) if (!types.has(child.__ref)) throw new Error(`Doc-type "${t.name}" references unknown child doc-type "${child.__ref}"`);
+	return {
+		types,
+		get(name) {
+			return types.get(name);
+		},
+		validateChildType(parent, child) {
+			if (!types.has(child)) return {
+				ok: false,
+				errors: [{
+					path: [],
+					message: `Unknown doc-type: ${child}`
+				}]
+			};
+			if (parent === null) return {
+				ok: false,
+				errors: [{
+					path: [],
+					message: `Doc-type "${child}" cannot be a root document — root-eligibility is reserved for Phase 2`
+				}]
+			};
+			const parentType = types.get(parent);
+			if (!parentType) return {
+				ok: false,
+				errors: [{
+					path: [],
+					message: `Unknown parent doc-type: ${parent}`
+				}]
+			};
+			if ((parentType.children ?? []).some((c) => c.__ref === child)) return {
+				ok: true,
+				value: void 0
+			};
+			return {
+				ok: false,
+				errors: [{
+					path: [],
+					message: `Doc-type "${child}" is not an allowed child of "${parent}"`
+				}]
+			};
+		},
+		validateMeta(name, value) {
+			const t = types.get(name);
+			if (!t) return {
+				ok: true,
+				value
+			};
+			const parsed = t.meta.safeParse(value);
+			if (parsed.success) return {
+				ok: true,
+				value: parsed.data
+			};
+			return {
+				ok: false,
+				errors: parsed.error.issues.map((i) => ({
+					path: i.path,
+					message: i.message,
+					code: i.code
+				}))
+			};
+		}
+	};
+}
+/**
+* Apply forward migrations to a meta object.
+*
+* Reads `meta.__schemaVersion` (defaults to `1` if absent) and applies
+* each `migrations[v]` from there up to the schema's declared `version`.
+* Each migration function receives the previous version's meta and
+* returns the next version's meta. The final value carries
+* `__schemaVersion = <highest version reached>`.
+*
+* Behaviour:
+* - **Unknown doc-type**: returns `meta` unchanged. Rule 4 — registries
+*   only constrain the types they declare.
+* - **No migrations declared**: returns `meta` unchanged. Useful for
+*   freshly-introduced doc-types still at v1.
+* - **Missing migration entry mid-chain**: stops at the highest
+*   reachable version. Caller can detect by inspecting
+*   `result.__schemaVersion` against `schema.get(typeName)?.version`.
+* - **Non-object meta** (null, undefined, primitives): returns
+*   unchanged. Migrations only operate on object meta.
+*
+* Migrations are pure: they receive a meta value and return a new
+* one. They MUST NOT mutate the input (callers may pass shared
+* references).
+*
+* @example
+*   // v2 of kanban introduces a new required-shape `boardLayout` key.
+*   const Kanban = defineDocType({
+*     name: "kanban",
+*     version: 2,
+*     meta: KanbanMetaV2,
+*     migrations: {
+*       1: (oldMeta) => ({ ...oldMeta, boardLayout: "default" }),
+*     },
+*   });
+*   const fresh = runMigrations(kanbanSchema, "kanban", { kanbanShowIcon: true });
+*   // fresh.boardLayout === "default"
+*   // fresh.__schemaVersion === 2
+*/
+function runMigrations(registry, typeName, meta) {
+	if (meta === null || typeof meta !== "object") return meta;
+	const t = registry.get(typeName);
+	if (!t) return meta;
+	const target = t.version;
+	const migrations = t.migrations;
+	const m = meta;
+	let currentVersion = typeof m.__schemaVersion === "number" && m.__schemaVersion >= 1 ? m.__schemaVersion : 1;
+	if (currentVersion >= target) return meta;
+	if (!migrations) return meta;
+	let working = meta;
+	let migrated = false;
+	while (currentVersion < target) {
+		const fn = migrations[currentVersion];
+		if (typeof fn !== "function") break;
+		working = fn(working);
+		currentVersion += 1;
+		migrated = true;
+	}
+	if (!migrated) return meta;
+	if (working === null || typeof working !== "object") return working;
+	return {
+		...working,
+		__schemaVersion: currentVersion
+	};
+}
+
+//#endregion
+export { Calendar, CalendarMeta, Chart, ChartMeta, Checklist, ChecklistMeta, Dashboard, DashboardMeta, Doc, DocMeta, Gallery, GalleryMeta, Graph, GraphMeta, IntegritySchema, Kanban, KanbanMeta, META_COLUMNS, MapDocType, MapMeta, Outline, OutlineMeta, Overview, OverviewMeta, PluginCapabilitySchema, PluginIdSchema, PluginManifestAuthorSchema, PluginManifestContributesSchema, PluginManifestSchema, PluginPricingSchema, PluginVersionStatusSchema, Prose, ProseMeta, RelativePathSchema, SemverRangeSchema, SemverSchema, Sheets, SheetsMeta, Slides, SlidesMeta, Table, TableMeta, Timeline, TimelineMeta, UniversalMeta, WhereClauseSchema, calendarSchema, chartSchema, checklistSchema, crdtMetaOf, dashboardSchema, defineDocType, defineSchema, docSchema, gallerySchema, graphSchema, kanbanSchema, mapSchema, outlineSchema, overviewSchema, parseWhereClause, proseSchema, ref, runMigrations, sheetsSchema, slidesSchema, tableSchema, timelineSchema, validatePluginManifest, yarray, ymap, ytext };
+//# sourceMappingURL=abracadabra-schema.esm.js.map