@mulmoclaude/core 0.14.0 → 0.18.0

package/dist/{server-Cc6XcyOA.js → server-0IVR-Y_G.js}

@@ -1,4 +1,4 @@
-import { A as isFieldDrivenEvery, C as SAFE_SLUG_PATTERN, D as FEED_SCHEDULES, E as AGENT_INGEST_KIND, O as INGEST_KINDS, S as SAFE_RECORD_ID_PATTERN, T as isSafeSlug, b as selectDynamicRecord, h as deriveAll, k as embedTargetId, l as parseIsoDate, u as parseIsoDateTime, v as firstDateField, w as isSafeRecordId, y as resolveIcon } from "./calendarGrid-kO6rGfm0.js";
+import { A as SAFE_RECORD_ID_PATTERN, C as coerceNumeric, E as actionVisible, F as COMPUTED_TYPES, I as FEED_SCHEDULES, L as INGEST_KINDS, M as isSafeRecordId, N as isSafeSlug, P as AGENT_INGEST_KIND, R as embedTargetId, S as backlinkRows, T as rollupValue, b as selectDynamicRecord, h as deriveAll, j as SAFE_SLUG_PATTERN, l as parseIsoDate, u as parseIsoDateTime, v as firstDateField, w as projectBacklinkRow, y as resolveIcon, z as isFieldDrivenEvery } from "./calendarGrid-B3dtFN-m.js";
 import { isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath } from "./collection/paths.js";
 import path from "node:path";
 import { promises, realpathSync } from "node:fs";
@@ -237,7 +237,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 lstat(filePath)).isFile();
@@ -633,13 +635,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 === "";
@@ -651,15 +646,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
@@ -827,6 +813,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 (!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 || !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
@@ -996,6 +1072,48 @@ var EmbedFieldZ = 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 = z.object({
+	type: z.literal("backlinks"),
+	...fieldBase,
+	from: z.string().min(1),
+	via: z.string().trim().min(1),
+	display: z.array(z.string().trim().min(1)).min(1),
+	filter: WhenZ.optional()
+}).refine((spec) => 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 = z.object({
+	type: z.literal("rollup"),
+	...fieldBase,
+	from: z.string().min(1),
+	via: z.string().trim().min(1),
+	op: z.enum(["sum", "count"]),
+	column: z.string().trim().min(1).optional(),
+	filter: WhenZ.optional()
+}).refine((spec) => 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
@@ -1018,23 +1136,61 @@ var FieldSpecZ = 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 = z.object({
+var actionBase = {
 	id: z.string().trim().min(1),
 	label: z.string().trim().min(1),
-	icon: z.string().trim().min(1).optional(),
-	kind: z.enum(["chat"]),
+	icon: 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 = z.object({
+	kind: z.enum(["chat", "agent"]),
+	...actionBase,
 	role: z.string().trim().min(1),
 	template: z.string().trim().min(1).refine(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 = z.object({
+	kind: z.literal("mutate"),
+	...actionBase,
+	require: WhenZ.optional(),
+	params: z.record(z.string().trim().min(1), SubFieldSpecZ).optional(),
+	set: z.record(z.string().trim().min(1), z.union([
+		z.string(),
+		z.number(),
+		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 = 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
@@ -1275,6 +1431,21 @@ var CollectionSchemaZ = 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 && !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"]
@@ -1548,6 +1719,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 readdir(dataDir)).filter((name) => name.endsWith(".json") && !name.startsWith("."));
+		return (await Promise.all(names.map((name) => isRegularFile(path.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
@@ -1570,6 +1807,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;
@@ -1584,11 +1829,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);
@@ -1599,9 +1849,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 backlinkRows(field, String(enriched[schema.primaryKey] ?? ""), Object.values(source.byId)).map((row) => 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;
@@ -1609,9 +1871,28 @@ function projectComputed(schema, enriched, linked) {
 			const targetId = 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 ? 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
@@ -1620,7 +1901,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, deriveAll(schema, item, refRecords), linked));
+	return items.map((item) => projectComputed(schema, deriveAll(schema, projectRollups(schema, item, linked), refRecords), linked));
 }
 //#endregion
 //#region src/collection/server/dynamicIcon.ts
@@ -2145,6 +2426,6 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 	};
 }
 //#endregion
-export { publishCollectionChange as $, deleteItem as A, writeFileAtomic as B, validateCollectionRecords as C, recordFieldProblem as D, compileRecordZ as E, readCustomViewI18n as F, resolveDataDir as G, isContainedInRoot as H, readItem as I, safeSlugName as J, resolveTemplatePath as K, readSkillTemplate as L, listItems as M, promptPathsFor as N, buildActionSeedPrompt as O, readCustomViewHtml as P, log as Q, resolveCreateItemId as R, CollectionSchemaZ as S, COMPUTED_TYPES as T, isContainedInWorkspace as U, SCHEMA_FILE as V, itemFilePath as W, configureCollectionHost as X, collectionsRegistriesConfigPath as Y, getWorkspaceRoot as Z, acceptParsedSchema as _, computeSuccessor as a, toDetail as b, isTriggerDue as c, resolveEvery as d, setCollectionChangePublisher as et, successorId as f, enrichItems as g, computeCollectionIcon as h, advanceTriggerDate as i, generateItemId as j, buildCollectionActionSeedPrompt as k, maybeSpawnSuccessor as l, errorMessage as m, deleteCollection as n, daysInMonth as o, ONE_SECOND_MS as p, safeRecordId as q, deleteCollectionRefusalMessage as r, formatCivil as s, deleteCustomView as t, parseCivil as u, discoverCollections as v, validateRecordObject as w, toSummary as x, loadCollection as y, writeItem as z };
+export { collectionsRegistriesConfigPath as $, recordFieldProblem as A, readItem as B, toSummary as C, validateCollectionRecords as D, firstMutateParamProblem as E, isRegularFile as F, SCHEMA_FILE as G, resolveCreateItemId as H, listItems as I, itemFilePath as J, isContainedInRoot as K, promptPathsFor as L, buildCollectionActionSeedPrompt as M, deleteItem as N, validateRecordObject as O, generateItemId as P, safeSlugName as Q, readCustomViewHtml as R, toDetail as S, applyMutateAction as T, writeItem as U, readSkillTemplate as V, writeFileAtomic as W, resolveTemplatePath as X, resolveDataDir as Y, safeRecordId as Z, buildWorkspaceOntology as _, computeSuccessor as a, discoverCollections as b, isTriggerDue as c, resolveEvery as d, configureCollectionHost as et, successorId as f, enrichItems as g, computeCollectionIcon as h, advanceTriggerDate as i, setCollectionChangePublisher as it, buildActionSeedPrompt as j, compileRecordZ as k, maybeSpawnSuccessor as l, errorMessage as m, deleteCollection as n, log as nt, daysInMonth as o, ONE_SECOND_MS as p, isContainedInWorkspace as q, deleteCollectionRefusalMessage as r, publishCollectionChange as rt, formatCivil as s, deleteCustomView as t, getWorkspaceRoot as tt, parseCivil as u, schemaRelations as v, CollectionSchemaZ as w, loadCollection as x, acceptParsedSchema as y, readCustomViewI18n as z };
 
-//# sourceMappingURL=server-Cc6XcyOA.js.map
+//# sourceMappingURL=server-0IVR-Y_G.js.map