@mulmoclaude/core 0.15.0 → 0.18.1

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

@@ -1,5 +1,5 @@
 const require_rolldown_runtime = require("./rolldown-runtime-D6vf50IK.cjs");
-const require_calendarGrid = require("./calendarGrid-gN4sei7s.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);
@@ -648,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
@@ -667,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)`;
@@ -824,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
@@ -993,7 +1074,7 @@ 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):
+/** Display-only REVERSE refs (plan step ② of plans/done/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
@@ -1011,6 +1092,30 @@ var BacklinksFieldZ = zod.z.object({
 	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/done/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
@@ -1034,23 +1139,60 @@ var FieldSpecZ = zod.z.discriminatedUnion("type", [
 	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/done/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
@@ -1291,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"]
@@ -1577,9 +1734,9 @@ function schemaRelations(schema) {
 			kind: spec.type,
 			to: spec.to
 		});
-		if (spec.type === "backlinks") relations.push({
+		if (spec.type === "backlinks" || spec.type === "rollup") relations.push({
 			field: key,
-			kind: "backlinks",
+			kind: spec.type,
 			to: spec.from
 		});
 		if (spec.type !== "table") continue;
@@ -1652,11 +1809,12 @@ 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). */
+/** 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.from.length > 0) sources.add(field.from);
+	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) {
@@ -1719,6 +1877,24 @@ function projectComputed(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
@@ -1727,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
@@ -2282,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() {
@@ -2378,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() {
@@ -2589,4 +2777,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=server-bsNrf2yW.cjs.map
+//# sourceMappingURL=server-Cd6HA_3-.cjs.map