@mulmoclaude/core 0.1.0

package/dist/collection/server/templatePath.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A safe skill-relative path: non-empty, no backslash, not absolute,
+ * and every `/`-separated segment is a plain `[A-Za-z0-9._-]+` token
+ * that isn't `.` / `..` (no traversal). Multi-segment (nested) paths
+ * are allowed. The reader's realpath containment is the hard
+ * guarantee; this fails a bad path fast.
+ */
+export declare function isSafeTemplatePath(value: string): boolean;
+/**
+ * An action `template` value: a safe path that lives under the skill's
+ * `templates/` subdir. This is the canonical contract — the schema
+ * validator rejects anything else up front, and the bridge mirrors
+ * exactly these. Nested paths (`templates/mail/welcome.md`) and any
+ * extension are allowed as long as the path is otherwise safe.
+ */
+export declare function isSafeActionTemplatePath(value: string): boolean;
+/**
+ * A custom-view `file` value: a safe path under the skill's `views/`
+ * subdir that ends in `.html`. Custom views are LLM-authored HTML the
+ * host renders in a sandboxed iframe; constraining them to `views/*.html`
+ * keeps the data folder and the schema/template files off-limits to the
+ * view-file reader. Same per-segment safety as templates; the reader's
+ * realpath containment is the hard guarantee.
+ */
+export declare function isSafeCustomViewPath(value: string): boolean;

package/dist/collection/server/util.d.ts

@@ -0,0 +1,3 @@
+/** Human-readable message from an unknown thrown value. */
+export declare function errorMessage(err: unknown): string;
+export declare const ONE_DAY_MS: number;

package/dist/collection/server/validate.d.ts

@@ -0,0 +1,19 @@
+import { LoadedCollection } from './discoveredCollection';
+import { CollectionItem, CollectionSchema } from '../core/schema';
+export interface RecordIssue {
+    /** Record filename, e.g. `lesson-003.json`. */
+    file: string;
+    /** Human-readable problem, written to be actionable by the LLM. */
+    problem: string;
+}
+export declare const COMPUTED_TYPES: ReadonlySet<string>;
+export declare function validateCollectionRecords(collection: LoadedCollection, opts?: {
+    workspaceRoot?: string;
+}): Promise<RecordIssue[]>;
+/** 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. */
+export declare function validateRecordObject(record: CollectionItem, itemId: string, schema: CollectionSchema): string | null;

package/dist/collection/server/views.d.ts

@@ -0,0 +1,20 @@
+import { IoOptions } from './io';
+import { LoadedCollection } from './discoveredCollection';
+export type DeleteViewResult = {
+    kind: "ok";
+    viewId: string;
+} | {
+    kind: "not-found";
+    viewId: string;
+} | {
+    kind: "user-scope";
+} | {
+    kind: "preset";
+} | {
+    kind: "unsafe-path";
+    viewId: string;
+};
+/** Delete one custom view from `collection`: unlink its HTML file and drop it
+ *  from every schema.json copy. User-scope and preset (mc-*) collections are
+ *  refused (read-only / re-seeded on boot), consistent with `deleteCollection`. */
+export declare function deleteCustomView(collection: LoadedCollection, viewId: string, opts?: IoOptions): Promise<DeleteViewResult>;

package/dist/deriveAll-C15OpM3K.cjs

