@mulmoclaude/core 0.15.0 → 0.18.1

package/dist/{server-BNTR7ySK.js → server-C3FOqabY.js}

@@ -1,4 +1,4 @@
-import { A as isSafeSlug, C as projectBacklinkRow, D as SAFE_RECORD_ID_PATTERN, F as embedTargetId, I as isFieldDrivenEvery, M as COMPUTED_TYPES, N as FEED_SCHEDULES, O as SAFE_SLUG_PATTERN, P as INGEST_KINDS, S as backlinkRows, b as selectDynamicRecord, h as deriveAll, j as AGENT_INGEST_KIND, k as isSafeRecordId, l as parseIsoDate, u as parseIsoDateTime, v as firstDateField, y as resolveIcon } from "./calendarGrid-CaR-q36Y.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";
@@ -646,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
@@ -822,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
@@ -991,7 +1072,7 @@ 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):
+/** 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
@@ -1009,6 +1090,30 @@ var BacklinksFieldZ = z.object({
 	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/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 = 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
@@ -1032,23 +1137,60 @@ var FieldSpecZ = 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 = 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/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 = 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
@@ -1289,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"]
@@ -1575,9 +1732,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;
@@ -1650,11 +1807,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) {
@@ -1717,6 +1875,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 ? 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
@@ -1725,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
@@ -2250,6 +2426,6 @@ async function deleteCustomView(collection, viewId, opts = {}) {
 	};
 }
 //#endregion
-export { getWorkspaceRoot as $, buildCollectionActionSeedPrompt as A, resolveCreateItemId as B, toSummary as C, compileRecordZ as D, validateRecordObject as E, promptPathsFor as F, isContainedInWorkspace as G, writeFileAtomic as H, readCustomViewHtml as I, resolveTemplatePath as J, itemFilePath as K, readCustomViewI18n as L, generateItemId as M, isRegularFile as N, recordFieldProblem as O, listItems as P, configureCollectionHost as Q, readItem as R, toDetail as S, validateCollectionRecords as T, SCHEMA_FILE as U, writeItem as V, isContainedInRoot as W, safeSlugName as X, safeRecordId as Y, collectionsRegistriesConfigPath as Z, buildWorkspaceOntology as _, computeSuccessor as a, discoverCollections as b, isTriggerDue as c, resolveEvery as d, log as et, successorId as f, enrichItems as g, computeCollectionIcon as h, advanceTriggerDate as i, deleteItem as j, buildActionSeedPrompt as k, maybeSpawnSuccessor as l, errorMessage as m, deleteCollection as n, setCollectionChangePublisher as nt, daysInMonth as o, ONE_SECOND_MS as p, resolveDataDir as q, deleteCollectionRefusalMessage as r, formatCivil as s, deleteCustomView as t, publishCollectionChange as tt, parseCivil as u, schemaRelations as v, CollectionSchemaZ as w, loadCollection as x, acceptParsedSchema as y, readSkillTemplate 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-BNTR7ySK.js.map
+//# sourceMappingURL=server-C3FOqabY.js.map