@mulmoclaude/core 0.13.1 → 0.15.0

package/dist/{server-G6GtOdaW.cjs → server-bsNrf2yW.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_deriveAll = require("./deriveAll-BQ_p5HSB.cjs");
+const require_calendarGrid = require("./calendarGrid-gN4sei7s.cjs");
 const require_collection_paths = require("./collection/paths.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
@@ -80,7 +80,6 @@ var log = {
 //#endregion
 //#region src/collection/server/paths.ts
 var SCHEMA_FILE = "schema.json";
-var SAFE_SLUG_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
 /** Sanitise a user-supplied slug into a safe directory-name leaf.
 *  Returns null for anything that fails the slug whitelist OR isn't a
 *  basename (i.e. survives `path.basename` round-trip unchanged).
@@ -88,12 +87,11 @@ var SAFE_SLUG_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9_-]*[a-zA-Z0-9])?$/;
 *  `js/path-injection` sanitiser. */
 function safeSlugName(slug) {
 	if (typeof slug !== "string") return null;
-	if (!SAFE_SLUG_PATTERN.test(slug)) return null;
+	if (!require_calendarGrid.SAFE_SLUG_PATTERN.test(slug)) return null;
 	const basename = node_path.default.basename(slug);
 	if (basename !== slug) return null;
 	return basename;
 }
-var SAFE_RECORD_ID_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9_.-]*[a-zA-Z0-9])?$/;
 /** Sanitise a user-supplied record id into a safe filename stem. Like
 *  `safeSlugName` but tolerates interior dots (so natural keys work),
 *  while still rejecting any `..` substring, path separators, and
@@ -101,7 +99,7 @@ var SAFE_RECORD_ID_PATTERN = /^[a-zA-Z0-9](?:[a-zA-Z0-9_.-]*[a-zA-Z0-9])?$/;
 *  `js/path-injection` sanitiser CodeQL recognises on `safeSlugName`. */
 function safeRecordId(recordId) {
 	if (typeof recordId !== "string") return null;
-	if (!SAFE_RECORD_ID_PATTERN.test(recordId)) return null;
+	if (!require_calendarGrid.SAFE_RECORD_ID_PATTERN.test(recordId)) return null;
 	if (recordId.includes("..")) return null;
 	const basename = node_path.default.basename(recordId);
 	if (basename !== recordId) return null;
@@ -241,7 +239,9 @@ async function writeFileAtomic(filePath, content) {
 *  inside an otherwise-contained data dir — without this, a record
 *  file could symlink to /etc/passwd and the detail endpoint would
 *  happily serve it. Returns false on ENOENT and on any other lstat
-*  failure so the caller's "missing" branch covers those cases too. */
+*  failure so the caller's "missing" branch covers those cases too.
+*  Exported so `ontology.ts`'s record COUNT classifies entries with the
+*  SAME lstat logic — the two must agree on what a record file is. */
 async function isRegularFile(filePath) {
 	try {
 		return (await (0, node_fs_promises.lstat)(filePath)).isFile();
@@ -636,13 +636,112 @@ ${dataJson}
 ${templateText}`;
 }
 //#endregion
+//#region src/collection/core/recordZ.ts
+/** The emptiness rule shared by `required` and the "only check present
+*  values" gate. NOT a truthiness check — `0` and `false` are filled. */
+var isEmptyValue = (value) => value === void 0 || value === null || value === "";
+/** The historical write-gate checks, verbatim: required non-empty, enum
+*  membership (compared as strings, so a numeric `5` satisfies `"5"`). */
+function enforcedProblem(key, spec, value) {
+	const empty = isEmptyValue(value);
+	if (spec.required && empty) return `missing required field '${key}'`;
+	if (!empty && spec.type === "enum" && !spec.values.includes(String(value))) return `'${key}' = '${String(value)}' is not one of [${spec.values.join(", ")}]`;
+	return null;
+}
+/** Numeric coercion for the strict `number`/`money` check: a plain number,
+*  or a non-blank numeric string (renderers coerce those via `Number(...)`,
+*  so they display fine). Anything else — arrays (`[]` stringifies to `""`
+*  = 0, `[42]` to `"42"`), booleans, objects — is NaN and gets flagged. */
+function coerceNumeric(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "string" && value.trim() !== "") return Number(value);
+	return NaN;
+}
+/** Report-only per-type checks on a PRESENT value. Date / datetime reuse the
+*  calendar's STRICT civil parsers (`parseIsoDate` / `parseIsoDateTime`), so
+*  the lint flags exactly the values the calendar / trigger / spawn code
+*  would silently drop — impossible days like `2026-02-30`, and datetimes
+*  outside the canonical `YYYY-MM-DDTHH:MM[:SS]` shape (e.g. a `Z` suffix,
+*  which the day view can't place). `string`-backed types accept anything
+*  stringifiable; `ref` existence is out of scope. */
+function strictTypeProblem(key, spec, value) {
+	switch (spec.type) {
+		case "number":
+		case "money": return Number.isFinite(coerceNumeric(value)) ? null : `'${key}' = '${String(value)}' is not numeric (a '${spec.type}' field stores a plain number)`;
+		case "boolean": return value === true || value === false ? null : `'${key}' = '${String(value)}' is not a boolean (store true or false, unquoted)`;
+		case "date": return require_calendarGrid.parseIsoDate(value) !== null ? null : `'${key}' = '${String(value)}' is not a real YYYY-MM-DD date`;
+		case "datetime": return require_calendarGrid.parseIsoDateTime(value) !== null ? null : `'${key}' = '${String(value)}' is not a YYYY-MM-DDTHH:MM datetime (seconds optional, no timezone suffix — the shape the calendar parses)`;
+		default: return null;
+	}
+}
+/** Strict check for a PRESENT `table` value: an array of row objects, each
+*  row conforming to the sub-schema (required / enum / typed sub-values).
+*  First row problem wins, prefixed with the row number so the fix is
+*  locatable. */
+function strictTableProblem(key, spec, value) {
+	if (!Array.isArray(value)) return `'${key}' = '${String(value)}' is not an array of rows (a 'table' field stores an array of row objects)`;
+	for (let index = 0; index < value.length; index++) {
+		const row = value[index];
+		if (!row || typeof row !== "object" || Array.isArray(row)) return `'${key}' row ${index + 1} is not an object`;
+		for (const [subKey, subSpec] of Object.entries(spec.of)) {
+			const subValue = row[subKey];
+			const problem = enforcedProblem(subKey, subSpec, subValue) ?? (isEmptyValue(subValue) ? null : strictTypeProblem(subKey, subSpec, subValue));
+			if (problem) return `'${key}' row ${index + 1}: ${problem}`;
+		}
+	}
+	return null;
+}
+/** First problem for one field's stored value under `tier`, or null.
+*  Enforced checks always run (and their messages never vary by tier — the
+*  scan and the write gate must agree on them); strict adds the per-type
+*  layer on present values only. */
+function recordFieldProblem(key, spec, value, tier) {
+	const enforced = enforcedProblem(key, spec, value);
+	if (enforced || tier === "enforced") return enforced;
+	if (isEmptyValue(value)) return null;
+	if (spec.type === "table") return strictTableProblem(key, spec, value);
+	return strictTypeProblem(key, spec, value);
+}
+var compiled = /* @__PURE__ */ new WeakMap();
+/** Compile `schema.fields` into a zod validator for a stored record.
+*  Loose object: unknown keys are allowed and any declared key may be
+*  absent (records are user files, not parse-and-rewrite targets —
+*  callers validate, they never persist the parse output). The checks run
+*  as ONE object-level refine iterating fields in declaration order —
+*  per-key shape schemas can't express "key may be absent BUT its absence
+*  must still reach the required check", and the single loop keeps the
+*  first reported issue identical to the historical first-problem-wins
+*  contract. */
+function compileRecordZ(schema, tier) {
+	const cached = compiled.get(schema)?.[tier];
+	if (cached) return cached;
+	const stored = Object.entries(schema.fields).filter(([, spec]) => !require_calendarGrid.COMPUTED_TYPES.has(spec.type));
+	const validator = zod.z.looseObject({}).superRefine((record, ctx) => {
+		for (const [key, spec] of stored) {
+			const problem = recordFieldProblem(key, spec, record[key], tier);
+			if (problem) ctx.addIssue({
+				code: "custom",
+				message: problem,
+				path: [key]
+			});
+		}
+	});
+	const entry = compiled.get(schema) ?? {};
+	entry[tier] = validator;
+	compiled.set(schema, entry);
+	return validator;
+}
+/** First schema problem on an in-memory record under `tier`, or null. One
+*  issue per record keeps the report short and the fix obvious (the
+*  historical contract of `validateRecordObject`). */
+function firstRecordProblem(record, schema, tier) {
+	const result = compileRecordZ(schema, tier).safeParse(record);
+	if (result.success) return null;
+	return result.error.issues[0]?.message ?? "record failed schema validation";
+}
+//#endregion
 //#region src/collection/server/validate.ts
 var MAX_ISSUES = 25;
-var COMPUTED_TYPES = /* @__PURE__ */ new Set([
-	"derived",
-	"embed",
-	"toggle"
-]);
 /** Read every `<id>.json` under the collection's dataDir and report the
 *  ones that won't load or violate the schema. An empty list means every
 *  record is fine. */
@@ -705,72 +804,70 @@ async function inspectRecord(fullPath, name, schema) {
 		file: name,
 		problem: "not a JSON object — skipped, won't appear"
 	};
-	const problem = validateRecordObject(parsed, name.replace(/\.json$/, ""), schema);
+	const problem = validateRecordObject(parsed, name.replace(/\.json$/, ""), schema, "strict");
 	return problem ? {
 		file: name,
 		problem
 	} : null;
 }
 /** First schema problem on an in-memory record (primaryKey↔id mismatch,
-*  missing required, bad enum value), or null when it's fine. One issue
-*  per record keeps the report short and the fix obvious. Pure +
-*  exported so write paths (manageCollection putItems) can gate on the
-*  SAME rules the post-hoc file scan reports — `itemId` is the id the
-*  record is (or would be) stored under. */
-function validateRecordObject(record, itemId, schema) {
+*  then the compiled per-field checks — see `../core/recordZ` for the two
+*  tiers), or null when it's fine. One issue per record keeps the report
+*  short and the fix obvious. Pure + exported so write paths
+*  (manageCollection putItems) can gate on the SAME enforced rules the
+*  post-hoc file scan reports — `itemId` is the id the record is (or
+*  would be) stored under. The default `"enforced"` tier keeps every
+*  write gate on the historical three checks; only pass `"strict"` from
+*  report-only surfaces. */
+function validateRecordObject(record, itemId, schema, tier = "enforced") {
 	const idValue = record[schema.primaryKey];
 	if (typeof idValue !== "string" || idValue !== itemId) return `'${schema.primaryKey}' is '${String(idValue ?? "")}' but must equal the filename ('${itemId}'), or the record can't be opened`;
-	for (const [field, spec] of Object.entries(schema.fields)) {
-		if (COMPUTED_TYPES.has(spec.type)) continue;
-		const value = record[field];
-		const empty = value === void 0 || value === null || value === "";
-		if (spec.required && empty) return `missing required field '${field}'`;
-		if (!empty && spec.type === "enum" && spec.values && !spec.values.includes(String(value))) return `'${field}' = '${String(value)}' is not one of [${spec.values.join(", ")}]`;
-	}
-	return null;
+	return firstRecordProblem(record, schema, tier);
 }
 //#endregion
-//#region src/collection/server/discovery.ts
-var refRefine = (spec) => {
-	if (spec.type !== "ref") return true;
-	if (typeof spec.to !== "string") return false;
-	return safeSlugName(spec.to) !== null;
-};
-var refMessage = {
-	message: "fields with type 'ref' must declare a `to` that is a valid collection slug (alphanumeric / hyphen / underscore, no path separators)",
-	path: ["to"]
-};
-var isDateLike = (type) => type === "date" || type === "datetime";
-var isTimeStringField = (type) => type === "string" || type === "text";
-var embedRefine = (spec) => {
-	if (spec.type !== "embed") return true;
-	if (typeof spec.to !== "string" || safeSlugName(spec.to) === null) return false;
-	return (typeof spec.id === "string" && spec.id.trim().length > 0) !== (typeof spec.idField === "string" && spec.idField.trim().length > 0);
-};
-var embedMessage = {
-	message: "fields with type 'embed' must declare a `to` (valid collection slug) and exactly one of `id` (a fixed record's primary key) or `idField` (a sibling field naming the per-record target)",
-	path: ["id"]
-};
-var enumRefine = (spec) => spec.type !== "enum" || Array.isArray(spec.values) && spec.values.length > 0 && spec.values.every((value) => typeof value === "string" && value.length > 0);
-var enumMessage = {
-	message: "fields with type 'enum' must declare a non-empty `values` array of non-empty strings",
-	path: ["values"]
+//#region src/collection/core/schemaZ.ts
+/** Optional visibility predicate shared by actions and fields: the target
+*  shows only when the open record's `field` (stringified) is one of `in`.
+*  Domain-free — `field` is any non-empty key, `in` a non-empty array of
+*  non-empty values; the host never interprets the meaning.
+*
+*  `trim().min(1)` rather than bare `min(1)` so a whitespace-only string
+*  ("   ") fails validation — otherwise the cell formatter / dropdown would
+*  render visual blanks that look like missing data. Applied consistently to
+*  every "non-empty string" slot in this file (CodeRabbit PR #1497). */
+var WhenZ = zod.z.object({
+	field: zod.z.string().trim().min(1),
+	in: zod.z.array(zod.z.string().trim().min(1)).min(1)
+});
+var fieldBase = {
+	label: zod.z.string().min(1),
+	primary: zod.z.boolean().optional(),
+	required: zod.z.boolean().optional(),
+	when: WhenZ.optional()
 };
-var currencyRefine = (spec) => {
-	if (!(spec.type === "money" || spec.type === "derived" && spec.display === "money")) return true;
-	const hasLiteral = typeof spec.currency === "string" && spec.currency.trim().length > 0;
-	const hasPointer = typeof spec.currencyField === "string" && spec.currencyField.trim().length > 0;
-	return hasLiteral || hasPointer;
+var currencyKeys = {
+	currency: zod.z.string().trim().min(1).optional(),
+	currencyField: zod.z.string().trim().min(1).optional()
 };
+var hasCurrencySource = (spec) => spec.currency !== void 0 || spec.currencyField !== void 0;
 var currencyMessage = {
 	message: "fields that render as money (type 'money', or 'derived' with display 'money') must declare either a literal `currency` (ISO 4217 code, e.g. 'USD', 'JPY') or a `currencyField` naming the record field that holds the code",
 	path: ["currency"]
 };
-var WhenSchema = zod.z.object({
-	field: zod.z.string().trim().min(1),
-	in: zod.z.array(zod.z.string().trim().min(1)).min(1)
-});
-var SubFieldSpecSchema = zod.z.object({
+var slugMessage = (key) => ({
+	message: `\`${key}\` must be a valid collection slug (alphanumeric / hyphen / underscore, no path separators)`,
+	path: [key]
+});
+/** The plain scalar field types. Stored and edited as primitive values; no
+*  variant-specific keys.
+*  - `image`: a workspace-relative image path (e.g. a `data/attachments/...`
+*    upload); rendered as an <img> in the detail view (not the list table —
+*    a per-row fetch is too expensive at scale). Stored as a plain string.
+*  - `file`: a workspace-relative file path as a plain string (e.g. an
+*    `artifacts/html/<name>.html` app). Rendered as a clickable link in both
+*    the list table and the detail view: HTML / SVG artifacts open their
+*    rendered form in a new tab; any other path opens in the File Explorer. */
+var ScalarFieldZ = zod.z.object({
 	type: zod.z.enum([
 		"string",
 		"text",
@@ -780,18 +877,39 @@ var SubFieldSpecSchema = zod.z.object({
 		"datetime",
 		"boolean",
 		"markdown",
-		"ref",
-		"money",
-		"enum"
+		"image",
+		"file"
 	]),
+	...fieldBase
+});
+/** A link to another collection: the record stores the target item's
+*  primary-key slug and the host renders a clickable link + dropdown picker.
+*  `to` must be a real slug (not `../foo`, not `mc-clients/extra` — see
+*  Codex P2 on PR #1495); whether the target collection exists resolves
+*  fail-soft at render time, never here. */
+var RefFieldZ = zod.z.object({
+	type: zod.z.literal("ref"),
+	...fieldBase,
+	to: zod.z.string().min(1)
+}).refine((spec) => require_calendarGrid.isSafeSlug(spec.to), slugMessage("to"));
+/** A money amount. See `currencyKeys` for the currency-source contract. */
+var MoneyFieldZ = zod.z.object({
+	type: zod.z.literal("money"),
+	...fieldBase,
+	...currencyKeys
+}).refine(hasCurrencySource, currencyMessage);
+/** A closed set of allowed string values. The form renders a `<select>`
+*  populated from `values`; storage is a plain string. */
+var EnumFieldZ = zod.z.object({
+	type: zod.z.literal("enum"),
+	...fieldBase,
+	values: zod.z.array(zod.z.string().trim().min(1)).min(1)
+});
+var subFieldBase = {
 	label: zod.z.string().min(1),
-	required: zod.z.boolean().optional(),
-	to: zod.z.string().min(1).optional(),
-	currency: zod.z.string().trim().min(1).optional(),
-	currencyField: zod.z.string().trim().min(1).optional(),
-	values: zod.z.array(zod.z.string().trim().min(1)).min(1).optional()
-}).refine(refRefine, refMessage).refine(enumRefine, enumMessage).refine(currencyRefine, currencyMessage);
-var FieldSpecSchema = zod.z.object({
+	required: zod.z.boolean().optional()
+};
+var SubScalarFieldZ = zod.z.object({
 	type: zod.z.enum([
 		"string",
 		"text",
@@ -800,62 +918,145 @@ var FieldSpecSchema = zod.z.object({
 		"date",
 		"datetime",
 		"boolean",
-		"markdown",
-		"ref",
-		"money",
-		"enum",
-		"table",
-		"derived",
-		"embed",
-		"image",
-		"file",
-		"toggle"
+		"markdown"
 	]),
-	label: zod.z.string().min(1),
-	primary: zod.z.boolean().optional(),
-	required: zod.z.boolean().optional(),
-	to: zod.z.string().min(1).optional(),
-	id: zod.z.string().trim().min(1).optional(),
-	idField: zod.z.string().trim().min(1).optional(),
-	currency: zod.z.string().trim().min(1).optional(),
-	currencyField: zod.z.string().trim().min(1).optional(),
-	values: zod.z.array(zod.z.string().trim().min(1)).min(1).optional(),
-	field: zod.z.string().trim().min(1).optional(),
-	onValue: zod.z.string().trim().min(1).optional(),
-	offValue: zod.z.string().trim().min(1).optional(),
-	of: zod.z.record(zod.z.string(), SubFieldSpecSchema).optional(),
-	formula: zod.z.string().trim().min(1).optional(),
-	/** Inner type to render a derived value as (e.g. `"money"`).
-	*  Restricted to the non-composite display targets — derived
-	*  values are scalars, so rendering them via `table` or another
-	*  `derived` would be meaningless. */
+	...subFieldBase
+});
+var SubRefFieldZ = zod.z.object({
+	type: zod.z.literal("ref"),
+	...subFieldBase,
+	to: zod.z.string().min(1)
+}).refine((spec) => require_calendarGrid.isSafeSlug(spec.to), slugMessage("to"));
+var SubMoneyFieldZ = zod.z.object({
+	type: zod.z.literal("money"),
+	...subFieldBase,
+	...currencyKeys
+}).refine(hasCurrencySource, currencyMessage);
+var SubEnumFieldZ = zod.z.object({
+	type: zod.z.literal("enum"),
+	...subFieldBase,
+	values: zod.z.array(zod.z.string().trim().min(1)).min(1)
+});
+var SubFieldSpecZ = zod.z.discriminatedUnion("type", [
+	SubScalarFieldZ,
+	SubRefFieldZ,
+	SubMoneyFieldZ,
+	SubEnumFieldZ
+]);
+/** A flat sub-table: each row is a record of `of`'s sub-schema (insertion
+*  order = column order). v0 disallows nested tables and derived columns to
+*  keep the editor + evaluator simple. */
+var TableFieldZ = zod.z.object({
+	type: zod.z.literal("table"),
+	...fieldBase,
+	of: zod.z.record(zod.z.string(), SubFieldSpecZ)
+}).refine((spec) => Object.keys(spec.of).length > 0, {
+	message: "fields with type 'table' must declare a non-empty `of` (sub-schema for each row)",
+	path: ["of"]
+});
+/** A computed scalar: `formula` is a tiny expression evaluated against the
+*  record — `+ - * /`, parens, identifier refs to top-level fields,
+*  `sum(tableField[].col)`, and `sum(tableField[].col * tableField[].col)`
+*  (see `./derivedFormula`). `display` picks the inner type the value renders
+*  as (default `"number"`) — restricted to the non-composite display targets,
+*  since a derived value is a scalar. Never stored; computed by `deriveAll`
+*  on both server and client. */
+var DerivedFieldZ = zod.z.object({
+	type: zod.z.literal("derived"),
+	...fieldBase,
+	formula: zod.z.string().trim().min(1),
 	display: zod.z.enum([
 		"string",
 		"number",
 		"money",
 		"date"
 	]).optional(),
-	when: WhenSchema.optional()
-}).refine(refRefine, refMessage).refine(enumRefine, enumMessage).refine(embedRefine, embedMessage).refine(currencyRefine, currencyMessage).refine((spec) => spec.type !== "table" || spec.of !== void 0 && Object.keys(spec.of).length > 0, {
-	message: "fields with type 'table' must declare a non-empty `of` (sub-schema for each row)",
-	path: ["of"]
-}).refine((spec) => spec.type !== "derived" || typeof spec.formula === "string" && spec.formula.length > 0, {
-	message: "fields with type 'derived' must declare a non-empty `formula` (see src/utils/collections/derivedFormula.ts)",
-	path: ["formula"]
-}).refine((spec) => spec.type !== "toggle" || typeof spec.field === "string" && spec.field.length > 0 && typeof spec.onValue === "string" && typeof spec.offValue === "string", {
-	message: "fields with type 'toggle' must declare `field` (the enum field to project), `onValue`, and `offValue`",
-	path: ["field"]
-});
-var ActionSpecSchema = zod.z.object({
+	...currencyKeys
+}).refine((spec) => spec.display !== "money" || hasCurrencySource(spec), currencyMessage);
+/** Pulls a record from another collection into the read-only detail view.
+*  Display-only — nothing is stored on this record, so it never appears in
+*  the list table or the edit form. Must declare a valid `to` slug (same
+*  path-traversal guard as `ref`) AND exactly one of `id` (a fixed target
+*  record, e.g. `me` for the singleton profile — same for every record) or
+*  `idField` (a sibling top-level field naming the per-record target, e.g.
+*  an invoice's `issuerId` selecting which profile to embed as the bill-from
+*  block; an absent/empty value resolves fail-soft to "no record"). The
+*  `idField` target is validated to be a real `ref`/`string` field by a
+*  schema-level refine below. */
+var EmbedFieldZ = zod.z.object({
+	type: zod.z.literal("embed"),
+	...fieldBase,
+	to: zod.z.string().min(1),
+	id: zod.z.string().trim().min(1).optional(),
+	idField: zod.z.string().trim().min(1).optional()
+}).refine((spec) => require_calendarGrid.isSafeSlug(spec.to) && spec.id !== void 0 !== (spec.idField !== void 0), {
+	message: "fields with type 'embed' must declare a `to` (valid collection slug) and exactly one of `id` (a fixed record's primary key) or `idField` (a sibling field naming the per-record target)",
+	path: ["id"]
+});
+/** Display-only REVERSE refs (plan step ② of plans/collection-ontology.md):
+*  a read-only sub-table of the records in collection `from` whose `via`
+*  ref field stores THIS record's primary key. Stores nothing (joins
+*  `COMPUTED_TYPES`); resolution is shared server/client via
+*  `core/backlinks.ts`. `display` names the `from` columns to show;
+*  `filter` (the standard `when` shape, matched against each SOURCE
+*  record) narrows the rows. Validation is shape-only, like `embed`:
+*  `from` must be a safe slug, but whether it exists — and whether `via` /
+*  `display` name real fields there — resolves fail-soft at render
+*  (empty sub-table). Do NOT add cross-schema existence checks here. */
+var BacklinksFieldZ = zod.z.object({
+	type: zod.z.literal("backlinks"),
+	...fieldBase,
+	from: zod.z.string().min(1),
+	via: zod.z.string().trim().min(1),
+	display: zod.z.array(zod.z.string().trim().min(1)).min(1),
+	filter: WhenZ.optional()
+}).refine((spec) => require_calendarGrid.isSafeSlug(spec.from), slugMessage("from"));
+/** A checkbox that is a pure PROJECTION of an `enum` field — it stores
+*  nothing of its own. Checked when the enum named by `field` equals
+*  `onValue`; toggling writes `onValue` / `offValue` back to that enum
+*  field. Lets a "done" checkbox front a kanban `status` field with the enum
+*  as the single source of truth (no separate stored boolean to keep in
+*  sync). `field` / `onValue` / `offValue` are validated against the target
+*  enum's `values` by a schema-level refine below. */
+var ToggleFieldZ = zod.z.object({
+	type: zod.z.literal("toggle"),
+	...fieldBase,
+	field: zod.z.string().trim().min(1),
+	onValue: zod.z.string().trim().min(1),
+	offValue: zod.z.string().trim().min(1)
+});
+var FieldSpecZ = zod.z.discriminatedUnion("type", [
+	ScalarFieldZ,
+	RefFieldZ,
+	MoneyFieldZ,
+	EnumFieldZ,
+	TableFieldZ,
+	DerivedFieldZ,
+	EmbedFieldZ,
+	BacklinksFieldZ,
+	ToggleFieldZ
+]);
+/** A schema-declared record action, rendered as a button in the read-only
+*  detail view. Domain-free: the host validates the shape; the meaning
+*  (which role, which template) is data. v1 ships only `kind: "chat"` —
+*  start a new chat in `role` with a templated seed prompt; the enum
+*  reserves room for a future `"mutate"` (status transitions) without
+*  another schema-shape change. */
+var ActionSpecZ = zod.z.object({
 	id: zod.z.string().trim().min(1),
 	label: zod.z.string().trim().min(1),
 	icon: zod.z.string().trim().min(1).optional(),
 	kind: zod.z.enum(["chat"]),
 	role: zod.z.string().trim().min(1),
 	template: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/invoice.md`; no `..`, no leading `/`, no backslash)"),
-	when: WhenSchema.optional()
-});
-var CustomViewSchema = zod.z.object({
+	when: WhenZ.optional()
+});
+/** A custom (LLM-authored) HTML view registration. Domain-free: the host
+*  validates the shape; the view's behaviour lives in the HTML file. `file`
+*  is constrained to `views/*.html` (path-safe) so the view-file reader can
+*  never reach the data folder or the schema/template files. `id` is
+*  validated to be a real slug + unique by schema-level refines below. */
+var CustomViewZ = zod.z.object({
 	id: zod.z.string().trim().min(1),
 	label: zod.z.string().trim().min(1),
 	icon: zod.z.string().trim().min(1).optional(),
@@ -868,7 +1069,14 @@ var CustomViewSchema = zod.z.object({
 	imageFields: zod.z.array(zod.z.string().trim().min(1)).optional(),
 	imageMaxEdge: zod.z.number().int().min(1).optional()
 });
-var EveryLiteralSchema = zod.z.object({
+/** Recurrence advance for `spawn.every`. `interval` is a positive integer
+*  count of `unit`s (`interval: 3` + `unit: "month"` = quarterly);
+*  `dayOfMonth` (month/year only) is the CANONICAL day-of-month anchor
+*  (1-31, read from the rule and clamped per-month at compute time so "31st
+*  of every month" never drifts) or the `"last"` sentinel for end-of-month.
+*  `.strict()` so the union below cleanly rejects an object carrying BOTH
+*  `unit` and `fromField` (it fails this arm on the unknown `fromField`). */
+var EveryLiteralZ = zod.z.object({
 	unit: zod.z.enum([
 		"day",
 		"week",
@@ -878,17 +1086,114 @@ var EveryLiteralSchema = zod.z.object({
 	interval: zod.z.number().int().min(1),
 	dayOfMonth: zod.z.union([zod.z.number().int().min(1).max(31), zod.z.literal("last")]).optional()
 }).strict();
-var EveryFieldDrivenSchema = zod.z.object({
+/** Field-driven recurrence: pick the interval per-record by an `enum`
+*  field's value — one collection can mix daily / weekly / monthly
+*  obligations in a single list. `map` keys are validated to exactly cover
+*  that field's `values` by a `CollectionSchemaZ` refine (which can see the
+*  sibling `fields`); here each map value just has to be a well-formed
+*  literal `every`. `.strict()` mirrors the literal arm so a both-keys
+*  object fails this arm too. */
+var EveryFieldDrivenZ = zod.z.object({
 	fromField: zod.z.string().trim().min(1),
-	map: zod.z.record(zod.z.string(), EveryLiteralSchema)
+	map: zod.z.record(zod.z.string(), EveryLiteralZ)
 }).strict();
-var EverySchema = zod.z.union([EveryLiteralSchema, EveryFieldDrivenSchema]);
-var SpawnSchema = zod.z.object({
-	when: WhenSchema.optional(),
-	every: EverySchema,
+/** Either a single literal interval (applied to every record) or the
+*  field-driven map. Two `.strict()` arms mean "both keys" and "neither
+*  key" both fail validation, with no extra refine. */
+var EveryZ = zod.z.union([EveryLiteralZ, EveryFieldDrivenZ]);
+/** Host-driven recurrence: when a record satisfies `when` (default:
+*  "`completionField` value ∈ `completionDoneValues`"), the host creates the
+*  next record with a forward-advanced `triggerField` date. `carry` copies
+*  record fields verbatim onto the successor; `set` forces fixed values
+*  (typically resetting the status field to its pending value). The
+*  successor's id and contents are a pure function of (source record, this
+*  rule); creation is create-if-absent, so the mechanism stays convergent. */
+var SpawnZ = zod.z.object({
+	when: WhenZ.optional(),
+	every: EveryZ,
 	carry: zod.z.array(zod.z.string().trim().min(1)).optional(),
 	set: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
 });
+/** Declarative retrieval config for a Feed (a collection that refills itself
+*  from the internet). `http-json` needs `itemsAt` (a path to the items
+*  array) only when the response body isn't itself the array; rss/atom yield
+*  items natively and ignore it — so no kind-specific requirement here. */
+var DeclarativeIngestZ = zod.z.object({
+	kind: zod.z.enum(require_calendarGrid.INGEST_KINDS),
+	url: zod.z.string().url(),
+	schedule: zod.z.enum(require_calendarGrid.FEED_SCHEDULES),
+	atHour: zod.z.number().int().min(0).max(23).optional(),
+	itemsAt: zod.z.string().trim().min(1).optional(),
+	map: zod.z.record(zod.z.string().trim().min(1), zod.z.string().trim().min(1)),
+	idFrom: zod.z.string().trim().min(1).optional(),
+	maxItems: zod.z.number().int().min(0).optional()
+});
+/** Agent-performed retrieval. Valid on any collection (the primary consumer
+*  is skill-backed collections — feeds keep their declarative kinds). No
+*  `url`/`map`: the worker owns retrieval and record shape, seeded by
+*  `template` + a summary of every record, run in `role`. `template` is
+*  validated the SAME way an action's template is (safe path under
+*  `templates/`), so the skill-bridge mirrors it identically. */
+var AgentIngestZ = zod.z.object({
+	kind: zod.z.literal(require_calendarGrid.AGENT_INGEST_KIND),
+	schedule: zod.z.enum(require_calendarGrid.FEED_SCHEDULES),
+	atHour: zod.z.number().int().min(0).max(23).optional(),
+	role: zod.z.string().trim().min(1),
+	template: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/refresh.md`; no `..`, no leading `/`, no backslash)")
+});
+/** `ingest` is a discriminated union on `kind`: the three declarative
+*  retrievers fetch-and-map; `agent` dispatches a hidden worker. Optional on
+*  every schema — skill-backed collections usually omit it; only feeds
+*  discovered from `<workspace>/feeds/` are REQUIRED to carry it (gated by
+*  `acceptParsedSchema`). */
+var IngestZ = zod.z.discriminatedUnion("kind", [DeclarativeIngestZ, AgentIngestZ]);
+var ValueRefZ = zod.z.object({
+	record: zod.z.string().trim().min(1).optional(),
+	field: zod.z.string().trim().min(1)
+});
+var WhereCondZ = zod.z.object({
+	field: zod.z.string().trim().min(1),
+	op: zod.z.enum([
+		"eq",
+		"ne",
+		"in",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"contains"
+	]),
+	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
+	valueFrom: ValueRefZ.optional()
+}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
+	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
+	path: ["value"]
+}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
+	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
+	path: ["value"]
+});
+var WhereZ = zod.z.array(WhereCondZ);
+var DynamicIconSourceZ = zod.z.object({
+	collection: zod.z.string().trim().min(1),
+	from: zod.z.enum([
+		"latest",
+		"first",
+		"when"
+	]).optional(),
+	orderBy: zod.z.string().trim().min(1).optional(),
+	where: WhereZ.optional()
+});
+var DynamicIconRuleZ = zod.z.object({
+	where: WhereZ,
+	icon: zod.z.string().trim().min(1)
+});
+var DynamicIconSpecZ = zod.z.object({
+	source: DynamicIconSourceZ,
+	rules: zod.z.array(DynamicIconRuleZ),
+	fallback: zod.z.string().trim().min(1).optional()
+});
+var isDateLike = (type) => type === "date" || type === "datetime";
+var isTimeStringField = (type) => type === "string" || type === "text";
 var CODE_FIELD_TYPES = /* @__PURE__ */ new Set([
 	"string",
 	"text",
@@ -926,7 +1231,7 @@ function spawnSuccessorStartsInert(schema) {
 }
 function fieldDrivenSpawnEvery(schema) {
 	const every = schema.spawn?.every;
-	if (!every || !require_deriveAll.isFieldDrivenEvery(every)) return null;
+	if (!every || !("fromField" in every)) return null;
 	return every;
 }
 function fieldDrivenFromFieldIsEnum(schema) {
@@ -954,93 +1259,30 @@ function fieldDrivenFromFieldCarried(schema) {
 	}
 	return (carry ?? []).includes(driven.fromField);
 }
-var DeclarativeIngestZ = zod.z.object({
-	kind: zod.z.enum(require_deriveAll.INGEST_KINDS),
-	url: zod.z.string().url(),
-	schedule: zod.z.enum(require_deriveAll.FEED_SCHEDULES),
-	atHour: zod.z.number().int().min(0).max(23).optional(),
-	itemsAt: zod.z.string().trim().min(1).optional(),
-	map: zod.z.record(zod.z.string().trim().min(1), zod.z.string().trim().min(1)),
-	idFrom: zod.z.string().trim().min(1).optional(),
-	maxItems: zod.z.number().int().min(0).optional()
-});
-var AgentIngestZ = zod.z.object({
-	kind: zod.z.literal(require_deriveAll.AGENT_INGEST_KIND),
-	schedule: zod.z.enum(require_deriveAll.FEED_SCHEDULES),
-	atHour: zod.z.number().int().min(0).max(23).optional(),
-	role: zod.z.string().trim().min(1),
-	template: zod.z.string().trim().min(1).refine(require_collection_paths.isSafeActionTemplatePath, "must be a safe path under `templates/` (e.g. `templates/refresh.md`; no `..`, no leading `/`, no backslash)")
-});
-var IngestSchemaZ = zod.z.discriminatedUnion("kind", [DeclarativeIngestZ, AgentIngestZ]);
-var ValueRefZ = zod.z.object({
-	record: zod.z.string().trim().min(1).optional(),
-	field: zod.z.string().trim().min(1)
-});
-var WhereCondZ = zod.z.object({
-	field: zod.z.string().trim().min(1),
-	op: zod.z.enum([
-		"eq",
-		"ne",
-		"in",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"contains"
-	]),
-	value: zod.z.union([zod.z.string(), zod.z.array(zod.z.string())]).optional(),
-	valueFrom: ValueRefZ.optional()
-}).refine((cond) => cond.value !== void 0 !== (cond.valueFrom !== void 0), {
-	message: "a where condition must declare exactly one of `value` (a literal) or `valueFrom` (a reference to another record's field), never both or neither",
-	path: ["value"]
-}).refine((cond) => cond.value === void 0 || cond.op === "in" === Array.isArray(cond.value), {
-	message: "`in` requires an array `value` (the allowed set); every other op requires a single string `value`",
-	path: ["value"]
-});
-var WhereZ = zod.z.array(WhereCondZ);
-var DynamicIconSourceZ = zod.z.object({
-	collection: zod.z.string().trim().min(1),
-	from: zod.z.enum([
-		"latest",
-		"first",
-		"when"
-	]).optional(),
-	orderBy: zod.z.string().trim().min(1).optional(),
-	where: WhereZ.optional()
-});
-var DynamicIconRuleZ = zod.z.object({
-	where: WhereZ,
-	icon: zod.z.string().trim().min(1)
-});
-var DynamicIconSpecZ = zod.z.object({
-	source: DynamicIconSourceZ,
-	rules: zod.z.array(DynamicIconRuleZ),
-	fallback: zod.z.string().trim().min(1).optional()
-});
 var CollectionSchemaZ = zod.z.object({
 	title: zod.z.string().min(1),
 	icon: zod.z.string().min(1),
 	dataPath: zod.z.string().min(1),
 	primaryKey: zod.z.string().min(1),
 	singleton: zod.z.string().trim().min(1).optional(),
-	fields: zod.z.record(zod.z.string(), FieldSpecSchema),
-	actions: zod.z.array(ActionSpecSchema).optional(),
-	collectionActions: zod.z.array(ActionSpecSchema).optional(),
+	fields: zod.z.record(zod.z.string(), FieldSpecZ),
+	actions: zod.z.array(ActionSpecZ).optional(),
+	collectionActions: zod.z.array(ActionSpecZ).optional(),
 	completionField: zod.z.string().trim().min(1).optional(),
 	completionDoneValues: zod.z.array(zod.z.string().trim().min(1)).min(1).optional(),
 	displayField: zod.z.string().trim().min(1).optional(),
 	triggerField: zod.z.string().trim().min(1).optional(),
 	triggerLeadDays: zod.z.number().int().min(0).optional(),
-	spawn: SpawnSchema.optional(),
+	spawn: SpawnZ.optional(),
 	calendarField: zod.z.string().trim().min(1).optional(),
 	calendarEndField: zod.z.string().trim().min(1).optional(),
 	calendarTimeField: zod.z.string().trim().min(1).optional(),
 	kanbanField: zod.z.string().trim().min(1).optional(),
-	views: zod.z.array(CustomViewSchema).optional(),
-	notifyWhen: WhenSchema.optional(),
-	ingest: IngestSchemaZ.optional(),
+	views: zod.z.array(CustomViewZ).optional(),
+	notifyWhen: WhenZ.optional(),
+	ingest: IngestZ.optional(),
 	dynamicIcon: DynamicIconSpecZ.optional()
-}).refine((schema) => schema.singleton === void 0 || safeRecordId(schema.singleton) !== null, {
+}).refine((schema) => schema.singleton === void 0 || require_calendarGrid.isSafeRecordId(schema.singleton), {
 	message: "schema `singleton` must be a valid item id (alphanumeric / hyphen / underscore / interior dot, no `..` or path separators)",
 	path: ["singleton"]
 }).refine((schema) => schema.actions === void 0 || new Set(schema.actions.map((action) => action.id)).size === schema.actions.length, {
@@ -1131,13 +1373,15 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => schema.notifyWhen === void 0 || schema.fields[schema.notifyWhen.field] !== void 0, {
 	message: "schema `notifyWhen.field` must name a top-level field declared in `fields`",
 	path: ["notifyWhen"]
-}).refine((schema) => schema.views === void 0 || schema.views.every((view) => safeSlugName(view.id) !== null), {
+}).refine((schema) => schema.views === void 0 || schema.views.every((view) => require_calendarGrid.isSafeSlug(view.id)), {
 	message: "every `views[].id` must be a valid slug (alphanumeric / hyphen / underscore, no path separators)",
 	path: ["views"]
 }).refine((schema) => schema.views === void 0 || new Set(schema.views.map((view) => view.id)).size === schema.views.length, {
 	message: "schema `views` must have unique `id`s",
 	path: ["views"]
 });
+//#endregion
+//#region src/collection/server/discovery.ts
 function applyFeedSchemaDefaults(parsed, slug) {
 	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return parsed;
 	const obj = parsed;
@@ -1320,6 +1564,72 @@ function toDetail(collection) {
 	};
 }
 //#endregion
+//#region src/collection/server/ontology.ts
+/** Extract the relations a schema declares, in field declaration order:
+*  top-level `ref` / `embed` / `backlinks` fields plus `ref` sub-fields
+*  inside `table` columns. Pure — exported so the phase-2 graph panel
+*  can reuse it on already-loaded schemas. */
+function schemaRelations(schema) {
+	const relations = [];
+	for (const [key, spec] of Object.entries(schema.fields)) {
+		if (spec.type === "ref" || spec.type === "embed") relations.push({
+			field: key,
+			kind: spec.type,
+			to: spec.to
+		});
+		if (spec.type === "backlinks") relations.push({
+			field: key,
+			kind: "backlinks",
+			to: spec.from
+		});
+		if (spec.type !== "table") continue;
+		for (const [subKey, subSpec] of Object.entries(spec.of)) if (subSpec.type === "ref") relations.push({
+			field: `${key}.${subKey}`,
+			kind: "ref",
+			to: subSpec.to
+		});
+	}
+	return relations;
+}
+/** Count the record files in a collection's data dir — the same
+*  `<id>.json` entries `listItems` considers, WITHOUT parsing them (the
+*  ontology is a summary; a malformed record is still a record). Each
+*  candidate is classified by the SHARED `isRegularFile` lstat helper —
+*  the exact file-disclosure defense `listItems` applies — so a
+*  symlinked record never counts and the count can't diverge from the
+*  readable set on any filesystem (Codex review on PR #2099, twice).
+*  Fail-soft: a missing dir or a dataDir escaping the workspace via
+*  symlink counts 0. */
+async function countRecordFiles(dataDir, workspaceRoot) {
+	if (!isContainedInRoot(dataDir, workspaceRoot)) return 0;
+	try {
+		const names = (await (0, node_fs_promises.readdir)(dataDir)).filter((name) => name.endsWith(".json") && !name.startsWith("."));
+		return (await Promise.all(names.map((name) => isRegularFile(node_path.default.join(dataDir, name))))).filter(Boolean).length;
+	} catch {
+		return 0;
+	}
+}
+async function toOntologyEntry(collection, workspaceRoot) {
+	const { schema } = collection;
+	return {
+		slug: collection.slug,
+		title: schema.title,
+		icon: schema.icon,
+		primaryKey: schema.primaryKey,
+		displayField: schema.displayField ?? schema.primaryKey,
+		recordCount: await countRecordFiles(collection.dataDir, workspaceRoot),
+		relations: schemaRelations(schema)
+	};
+}
+/** Build the workspace ontology: every discovered collection (slug-sorted,
+*  discovery's order), each with its outbound relations and a
+*  readdir-cheap record count — fine to call on demand. */
+async function buildWorkspaceOntology(opts = {}) {
+	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
+	const collections = await discoverCollections(opts);
+	return Promise.all(collections.map((collection) => toOntologyEntry(collection, workspaceRoot)));
+}
+//#endregion
 //#region src/collection/server/derive.ts
 /** Slugs of every collection referenced by a `ref` field — top-level
 *  and one level into `table` sub-fields (nested tables are
@@ -1342,6 +1652,13 @@ function uniqueEmbedTargets(schema) {
 	for (const field of Object.values(schema.fields)) if (field.type === "embed" && typeof field.to === "string" && field.to.length > 0) targets.add(field.to);
 	return [...targets];
 }
+/** Slugs of every SOURCE collection a `backlinks` field reverses over —
+*  loaded exactly like ref/embed targets (whole collection, once). */
+function uniqueBacklinkSources(schema) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const field of Object.values(schema.fields)) if (field.type === "backlinks" && field.from.length > 0) sources.add(field.from);
+	return [...sources];
+}
 async function loadTarget(slug, opts) {
 	const target = await loadCollection(slug, opts);
 	if (!target) return null;
@@ -1349,18 +1666,23 @@ async function loadTarget(slug, opts) {
 	const byId = {};
 	for (const item of items) {
 		const itemId = item[target.schema.primaryKey];
-		if (typeof itemId === "string" && itemId.length > 0) byId[itemId] = require_deriveAll.deriveAll(target.schema, item, {});
+		if (typeof itemId === "string" && itemId.length > 0) byId[itemId] = require_calendarGrid.deriveAll(target.schema, item, {});
 	}
 	return {
 		schema: target.schema,
 		byId
 	};
 }
-/** Load every ref/embed target collection once. Unknown / unloadable
-*  targets are simply absent — downstream derefs resolve to null, the
-*  same fail-soft the UI renders as an em-dash. */
+/** Load every ref/embed target and backlink source collection once.
+*  Unknown / unloadable targets are simply absent — downstream derefs
+*  resolve to null (em-dash) and backlinks to an empty row set, the
+*  same fail-soft the UI renders. */
 async function loadLinkedTargets(schema, opts) {
-	const slugs = [.../* @__PURE__ */ new Set([...uniqueRefTargets(schema), ...uniqueEmbedTargets(schema)])];
+	const slugs = [.../* @__PURE__ */ new Set([
+		...uniqueRefTargets(schema),
+		...uniqueEmbedTargets(schema),
+		...uniqueBacklinkSources(schema)
+	])];
 	const loaded = {};
 	for (const slug of slugs) {
 		const target = await loadTarget(slug, opts);
@@ -1371,16 +1693,29 @@ async function loadLinkedTargets(schema, opts) {
 function toRefRecords(linked) {
 	return Object.fromEntries(Object.entries(linked).map(([slug, target]) => [slug, target.byId]));
 }
+/** The matching source rows for one `backlinks` field, projected to the
+*  source primaryKey + `display` columns — so getItems on a
+*  heavily-referenced record stays a summary, not a dump of the source
+*  collection. Missing source ⇒ [] (fail-soft). The rows come from the
+*  DERIVED source records (`byId`), so `display`/`filter` on a derived
+*  source column (an invoice `total`) works. */
+function projectBacklinks(field, schema, enriched, linked) {
+	const source = linked[field.from];
+	if (!source) return [];
+	return require_calendarGrid.backlinkRows(field, String(enriched[schema.primaryKey] ?? ""), Object.values(source.byId)).map((row) => require_calendarGrid.projectBacklinkRow(row, field.display, source.schema.primaryKey));
+}
 /** Project the computed (never-stored) field kinds onto one derived
 *  record: `toggle` → boolean off its enum, `embed` → the target record
-*  (fixed `id` or per-record `idField`), or null when missing. */
+*  (fixed `id` or per-record `idField`), or null when missing,
+*  `backlinks` → the matching source rows (see `projectBacklinks`). */
 function projectComputed(schema, enriched, linked) {
 	for (const [key, field] of Object.entries(schema.fields)) {
 		if (field.type === "toggle" && field.field) enriched[key] = String(enriched[field.field] ?? "") === field.onValue;
 		if (field.type === "embed" && field.to) {
-			const targetId = require_deriveAll.embedTargetId(field, enriched);
+			const targetId = require_calendarGrid.embedTargetId(field, enriched);
 			enriched[key] = targetId && linked[field.to]?.byId[targetId] || null;
 		}
+		if (field.type === "backlinks") enriched[key] = projectBacklinks(field, schema, enriched, linked);
 	}
 	return enriched;
 }
@@ -1392,7 +1727,7 @@ async function enrichItems(collection, items, opts = {}) {
 	const { schema } = collection;
 	const linked = await loadLinkedTargets(schema, opts);
 	const refRecords = toRefRecords(linked);
-	return items.map((item) => projectComputed(schema, require_deriveAll.deriveAll(schema, item, refRecords), linked));
+	return items.map((item) => projectComputed(schema, require_calendarGrid.deriveAll(schema, item, refRecords), linked));
 }
 //#endregion
 //#region src/collection/server/dynamicIcon.ts
@@ -1428,9 +1763,9 @@ async function computeCollectionIcon(collection, opts = {}) {
 		const source = await loadCollection(spec.source.collection, opts);
 		if (!source) return spec.fallback ?? schema.icon;
 		const ordered = sortByPrimaryKey(await listItems(source.dataDir, { workspaceRoot: opts.workspaceRoot }), source.schema.primaryKey);
-		const orderBy = spec.source.orderBy ?? require_deriveAll.firstDateField(source.schema);
+		const orderBy = spec.source.orderBy ?? require_calendarGrid.firstDateField(source.schema);
 		const recordsById = buildRecordsById(ordered, source.schema.primaryKey);
-		return require_deriveAll.resolveIcon(require_deriveAll.selectDynamicRecord(ordered, spec.source, orderBy, recordsById), spec, schema.icon, recordsById);
+		return require_calendarGrid.resolveIcon(require_calendarGrid.selectDynamicRecord(ordered, spec.source, orderBy, recordsById), spec, schema.icon, recordsById);
 	} catch (err) {
 		log.warn("collections", "dynamic icon compute failed, falling back", {
 			slug: collection.slug,
@@ -1564,7 +1899,7 @@ function matchesWhen(when, schema, item) {
 *  Discovery rejects a map that doesn't cover the enum's values, so null
 *  here means a record that predates a map/enum edit. */
 function resolveEvery(every, sourceItem) {
-	if (!require_deriveAll.isFieldDrivenEvery(every)) return every;
+	if (!require_calendarGrid.isFieldDrivenEvery(every)) return every;
 	const raw = sourceItem[every.fromField];
 	if (raw === void 0 || raw === null || raw === "") return null;
 	return every.map[String(raw)] ?? null;
@@ -1604,7 +1939,7 @@ function logSpawnSkip(slug, triggerField, every, sourceItem, sourceId) {
 		});
 		return;
 	}
-	const fromField = require_deriveAll.isFieldDrivenEvery(every) ? every.fromField : void 0;
+	const fromField = require_calendarGrid.isFieldDrivenEvery(every) ? every.fromField : void 0;
 	log.warn("collections", "spawn skipped: no `every` mapping for frequency value", {
 		slug,
 		sourceId,
@@ -1917,12 +2252,6 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 	};
 }
 //#endregion
-Object.defineProperty(exports, "COMPUTED_TYPES", {
-	enumerable: true,
-	get: function() {
-		return COMPUTED_TYPES;
-	}
-});
 Object.defineProperty(exports, "CollectionSchemaZ", {
 	enumerable: true,
 	get: function() {
@@ -1965,12 +2294,24 @@ Object.defineProperty(exports, "buildCollectionActionSeedPrompt", {
 		return buildCollectionActionSeedPrompt;
 	}
 });
+Object.defineProperty(exports, "buildWorkspaceOntology", {
+	enumerable: true,
+	get: function() {
+		return buildWorkspaceOntology;
+	}
+});
 Object.defineProperty(exports, "collectionsRegistriesConfigPath", {
 	enumerable: true,
 	get: function() {
 		return collectionsRegistriesConfigPath;
 	}
 });
+Object.defineProperty(exports, "compileRecordZ", {
+	enumerable: true,
+	get: function() {
+		return compileRecordZ;
+	}
+});
 Object.defineProperty(exports, "computeCollectionIcon", {
 	enumerable: true,
 	get: function() {
@@ -2067,6 +2408,12 @@ Object.defineProperty(exports, "isContainedInWorkspace", {
 		return isContainedInWorkspace;
 	}
 });
+Object.defineProperty(exports, "isRegularFile", {
+	enumerable: true,
+	get: function() {
+		return isRegularFile;
+	}
+});
 Object.defineProperty(exports, "isTriggerDue", {
 	enumerable: true,
 	get: function() {
@@ -2145,6 +2492,12 @@ Object.defineProperty(exports, "readSkillTemplate", {
 		return readSkillTemplate;
 	}
 });
+Object.defineProperty(exports, "recordFieldProblem", {
+	enumerable: true,
+	get: function() {
+		return recordFieldProblem;
+	}
+});
 Object.defineProperty(exports, "resolveCreateItemId", {
 	enumerable: true,
 	get: function() {
@@ -2181,6 +2534,12 @@ Object.defineProperty(exports, "safeSlugName", {
 		return safeSlugName;
 	}
 });
+Object.defineProperty(exports, "schemaRelations", {
+	enumerable: true,
+	get: function() {
+		return schemaRelations;
+	}
+});
 Object.defineProperty(exports, "setCollectionChangePublisher", {
 	enumerable: true,
 	get: function() {
@@ -2230,4 +2589,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-G6GtOdaW.cjs.map
+//# sourceMappingURL=server-bsNrf2yW.cjs.map