@mulmoclaude/core 0.14.0 → 0.18.0

package/dist/{server-Cd5WdM8a.cjs → server-BeoOWQ-a.cjs}

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_calendarGrid = require("./calendarGrid-C1rfCXJ3.cjs");
+const require_calendarGrid = require("./calendarGrid-CRaMAguM.cjs");
 const require_collection_paths = require("./collection/paths.cjs");
 let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
@@ -239,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();
@@ -635,13 +637,6 @@ ${templateText}`;
 }
 //#endregion
 //#region src/collection/core/recordZ.ts
-/** derived/embed/toggle are host-computed or projected — never written to
-*  the record JSON, so required / value checks must not apply to them. */
-var COMPUTED_TYPES = /* @__PURE__ */ new Set([
-	"derived",
-	"embed",
-	"toggle"
-]);
 /** 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 === "";
@@ -653,15 +648,6 @@ function enforcedProblem(key, spec, value) {
 	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
@@ -672,7 +658,7 @@ function coerceNumeric(value) {
 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 "money": return Number.isFinite(require_calendarGrid.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)`;
@@ -720,7 +706,7 @@ var compiled = /* @__PURE__ */ new WeakMap();
 function compileRecordZ(schema, tier) {
 	const cached = compiled.get(schema)?.[tier];
 	if (cached) return cached;
-	const stored = Object.entries(schema.fields).filter(([, spec]) => !COMPUTED_TYPES.has(spec.type));
+	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);
@@ -829,6 +815,96 @@ function validateRecordObject(record, itemId, schema, tier = "enforced") {
 	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`;
 	return firstRecordProblem(record, schema, tier);
 }
+/** The param name a `set` value references, or null when the value is a
+*  literal (non-strings can never be references). A bare/empty prefix
+*  (`"$params."`) returns the empty string — the schema refine rejects
+*  it as an undeclared param, never silently treats it as a literal. */
+function paramRefName(value) {
+	if (typeof value !== "string" || !value.startsWith("$params.")) return null;
+	return value.slice(8);
+}
+/** Resolve a mutate action's `set` map against the submitted params:
+*  literals pass through, `$params.<name>` reads the param value. An
+*  ABSENT referenced param omits the key entirely (merge semantics —
+*  the stored value survives), mirroring how the record form omits
+*  empty optionals rather than writing empty strings. */
+function resolveMutateSet(set, params) {
+	const resolved = {};
+	for (const [key, value] of Object.entries(set)) {
+		const ref = paramRefName(value);
+		if (ref === null) {
+			resolved[key] = value;
+			continue;
+		}
+		const paramValue = params[ref];
+		if (paramValue !== void 0 && paramValue !== null && paramValue !== "") resolved[key] = paramValue;
+	}
+	return resolved;
+}
+//#endregion
+//#region src/collection/server/mutate.ts
+/** First problem with the submitted params, or null. Every declared param
+*  is checked by the shared record-field validator; keys the action never
+*  declared are rejected outright — a stray key would otherwise ride the
+*  resolved `set` semantics silently. */
+function firstMutateParamProblem(action, params) {
+	const declared = action.params ?? {};
+	for (const key of Object.keys(params)) if (declared[key] === void 0) return `unknown param '${key}' — not declared by action '${action.id}'`;
+	for (const [key, spec] of Object.entries(declared)) {
+		const problem = recordFieldProblem(key, spec, params[key], "strict");
+		if (problem) return problem;
+	}
+	return null;
+}
+/** Apply one mutate action to one record. Never throws for data-shaped
+*  failures — the outcome's `problem` doubles as agent feedback when an
+*  LLM (not the user) pressed the button. */
+async function applyMutateAction(collection, action, itemId, params, opts = {}) {
+	const paramProblem = firstMutateParamProblem(action, params);
+	if (paramProblem) return {
+		ok: false,
+		status: "invalid-params",
+		problem: paramProblem
+	};
+	const existing = await readItem(collection.dataDir, itemId, opts);
+	if (!existing) return {
+		ok: false,
+		status: "not-found",
+		problem: `item '${itemId}' not found`
+	};
+	if (!require_calendarGrid.actionVisible(action, existing)) return {
+		ok: false,
+		status: "require-unmet",
+		problem: `action '${action.id}' is not available for item '${itemId}' in its current state`
+	};
+	const stored = Object.entries(existing).filter(([key]) => {
+		const spec = collection.schema.fields[key];
+		return !spec || !require_calendarGrid.COMPUTED_TYPES.has(spec.type);
+	});
+	const merged = {
+		...Object.fromEntries(stored),
+		...resolveMutateSet(action.set, params)
+	};
+	const invalid = validateRecordObject(merged, itemId, collection.schema);
+	if (invalid) return {
+		ok: false,
+		status: "invalid-record",
+		problem: invalid
+	};
+	const result = await writeItem(collection.dataDir, itemId, merged, {
+		workspaceRoot: opts.workspaceRoot,
+		slug: collection.slug
+	});
+	if (result.kind !== "ok") return {
+		ok: false,
+		status: "write-refused",
+		problem: `write refused (${result.kind})`
+	};
+	return {
+		ok: true,
+		item: merged
+	};
+}
 //#endregion
 //#region src/collection/core/schemaZ.ts
 /** Optional visibility predicate shared by actions and fields: the target
@@ -998,6 +1074,48 @@ var EmbedFieldZ = zod.z.object({
 	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 cross-collection AGGREGATE over a backlink relation (plan step ⑤ of
+*  plans/collection-ontology.md): a computed number — never stored — that
+*  sums a source column (or counts rows) over the records in `from` whose
+*  `via` ref points at this record. Same `from`/`via`/`filter` vocabulary
+*  and reverse-loading machinery as `backlinks`; resolution shared
+*  server/client via `core/backlinks.ts`'s `rollupValue`. Deliberately a
+*  STRUCTURED field, not `sumOver(...)` formula syntax — the derived
+*  evaluator's no-string-literals boundary stays untouched — and
+*  deliberately just `sum` | `count`. Rollups resolve BEFORE the formula
+*  pass, so a sibling `derived` formula may read them as identifiers
+*  (`played = homePlayed + awayPlayed`). Fail-soft: an unresolvable
+*  `from` renders em-dash; an empty match set is a real 0. */
+var RollupFieldZ = zod.z.object({
+	type: zod.z.literal("rollup"),
+	...fieldBase,
+	from: zod.z.string().min(1),
+	via: zod.z.string().trim().min(1),
+	op: zod.z.enum(["sum", "count"]),
+	column: zod.z.string().trim().min(1).optional(),
+	filter: WhenZ.optional()
+}).refine((spec) => require_calendarGrid.isSafeSlug(spec.from), slugMessage("from")).refine((spec) => spec.op === "sum" === (spec.column !== void 0), {
+	message: "a rollup's `column` names the source column to aggregate: required for op \"sum\", meaningless for op \"count\"",
+	path: ["column"]
+});
 /** 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
@@ -1020,23 +1138,61 @@ var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	TableFieldZ,
 	DerivedFieldZ,
 	EmbedFieldZ,
+	BacklinksFieldZ,
+	RollupFieldZ,
 	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({
+var actionBase = {
 	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"]),
+	icon: zod.z.string().trim().min(1).optional()
+};
+/** The LLM-seeded action kinds — same shape, different visibility:
+*  - `"chat"` — start a new VISIBLE chat in `role` with the templated
+*    seed prompt (judgment work: drafting, planning, conversation).
+*  - `"agent"` — dispatch a HIDDEN worker (origin `system`) with the SAME
+*    seed; it edits records via manageCollection and finishes silently
+*    (mechanical enrichment: refresh a price, fetch metadata). Spinner
+*    while running, deduped failure bell on error — see
+*    server/api/routes/collectionAgentActions.ts. */
+var SeededActionZ = zod.z.object({
+	kind: zod.z.enum(["chat", "agent"]),
+	...actionBase,
 	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: WhenZ.optional()
 });
+/** `kind: "mutate"` — a declarative, HOST-executed write; no LLM, no
+*  tokens (plan step ④ of plans/collection-ontology.md). Clicking the
+*  button (after an optional `params` mini-form) merges `set` into the
+*  record: values are literals or `$params.<name>` references. `require`
+*  is the state gate — the standard `when` shape, both the visibility
+*  rule AND the server-side authorization rule, exactly like `when` on
+*  the seeded kinds. `params` reuses the table sub-field DSL, and the
+*  form is validated by the SAME compiled record checks `putItems` uses
+*  (`recordFieldProblem`), not a third mechanism. Record-level only —
+*  a collection-level mutate has no record to write (schema refine
+*  below). Merge semantics make half-states unconstructible THROUGH
+*  THIS PATH; the raw file stays editable by design (lint, not lock). */
+var MutateActionZ = zod.z.object({
+	kind: zod.z.literal("mutate"),
+	...actionBase,
+	require: WhenZ.optional(),
+	params: zod.z.record(zod.z.string().trim().min(1), SubFieldSpecZ).optional(),
+	set: zod.z.record(zod.z.string().trim().min(1), zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean()
+	]))
+}).refine((spec) => Object.keys(spec.set).length > 0, {
+	message: "a mutate action's `set` must name at least one field to write",
+	path: ["set"]
+});
+/** A schema-declared record action, rendered as a button in the read-only
+*  detail view. Domain-free: the host validates the shape; the meaning
+*  (role + template prose, or the declarative `set`) is data. A
+*  discriminated union on `kind` — each kind declares only its own keys. */
+var ActionSpecZ = zod.z.discriminatedUnion("kind", [SeededActionZ, MutateActionZ]);
 /** 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
@@ -1277,6 +1433,21 @@ var CollectionSchemaZ = zod.z.object({
 }).refine((schema) => schema.collectionActions === void 0 || new Set(schema.collectionActions.map((action) => action.id)).size === schema.collectionActions.length, {
 	message: "schema `collectionActions` must have unique `id`s",
 	path: ["collectionActions"]
+}).refine((schema) => (schema.actions ?? []).every((action) => action.kind !== "mutate" || Object.keys(action.set).every((key) => {
+	const target = schema.fields[key];
+	return target !== void 0 && !require_calendarGrid.COMPUTED_TYPES.has(target.type) && key !== schema.primaryKey;
+})), {
+	message: "a mutate action's `set` keys must name declared, non-computed fields (and never the primaryKey)",
+	path: ["actions"]
+}).refine((schema) => (schema.actions ?? []).every((action) => action.kind !== "mutate" || Object.values(action.set).every((value) => {
+	const ref = paramRefName(value);
+	return ref === null || (action.params ?? {})[ref] !== void 0;
+})), {
+	message: "a mutate action's `$params.<name>` references must name keys declared in its `params`",
+	path: ["actions"]
+}).refine((schema) => (schema.collectionActions ?? []).every((action) => action.kind !== "mutate"), {
+	message: "`collectionActions` cannot contain `kind: \"mutate\"` — a collection-level action has no record to write",
+	path: ["collectionActions"]
 }).refine((schema) => collectCurrencyFieldRefs(schema.fields).every((name) => CODE_FIELD_TYPES.has(schema.fields[name]?.type ?? "")), {
 	message: "a money field's `currencyField` must name a top-level `string`, `text`, or `enum` field that holds the currency code",
 	path: ["fields"]
@@ -1550,6 +1721,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" || spec.type === "rollup") relations.push({
+			field: key,
+			kind: spec.type,
+			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
@@ -1572,6 +1809,14 @@ 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` or `rollup` field
+*  reverses over — loaded exactly like ref/embed targets (whole
+*  collection, once; the two field kinds share one load). */
+function uniqueBacklinkSources(schema) {
+	const sources = /* @__PURE__ */ new Set();
+	for (const field of Object.values(schema.fields)) if ((field.type === "backlinks" || field.type === "rollup") && 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;
@@ -1586,11 +1831,16 @@ async function loadTarget(slug, opts) {
 		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);
@@ -1601,9 +1851,21 @@ 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;
@@ -1611,9 +1873,28 @@ function projectComputed(schema, enriched, linked) {
 			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;
 }
+/** Resolve every rollup field onto a COPY of the record, BEFORE the
+*  formula pass — a `derived` formula may reference rollup values as
+*  plain identifiers (`played = homePlayed + awayPlayed`). Same reverse
+*  machinery as backlinks, collapsed to a number: an unresolvable source
+*  is null (a formula reading it fails soft to em-dash); an empty match
+*  set is a real 0. Returns `record` unchanged when the schema declares
+*  no rollups. */
+function projectRollups(schema, record, linked) {
+	let out = record;
+	for (const [key, field] of Object.entries(schema.fields)) {
+		if (field.type !== "rollup") continue;
+		if (out === record) out = { ...record };
+		const source = linked[field.from];
+		const selfId = String(record[schema.primaryKey] ?? "");
+		out[key] = source ? require_calendarGrid.rollupValue(field, selfId, Object.values(source.byId)) : null;
+	}
+	return out;
+}
 /** Enrich records with every host-computed field: derived formulas
 *  evaluated (cross-collection derefs included), toggles projected,
 *  embeds resolved. Loads each linked collection ONCE per call. Input
@@ -1622,7 +1903,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_calendarGrid.deriveAll(schema, item, refRecords), linked));
+	return items.map((item) => projectComputed(schema, require_calendarGrid.deriveAll(schema, projectRollups(schema, item, linked), refRecords), linked));
 }
 //#endregion
 //#region src/collection/server/dynamicIcon.ts
@@ -2147,12 +2428,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() {
@@ -2183,6 +2458,12 @@ Object.defineProperty(exports, "advanceTriggerDate", {
 		return advanceTriggerDate;
 	}
 });
+Object.defineProperty(exports, "applyMutateAction", {
+	enumerable: true,
+	get: function() {
+		return applyMutateAction;
+	}
+});
 Object.defineProperty(exports, "buildActionSeedPrompt", {
 	enumerable: true,
 	get: function() {
@@ -2195,6 +2476,12 @@ Object.defineProperty(exports, "buildCollectionActionSeedPrompt", {
 		return buildCollectionActionSeedPrompt;
 	}
 });
+Object.defineProperty(exports, "buildWorkspaceOntology", {
+	enumerable: true,
+	get: function() {
+		return buildWorkspaceOntology;
+	}
+});
 Object.defineProperty(exports, "collectionsRegistriesConfigPath", {
 	enumerable: true,
 	get: function() {
@@ -2273,6 +2560,12 @@ Object.defineProperty(exports, "errorMessage", {
 		return errorMessage;
 	}
 });
+Object.defineProperty(exports, "firstMutateParamProblem", {
+	enumerable: true,
+	get: function() {
+		return firstMutateParamProblem;
+	}
+});
 Object.defineProperty(exports, "formatCivil", {
 	enumerable: true,
 	get: function() {
@@ -2303,6 +2596,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() {
@@ -2423,6 +2722,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() {
@@ -2472,4 +2777,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-Cd5WdM8a.cjs.map
+//# sourceMappingURL=server-BeoOWQ-a.cjs.map