@@ -0,0 +1,399 @@
+//#region src/collection/core/schema.ts
+/** Retriever kinds a Feed's `ingest.kind` may declare. The host's feeds engine
+*  dispatches on these; they live here (with the schema contract) so the schema
+*  validator can enforce them. The host re-exports these from
+*  `server/workspace/feeds/ingestTypes.ts`. */
+var INGEST_KINDS = [
+	"rss",
+	"atom",
+	"http-json"
+];
+/** Refresh cadences a Feed's `ingest.schedule` may declare. */
+var FEED_SCHEDULES = [
+	"hourly",
+	"daily",
+	"weekly",
+	"on-demand"
+];
+/** Narrowing guard: true when `every` is the field-driven arm. */
+function isFieldDrivenEvery(every) {
+	return "fromField" in every;
+}
+//#endregion
+//#region src/collection/core/derivedFormula.ts
+function evaluateDerived(formula, ctx) {
+	let tokens;
+	try {
+		tokens = tokenize(formula);
+	} catch {
+		return null;
+	}
+	const parser = new Parser(tokens);
+	let ast;
+	try {
+		ast = parser.parseExpr();
+		if (!parser.atEnd()) return null;
+	} catch {
+		return null;
+	}
+	const value = evaluate(ast, ctx);
+	return Number.isFinite(value) ? value : null;
+}
+var SINGLE_CHAR_PUNCT = new Set([
+	"(",
+	")",
+	"+",
+	"-",
+	"*",
+	"/",
+	"."
+]);
+function consumeWhitespace(cur) {
+	const char = cur.input[cur.index];
+	if (char === " " || char === "	" || char === "\n") {
+		cur.index++;
+		return true;
+	}
+	return false;
+}
+function consumeNumber(cur) {
+	const char = cur.input[cur.index] ?? "";
+	const next = cur.input[cur.index + 1] ?? "";
+	if (!isDigit(char) && !(char === "." && isDigit(next))) return null;
+	let raw = "";
+	while (cur.index < cur.input.length) {
+		const here = cur.input[cur.index] ?? "";
+		if (!isDigit(here) && here !== ".") break;
+		raw += here;
+		cur.index++;
+	}
+	const num = Number(raw);
+	if (!Number.isFinite(num)) throw new Error("bad number");
+	return {
+		kind: "number",
+		value: num
+	};
+}
+function consumeIdent(cur) {
+	if (!isIdentStart(cur.input[cur.index] ?? "")) return null;
+	let raw = "";
+	while (cur.index < cur.input.length && isIdentChar(cur.input[cur.index] ?? "")) {
+		raw += cur.input[cur.index];
+		cur.index++;
+	}
+	return {
+		kind: "ident",
+		value: raw
+	};
+}
+function consumePunct(cur) {
+	const char = cur.input[cur.index] ?? "";
+	if (char === "[" && cur.input[cur.index + 1] === "]") {
+		cur.index += 2;
+		return { kind: "[]" };
+	}
+	if (SINGLE_CHAR_PUNCT.has(char)) {
+		cur.index++;
+		return { kind: char };
+	}
+	return null;
+}
+function tokenize(input) {
+	const tokens = [];
+	const cur = {
+		input,
+		index: 0
+	};
+	while (cur.index < input.length) {
+		if (consumeWhitespace(cur)) continue;
+		const numTok = consumeNumber(cur);
+		if (numTok) {
+			tokens.push(numTok);
+			continue;
+		}
+		const punctTok = consumePunct(cur);
+		if (punctTok) {
+			tokens.push(punctTok);
+			continue;
+		}
+		const identTok = consumeIdent(cur);
+		if (identTok) {
+			tokens.push(identTok);
+			continue;
+		}
+		throw new Error(`unexpected char ${input[cur.index]}`);
+	}
+	return tokens;
+}
+function isDigit(char) {
+	return char >= "0" && char <= "9";
+}
+function isIdentStart(char) {
+	return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_";
+}
+function isIdentChar(char) {
+	return isIdentStart(char) || isDigit(char);
+}
+var Parser = class {
+	tokens;
+	cursor = 0;
+	constructor(tokens) {
+		this.tokens = tokens;
+	}
+	atEnd() {
+		return this.cursor >= this.tokens.length;
+	}
+	peek() {
+		return this.tokens[this.cursor];
+	}
+	consume() {
+		const tok = this.tokens[this.cursor++];
+		if (!tok) throw new Error("unexpected end of input");
+		return tok;
+	}
+	expect(kind) {
+		const tok = this.consume();
+		if (tok.kind !== kind) throw new Error(`expected ${kind}, got ${tok.kind}`);
+		return tok;
+	}
+	parseExpr() {
+		let left = this.parseTerm();
+		while (this.peek()?.kind === "+" || this.peek()?.kind === "-") {
+			const operator = this.consume().kind;
+			const right = this.parseTerm();
+			left = {
+				kind: "binop",
+				operator,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseTerm() {
+		let left = this.parseFactor();
+		while (this.peek()?.kind === "*" || this.peek()?.kind === "/") {
+			const operator = this.consume().kind;
+			const right = this.parseFactor();
+			left = {
+				kind: "binop",
+				operator,
+				left,
+				right
+			};
+		}
+		return left;
+	}
+	parseFactor() {
+		const tok = this.peek();
+		if (!tok) throw new Error("unexpected end in factor");
+		if (tok.kind === "number") {
+			this.consume();
+			return {
+				kind: "num",
+				value: tok.value
+			};
+		}
+		if (tok.kind === "(") {
+			this.consume();
+			const inner = this.parseExpr();
+			this.expect(")");
+			return inner;
+		}
+		if (tok.kind === "ident") {
+			const name = tok.value ?? "";
+			if (name === "sum" && this.tokens[this.cursor + 1]?.kind === "(") {
+				this.consume();
+				this.expect("(");
+				const arg = this.parseSumArg();
+				this.expect(")");
+				return {
+					kind: "sum",
+					arg
+				};
+			}
+			this.consume();
+			if (this.peek()?.kind === ".") {
+				this.consume();
+				return {
+					kind: "ref",
+					field: name,
+					col: this.expect("ident").value
+				};
+			}
+			return {
+				kind: "ident",
+				name
+			};
+		}
+		throw new Error(`unexpected token ${tok.kind} in factor`);
+	}
+	parseSumArg() {
+		const factors = [];
+		const operators = [];
+		factors.push(this.parseTableCol());
+		while (this.peek()?.kind === "*" || this.peek()?.kind === "/") {
+			const operator = this.consume().kind;
+			operators.push(operator);
+			factors.push(this.parseTableCol());
+		}
+		return {
+			factors,
+			operators
+		};
+	}
+	parseTableCol() {
+		const tableTok = this.expect("ident");
+		this.expect("[]");
+		this.expect(".");
+		const colTok = this.expect("ident");
+		return {
+			table: tableTok.value,
+			col: colTok.value
+		};
+	}
+};
+function evaluate(node, ctx) {
+	if (node.kind === "num") return node.value;
+	if (node.kind === "ident") {
+		const raw = ctx.record[node.name];
+		return toFiniteNumber(raw);
+	}
+	if (node.kind === "ref") {
+		const target = ctx.refs?.[node.field] ?? null;
+		if (!target) return NaN;
+		return toFiniteNumber(target[node.col]);
+	}
+	if (node.kind === "binop") {
+		const left = evaluate(node.left, ctx);
+		const right = evaluate(node.right, ctx);
+		return applyBinop(node.operator, left, right);
+	}
+	if (node.kind === "sum") return evaluateSum(node.arg, ctx);
+	throw new Error(`unknown node`);
+}
+function applyBinop(operator, left, right) {
+	if (!Number.isFinite(left) || !Number.isFinite(right)) return NaN;
+	if (operator === "+") return left + right;
+	if (operator === "-") return left - right;
+	if (operator === "*") return left * right;
+	if (right === 0) return NaN;
+	return left / right;
+}
+function evaluateSum(arg, ctx) {
+	if (arg.factors.length === 0) return 0;
+	const tableName = arg.factors[0].table;
+	for (const factor of arg.factors) if (factor.table !== tableName) return NaN;
+	const rows = ctx.record[tableName];
+	if (!Array.isArray(rows)) return 0;
+	let total = 0;
+	for (const row of rows) {
+		if (!row || typeof row !== "object") continue;
+		let product = toFiniteNumber(row[arg.factors[0].col]);
+		if (!Number.isFinite(product)) return NaN;
+		for (let i = 1; i < arg.factors.length; i++) {
+			const value = toFiniteNumber(row[arg.factors[i].col]);
+			if (!Number.isFinite(value)) return NaN;
+			product = applyBinop(arg.operators[i - 1], product, value);
+		}
+		total += product;
+	}
+	return total;
+}
+function toFiniteNumber(value) {
+	if (typeof value === "number") return Number.isFinite(value) ? value : NaN;
+	if (typeof value === "string" && value.length > 0) {
+		const num = Number(value);
+		return Number.isFinite(num) ? num : NaN;
+	}
+	return NaN;
+}
+//#endregion
+//#region src/collection/core/deriveAll.ts
+/** Map each `ref` field's stored slug to its loaded target record (or
+*  null when dangling / not loaded), keyed by the LOCAL field name —
+*  the shape `evaluateDerived` reads for `<field>.<col>` derefs. */
+function resolveRowRefs(schema, record, refRecords) {
+	const refs = {};
+	for (const [key, field] of Object.entries(schema.fields)) {
+		if (field.type !== "ref" || !field.to) continue;
+		const slug = record[key];
+		refs[key] = typeof slug === "string" ? refRecords[field.to]?.[slug] ?? null : null;
+	}
+	return refs;
+}
+/** Evaluate every `derived` field against `base`, saturating so a
+*  derived field can read another derived field computed in an earlier
+*  pass (`subtotal → tax → total` converges in ≤ field-count passes).
+*  Cycles can't loop forever — passes are bounded by the number of
+*  derived fields and the loop breaks as soon as a pass changes
+*  nothing. Failed formulas stay ABSENT (the UI renders them as
+*  em-dash). Returns a copy; `base` is never mutated.
+*
+*  Derived keys already present in `base` are stripped before
+*  evaluation: computed output is host-truth, never persisted-input
+*  fallback. A record JSON can carry a stale (or forged) derived value
+*  — raw Write/Edit, legacy data — and without the strip, a failing
+*  formula would silently surface that value as if the host computed
+*  it. */
+function deriveAll(schema, base, refRecords) {
+	const derivedKeys = new Set(Object.keys(schema.fields).filter((key) => schema.fields[key]?.type === "derived"));
+	const enriched = Object.fromEntries(Object.entries(base).filter(([key]) => !derivedKeys.has(key)));
+	const refs = resolveRowRefs(schema, base, refRecords);
+	const maxPasses = Object.values(schema.fields).filter((field) => field.type === "derived").length;
+	for (let pass = 0; pass < maxPasses; pass++) {
+		let mutated = false;
+		for (const [key, field] of Object.entries(schema.fields)) {
+			if (field.type !== "derived" || !field.formula) continue;
+			const next = evaluateDerived(field.formula, {
+				record: enriched,
+				refs
+			});
+			if (next !== null && enriched[key] !== next) {
+				enriched[key] = next;
+				mutated = true;
+			}
+		}
+		if (!mutated) break;
+	}
+	return enriched;
+}
+//#endregion
+Object.defineProperty(exports, "FEED_SCHEDULES", {
+	enumerable: true,
+	get: function() {
+		return FEED_SCHEDULES;
+	}
+});
+Object.defineProperty(exports, "INGEST_KINDS", {
+	enumerable: true,
+	get: function() {
+		return INGEST_KINDS;
+	}
+});
+Object.defineProperty(exports, "deriveAll", {
+	enumerable: true,
+	get: function() {
+		return deriveAll;
+	}
+});
+Object.defineProperty(exports, "evaluateDerived", {
+	enumerable: true,
+	get: function() {
+		return evaluateDerived;
+	}
+});
+Object.defineProperty(exports, "isFieldDrivenEvery", {
+	enumerable: true,
+	get: function() {
+		return isFieldDrivenEvery;
+	}
+});
+Object.defineProperty(exports, "resolveRowRefs", {
+	enumerable: true,
+	get: function() {
+		return resolveRowRefs;
+	}
+});
+
+//# sourceMappingURL=deriveAll-C15OpM3K.cjs.map

package/dist/deriveAll-C15OpM3K.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"deriveAll-C15OpM3K.cjs","names":[],"sources":["../src/collection/core/schema.ts","../src/collection/core/derivedFormula.ts","../src/collection/core/deriveAll.ts"],"sourcesContent":["// Schema-driven collection types. A \"collection\" is a skill (under\n// .claude/skills/<slug>/) that also ships a sibling `schema.json`.\n// The host's <CollectionView> reads the schema + records and renders\n// a table/form; Claude reads SKILL.md and CRUDs the records as JSON\n// files.\n//\n// Field types for v0 — keep this list narrow and grow it only when a\n// real collection needs the new type. v0 supports flat records only;\n// nested tables / cross-collection refs / derived fields / actions are\n// deferred to follow-ups (see plans/done/feat-skill-driven-apps.md and\n// plans/done/feat-skill-driven-apps-worklog.md — historical names predate\n// the rename).\n\n/** Minimal \"this collection is a feed\" descriptor carried on the schema.\n *  Deliberately narrow — the canonical collection contract stays\n *  independent of the host's feeds subsystem. The host's richer retrieval\n *  spec (`IngestSpec` in `server/workspace/feeds/ingestTypes.ts`)\n *  `extends CollectionIngest`, so feed code reads the extra fields by\n *  typing feed schemas with that subtype; collection rendering only needs\n *  these three + the presence check. */\nexport interface CollectionIngest {\n  kind: string;\n  url: string;\n  schedule: string;\n}\n\n/** Retriever kinds a Feed's `ingest.kind` may declare. The host's feeds engine\n *  dispatches on these; they live here (with the schema contract) so the schema\n *  validator can enforce them. The host re-exports these from\n *  `server/workspace/feeds/ingestTypes.ts`. */\nexport const INGEST_KINDS = [\"rss\", \"atom\", \"http-json\"] as const;\nexport type IngestKind = (typeof INGEST_KINDS)[number];\n\n/** Refresh cadences a Feed's `ingest.schedule` may declare. */\nexport const FEED_SCHEDULES = [\"hourly\", \"daily\", \"weekly\", \"on-demand\"] as const;\nexport type FeedSchedule = (typeof FEED_SCHEDULES)[number];\n\nexport type CollectionFieldType =\n  | \"string\"\n  | \"text\"\n  | \"email\"\n  | \"number\"\n  | \"date\"\n  | \"datetime\"\n  | \"boolean\"\n  | \"markdown\"\n  | \"ref\"\n  | \"money\"\n  | \"enum\"\n  | \"table\"\n  | \"derived\"\n  | \"embed\"\n  // Holds a workspace-relative image path (e.g. a `data/attachments/...`\n  // upload); rendered as an <img> in the detail view (not the list table —\n  // a per-row fetch is too expensive at scale). Stored and edited as a\n  // plain string.\n  | \"image\"\n  // Holds a workspace-relative file path as a plain string (e.g. an\n  // `artifacts/html/<name>.html` app). Rendered as a clickable link in\n  // both the list table and the detail view: HTML / SVG artifacts open\n  // their rendered form in a new tab; any other path opens in the File\n  // Explorer. Stored and edited as a plain string, like `image`.\n  | \"file\"\n  // A checkbox that is a pure PROJECTION of an `enum` field — it stores\n  // nothing of its own. Checked when the enum equals `onValue`; toggling\n  // writes `onValue` / `offValue` back to that enum field. Lets a \"done\"\n  // checkbox front a kanban `status` field with the enum as the single\n  // source of truth (no separate stored boolean to keep in sync).\n  | \"toggle\";\n\n// \"feed\" collections live in the non-skill `<workspace>/feeds/` registry\n// and carry an `ingest` block; they reuse the same storage + rendering\n// as skill-backed collections but are never loaded into the agent prompt.\nexport type CollectionSource = \"user\" | \"project\" | \"feed\";\n\n/** Recurrence unit for a `spawn.every` advance. */\nexport type CollectionRecurUnit = \"day\" | \"week\" | \"month\" | \"year\";\n\n/** How a `spawn` advances the source item's `triggerField` date to\n *  produce the successor's. All arithmetic is done on the civil\n *  (year, month, day) triple — never by adding milliseconds — so month\n *  lengths and leap years are handled correctly. */\nexport interface CollectionEvery {\n  unit: CollectionRecurUnit;\n  /** Number of `unit`s to advance (≥ 1). `interval: 3` + `unit: \"month\"`\n   *  = quarterly; `interval: 1` + `unit: \"year\"` = annual. */\n  interval: number;\n  /** Day-of-month anchor for `month`/`year` units. The CANONICAL day —\n   *  read from the rule, never re-derived from the prior concrete date,\n   *  so \"31st of every month\" yields 31 → 28/29 → 31 → 30 … with no\n   *  drift (it is clamped per-month at compute time, not stored\n   *  clamped). `\"last\"` always means the last day of the target month.\n   *  Omitted ⇒ preserve the source date's day (safe for days ≤ 28).\n   *  Ignored for `day`/`week` units. */\n  dayOfMonth?: number | \"last\";\n}\n\n/** Field-driven recurrence: the advance interval is selected PER RECORD by\n *  the value of an `enum` field (`fromField`), looked up in `map`. Lets one\n *  collection mix daily / weekly / monthly obligations in a single list — the\n *  host reads `record[fromField]`, finds the matching `CollectionEvery`, and\n *  advances by it. `fromField` must point at a top-level `enum` field whose\n *  `values` the `map` keys exactly cover (validated at discovery), and must\n *  itself be carried/`set` onto the successor so the chain keeps recurring. */\nexport interface CollectionEveryFieldDriven {\n  /** Top-level `enum` field whose value selects the interval. */\n  fromField: string;\n  /** Interval per enum value. Keys exactly cover `fromField`'s `values`;\n   *  each value is a literal {@link CollectionEvery}. */\n  map: Record<string, CollectionEvery>;\n}\n\n/** The `every` of a `spawn`: either a single literal interval applied to\n *  every record, or a per-record interval selected by an `enum` field. The\n *  literal arm is what `advanceTriggerDate` consumes — the field-driven arm\n *  is resolved down to one of its `map` values before the date math runs. */\nexport type CollectionSpawnEvery = CollectionEvery | CollectionEveryFieldDriven;\n\n/** Narrowing guard: true when `every` is the field-driven arm. */\nexport function isFieldDrivenEvery(every: CollectionSpawnEvery): every is CollectionEveryFieldDriven {\n  return \"fromField\" in every;\n}\n\n/** Host-driven recurrence: when a record satisfies `when`, the host\n *  creates the next record with a forward-advanced `triggerField` date.\n *  The successor's id and contents are a pure function of (source\n *  record, this rule); creation is create-if-absent, so the mechanism\n *  stays convergent — observing the predicate N times writes one\n *  successor. Requires the schema to declare `triggerField`. */\nexport interface CollectionSpawn {\n  /** Predicate that fires the spawn (a `CollectionWhen`). Defaults to\n   *  \"`completionField` value ∈ `completionDoneValues`\" (i.e. spawn the\n   *  next instance when this one is done). */\n  when?: CollectionWhen;\n  /** How to advance `triggerField` from the source to the successor —\n   *  either a single literal interval or a per-record, field-driven map. */\n  every: CollectionSpawnEvery;\n  /** Record fields copied verbatim onto the successor. Fields not listed\n   *  here, not in `set`, and not the trigger / primary keys start\n   *  blank. */\n  carry?: string[];\n  /** Fields forced to fixed values on the successor (typically resetting\n   *  the status field to its pending value). */\n  set?: Record<string, unknown>;\n}\n\n/** The kind of work an action kicks off. v1 ships only `\"chat\"` —\n *  start a new chat in a role with a templated seed prompt. The enum\n *  reserves room for a future `\"mutate\"` (status transitions) without\n *  another schema-shape change. */\nexport type CollectionActionKind = \"chat\";\n\n/** Optional visibility predicate: the target (an action button or a\n *  field) renders only when the open record's `field` (stringified) is\n *  one of `in`. Generic and domain-free — the host evaluates it against\n *  the record with no knowledge of what the field means. Absent ⇒\n *  always shown. */\nexport interface CollectionWhen {\n  /** Top-level record field key whose value gates visibility. */\n  field: string;\n  /** Allowed values; the target shows when `String(record[field])` is\n   *  one of these. Non-empty. */\n  in: string[];\n}\n\n/** @deprecated Name retained for back-compat; use {@link CollectionWhen}.\n *  Both actions and fields share the same predicate shape. */\nexport type CollectionActionWhen = CollectionWhen;\n\n/** What a custom view's capability token is allowed to do against the\n *  collection's data endpoint. `read` returns enriched records (getItems\n *  semantics); `write` validates-and-stores rows (putItems semantics).\n *  There is deliberately no `delete` — a view can never do more than the\n *  agent's own `manageCollection` tool. */\nexport type CollectionViewCapability = \"read\" | \"write\";\n\n/** A custom (LLM-authored) HTML view for a collection. The host renders\n *  `file` in a sandboxed iframe over the collection's records; the view\n *  reaches its data only through a slug- and capability-scoped token (see\n *  `server/api/auth/viewToken.ts`). Pure data — the host holds no\n *  view-specific code; meaning lives in the HTML file + this registration. */\nexport interface CollectionCustomView {\n  /** Stable id; the view-mode selector key (`custom:<id>`) and the\n   *  capability-token clamp key. Must be a valid slug. */\n  id: string;\n  /** Button label in the view-mode selector (author-authored, like field\n   *  labels — not run through i18n). */\n  label: string;\n  /** Optional Material-icon name for the selector button. */\n  icon?: string;\n  /** Skill-relative path to the HTML file under `views/` (e.g.\n   *  `views/year.html`). Path-safe, must end in `.html`. */\n  file: string;\n  /** What the view may do with the data endpoint. Defaults to `[\"read\"]`\n   *  (least privilege); declare `[\"read\",\"write\"]` only for views that\n   *  edit records. The mint endpoint clamps any requested caps to this. */\n  capabilities?: CollectionViewCapability[];\n}\n\n/** A schema-declared, per-record action rendered as a button in the\n *  read-only detail view. Pure UI/behaviour directive — never stored,\n *  never validated against record data. All domain specifics (label,\n *  role, template) live here in the schema / skill folder, so the host\n *  stays generic. */\nexport interface CollectionAction {\n  /** Stable id (used in the dispatch route + testids). */\n  id: string;\n  /** Button text (English, like field labels). */\n  label: string;\n  /** Material-icon name shown on the button. */\n  icon?: string;\n  /** What the action does. v1: `\"chat\"`. */\n  kind: CollectionActionKind;\n  /** `kind: \"chat\"`: the role id the new chat runs in. */\n  role: string;\n  /** `kind: \"chat\"`: skill-relative path to the template file whose\n   *  text becomes the seed prompt body (e.g. `templates/invoice.md`). */\n  template: string;\n  /** Optional visibility predicate; the button renders only when the\n   *  open record matches (see CollectionWhen). Absent ⇒ always\n   *  shown. */\n  when?: CollectionWhen;\n}\n\nexport interface CollectionFieldSpec {\n  type: CollectionFieldType;\n  label: string;\n  /** True for the field whose value is the record's filename (no\n   *  separate auto-id). Exactly one field per schema may set this. */\n  primary?: boolean;\n  required?: boolean;\n  /** When `type === \"ref\"` or `type === \"embed\"`: the slug of the\n   *  target collection. For `ref` the record stores the target\n   *  item's primary-key slug and the host renders a clickable link\n   *  + dropdown picker. For `embed` the host pulls a *fixed* record\n   *  (see `id`) from the target and renders its fields read-only in\n   *  the detail view. Required for both; ignored on every other\n   *  type. */\n  to?: string;\n  /** When `type === \"embed\"`: the primary-key value of the fixed\n   *  record to pull from the `to` collection (e.g. `me` for the\n   *  singleton mc-profile). Nothing is stored on this record — the\n   *  embed is a display-only directive resolved at render time, so\n   *  it never appears in the list table or the edit form. Required\n   *  when type is `embed`; ignored on every other type. */\n  id?: string;\n  /** When `type === \"money\"` (or `type === \"derived\"` with\n   *  `display: \"money\"`): a literal ISO 4217 currency code passed to\n   *  `Intl.NumberFormat` for display — fixed for every record. The\n   *  stored value is always a plain decimal number; currency is\n   *  presentation only. Mutually substitutable with `currencyField`:\n   *  a money field must declare at least one of the two. */\n  currency?: string;\n  /** When `type === \"money\"` (or `type === \"derived\"` with\n   *  `display: \"money\"`): the name of a sibling record field whose\n   *  value holds the ISO 4217 code, letting currency vary per record\n   *  (e.g. an invoice's `currency` enum). The renderer reads\n   *  `record[currencyField]` and falls back to the literal `currency`\n   *  (then \"USD\") when the field is absent or empty. Resolved against\n   *  the top-level record even for money sub-fields inside a table. */\n  currencyField?: string;\n  /** When `type === \"enum\"`: the closed set of allowed string\n   *  values. The form renders a `<select>` populated from this\n   *  list; storage is a plain string. Required when type is\n   *  `enum`; ignored on every other type. */\n  values?: readonly string[];\n  /** When `type === \"table\"`: the sub-schema for each row (a flat\n   *  record of non-table / non-derived field specs). Required when\n   *  type is `table`. v0 disallows nested tables and derived\n   *  columns to keep the editor + evaluator simple. */\n  of?: Record<string, CollectionFieldSpec>;\n  /** When `type === \"derived\"`: a tiny expression evaluated against\n   *  the record. Supports `+ - * /`, parens, identifier refs to\n   *  top-level fields, `sum(tableField[].col)`, and\n   *  `sum(tableField[].col * tableField[].col)`. See\n   *  `src/utils/collections/derivedFormula.ts`. Required when type\n   *  is `derived`. */\n  formula?: string;\n  /** When `type === \"derived\"`: an inner field type the computed\n   *  value should be rendered as (e.g. `\"money\"` so $1,234.56 is\n   *  formatted). Defaults to `\"number\"`. */\n  display?: CollectionFieldType;\n  /** Optional visibility predicate: this field renders only when the\n   *  record matches (e.g. hide a `rating` field until `visited` is\n   *  `true` via `{ field: \"visited\", in: [\"true\"] }`). Applies to the\n   *  list cell (blank when hidden), the edit form (hidden live as the\n   *  gating field changes), and the detail view. Purely presentational\n   *  — a hidden field's stored value is never cleared. `when.field`\n   *  must name another top-level field. Absent ⇒ always shown. Only\n   *  honoured on top-level fields, not inside a `table`'s `of`. */\n  when?: CollectionWhen;\n  /** When `type === \"toggle\"`: the name of the top-level `enum` field this\n   *  checkbox projects. The toggle stores nothing itself — it reads and\n   *  writes this field. Required when type is `toggle`; ignored otherwise.\n   *  Must name a real `enum` field. */\n  field?: string;\n  /** When `type === \"toggle\"`: the enum value that means \"checked\". The\n   *  box is checked when the projected `field` equals this; checking writes\n   *  it. Required when type is `toggle`; must be one of the enum's `values`. */\n  onValue?: string;\n  /** When `type === \"toggle\"`: the enum value written when the box is\n   *  unchecked. Required when type is `toggle`; must be one of the enum's\n   *  `values`. */\n  offValue?: string;\n}\n\nexport interface CollectionSchema {\n  /** Human-facing collection name (sidebar, header). */\n  title: string;\n  /** Material-icon name shown next to the title. */\n  icon: string;\n  /** Workspace-relative folder holding one-JSON-per-record. Validated\n   *  to live under the workspace root at load time. */\n  dataPath: string;\n  /** Field name whose value doubles as the record's filename. */\n  primaryKey: string;\n  /** When set, the collection is a singleton: at most one record,\n   *  whose primary key is fixed to this value (e.g. `me` for the\n   *  business profile). The host pre-fills + locks the create form's\n   *  primary key and hides Add once the record exists. */\n  singleton?: string;\n  /** Ordered map: insertion order = column order in the table view. */\n  fields: Record<string, CollectionFieldSpec>;\n  /** Optional per-record actions rendered as buttons in the detail\n   *  view (e.g. \"Generate PDF\"). Order = button order. */\n  actions?: CollectionAction[];\n  /** Optional collection-level actions rendered as buttons in the\n   *  collection header (e.g. \"Extend the course\"). Unlike `actions`,\n   *  these carry no record context: the seed prompt injects a compact\n   *  progress summary of every record instead. The `when` predicate is\n   *  not evaluated (there is no record to gate on). Order = button order. */\n  collectionActions?: CollectionAction[];\n  /** Name of the field whose value marks an item as \"done\". When set,\n   *  a notification fires on item create (unless the item is born done)\n   *  and clears when the field's value transitions into\n   *  `completionDoneValues`. Must name a real field in `fields`. */\n  completionField?: string;\n  /** The set of values for `completionField` that count as \"done\"\n   *  (e.g. `[\"Done\"]` for a todo status field, `[\"paid\"]` for an\n   *  invoice). Non-empty. Compared as strings. */\n  completionDoneValues?: readonly string[];\n  /** Name of the field whose value is shown as the human-readable\n   *  label in a completion notification's title (e.g. a `name` field,\n   *  so the bell reads `Contacts: Jane Doe` instead of the opaque\n   *  primaryKey). Must name a real field in `fields`. When unset — or\n   *  when the record's value for it is empty — the title falls back to\n   *  the record's primaryKey value. Display-only; never stored. */\n  displayField?: string;\n  /** Name of a `date` field that gates this item's completion\n   *  notification: the bell is suppressed until the clock reaches that\n   *  date (compared at day-granularity in the server's local timezone),\n   *  instead of firing on create. Requires `completionField` /\n   *  `completionDoneValues` (the bell still clears via the done value).\n   *  Must name a real `date` field. Absent ⇒ fire on create, as before. */\n  triggerField?: string;\n  /** Lead time in whole days: fire the bell this many days BEFORE\n   *  `triggerField` (so `10` shows the reminder 10 days early). The lead\n   *  is applied at fire time, not stored, so it composes with `spawn` —\n   *  every recurred cycle fires the same number of days before its own\n   *  trigger. Non-negative integer; requires `triggerField`. Default 0\n   *  (fire on the trigger date). */\n  triggerLeadDays?: number;\n  /** Host-driven recurrence. When set, requires `triggerField`. See\n   *  {@link CollectionSpawn}. */\n  spawn?: CollectionSpawn;\n  /** Name of a `date` field that anchors the optional calendar view: a\n   *  month grid where each record lands on the day cell matching this\n   *  field's value. When unset, the calendar toggle still appears if the\n   *  schema has any `date` field (the first one, in declaration order, is\n   *  used by default and is switchable in-view). Set this to pin a specific\n   *  anchor. Must name a real `date` field. */\n  calendarField?: string;\n  /** Name of a second `date` field marking the END of a multi-day span on\n   *  the calendar: the record renders from `calendarField` through this\n   *  date inclusive. Requires `calendarField`. Must name a real `date`\n   *  field. Absent ⇒ single-day placement. */\n  calendarEndField?: string;\n  /** Name of a string field holding a free-form time or time-range\n   *  (e.g. \"14:00-17:00\", \"17:00-\", \"16:30\") that places records on the\n   *  calendar's day (time-allocation) view. Consulted only when the calendar\n   *  date fields are date-only. Requires `calendarField`. */\n  calendarTimeField?: string;\n  /** Name of an `enum` field that groups records into columns on the\n   *  optional Kanban board: each record lands in the column matching its\n   *  value, with empty/unknown values collected in an \"Uncategorized\"\n   *  column. When unset, the Kanban toggle still appears if the schema has\n   *  any `enum` field (the first one, in declaration order, is used by\n   *  default and is switchable in-view). Set this to pin a specific group\n   *  field. Must name a real `enum` field. */\n  kanbanField?: string;\n  /** Optional custom (LLM-authored) HTML views, each rendered in a\n   *  sandboxed iframe over the records. Absent ⇒ only the built-in\n   *  field-derived views (table / calendar / kanban / dashboard). See\n   *  {@link CollectionCustomView}. */\n  views?: CollectionCustomView[];\n  /** Optional predicate that gates the completion bell: when set, the bell\n   *  fires only for records whose `String(record[notifyWhen.field])` is one\n   *  of `notifyWhen.in` (e.g. notify only `high`/`urgent` priority todos).\n   *  Reuses the `when` predicate shape. Requires `completionField` — it\n   *  narrows that bell rather than introducing a second one. The bell still\n   *  clears on done / delete / when the predicate stops matching. Absent ⇒\n   *  notify for every open record (the prior behaviour). `notifyWhen.field`\n   *  must name a real top-level field. */\n  notifyWhen?: CollectionWhen;\n  /** Optional declarative retrieval config. When present, this collection\n   *  is a \"Feed\": the host periodically fetches `ingest.url`, maps the\n   *  response into records, and upserts them by `primaryKey`. Only feeds\n   *  discovered from the `<workspace>/feeds/` registry carry this; skill\n   *  collections omit it. The host's feeds subsystem narrows this to its\n   *  richer `IngestSpec` (which `extends CollectionIngest`). */\n  ingest?: CollectionIngest;\n}\n\nexport interface CollectionSummary {\n  slug: string;\n  title: string;\n  icon: string;\n  source: CollectionSource;\n}\n\nexport interface CollectionDetail extends CollectionSummary {\n  schema: CollectionSchema;\n}\n\nexport type CollectionItem = Record<string, unknown>;\n","// Tiny expression evaluator for the `derived` field type on\n// schema-driven collections (see plans/done/feat-mc-invoice.md).\n//\n// Grammar (recursive-descent, no precedence climbing — six\n// non-terminals total):\n//\n//   expr   := term (('+' | '-') term)*\n//   term   := factor (('*' | '/') factor)*\n//   factor := number | sumCall | refAccess | identifier | '(' expr ')'\n//   sumCall:= 'sum' '(' sumArg ')'\n//   sumArg := tableCol (('*' | '/') tableCol)*      // e.g. lineItems[].quantity * lineItems[].rate\n//   tableCol := identifier '[]' '.' identifier\n//   refAccess := identifier '.' identifier          // e.g. ticker.price — deref a ref field into its target record\n//\n// `identifier` accepts top-level field names (single segment).\n// Inside `sumArg`, identifiers are the `<table>[].col` form.\n// A two-segment `<field>.<col>` at factor level is a *ref deref*:\n// `<field>` must be a `ref`-typed field on this record (its stored\n// value is the target item's slug), and `<col>` is a numeric column\n// read from that target record. The caller resolves the target into\n// `ctx.refs` (it owns the schema + the loaded target collection);\n// the evaluator stays pure and never does I/O.\n//\n// What's deliberately NOT supported (and would parse-error rather\n// than silently misbehave):\n//   - String literals, boolean operators, comparisons, conditionals\n//   - Nested function calls beyond `sum(...)`\n//   - Anything in the record that isn't a number / table-of-objects\n//\n// All evaluation is pure — no eval(), no Function constructor.\n// Returns `null` on any failure (parse error, unbound identifier,\n// non-finite arithmetic). The caller renders `null` as em-dash in\n// the table cell + form display.\n\nexport interface FormulaContext {\n  /** The record being evaluated. For derived fields in the form,\n   *  this is the live draft (text + table both converted via the\n   *  same `draftToRecord` pipeline). For the main table cell,\n   *  this is the persisted item. */\n  record: Record<string, unknown>;\n  /** Resolved ref-target records for THIS row, keyed by the local\n   *  `ref` field name. The caller (which has the schema + the linked\n   *  collection's items loaded) maps each ref field's stored slug to\n   *  the full target record and passes it here, so a `<field>.<col>`\n   *  formula can read a numeric column off the referenced record\n   *  (e.g. `shares * ticker.price`). A missing key or `null` value\n   *  (unknown field / dangling slug) makes that deref evaluate to\n   *  NaN → the whole formula returns `null` → em-dash, consistent\n   *  with every other failure mode. Absent ⇒ no refs available. */\n  refs?: Record<string, Record<string, unknown> | null>;\n}\n\nexport function evaluateDerived(formula: string, ctx: FormulaContext): number | null {\n  let tokens: Token[];\n  try {\n    tokens = tokenize(formula);\n  } catch {\n    return null;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Parser class is defined later in the file (grouped with its AST + evaluator); evaluateDerived runs after module init so the TDZ concern doesn't apply.\n  const parser = new Parser(tokens);\n  let ast: Node;\n  try {\n    ast = parser.parseExpr();\n    if (!parser.atEnd()) return null; // trailing junk\n  } catch {\n    return null;\n  }\n  const value = evaluate(ast, ctx);\n  return Number.isFinite(value) ? value : null;\n}\n\n// ─── Tokens ────────────────────────────────────────────────\n\ntype TokenKind = \"number\" | \"ident\" | \"(\" | \")\" | \"+\" | \"-\" | \"*\" | \"/\" | \"[]\" | \".\";\n\ninterface Token {\n  kind: TokenKind;\n  value?: string | number;\n}\n\nconst SINGLE_CHAR_PUNCT = new Set<TokenKind>([\"(\", \")\", \"+\", \"-\", \"*\", \"/\", \".\"]);\n\ninterface Cursor {\n  input: string;\n  index: number;\n}\n\nfunction consumeWhitespace(cur: Cursor): boolean {\n  const char = cur.input[cur.index];\n  if (char === \" \" || char === \"\\t\" || char === \"\\n\") {\n    cur.index++;\n    return true;\n  }\n  return false;\n}\n\nfunction consumeNumber(cur: Cursor): Token | null {\n  const char = cur.input[cur.index] ?? \"\";\n  const next = cur.input[cur.index + 1] ?? \"\";\n  if (!isDigit(char) && !(char === \".\" && isDigit(next))) return null;\n  let raw = \"\";\n  while (cur.index < cur.input.length) {\n    const here = cur.input[cur.index] ?? \"\";\n    if (!isDigit(here) && here !== \".\") break;\n    raw += here;\n    cur.index++;\n  }\n  const num = Number(raw);\n  if (!Number.isFinite(num)) throw new Error(\"bad number\");\n  return { kind: \"number\", value: num };\n}\n\nfunction consumeIdent(cur: Cursor): Token | null {\n  const char = cur.input[cur.index] ?? \"\";\n  if (!isIdentStart(char)) return null;\n  let raw = \"\";\n  while (cur.index < cur.input.length && isIdentChar(cur.input[cur.index] ?? \"\")) {\n    raw += cur.input[cur.index];\n    cur.index++;\n  }\n  return { kind: \"ident\", value: raw };\n}\n\nfunction consumePunct(cur: Cursor): Token | null {\n  const char = cur.input[cur.index] ?? \"\";\n  if (char === \"[\" && cur.input[cur.index + 1] === \"]\") {\n    cur.index += 2;\n    return { kind: \"[]\" };\n  }\n  if (SINGLE_CHAR_PUNCT.has(char as TokenKind)) {\n    cur.index++;\n    return { kind: char as TokenKind };\n  }\n  return null;\n}\n\nfunction tokenize(input: string): Token[] {\n  const tokens: Token[] = [];\n  const cur: Cursor = { input, index: 0 };\n  while (cur.index < input.length) {\n    if (consumeWhitespace(cur)) continue;\n    // Number FIRST so a leading-dot literal (`.25`) isn't split by\n    // the `.` punctuation branch.\n    const numTok = consumeNumber(cur);\n    if (numTok) {\n      tokens.push(numTok);\n      continue;\n    }\n    const punctTok = consumePunct(cur);\n    if (punctTok) {\n      tokens.push(punctTok);\n      continue;\n    }\n    const identTok = consumeIdent(cur);\n    if (identTok) {\n      tokens.push(identTok);\n      continue;\n    }\n    throw new Error(`unexpected char ${input[cur.index]}`);\n  }\n  return tokens;\n}\n\nfunction isDigit(char: string): boolean {\n  return char >= \"0\" && char <= \"9\";\n}\nfunction isIdentStart(char: string): boolean {\n  return (char >= \"a\" && char <= \"z\") || (char >= \"A\" && char <= \"Z\") || char === \"_\";\n}\nfunction isIdentChar(char: string): boolean {\n  return isIdentStart(char) || isDigit(char);\n}\n\n// ─── AST + Parser ───────────────────────────────────────────\n\ntype Node =\n  | { kind: \"num\"; value: number }\n  | { kind: \"ident\"; name: string }\n  | { kind: \"ref\"; field: string; col: string }\n  | { kind: \"binop\"; operator: \"+\" | \"-\" | \"*\" | \"/\"; left: Node; right: Node }\n  | { kind: \"sum\"; arg: SumArg };\n\ninterface SumArg {\n  // factors multiplied/divided together; each is a (tableName, colName) ref into a row.\n  factors: { table: string; col: string }[];\n  /** Operators between factors: length = factors.length - 1; each\n   *  is \"*\" or \"/\". For a single-factor sum (`sum(lineItems[].amount)`)\n   *  this is empty. */\n  operators: (\"*\" | \"/\")[];\n}\n\nclass Parser {\n  private cursor = 0;\n  constructor(private readonly tokens: Token[]) {}\n\n  atEnd(): boolean {\n    return this.cursor >= this.tokens.length;\n  }\n  private peek(): Token | undefined {\n    return this.tokens[this.cursor];\n  }\n  private consume(): Token {\n    const tok = this.tokens[this.cursor++];\n    if (!tok) throw new Error(\"unexpected end of input\");\n    return tok;\n  }\n  private expect(kind: TokenKind): Token {\n    const tok = this.consume();\n    if (tok.kind !== kind) throw new Error(`expected ${kind}, got ${tok.kind}`);\n    return tok;\n  }\n\n  parseExpr(): Node {\n    let left = this.parseTerm();\n    while (this.peek()?.kind === \"+\" || this.peek()?.kind === \"-\") {\n      const operator = this.consume().kind as \"+\" | \"-\";\n      const right = this.parseTerm();\n      left = { kind: \"binop\", operator, left, right };\n    }\n    return left;\n  }\n\n  private parseTerm(): Node {\n    let left = this.parseFactor();\n    while (this.peek()?.kind === \"*\" || this.peek()?.kind === \"/\") {\n      const operator = this.consume().kind as \"*\" | \"/\";\n      const right = this.parseFactor();\n      left = { kind: \"binop\", operator, left, right };\n    }\n    return left;\n  }\n\n  private parseFactor(): Node {\n    const tok = this.peek();\n    if (!tok) throw new Error(\"unexpected end in factor\");\n    if (tok.kind === \"number\") {\n      this.consume();\n      return { kind: \"num\", value: tok.value as number };\n    }\n    if (tok.kind === \"(\") {\n      this.consume();\n      const inner = this.parseExpr();\n      this.expect(\")\");\n      return inner;\n    }\n    if (tok.kind === \"ident\") {\n      const name = (tok.value as string) ?? \"\";\n      // sum(...) — only function call we support\n      if (name === \"sum\" && this.tokens[this.cursor + 1]?.kind === \"(\") {\n        this.consume(); // ident\n        this.expect(\"(\");\n        const arg = this.parseSumArg();\n        this.expect(\")\");\n        return { kind: \"sum\", arg };\n      }\n      this.consume(); // ident\n      // ref deref: `<field>.<col>` (e.g. ticker.price). The table-row\n      // form `<table>[].col` only appears inside sum(), so a `.`\n      // immediately after a top-level ident is unambiguously a ref\n      // dereference here.\n      if (this.peek()?.kind === \".\") {\n        this.consume(); // '.'\n        const col = this.expect(\"ident\");\n        return { kind: \"ref\", field: name, col: col.value as string };\n      }\n      return { kind: \"ident\", name };\n    }\n    throw new Error(`unexpected token ${tok.kind} in factor`);\n  }\n\n  private parseSumArg(): SumArg {\n    const factors: { table: string; col: string }[] = [];\n    const operators: (\"*\" | \"/\")[] = [];\n    factors.push(this.parseTableCol());\n    while (this.peek()?.kind === \"*\" || this.peek()?.kind === \"/\") {\n      const operator = this.consume().kind as \"*\" | \"/\";\n      operators.push(operator);\n      factors.push(this.parseTableCol());\n    }\n    return { factors, operators };\n  }\n\n  private parseTableCol(): { table: string; col: string } {\n    const tableTok = this.expect(\"ident\");\n    this.expect(\"[]\");\n    this.expect(\".\");\n    const colTok = this.expect(\"ident\");\n    return { table: tableTok.value as string, col: colTok.value as string };\n  }\n}\n\n// ─── Evaluator ──────────────────────────────────────────────\n\nfunction evaluate(node: Node, ctx: FormulaContext): number {\n  if (node.kind === \"num\") return node.value;\n  if (node.kind === \"ident\") {\n    const raw = ctx.record[node.name];\n    return toFiniteNumber(raw);\n  }\n  if (node.kind === \"ref\") {\n    // `<field>.<col>`: read `col` off the resolved target record the\n    // caller put in ctx.refs. Unknown field / dangling slug → null →\n    // NaN, so the whole formula fails soft to an em-dash.\n    const target = ctx.refs?.[node.field] ?? null;\n    if (!target) return Number.NaN;\n    return toFiniteNumber(target[node.col]);\n  }\n  if (node.kind === \"binop\") {\n    const left = evaluate(node.left, ctx);\n    const right = evaluate(node.right, ctx);\n    return applyBinop(node.operator, left, right);\n  }\n  if (node.kind === \"sum\") {\n    return evaluateSum(node.arg, ctx);\n  }\n  // Exhaustive — TS narrows above branches but throw keeps runtime honest.\n  throw new Error(`unknown node`);\n}\n\nfunction applyBinop(operator: \"+\" | \"-\" | \"*\" | \"/\", left: number, right: number): number {\n  if (!Number.isFinite(left) || !Number.isFinite(right)) return Number.NaN;\n  if (operator === \"+\") return left + right;\n  if (operator === \"-\") return left - right;\n  if (operator === \"*\") return left * right;\n  // operator === \"/\"\n  if (right === 0) return Number.NaN;\n  return left / right;\n}\n\nfunction evaluateSum(arg: SumArg, ctx: FormulaContext): number {\n  if (arg.factors.length === 0) return 0;\n  const tableName = arg.factors[0].table;\n  // All factors must reference the SAME table (you can't multiply\n  // a row from lineItems against a row from another table — the\n  // semantics would be ambiguous). Reject mismatch.\n  for (const factor of arg.factors) {\n    if (factor.table !== tableName) return Number.NaN;\n  }\n  const rows = ctx.record[tableName];\n  if (!Array.isArray(rows)) return 0;\n  let total = 0;\n  for (const row of rows) {\n    if (!row || typeof row !== \"object\") continue;\n    let product = toFiniteNumber((row as Record<string, unknown>)[arg.factors[0].col]);\n    if (!Number.isFinite(product)) return Number.NaN;\n    for (let i = 1; i < arg.factors.length; i++) {\n      const value = toFiniteNumber((row as Record<string, unknown>)[arg.factors[i].col]);\n      if (!Number.isFinite(value)) return Number.NaN;\n      product = applyBinop(arg.operators[i - 1], product, value);\n    }\n    total += product;\n  }\n  return total;\n}\n\nfunction toFiniteNumber(value: unknown): number {\n  if (typeof value === \"number\") return Number.isFinite(value) ? value : Number.NaN;\n  if (typeof value === \"string\" && value.length > 0) {\n    const num = Number(value);\n    return Number.isFinite(num) ? num : Number.NaN;\n  }\n  return Number.NaN;\n}\n","// The derived-field saturation loop for schema-driven collections,\n// extracted from `composables/collections/useCollectionRendering.ts` so\n// the server (manageCollection getItems enrichment) and the client\n// (table cells, form display) evaluate formulas through ONE\n// implementation — if the two ever diverged, the UI and the LLM would\n// disagree on a number. Pure module: no Vue, no I/O.\n//\n// Like `actionVisible.ts`, the input types are minimal structural\n// shapes so both the client `FieldSpec`/`CollectionSchema`\n// (src/components/collectionTypes.ts) and the server\n// `CollectionFieldSpec`/`CollectionSchema`\n// (server/workspace/collections/types.ts) satisfy them as-is.\n\nimport { evaluateDerived, type FormulaContext } from \"./derivedFormula\";\n\n/** Minimal field shape the derive loop needs — accepts both the client\n *  FieldSpec and the server CollectionFieldSpec. */\nexport interface DerivableFieldSpec {\n  type: string;\n  /** When type === \"ref\": slug of the target collection. */\n  to?: string;\n  /** When type === \"derived\": formula evaluated against the record. */\n  formula?: string;\n}\n\n/** Minimal schema shape: just the ordered field map. */\nexport interface DerivableSchema {\n  fields: Record<string, DerivableFieldSpec>;\n}\n\nexport type DerivableRecord = Record<string, unknown>;\n\n/** Per-target-collection cache of loaded referenced records:\n *  target collection slug → item slug → full record. Mirrors the\n *  client's `RefRecordCache` / the server's enrichment loader. */\nexport type DeriveRefRecords = Record<string, Record<string, DerivableRecord>>;\n\n/** Map each `ref` field's stored slug to its loaded target record (or\n *  null when dangling / not loaded), keyed by the LOCAL field name —\n *  the shape `evaluateDerived` reads for `<field>.<col>` derefs. */\nexport function resolveRowRefs(schema: DerivableSchema, record: DerivableRecord, refRecords: DeriveRefRecords): NonNullable<FormulaContext[\"refs\"]> {\n  const refs: NonNullable<FormulaContext[\"refs\"]> = {};\n  for (const [key, field] of Object.entries(schema.fields)) {\n    if (field.type !== \"ref\" || !field.to) continue;\n    const slug = record[key];\n    refs[key] = typeof slug === \"string\" ? (refRecords[field.to]?.[slug] ?? null) : null;\n  }\n  return refs;\n}\n\n/** Evaluate every `derived` field against `base`, saturating so a\n *  derived field can read another derived field computed in an earlier\n *  pass (`subtotal → tax → total` converges in ≤ field-count passes).\n *  Cycles can't loop forever — passes are bounded by the number of\n *  derived fields and the loop breaks as soon as a pass changes\n *  nothing. Failed formulas stay ABSENT (the UI renders them as\n *  em-dash). Returns a copy; `base` is never mutated.\n *\n *  Derived keys already present in `base` are stripped before\n *  evaluation: computed output is host-truth, never persisted-input\n *  fallback. A record JSON can carry a stale (or forged) derived value\n *  — raw Write/Edit, legacy data — and without the strip, a failing\n *  formula would silently surface that value as if the host computed\n *  it. */\nexport function deriveAll(schema: DerivableSchema, base: DerivableRecord, refRecords: DeriveRefRecords): DerivableRecord {\n  const derivedKeys = new Set(Object.keys(schema.fields).filter((key) => schema.fields[key]?.type === \"derived\"));\n  const enriched: DerivableRecord = Object.fromEntries(Object.entries(base).filter(([key]) => !derivedKeys.has(key)));\n  const refs = resolveRowRefs(schema, base, refRecords);\n  const maxPasses = Object.values(schema.fields).filter((field) => field.type === \"derived\").length;\n  for (let pass = 0; pass < maxPasses; pass++) {\n    let mutated = false;\n    for (const [key, field] of Object.entries(schema.fields)) {\n      if (field.type !== \"derived\" || !field.formula) continue;\n      const next = evaluateDerived(field.formula, { record: enriched, refs });\n      if (next !== null && enriched[key] !== next) {\n        enriched[key] = next;\n        mutated = true;\n      }\n    }\n    if (!mutated) break;\n  }\n  return enriched;\n}\n"],"mappings":"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"}