@mulmoclaude/core 3.6.0 → 3.7.0

package/dist/{discovery-CdkaURVY.js → store-_61sO8K8.js}

@@ -7,9 +7,9 @@ import { readFileSync, realpathSync, watch } from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 import { lstat, mkdir, open, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { z } from "zod";
 import { tmpdir } from "node:os";
 import iconv from "iconv-lite";
-import { z } from "zod";
 //#region src/host/hostSlot.ts
 function createHostSlot(name) {
 	let current = null;
@@ -606,1541 +606,363 @@ function appManifestReason(failure, root) {
 	if (failure.kind === "unreadable") return `cannot read ${manifestPath}: ${failure.detail}`;
 	return `${manifestPath} ${failure.detail}`;
 }
-//#endregion
-//#region src/collection/server/io.ts
-/** True iff `filePath` exists and is a regular file (NOT a symlink).
-*  Defends `listItems` / `readItem` against `*.json` symlinks placed
-*  inside an otherwise-contained data dir — without this, a record
-*  file could symlink to /etc/passwd and the detail endpoint would
-*  happily serve it. Returns false on ENOENT and on any other lstat
-*  failure so the caller's "missing" branch covers those cases too.
-*  Exported so `ontology.ts`'s record COUNT classifies entries with the
-*  SAME lstat logic — the two must agree on what a record file is. */
-async function isRegularFile(filePath) {
-	try {
-		return (await lstat(filePath)).isFile();
-	} catch {
-		return false;
-	}
-}
-/** Read one JSON record file. Returns null when the file is missing,
-*  is a symlink (file-disclosure defense), parses to a non-object,
-*  or has a read/parse error. Caller logs the per-entry skip — this
-*  helper just classifies. Split out to keep `listItems` under the
-*  `sonarjs/cognitive-complexity` threshold. */
-/** Parse a record file's text into a plain-object `CollectionItem`, or
-*  null when it isn't a JSON object (array / scalar / null). */
-function parseRecordJson(raw) {
-	const parsed = JSON.parse(raw);
-	return isRecord(parsed) ? parsed : null;
-}
-async function tryReadRecord(filePath) {
-	if (!await isRegularFile(filePath)) return null;
-	try {
-		return parseRecordJson(await readFile(filePath, "utf-8"));
-	} catch {
-		return null;
-	}
+/** 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);
 }
-/** Read every record under `dataDir`. Returns [] if the dir doesn't
-*  exist yet (legitimate first-use state). Malformed JSON files and
-*  symlinked records are skipped (the latter is a file-disclosure
-*  defense — see `isRegularFile`). Re-validates the realpath
-*  containment to defend against a symlinked data dir appearing
-*  between discovery and use. */
-async function listItems(dataDir, opts = {}) {
-	if (!isContainedInRoot(dataDir, opts.workspaceRoot ?? getWorkspaceRoot())) {
-		log.warn("collections", "listItems refused: dataDir escapes workspace via symlink", { dataDir });
-		return [];
-	}
-	let entries;
-	try {
-		entries = await readdir(dataDir);
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
-		throw err;
-	}
-	const results = [];
-	for (const name of entries) {
-		if (!name.endsWith(".json")) continue;
-		if (name.startsWith(".")) continue;
-		const filePath = path.join(dataDir, name);
-		const record = await tryReadRecord(filePath);
-		if (record === null) {
-			log.warn("collections", "skipping record (missing, symlink, or unreadable)", { path: filePath });
+/** 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;
 		}
-		results.push(record);
+		const paramValue = params[ref];
+		if (paramValue !== void 0 && paramValue !== null && paramValue !== "") resolved[key] = paramValue;
 	}
-	return results;
+	return resolved;
 }
-/** Read one record by id. Returns null when the file is missing,
-*  when the resolved path escapes the workspace via a symlink, or
-*  when the record file itself is a symlink (file-disclosure
-*  defense — see `isRegularFile`). */
-async function readItem(dataDir, itemId, opts = {}) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return null;
-	if (!isContainedInRoot(dataDir, opts.workspaceRoot ?? getWorkspaceRoot())) return null;
-	const filePath = itemFilePath(dataDir, safeId);
-	if (!await isRegularFile(filePath)) return null;
-	try {
-		return parseRecordJson(await readFile(filePath, "utf-8"));
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return null;
-		throw err;
-	}
+//#endregion
+//#region src/collection/core/schemaRules.ts
+var declaredField = (fields, name) => Object.hasOwn(fields, name) ? fields[name] : void 0;
+var isDateLike = (type) => type === "date" || type === "datetime";
+var isTimeStringField = (type) => type === "string" || type === "text";
+var CODE_FIELD_TYPES = /* @__PURE__ */ new Set([
+	"string",
+	"text",
+	"enum"
+]);
+var namesStoredField = (fields, name, primaryKey) => {
+	const target = declaredField(fields, name);
+	return target !== void 0 && !COMPUTED_TYPES.has(target.type) && name !== primaryKey;
+};
+var hasUniqueIds = (entries) => entries === void 0 || new Set(entries.map((entry) => entry.id)).size === entries.length;
+/** Exactly one storage declaration: native records need `dataPath`, an external
+*  data file needs `dataSource`, an alternative backend needs `storage`. Zero
+*  (nowhere to read) and several (ambiguous which wins) are equally
+*  meaningless — fail loudly at load instead of picking silently. */
+function declaresExactlyOneStore(schema) {
+	return [
+		schema.dataPath,
+		schema.dataSource,
+		schema.storage
+	].filter((declared) => declared !== void 0).length === 1;
 }
-/** The symlink-containment refusal every record path shares: one check, one
-*  warn, one answer. Extracted because this is a security RULE applied at
-*  three sites (write pre-mkdir, write post-mkdir, delete) — a fix to the
-*  check must not be able to land at only one of them.
-*
-*  `stage` names the call site so the warn stays as diagnosable as the three
-*  hand-written copies were.
-*
-*  Scope, stated explicitly because a reviewer asks every time: this catches
-*  a symlink that EXISTS when we look — `isContainedInRoot` realpaths the
-*  closest existing ancestor, so a pre-planted escape is refused. It does not
-*  and cannot close the check-then-use race, where an ancestor is swapped for
-*  a symlink between this call and the `mkdir` / `open` / `unlink` that
-*  follows. Closing that needs directory-handle I/O anchored at the workspace
-*  (`openat` + `O_NOFOLLOW`), which `node:fs` does not expose — it would mean
-*  a different I/O layer, not a tighter check here.
-*
-*  That race is deliberately outside this app's threat model: the process is
-*  loopback-bound and bearer-authed, so anyone able to swap directories inside
-*  the workspace is already the workspace owner — the same trust principal the
-*  writes belong to. Revisit if collections ever serve a lower-trust caller. */
-function escapesWorkspace(dataDir, workspaceRoot, itemId, stage) {
-	if (isContainedInRoot(dataDir, workspaceRoot)) return false;
-	log.warn("collections", `${stage} refused: dataDir escapes workspace via symlink`, {
-		dataDir,
-		itemId
-	});
+/** A `dataSource` collection is read-only by definition, so schema-level write
+*  machinery can never fire: `singleton` pins CREATES, `ingest` REFILLS
+*  records, `spawn` WRITES successor records. Rejecting them at validation
+*  kills whole classes of writes before any runtime guard. */
+function dataSourceDeclaresNoWriteMachinery(schema) {
+	if (schema.dataSource === void 0) return true;
+	return schema.singleton === void 0 && schema.ingest === void 0 && schema.spawn === void 0 && schema.googleCalendar === void 0;
+}
+/** Same rule for declarative host writes: a mutate action writes the record
+*  it's invoked on, which a read-only collection has no business doing. */
+function dataSourceDeclaresNoMutateAction(schema) {
+	if (schema.dataSource !== void 0) return [...schema.actions ?? [], ...schema.collectionActions ?? []].every((action) => action.kind !== "mutate");
 	return true;
 }
-/** Write a record. Ensures the directory exists, validates the id,
-*  re-checks symlink containment after mkdir, and writes atomically.
-*
-*  Create path (`refuseOverwrite: true`) uses an O_EXCL `wx` open
-*  rather than `stat` + `writeFileAtomic` to close a check-then-write
-*  race: two concurrent POSTs would otherwise both pass the existence
-*  check and one would silently overwrite the other. The trade-off
-*  is that the create path is not crash-atomic (a partial file could
-*  remain if the process dies mid-write); acceptable here because
-*  records are small JSON blobs and the next read either parses or
-*  is skipped via the "malformed JSON" branch in `listItems`.
-*
-*  Update path (`refuseOverwrite: false`) uses `writeFileAtomic` so
-*  PUT remains crash-atomic. No race there — the URL pins the id. */
-async function writeItem(dataDir, itemId, item, opts = {}) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return {
-		kind: "invalid-id",
-		itemId
-	};
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	if (escapesWorkspace(dataDir, workspaceRoot, safeId, "writeItem (pre-mkdir)")) return {
-		kind: "path-escape",
-		itemId: safeId
-	};
-	await mkdir(dataDir, { recursive: true });
-	if (escapesWorkspace(dataDir, workspaceRoot, safeId, "writeItem (post-mkdir)")) return {
-		kind: "path-escape",
-		itemId: safeId
-	};
-	const filePath = itemFilePath(dataDir, safeId);
-	const payload = `${JSON.stringify(item, null, 2)}\n`;
-	if (opts.refuseOverwrite) {
-		let handle;
-		try {
-			handle = await open(filePath, "wx");
-		} catch (err) {
-			if (isErrorWithCode(err) && err.code === "EEXIST") return {
-				kind: "conflict",
-				itemId: safeId
-			};
-			throw err;
-		}
-		try {
-			await handle.writeFile(payload);
-		} finally {
-			await handle.close();
-		}
-	} else await writeFileAtomic(filePath, payload);
-	if (opts.slug) publishCollectionChange(collectionChangePayload({
-		slug: opts.slug,
-		ids: [safeId],
-		op: "upsert"
-	}, opts.workspaceRoot));
-	return {
-		kind: "ok",
-		itemId: safeId,
-		item
-	};
+/** Action ids must be unique so the dispatch route resolves unambiguously. */
+function actionIdsAreUnique(schema) {
+	return hasUniqueIds(schema.actions);
 }
-async function deleteItem(dataDir, itemId, opts = {}) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return {
-		kind: "invalid-id",
-		itemId
-	};
-	if (escapesWorkspace(dataDir, opts.workspaceRoot ?? getWorkspaceRoot(), safeId, "deleteItem")) return {
-		kind: "path-escape",
-		itemId: safeId
-	};
-	const filePath = itemFilePath(dataDir, safeId);
-	try {
-		await unlink(filePath);
-		if (opts.slug) publishCollectionChange(collectionChangePayload({
-			slug: opts.slug,
-			ids: [safeId],
-			op: "delete"
-		}, opts.workspaceRoot));
-		return {
-			kind: "ok",
-			itemId: safeId
-		};
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return {
-			kind: "not-found",
-			itemId: safeId
-		};
-		throw err;
-	}
-}
-/** Generate a short random hex id. Used by POST when the form doesn't
-*  carry a primary-key value (UI shortcut — Claude normally derives a
-*  semantic id from the record's name). */
-function generateItemId() {
-	return randomBytes(4).toString("hex");
-}
-/** The item id a CREATE should use for `schema`, or null when the
-*  caller should generate one. A singleton collection pins every
-*  create to its fixed `schema.singleton` id, so the "at most one
-*  record" contract is enforced server-side (a second create targets
-*  the same file and hits `writeItem`'s refuseOverwrite conflict) —
-*  not only in the UI. Otherwise the record's own primaryKey value
-*  wins, falling back to a generated id (null = "generate"). */
-function resolveCreateItemId(schema, record) {
-	if (schema.singleton) return schema.singleton;
-	const primaryRaw = record[schema.primaryKey];
-	return typeof primaryRaw === "string" && primaryRaw.length > 0 ? primaryRaw : null;
+/** Collection-level action ids must likewise be unique. */
+function collectionActionIdsAreUnique(schema) {
+	return hasUniqueIds(schema.collectionActions);
 }
-//#endregion
-//#region src/collection/core/queryZ.ts
-/** Result-column aliases double as SQL identifiers and JSON keys — keep
-*  them to a conservative identifier charset so neither side needs
-*  escaping gymnastics. */
-var SAFE_ALIAS_PATTERN = /^[A-Za-z_]\w{0,63}$/;
-/** Hard ceiling on returned rows; `limit` clamps below it. A group-by on
-*  a near-unique column would otherwise return one row per source row —
-*  the exact materialization the aggregate path exists to avoid. */
-var MAX_QUERY_ROWS = 1e4;
-/** Default row cap when the query declares no `limit`. */
-var DEFAULT_QUERY_ROWS = 1e3;
-/** One aggregate column: `count` (rows; `column` optional to count
-*  non-null cells) or `sum`/`avg`/`min`/`max` over a named CSV column. */
-var QueryAggregateZ = z.object({
-	op: z.enum([
-		"count",
-		"sum",
-		"avg",
-		"min",
-		"max"
-	]),
-	column: z.string().min(1).optional()
-}).refine((aggregate) => aggregate.op === "count" || aggregate.column !== void 0, {
-	message: "`column` is required for every aggregate op except `count`",
-	path: ["column"]
-});
-/** One filter condition. Same op vocabulary as the schema-level `where`
-*  (`core/where.ts`) so authors learn one set; values may be typed
-*  (number / boolean) since CSV columns are. `in` requires an array
-*  value, every other op a scalar. */
-var QueryWhereZ = z.object({
-	field: z.string().min(1),
-	op: z.enum([
-		"eq",
-		"ne",
-		"in",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"contains"
-	]),
-	value: z.union([
-		z.string(),
-		z.number(),
-		z.boolean(),
-		z.array(z.union([
-			z.string(),
-			z.number(),
-			z.boolean()
-		])).min(1).max(100)
-	])
-}).refine((cond) => cond.op === "in" === Array.isArray(cond.value), {
-	message: "`in` requires an array value (the allowed set); every other op requires a scalar value",
-	path: ["value"]
-});
-var QueryOrderZ = z.object({
-	/** A `groupBy` column or an aggregate alias — membership enforced by
-	*  the whole-query refine below. */
-	field: z.string().min(1),
-	dir: z.enum(["asc", "desc"]).optional()
-});
-/** The whole query. At least one of `groupBy` / `aggregates` must be
-*  present: bare `groupBy` is a DISTINCT listing, bare `aggregates` a
-*  whole-file scalar row, together a grouped aggregation. */
-var CollectionQueryZ = z.object({
-	groupBy: z.array(z.string().min(1)).max(8).refine((columns) => new Set(columns.map((column) => column.toLowerCase())).size === columns.length, { message: "`groupBy` columns must be unique (case-insensitively — SQL identifiers ignore case)" }).optional(),
-	aggregates: z.record(z.string().regex(SAFE_ALIAS_PATTERN, "aggregate aliases must be simple identifiers (letters/digits/underscore)"), QueryAggregateZ).optional(),
-	where: z.array(QueryWhereZ).max(16).optional(),
-	orderBy: z.array(QueryOrderZ).max(4).optional(),
-	limit: z.number().int().min(1).max(MAX_QUERY_ROWS).optional()
-}).refine((query) => (query.groupBy?.length ?? 0) > 0 || Object.keys(query.aggregates ?? {}).length > 0, {
-	message: "declare at least one of `groupBy` (columns to bucket by) or `aggregates` (values to compute)",
-	path: ["groupBy"]
-}).refine((query) => Object.keys(query.aggregates ?? {}).length <= 32, {
-	message: `\`aggregates\` supports at most 32 entries`,
-	path: ["aggregates"]
-}).refine((query) => {
-	const groupLower = new Set((query.groupBy ?? []).map((column) => column.toLowerCase()));
-	const seen = /* @__PURE__ */ new Set();
-	return Object.keys(query.aggregates ?? {}).every((alias) => {
-		const lower = alias.toLowerCase();
-		if (groupLower.has(lower) || seen.has(lower)) return false;
-		seen.add(lower);
-		return true;
-	});
-}, {
-	message: "aggregate aliases must be unique and must not collide with `groupBy` column names (case-insensitively — SQL identifiers ignore case)",
-	path: ["aggregates"]
-}).refine((query) => {
-	const sortable = /* @__PURE__ */ new Set([...query.groupBy ?? [], ...Object.keys(query.aggregates ?? {})]);
-	return (query.orderBy ?? []).every((order) => sortable.has(order.field));
-}, {
-	message: "every `orderBy.field` must be a `groupBy` column or an aggregate alias",
-	path: ["orderBy"]
-});
-//#endregion
-//#region src/collection/server/csvQuery.ts
-/** Double-quote a SQL identifier (CSV column name / result alias). */
-function quoteIdent(name) {
-	return `"${name.replaceAll("\"", "\"\"")}"`;
+/** A mutate action's `set` writes real STORED fields: a typo'd key would write
+*  a stray value forever, a computed/projected field is never persisted, and
+*  the primaryKey is the filename (renaming is not a mutation). */
+function mutateSetKeysNameStoredFields(schema) {
+	return (schema.actions ?? []).every((action) => action.kind !== "mutate" || Object.keys(action.set).every((key) => namesStoredField(schema.fields, key, schema.primaryKey)));
 }
-/** Single-quote a SQL string literal (a `types={...}` struct key). */
-function quoteLiteral(value) {
-	return `'${value.replaceAll("'", "''")}'`;
+/** Every `$params.<name>` reference in `set` must name a declared param — an
+*  undeclared one would silently no-op the assignment. */
+function mutateParamRefsAreDeclared(schema) {
+	return (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;
+	}));
 }
-/** The `read_csv` argument list shared by every CSV query: the (prepared)
-*  path plus a `types` pin forcing the key column to VARCHAR — without it
-*  DuckDB's sniffer turns `001` into BIGINT 1, so leading zeros vanish
-*  and distinct keys collapse. */
-function readCsvArgs(primaryKey) {
-	return `?, types={${quoteLiteral(primaryKey)}: 'VARCHAR'}`;
+/** A collection-level action has no record to write. */
+function collectionActionsAreNotMutate(schema) {
+	return (schema.collectionActions ?? []).every((action) => action.kind !== "mutate");
 }
-/** One aggregate's SQL expression. `sum`/`avg` TRY_CAST to DOUBLE so a
-*  column the sniffer kept as VARCHAR (mixed values) aggregates over its
-*  numeric cells instead of erroring; non-numeric cells become NULL and
-*  are skipped — standard BI tolerance. `min`/`max` stay native (they are
-*  meaningful on strings and dates too). */
-function aggregateExpr(aggregate) {
-	const { op, column } = aggregate;
-	if (op === "count") return column === void 0 ? "count(*)" : `count(${quoteIdent(column)})`;
-	if (op === "sum" || op === "avg") return `${op}(TRY_CAST(${quoteIdent(column ?? "")} AS DOUBLE))`;
-	return `${op}(${quoteIdent(column ?? "")})`;
+/** The singleton value becomes a record id (and thus a `<id>.json` filename),
+*  so it must satisfy the SAME record-id rule the write path enforces —
+*  otherwise the create form would lock the primary key to a value the POST
+*  route then rejects, making the collection impossible to initialize. */
+function singletonIsAValidRecordId(schema) {
+	return schema.singleton === void 0 || isSafeRecordId(schema.singleton);
 }
-/** One where condition → SQL fragment + its bound parameters. String
-*  equality compares against `CAST(col AS VARCHAR)` so a sniffer-typed
-*  column still matches its textual value; numeric/boolean values compare
-*  natively (DuckDB coerces the column side). */
-function whereFragment(cond) {
-	const column = quoteIdent(cond.field);
-	const asText = `CAST(${column} AS VARCHAR)`;
-	if (cond.op === "in") {
-		const values = arrayValue(cond);
-		return {
-			sql: `${values.every((value) => typeof value === "string") ? asText : column} IN (${values.map(() => "?").join(", ")})`,
-			params: values
-		};
+function collectCurrencyFieldRefs(fields) {
+	const refs = [];
+	for (const field of Object.values(fields)) {
+		if (typeof field.currencyField === "string" && field.currencyField.length > 0) refs.push(field.currencyField);
+		for (const sub of Object.values(field.of ?? {})) if (typeof sub.currencyField === "string" && sub.currencyField.length > 0) refs.push(sub.currencyField);
 	}
-	if (cond.op === "contains") return {
-		sql: `contains(${asText}, ?)`,
-		params: [String(scalarValue(cond))]
-	};
-	const operator = {
-		eq: "=",
-		ne: "<>",
-		gt: ">",
-		gte: ">=",
-		lt: "<",
-		lte: "<="
-	}[cond.op];
-	return {
-		sql: `${typeof cond.value === "string" && (cond.op === "eq" || cond.op === "ne") ? asText : column} ${operator} ?`,
-		params: [scalarValue(cond)]
-	};
+	return refs;
 }
-/** Mirror of `scalarValue` for the one op that takes a set: a scalar under
-*  `in` also means the query skipped `CollectionQueryZ`. Left unchecked it
-*  failed as `values.every is not a function`, naming neither the field nor
-*  the op. */
-function arrayValue(cond) {
-	if (!Array.isArray(cond.value)) throw new Error(`where condition on '${cond.field}' uses op 'in', which requires an array value, not a scalar`);
-	return cond.value;
+/** A `currencyField` pointer must name a real top-level field that holds a code
+*  string — a typo (`curreny`) would otherwise pass the per-field check, then
+*  silently fall back to the literal / USD at render and mislabel amounts. */
+function currencyFieldRefsNameCodeFields(schema) {
+	return collectCurrencyFieldRefs(schema.fields).every((name) => CODE_FIELD_TYPES.has(declaredField(schema.fields, name)?.type ?? ""));
 }
-/** `CollectionQueryZ` refines "`in` ⇔ array value", so an array reaching a
-*  scalar op means the query was compiled without being validated first —
-*  binding it would send an array to a single `?`. */
-function scalarValue(cond) {
-	if (Array.isArray(cond.value)) throw new Error(`where condition on '${cond.field}' uses op '${cond.op}', which requires a scalar value, not an array`);
-	return cond.value;
+/** The pair must be declared together — one without the other is meaningless:
+*  the host would either never fire (no done values to compare against) or
+*  never clear (no field to read).
+*
+*  EXCEPTION: when `completionField` names a `flag` field, done ⇔ the flag's
+*  `where` matches, so `completionDoneValues` carries no information and MUST
+*  be omitted (declaring it would invite a contradictory second source of
+*  truth). */
+function completionPairIsCoherent(schema) {
+	if (schema.completionField !== void 0 && declaredField(schema.fields, schema.completionField)?.type === "flag") return schema.completionDoneValues === void 0;
+	return schema.completionField === void 0 === (schema.completionDoneValues === void 0);
 }
-/** Compile a validated query against `fromSql` (a table-function call
-*  whose FIRST placeholder is the source path — the executor binds it).
-*  Returns the SQL and the where-value parameters that follow the path.
-*  Callers MUST have run `CollectionQueryZ` first; this function trusts
-*  the shape (aliases already charset-checked, orderBy membership already
-*  enforced). */
-function compileQuery(query, fromSql) {
-	const groupBy = query.groupBy ?? [];
-	const aggregates = Object.entries(query.aggregates ?? {});
-	const selectList = [...groupBy.map(quoteIdent), ...aggregates.map(([alias, aggregate]) => `${aggregateExpr(aggregate)} AS ${quoteIdent(alias)}`)];
-	const where = (query.where ?? []).map(whereFragment);
-	const clauses = [`SELECT ${selectList.join(", ")}`, `FROM ${fromSql}`];
-	if (where.length > 0) clauses.push(`WHERE ${where.map((fragment) => fragment.sql).join(" AND ")}`);
-	if (groupBy.length > 0) clauses.push(`GROUP BY ${groupBy.map(quoteIdent).join(", ")}`);
-	const orderBy = (query.orderBy ?? []).map((order) => quoteIdent(order.field) + (order.dir === "desc" ? " DESC" : " ASC"));
-	if (orderBy.length > 0) clauses.push(`ORDER BY ${orderBy.join(", ")}`);
-	clauses.push(`LIMIT ${query.limit ?? 1e3}`);
-	return {
-		sql: clauses.join(" "),
-		params: where.flatMap((fragment) => fragment.params)
-	};
+/** `completionField` must name a real top-level field — a typo would silently
+*  disable the notification mechanism otherwise. */
+function completionFieldIsDeclared(schema) {
+	return schema.completionField === void 0 || declaredField(schema.fields, schema.completionField) !== void 0;
 }
-/** Compile against a CSV file (the dataSource store's engine). */
-function compileCsvQuery(query, primaryKey) {
-	return compileQuery(query, `read_csv(${readCsvArgs(primaryKey)})`);
+/** A flag named by `completionField` is evaluated against the RAW record — the
+*  reconciler (and spawn's fallback) read items straight off disk, BEFORE any
+*  `deriveAll` enrichment — so its `where` may only reference STORED fields. A
+*  condition over a computed sibling would see an absent key: `ne` matches
+*  vacuously, every other op reads false, and the bell would clear wrongly /
+*  never. General (non-completion) flags keep the full vocabulary — the UI
+*  evaluates them post-enrichment. */
+function completionFlagReadsOnlyStoredFields(schema) {
+	const spec = schema.completionField === void 0 ? void 0 : declaredField(schema.fields, schema.completionField);
+	if (spec?.type !== "flag") return true;
+	return spec.where.every((cond) => [cond.field, ...cond.valueFrom ? [cond.valueFrom.field] : []].every((name) => {
+		const target = declaredField(schema.fields, name);
+		return target !== void 0 && !COMPUTED_TYPES.has(target.type);
+	}));
 }
-/** Compile against a JSONL file of ENRICHED records — the file-backed
-*  collections' engine (see `jsonlQuery.ts`). No VARCHAR key pin needed:
-*  enriched record ids are already strings. `sample_size=-1` makes the
-*  schema inference scan EVERY line — with the default sample, a sparse
-*  optional/derived field first appearing past the sample would not be
-*  inferred as a column and the query would binder-error on it (Codex P2
-*  on #2165). The full scan costs nothing extra here: aggregation reads
-*  the whole file anyway. */
-function compileJsonlQuery(query) {
-	return compileQuery(query, `read_json(?, format='newline_delimited', sample_size=-1)`);
+/** `displayField`, like `completionField`, must name a real top-level field —
+*  a typo would silently fall back to the primaryKey forever. */
+function displayFieldIsDeclared(schema) {
+	return schema.displayField === void 0 || declaredField(schema.fields, schema.displayField) !== void 0;
 }
-//#endregion
-//#region src/collection/server/csvStore.ts
-/** `list()` row cap. Over-cap files are truncated with a warn — the v1
-*  contract is "browse + per-record views", not full-table analytics. */
-var MAX_CSV_ROWS = 5e3;
-/** Record ids minted from non-safe key values: `id0x` + utf-8 hex. Raw key
-*  values that themselves match this pattern are ALSO encoded, so the
-*  encoded namespace never collides with a raw value (injective mapping). */
-var ENCODED_ID_PATTERN = /^id0x([0-9a-f]+)$/;
-/** A CSV key value → the record id it's addressed by. Safe values pass
-*  through untouched; everything else (and anything shaped like an encoded
-*  id) becomes `id0x<hex>`. Pure + exported for unit tests. */
-function encodeCsvRecordId(rawKey) {
-	if (safeRecordId(rawKey) === rawKey && !ENCODED_ID_PATTERN.test(rawKey)) return rawKey;
-	return `id0x${Buffer.from(rawKey, "utf-8").toString("hex")}`;
+/** A field's `when.field` gates its visibility against a sibling's value, so it
+*  must name a real top-level field — a typo would silently keep the field
+*  hidden forever (the gate never matches). */
+function fieldVisibilityGatesNameDeclaredFields(schema) {
+	return Object.values(schema.fields).every((field) => field.when === void 0 || declaredField(schema.fields, field.when.field) !== void 0);
 }
-/** A record id → the CSV key value to look up. Inverse of
-*  `encodeCsvRecordId` for encoded ids; anything else is already the raw
-*  value. Pure + exported for unit tests. */
-function decodeCsvRecordId(itemId) {
-	const hex = ENCODED_ID_PATTERN.exec(itemId)?.[1];
-	if (hex === void 0) return itemId;
-	return Buffer.from(hex, "hex").toString("utf-8");
+/** A flag's `where` reads sibling fields (both `cond.field` and a same-record
+*  `valueFrom.field`), so each must name a real top-level field — a typo would
+*  silently pin the flag false forever (`ne`: true forever). */
+function flagConditionsNameDeclaredFields(schema) {
+	return Object.values(schema.fields).every((field) => field.type !== "flag" || field.where.every((cond) => declaredField(schema.fields, cond.field) !== void 0 && (cond.valueFrom === void 0 || declaredField(schema.fields, cond.valueFrom.field) !== void 0)));
 }
-/** Normalize one DuckDB JS value into a JSON-safe record value: BigInt →
-*  number (string beyond the safe range), DATE/TIMESTAMP → ISO string
-*  (date-only when the clock is exactly UTC midnight, matching the `date`
-*  field contract), exotic DuckDB values → their string form. Pure +
-*  exported for unit tests. */
-/** `JSON.stringify` restricted to what a CSV cell can survive. Returns the
-*  serialised value, or `String(value)` when serialisation is impossible —
-*  losing the content of one cell is bad, failing the entire query is worse. */
-function safeJsonCell(value) {
-	try {
-		return JSON.stringify(value, (_key, entry) => typeof entry === "bigint" ? entry.toString() : entry) ?? String(value);
-	} catch {
-		return String(value);
-	}
+/** An `embed`'s `idField` resolves the target record id from a sibling's value,
+*  so it must name a real top-level field — and one whose stored value is a
+*  plain id string. Only `ref` / `string` qualify: the editor writes the picked
+*  id into that field, so a non-persisted or composite type would either not
+*  round-trip on save or hold no usable id. */
+function embedIdFieldsNameIdBearingFields(schema) {
+	return Object.values(schema.fields).every((field) => {
+		if (field.type !== "embed" || field.idField === void 0) return true;
+		const target = declaredField(schema.fields, field.idField);
+		return target !== void 0 && (target.type === "ref" || target.type === "string");
+	});
 }
-function normalizeCsvValue(value) {
-	if (typeof value === "bigint") return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(-Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
-	if (value instanceof Date) {
-		const iso = value.toISOString();
-		return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso;
+/** The sync writes each mapped value into a declared field, and puts the Google
+*  event id in the primary field — so a map key that names no field (or names
+*  the primary) would silently drop data or fight the id. */
+function googleCalendarMapNamesStoredFields(schema) {
+	if (schema.googleCalendar === void 0) return true;
+	return Object.keys(schema.googleCalendar.map).every((key) => namesStoredField(schema.fields, key, schema.primaryKey));
+}
+/** A `toggle` field projects an `enum` field: its `field` must name a real
+*  top-level enum, and `onValue` / `offValue` must be members of that enum's
+*  `values` — otherwise toggling would write a value outside the closed set
+*  (and never appear "checked"). */
+function togglesProjectValidEnums(schema) {
+	const { fields } = schema;
+	for (const spec of Object.values(fields)) {
+		if (spec.type !== "toggle") continue;
+		const target = declaredField(fields, spec.field);
+		if (!target || target.type !== "enum") return false;
+		const allowed = new Set(target.values);
+		if (!allowed.has(spec.onValue) || !allowed.has(spec.offValue)) return false;
 	}
-	if (value !== null && typeof value === "object") return safeJsonCell(value);
-	return value;
+	return true;
 }
-/** One raw DuckDB row → a CollectionItem, or null when the key cell is
-*  missing/empty (the row can't be addressed). The primaryKey field is
-*  OVERWRITTEN with the (possibly encoded) record id so `item[primaryKey]`
-*  and the record's address never drift — same invariant the file store's
-*  write path enforces. Pure + exported for unit tests. */
-function csvRowToItem(row, primaryKey) {
-	const normalized = Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)]));
-	const rawKey = normalized[primaryKey];
-	const keyText = fieldTextOrNull(rawKey);
-	if (keyText === null || keyText === "") return null;
-	return {
-		...normalized,
-		[primaryKey]: encodeCsvRecordId(keyText)
-	};
+/** `triggerField` requires the completion pair: the time gate only suppresses
+*  the *completion* bell until the date, and the bell still clears via
+*  `completionDoneValues`. Without completion there is no bell to gate. */
+function triggerFieldRequiresCompletion(schema) {
+	return schema.triggerField === void 0 || schema.completionField !== void 0;
 }
-/** Dedupe by record id, LAST row wins (matches `csvRead`'s last-match
-*  pick). Returns the surviving items in first-seen order. Pure +
-*  exported for unit tests. */
-function dedupeByRecordId(items, primaryKey) {
-	const byId = /* @__PURE__ */ new Map();
-	for (const item of items) byId.set(String(item[primaryKey]), item);
-	return {
-		items: [...byId.values()],
-		duplicates: items.length - byId.size
-	};
+/** `triggerField` must name a real `date` field — the gate parses its value as
+*  `YYYY-MM-DD`; any other type can't be compared to the clock. */
+function triggerFieldIsADateField(schema) {
+	return schema.triggerField === void 0 || declaredField(schema.fields, schema.triggerField)?.type === "date";
 }
-/** True when a thrown DuckDB error is the `types` pin naming a column the
-*  CSV doesn't have — the schema/file-mismatch case the caller downgrades
-*  to "empty collection + warn" instead of a 500. */
-function isMissingKeyColumnError(err) {
-	return String(err).includes("do not exist in the CSV");
+/** `triggerLeadDays` only means something relative to a trigger date. */
+function triggerLeadDaysRequiresTriggerField(schema) {
+	return schema.triggerLeadDays === void 0 || schema.triggerField !== void 0;
 }
-/** Bytes sniffed for UTF-8 validity. The trailing 3 bytes of the sample
-*  are dropped so a multibyte char split at the boundary can't produce a
-*  false negative on a valid file. */
-var SNIFF_BYTES = 1048576;
-function isValidUtf8(buf) {
-	try {
-		new TextDecoder("utf-8", { fatal: true }).decode(buf);
-		return true;
-	} catch {
-		return false;
-	}
+/** `spawn` advances `triggerField` to compute the successor's trigger date, so
+*  the schema must declare one. */
+function spawnRequiresTriggerField(schema) {
+	return schema.spawn === void 0 || schema.triggerField !== void 0;
 }
-/** Detect the (best-effort) encoding of a non-UTF-8 buffer. BOMs decide
-*  UTF-16; otherwise cp932 (the Shift_JIS superset — Excel-exported
-*  Japanese CSVs are the primary non-UTF-8 case this feature serves). */
-function fallbackEncoding(buf) {
-	if (buf.length >= 2 && buf[0] === 255 && buf[1] === 254) return "utf-16le";
-	if (buf.length >= 2 && buf[0] === 254 && buf[1] === 255) return "utf-16be";
-	return "cp932";
+/** `spawn.when.field` must name a real top-level field — a typo would silently
+*  never match. */
+function spawnWhenFieldIsDeclared(schema) {
+	return schema.spawn?.when === void 0 || declaredField(schema.fields, schema.spawn.when.field) !== void 0;
 }
-function cacheDir() {
-	return path.join(tmpdir(), "mulmoclaude-csv-utf8");
+/** Every `spawn.carry` entry must name a real top-level field — a typo would
+*  silently never copy. */
+function spawnCarryEntriesAreDeclared(schema) {
+	return (schema.spawn?.carry ?? []).every((name) => declaredField(schema.fields, name) !== void 0);
 }
-/** Read only the first `bytes` of a file — the encoding sniff must not
-*  pull a multi-hundred-MB CSV into memory on the (common) UTF-8 path. */
-async function readHead(absPath, bytes) {
-	const handle = await open(absPath, "r");
-	try {
-		const { size } = await handle.stat();
-		const buf = Buffer.alloc(Math.min(bytes, size));
-		await handle.read(buf, 0, buf.length, 0);
-		return buf;
-	} finally {
-		await handle.close();
-	}
+/** A successor must NOT be born already matching its own spawn predicate — it
+*  would re-spawn on its first reconcile, fanning out into an unbounded chain
+*  of records. The predicate field/values are `spawn.when` when given, else the
+*  completion-done pair. The successor's value for that field is `set[field]`
+*  if set, else the carried source value (which matched, by definition, when
+*  the spawn fired) if carried, else absent (safe). */
+function spawnSuccessorStartsInert(schema) {
+	const { spawn } = schema;
+	if (!spawn) return true;
+	const field = spawn.when?.field ?? schema.completionField;
+	const values = spawn.when?.in ?? schema.completionDoneValues;
+	if (!field || !values) return true;
+	if (spawn.set && Object.prototype.hasOwnProperty.call(spawn.set, field)) return !values.includes(String(spawn.set[field]));
+	return !(spawn.carry ?? []).includes(field);
 }
-/** Decode the whole file into a UTF-8 cache copy and return its path.
-*  Cache key = (path, mtime, size), so a replaced CSV re-decodes and an
-*  unchanged one never does. */
-async function pathExists(target) {
-	try {
-		await stat(target);
-		return true;
-	} catch {
-		return false;
-	}
+/** `spawnSuccessorStartsInert` cannot see through a flag's `where` (the
+*  predicate would need full record evaluation against `set`/`carry`). So a
+*  schema whose completion is flag-form may only spawn with an explicit
+*  `spawn.when` — which that check CAN evaluate. */
+function flagCompletionSpawnDeclaresWhen(schema) {
+	return schema.spawn === void 0 || schema.spawn.when !== void 0 || declaredField(schema.fields, schema.completionField ?? "")?.type !== "flag";
 }
-/** Best-effort removal of older decode-cache entries for the same source
-*  path — a frequently-replaced large CSV would otherwise accumulate one
-*  full copy per (mtime, size) forever. Runs AFTER the current copy is
-*  published; a concurrent reader holding an old fd is unaffected
-*  (unlink-while-open is safe on POSIX). */
-async function evictSupersededCache(key, keepBasename) {
-	try {
-		const entries = await readdir(cacheDir());
-		await Promise.all(entries.filter((name) => name.startsWith(`${key}-`) && name !== keepBasename).map((name) => unlink(path.join(cacheDir(), name)).catch(() => void 0)));
-	} catch {}
+function fieldDrivenSpawnEvery(schema) {
+	const every = schema.spawn?.every;
+	if (!every || !("fromField" in every)) return null;
+	return every;
 }
-/** Decode the whole file into a UTF-8 cache copy and return its path.
-*  Cache key = (path, mtime, size), so a replaced CSV re-decodes and an
-*  unchanged one never does; superseded copies are evicted. The cache
-*  lives in the SHARED OS tmpdir, so the dir is 0700 and files 0600 —
-*  decoded rows must not be readable by other local users. */
-async function decodeToCache(absPath, info) {
-	const key = createHash("sha256").update(absPath).digest("hex").slice(0, 16);
-	const cached = path.join(cacheDir(), `${key}-${Math.trunc(info.mtimeMs)}-${info.size}.csv`);
-	if (!await pathExists(cached)) {
-		const whole = await readFile(absPath);
-		const encoding = fallbackEncoding(whole);
-		const text = iconv.decode(whole, encoding);
-		await mkdir(cacheDir(), {
-			recursive: true,
-			mode: 448
-		});
-		const tmp = `${cached}.${randomBytes(4).toString("hex")}.tmp`;
-		await writeFile(tmp, text, {
-			encoding: "utf-8",
-			mode: 384
-		});
-		await rename(tmp, cached);
-		log.info("collections", "decoded non-UTF-8 dataSource file to cache", {
-			path: absPath,
-			encoding
-		});
-		await evictSupersededCache(key, path.basename(cached));
-	}
-	return cached;
+/** §4.1 — `fromField` must name a real top-level `enum` field. The `map` keys
+*  are only meaningful against a closed value set, and the field renders as a
+*  form `<select>`; a non-enum target has no finite values to validate. */
+function fieldDrivenFromFieldIsEnum(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	return declaredField(schema.fields, driven.fromField)?.type === "enum";
 }
-/** Re-validate the dataSource file at READ time, mirroring the JSON
-*  store's per-read defenses: realpath containment (a symlink swapped in
-*  after discovery must not walk out of the workspace) and an lstat
-*  regular-file check (a symlink leaf is refused outright, even one
-*  pointing inside the workspace — same rule as `isRegularFile` on
-*  record files). Returns the stat info, or null for "no readable file"
-*  (ENOENT / refused), which callers render as an empty collection. */
-async function safeCsvStat(absPath, workspaceRoot) {
-	if (!isContainedInRoot(absPath, workspaceRoot)) {
-		log.warn("collections", "dataSource read refused: path escapes workspace", { path: absPath });
-		return null;
-	}
-	let info;
-	try {
-		info = await lstat(absPath);
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return null;
-		throw err;
-	}
-	if (!info.isFile()) {
-		log.warn("collections", "dataSource read refused: not a regular file (symlink?)", { path: absPath });
-		return null;
+/** §4.2 — `map` keys must EXACTLY cover the enum's `values` (no missing keys —
+*  a record could pick an unmapped frequency and silently stall; no extra keys
+*  — a stale map outliving an enum edit). */
+function fieldDrivenMapCoversValues(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	const target = declaredField(schema.fields, driven.fromField);
+	if (target?.type !== "enum") return true;
+	const values = new Set(target.values);
+	const keys = Object.keys(driven.map);
+	return keys.length === values.size && keys.every((key) => values.has(key));
+}
+/** §4.5 — `fromField` must reach the successor (via `carry` or `set`);
+*  otherwise the successor loses its frequency and the NEXT spawn along the
+*  chain can't resolve an interval, silently halting the recurrence.
+*
+*  `set` writes a FIXED value, so it must itself be a key of `map` (else the
+*  successor is born with an unresolvable driver and `resolveEvery` skips it —
+*  the exact silent-halt §4.5 exists to prevent). `carry` copies the source's
+*  own value, which — for a record that matched the spawn — is one of the
+*  enum's values, all of which `map` covers by §4.2; so a carried driver is
+*  always resolvable and needs no value check here. */
+function fieldDrivenFromFieldCarried(schema) {
+	const driven = fieldDrivenSpawnEvery(schema);
+	if (!driven) return true;
+	const { carry, set } = schema.spawn ?? {};
+	if (set && Object.prototype.hasOwnProperty.call(set, driven.fromField)) {
+		const raw = set[driven.fromField];
+		if (raw === void 0 || raw === null || raw === "") return false;
+		const key = fieldTextOrNull(raw);
+		return key !== null && Object.prototype.hasOwnProperty.call(driven.map, key);
 	}
-	return info;
+	return (carry ?? []).includes(driven.fromField);
 }
-/** Return a path DuckDB can read as UTF-8: the original file when it
-*  already is UTF-8 (the cheap, common case — only the head is sniffed),
-*  else a decoded cache copy (see `decodeToCache`). Returns null when
-*  there is no readable file (missing, symlink, or containment-refused —
-*  see `safeCsvStat`), which callers render as an empty collection. */
-async function ensureUtf8CsvPath(absPath, workspaceRoot) {
-	const info = await safeCsvStat(absPath, workspaceRoot);
-	if (info === null) return null;
-	const head = await readHead(absPath, SNIFF_BYTES);
-	const sample = head.length === SNIFF_BYTES ? head.subarray(0, 1048573) : head;
-	if (!(head.length >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) && isValidUtf8(sample)) return absPath;
-	return decodeToCache(absPath, info);
+/** `calendarField` must name a real `date`/`datetime` field — the calendar view
+*  parses its value to place records on the month grid (a `datetime` anchor
+*  also carries the clock for the day view). */
+function calendarFieldIsDateLike(schema) {
+	return schema.calendarField === void 0 || isDateLike(declaredField(schema.fields, schema.calendarField)?.type);
 }
-var instancePromise = null;
-/** Lazily create one shared in-memory DuckDB instance. The dynamic import
-*  keeps the native module OUT of core's load path — a platform where the
-*  prebuilt binding is missing degrades to a per-query error on dataSource
-*  collections only, never a broken core. A failed init is retried on the
-*  next call (the promise is reset). */
-async function duckDbInstance() {
-	if (instancePromise === null) instancePromise = import("@duckdb/node-api").then((mod) => mod.DuckDBInstance.create(":memory:"));
-	try {
-		return await instancePromise;
-	} catch (err) {
-		instancePromise = null;
-		throw new BackendUnavailableError(`DuckDB is unavailable on this host (@duckdb/node-api failed to load: ${String(err)}) — dataSource collections cannot be read`);
-	}
+/** `calendarEndField` marks the end of a multi-day span, so it only means
+*  something alongside a start anchor. */
+function calendarEndFieldRequiresCalendarField(schema) {
+	return schema.calendarEndField === void 0 || schema.calendarField !== void 0;
 }
-async function queryCsv(sql, params) {
-	const connection = await (await duckDbInstance()).connect();
-	try {
-		return (await connection.runAndReadAll(sql, params)).getRowObjectsJS();
-	} finally {
-		connection.disconnectSync();
-	}
+/** `calendarEndField` must also name a real `date`/`datetime` field — same parse. */
+function calendarEndFieldIsDateLike(schema) {
+	return schema.calendarEndField === void 0 || isDateLike(declaredField(schema.fields, schema.calendarEndField)?.type);
 }
-async function csvList(absPath, primaryKey, workspaceRoot) {
-	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
-	if (utf8Path === null) return {
-		items: [],
-		truncated: false
-	};
-	let rows;
-	try {
-		rows = await queryCsv(`SELECT * FROM read_csv(${readCsvArgs(primaryKey)}) LIMIT 5001`, [utf8Path]);
-	} catch (err) {
-		if (!isMissingKeyColumnError(err)) throw err;
-		log.warn("collections", "dataSource CSV has no primaryKey column — every row is skipped", {
-			path: absPath,
-			primaryKey
-		});
-		return {
-			items: [],
-			truncated: false
-		};
-	}
-	const truncated = rows.length > MAX_CSV_ROWS;
-	if (truncated) {
-		log.warn("collections", "dataSource CSV truncated to row cap", {
-			path: absPath,
-			cap: MAX_CSV_ROWS
-		});
-		rows.length = MAX_CSV_ROWS;
-	}
-	const items = rows.map((row) => csvRowToItem(row, primaryKey)).filter((item) => item !== null);
-	const skipped = rows.length - items.length;
-	if (skipped > 0) log.warn("collections", "dataSource CSV rows skipped (empty key cell)", {
-		path: absPath,
-		skipped
-	});
-	const deduped = dedupeByRecordId(items, primaryKey);
-	if (deduped.duplicates > 0) log.warn("collections", "dataSource CSV has duplicate key values (last row wins)", {
-		path: absPath,
-		duplicates: deduped.duplicates
-	});
-	return {
-		items: deduped.items,
-		truncated
-	};
+/** `calendarTimeField` places records on the day view, so it only means
+*  something alongside a start anchor. */
+function calendarTimeFieldRequiresCalendarField(schema) {
+	return schema.calendarTimeField === void 0 || schema.calendarField !== void 0;
 }
-/** The scan-order ordinal column the last-match read adds. Underscore
-*  prefix keeps it out of any plausible CSV header namespace; it is
-*  stripped from the returned record either way. */
-var ROW_ORDINAL = "__mc_row";
-/** One record by id. The comparison value rides as a prepared-statement
-*  parameter, and the LAST matching row is selected IN DuckDB (scan-order
-*  ordinal + LIMIT 1) — a CSV with thousands of duplicate keys must not
-*  materialize them all for one detail read. Consistent with csvList's
-*  last-wins dedupe. */
-async function csvRead(absPath, primaryKey, itemId, workspaceRoot) {
-	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
-	if (utf8Path === null) return null;
-	const rawKey = decodeCsvRecordId(itemId);
-	const last = (await queryCsv(`SELECT * FROM (SELECT *, row_number() OVER () AS ${quoteIdent(ROW_ORDINAL)} FROM read_csv(${readCsvArgs(primaryKey)})) WHERE CAST(${quoteIdent(primaryKey)} AS VARCHAR) = ? ORDER BY ${quoteIdent(ROW_ORDINAL)} DESC LIMIT 1`, [utf8Path, rawKey])).at(0);
-	if (last === void 0) return null;
-	const { [ROW_ORDINAL]: __ordinal, ...record } = last;
-	return csvRowToItem(record, primaryKey);
+/** `calendarTimeField` must name a real top-level field (a free-form time
+*  string the day view parses). */
+function calendarTimeFieldIsDeclared(schema) {
+	return schema.calendarTimeField === void 0 || declaredField(schema.fields, schema.calendarTimeField) !== void 0;
 }
-/** Run a validated aggregation query (the structured DSL — see
-*  `core/queryZ.ts`) over the WHOLE file: no row cap on the scan (a
-*  capped aggregate would be a wrong number), only the result-row LIMIT
-*  the compiler emits. Values are normalized like list/read rows so a
-*  chart consumer gets plain JSON scalars. */
-async function csvRunQuery(absPath, primaryKey, query, workspaceRoot) {
-	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
-	if (utf8Path === null) return [];
-	const { sql, params } = compileCsvQuery(query, primaryKey);
-	return (await queryCsv(sql, [utf8Path, ...params])).map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)])));
+/** …and that field must be string-backed — the day view parses its value as a
+*  time string, so a number/enum/date column can't drive it. */
+function calendarTimeFieldIsStringBacked(schema) {
+	return schema.calendarTimeField === void 0 || isTimeStringField(declaredField(schema.fields, schema.calendarTimeField)?.type);
+}
+/** `kanbanField` must name a real `enum` field — the board groups records into
+*  one column per declared enum value; any other type has no closed set of
+*  columns to group by. */
+function kanbanFieldIsAnEnum(schema) {
+	return schema.kanbanField === void 0 || declaredField(schema.fields, schema.kanbanField)?.type === "enum";
+}
+/** `notifyWhen` narrows the completion bell, so it only means something with
+*  completion tracking. */
+function notifyWhenRequiresCompletion(schema) {
+	return schema.notifyWhen === void 0 || schema.completionField !== void 0;
+}
+/** `notifyWhen.field` must name a real top-level field. */
+function notifyWhenFieldIsDeclared(schema) {
+	return schema.notifyWhen === void 0 || declaredField(schema.fields, schema.notifyWhen.field) !== void 0;
+}
+/** Every custom view `id` must be a valid slug — it doubles as the view-mode
+*  selector key (`custom:<id>`) and the capability-token clamp key, both of
+*  which expect a path-safe token. */
+function viewIdsAreSlugs(schema) {
+	return schema.views === void 0 || schema.views.every((view) => isSafeSlug(view.id));
+}
+/** Custom view ids must be unique so the selector + token clamp resolve
+*  unambiguously. */
+function viewIdsAreUnique(schema) {
+	return hasUniqueIds(schema.views);
 }
 //#endregion
-//#region src/collection/server/watchFs.ts
-/** An atomic file replace (editor save, `mv` over the target) surfaces as
-*  2-3 events. Collapse them so one user action reports one change. */
-var REPLACE_DEBOUNCE_MS = 300;
-/** The path to hand `watch()`, with Windows 8.3 short names resolved away.
-*
-*  ReadDirectoryChangesW reports filenames against the LONG path, but a watch
-*  opened on a short path (`C:\Users\RUNNER~1\…` — what `os.tmpdir()` returns
-*  on GitHub's Windows runners) keeps the short form. libuv's
-*  `assert(!_wcsnicmp(filename, dir, dirlen))` in `src/win/fs-event.c` then
-*  aborts the PROCESS on the first event — a native assert, so neither
-*  `watcher.on("error")` nor a try/catch can contain it.
-*
-*  POSIX is deliberately left alone: `realpath` there also collapses symlinks
-*  (`/var` → `/private/var` on macOS), which we neither need nor want to
-*  change. A failure falls back to the original path — worst case we are no
-*  worse off than before. */
-function watchablePath(dir) {
-	if (process.platform !== "win32") return dir;
-	try {
-		return realpathSync.native(dir);
-	} catch {
-		return dir;
-	}
-}
-/** Watch `dir`, reporting each accepted filename. `accept` decides what is
-*  noise; a null filename always passes (the platform didn't tell us which
-*  file, so the caller must assume the worst). */
-async function watchDirectory(dir, accept, onHit) {
-	try {
-		await mkdir(dir, { recursive: true });
-		const watcher = watch(watchablePath(dir), { persistent: false }, (_eventType, rawFilename) => {
-			const filename = rawFilename === null ? null : String(rawFilename);
-			if (filename !== null && !accept(filename)) return;
-			onHit(filename);
-		});
-		watcher.on("error", (err) => {
-			log.warn("collections", "fs watch error", {
-				dir,
-				error: String(err)
-			});
-		});
-		return { close: () => watcher.close() };
-	} catch (err) {
-		log.warn("collections", "fs watch start failed", {
-			dir,
-			error: String(err)
-		});
-		return null;
-	}
-}
-/** Watch the single file `absPath` by watching its PARENT directory, so an
-*  atomic replace can't strand the watch on a dead inode. `alsoAccept`
-*  widens the filter beyond the exact basename (sqlite's `-wal`/`-journal`
-*  sidecars). Reports are debounced: one replace, one call. */
-async function watchSingleFile(absPath, alsoAccept, onChange) {
-	const dir = path.dirname(absPath);
-	const base = path.basename(absPath);
-	let timer = null;
-	const fire = () => {
-		if (timer) clearTimeout(timer);
-		timer = setTimeout(() => {
-			timer = null;
-			onChange();
-		}, REPLACE_DEBOUNCE_MS);
-		timer.unref?.();
-	};
-	const handle = await watchDirectory(dir, (filename) => filename === base || alsoAccept(base, filename), fire);
-	if (!handle) return null;
-	return { close: () => {
-		if (timer) clearTimeout(timer);
-		timer = null;
-		handle.close();
-	} };
-}
-/** An `FsWatchHandle` as a bare unsubscribe — `null` straight through, so an
-*  unarmed watch stays distinguishable from an armed one. Lives here rather
-*  than beside the store contract so both `store.ts` and the backends it
-*  registers can reach it without importing each other. */
-function closerFor(handle) {
-	return handle === null ? null : () => handle.close();
-}
-//#endregion
-//#region src/collection/server/sqliteStore.ts
-/** A constructor's parameter and return types are not observable at runtime,
-*  so the check stops at "DatabaseSync is constructible" — the only member of
-*  the module this store ever touches. */
-function isSqliteModule(mod) {
-	return isRecord(mod) && typeof mod.DatabaseSync === "function";
-}
-var sqliteModule = null;
-/** Drops the memo first so a later call can retry (e.g. tests stubbing the
-*  runtime), then reports why the backend is unusable. */
-function sqliteUnavailable(reason) {
-	sqliteModule = null;
-	throw new BackendUnavailableError(`sqlite storage needs the node:sqlite module (Node.js >= 22.5) — this runtime cannot load it: ${reason}`);
-}
-/** Lazy-load node:sqlite once. A runtime without it (Node < 22.5) throws a
-*  clearly-worded error the caller surfaces — never a bare MODULE_NOT_FOUND. */
-function loadSqlite() {
-	sqliteModule ??= import("node:sqlite").then((mod) => isSqliteModule(mod) ? mod : sqliteUnavailable("the module exposes no DatabaseSync constructor"), (err) => sqliteUnavailable(String(err)));
-	return sqliteModule;
-}
-/** The db file's on-disk state. A symlink or non-regular file is refused
-*  (file-disclosure defense, same rule as io.ts record files); ENOENT is
-*  just "no records yet". Any OTHER lstat failure (EACCES, EIO, …) is
-*  rethrown so reads surface a real filesystem problem instead of
-*  silently reporting an empty collection. */
-async function dbFileState(absPath) {
-	try {
-		return (await lstat(absPath)).isFile() ? "file" : "refused";
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return "missing";
-		throw err;
-	}
-}
-var CREATE_TABLE = "CREATE TABLE IF NOT EXISTS records (id TEXT PRIMARY KEY, record TEXT NOT NULL)";
-/** Open the database for one operation, classifying the two unavailable
-*  states so callers can map them honestly (`refused` ⇒ path-escape,
-*  `missing` ⇒ empty / not-found — conflating them would misreport a
-*  containment escape as "item not found"). The containment pre-check runs
-*  BEFORE mkdir even when the file is missing — `isContainedInRoot`
-*  resolves through the closest existing ancestor, so a symlinked-away
-*  parent can never make the recursive mkdir create directories outside
-*  the workspace (same pre/post belt-and-suspenders as io.ts writes). */
-async function openDb(absPath, workspaceRoot, mode) {
-	const state = await dbFileState(absPath);
-	if (state === "refused") {
-		log.warn("collections", "sqlite database refused: not a regular file", { path: absPath });
-		return { kind: "refused" };
-	}
-	if (!isContainedInRoot(path.dirname(absPath), workspaceRoot)) {
-		log.warn("collections", "sqlite refused: database dir escapes workspace via symlink", { path: absPath });
-		return { kind: "refused" };
-	}
-	if (mode === "read" && state === "missing") return { kind: "missing" };
-	if (mode === "write") {
-		await mkdir(path.dirname(absPath), { recursive: true });
-		if (!isContainedInRoot(path.dirname(absPath), workspaceRoot)) {
-			log.warn("collections", "sqlite write refused: database dir escapes workspace via symlink (post-mkdir)", { path: absPath });
-			return { kind: "refused" };
-		}
-	}
-	const { DatabaseSync } = await loadSqlite();
-	const database = new DatabaseSync(absPath);
-	database.exec("PRAGMA busy_timeout = 5000");
-	database.exec(CREATE_TABLE);
-	return {
-		kind: "ok",
-		database
-	};
-}
-/** Run `operation` against the database and always close it; unavailable
-*  states resolve through `onUnavailable` so each caller maps `missing`
-*  vs `refused` to its own result kind. */
-async function withDb(absPath, workspaceRoot, mode, onUnavailable, operation) {
-	const handle = await openDb(absPath, workspaceRoot, mode);
-	if (handle.kind !== "ok") return onUnavailable(handle.kind);
-	try {
-		return await operation(handle.database);
-	} finally {
-		handle.database.close();
-	}
-}
-var SQLITE_CONSTRAINT_PRIMARYKEY = 1555;
-var SQLITE_CONSTRAINT_UNIQUE = 2067;
-/** node:sqlite throws ERR_SQLITE_ERROR with the SQLite extended result
-*  code on `errcode`. Checked structurally (message text kept only as a
-*  fallback for runtimes that don't expose `errcode`). */
-function isUniqueConstraintError(err) {
-	if (hasNumberProp(err, "errcode")) return err.errcode === SQLITE_CONSTRAINT_PRIMARYKEY || err.errcode === SQLITE_CONSTRAINT_UNIQUE;
-	return String(err).includes("UNIQUE constraint");
-}
-function parseRow(raw) {
-	if (typeof raw !== "string") return null;
-	try {
-		const parsed = JSON.parse(raw);
-		return isRecord(parsed) ? parsed : null;
-	} catch {
-		return null;
-	}
-}
-/** One column of a result row. node:sqlite types rows as `unknown`, so a
-*  value that is not a row object yields no column at all. */
-function readColumn(row, column) {
-	return isRecord(row) ? row[column] : void 0;
-}
-function rowsToItems(rows) {
-	return rows.map((row) => parseRow(readColumn(row, "record"))).filter((item) => item !== null);
-}
-/** node:sqlite hands back an integer column as `number`, or as `bigint` once
-*  it leaves the safe-integer range — COUNT(*) can be either. */
-function countRecords(database) {
-	const count = readColumn(database.prepare("SELECT COUNT(*) AS n FROM records").get(), "n");
-	if (typeof count === "number") return count;
-	if (typeof count === "bigint") return Number(count);
-	throw new Error(`sqlite COUNT(*) returned no numeric row count (got ${typeof count})`);
-}
-async function sqliteList(absPath, workspaceRoot) {
-	return withDb(absPath, workspaceRoot, "read", () => [], (database) => rowsToItems(database.prepare("SELECT record FROM records ORDER BY id").all()));
-}
-async function sqlitePage(absPath, primaryKey, opts, workspaceRoot) {
-	const emptyPage = {
-		items: [],
-		total: 0,
-		truncated: false
-	};
-	return withDb(absPath, workspaceRoot, "read", () => emptyPage, (database) => {
-		const total = countRecords(database);
-		const offset = Math.max(0, opts.offset ?? 0);
-		const limit = opts.limit === void 0 ? -1 : Math.max(0, opts.limit);
-		return {
-			items: projectItemFields(rowsToItems(database.prepare("SELECT record FROM records ORDER BY id LIMIT ? OFFSET ?").all(limit, offset)), opts.fields, primaryKey),
-			total,
-			truncated: false
-		};
-	});
-}
-async function sqliteRead(absPath, itemId, workspaceRoot) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return null;
-	return withDb(absPath, workspaceRoot, "read", () => null, (database) => {
-		return parseRow(readColumn(database.prepare("SELECT record FROM records WHERE id = ?").get(safeId), "record"));
-	});
-}
-async function sqliteWrite(absPath, itemId, item, opts) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return {
-		kind: "invalid-id",
-		itemId
-	};
-	const outcome = await withDb(absPath, opts.workspaceRoot, "write", () => ({
-		kind: "path-escape",
-		itemId: safeId
-	}), (database) => {
-		const payload = JSON.stringify(item);
-		if (opts.refuseOverwrite) try {
-			database.prepare("INSERT INTO records (id, record) VALUES (?, ?)").run(safeId, payload);
-		} catch (err) {
-			if (isUniqueConstraintError(err)) return {
-				kind: "conflict",
-				itemId: safeId
-			};
-			throw err;
-		}
-		else database.prepare("INSERT INTO records (id, record) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET record = excluded.record").run(safeId, payload);
-		return {
-			kind: "ok",
-			itemId: safeId,
-			item
-		};
-	});
-	if (outcome.kind === "ok" && opts.slug) publishCollectionChange(collectionChangePayload({
-		slug: opts.slug,
-		ids: [safeId],
-		op: "upsert"
-	}, opts.publishRoot));
-	return outcome;
-}
-async function sqliteDelete(absPath, itemId, opts) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return {
-		kind: "invalid-id",
-		itemId
-	};
-	const outcome = await withDb(absPath, opts.workspaceRoot, "read", (reason) => reason === "refused" ? {
-		kind: "path-escape",
-		itemId: safeId
-	} : {
-		kind: "not-found",
-		itemId: safeId
-	}, (database) => {
-		const { changes } = database.prepare("DELETE FROM records WHERE id = ?").run(safeId);
-		return Number(changes) === 0 ? {
-			kind: "not-found",
-			itemId: safeId
-		} : {
-			kind: "ok",
-			itemId: safeId
-		};
-	});
-	if (outcome.kind === "ok" && opts.slug) publishCollectionChange(collectionChangePayload({
-		slug: opts.slug,
-		ids: [safeId],
-		op: "delete"
-	}, opts.publishRoot));
-	return outcome;
-}
-/** Best-effort full WAL checkpoint so the MAIN db file alone is a
-*  complete snapshot (committed pages in `<db>-wal` are folded in and the
-*  WAL truncated). Used by `deleteCollection` before archiving. Returns
-*  false on any failure (runtime without node:sqlite, locked db, missing
-*  file) — the caller then archives the sidecar files alongside the db so
-*  no committed data is lost either way. */
-async function checkpointSqliteDatabase(absPath) {
-	try {
-		const { DatabaseSync } = await loadSqlite();
-		const database = new DatabaseSync(absPath);
-		try {
-			database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-		} finally {
-			database.close();
-		}
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** A `storage: sqlite` store over `collection.storageFile`. A schema whose
-*  `storageFile` failed to resolve yields a read-only EMPTY store rather
-*  than a writable one — same fail-closed rule as the CSV store. */
-function sqliteStoreFor(collection, opts) {
-	const file = collection.storageFile;
-	const key = collection.schema.primaryKey;
-	const slug = opts.slug ?? collection.slug;
-	const root = () => opts.workspaceRoot ?? getWorkspaceRoot();
-	const publishRoot = opts.workspaceRoot;
-	if (file === void 0) return {
-		capabilities: {
-			writable: false,
-			nativeQuery: false,
-			nativePaging: false
-		},
-		list: () => Promise.resolve([]),
-		page: () => Promise.resolve({
-			items: [],
-			total: 0,
-			truncated: false
-		}),
-		read: () => Promise.resolve(null)
-	};
-	return {
-		capabilities: {
-			writable: true,
-			nativeQuery: false,
-			nativePaging: true
-		},
-		list: () => sqliteList(file, root()),
-		page: (pageOpts = {}) => sqlitePage(file, key, pageOpts, root()),
-		read: (itemId) => sqliteRead(file, itemId, root()),
-		write: (itemId, item, writeOpts = {}) => sqliteWrite(file, itemId, item, {
-			workspaceRoot: root(),
-			publishRoot,
-			slug,
-			refuseOverwrite: writeOpts.refuseOverwrite
-		}),
-		delete: (itemId) => sqliteDelete(file, itemId, {
-			workspaceRoot: root(),
-			publishRoot,
-			slug
-		}),
-		watch: async (onChange) => closerFor(await watchSingleFile(file, (base, name) => name.startsWith(base), () => onChange({ kind: "collection" })))
-	};
-}
-//#endregion
-//#region src/collection/server/store.ts
-/** The file store's stable order: lexicographic by record id (codepoint
-*  compare — locale-independent). `listItems` returns readdir order, which
-*  is filesystem-dependent; paging needs determinism. */
-function sortByRecordId(items, primaryKey) {
-	return [...items].sort((left, right) => {
-		const leftId = fieldText(left[primaryKey]);
-		const rightId = fieldText(right[primaryKey]);
-		if (leftId < rightId) return -1;
-		return leftId > rightId ? 1 : 0;
-	});
-}
-/** True when the collection accepts UI/tool writes. A `dataSource`
-*  collection is read-only: updates happen by editing/replacing the
-*  data file itself. Every write entry point checks this BEFORE calling
-*  `writeItem`/`deleteItem` — server-enforced, not just UI-hidden. */
-function collectionWritable(collection) {
-	return !isReadOnlySchema(collection.schema);
-}
-/** The one-line refusal write paths surface (HTTP 405 / MCP error text). */
-function readOnlyRefusal(slug) {
-	return `collection '${slug}' is read-only (backed by an external dataSource) — update the data file itself instead`;
-}
-/** A `dataSource` store over `file` (CSV row order; DuckDB-native query).
-*  A schema whose `dataSourceFile` failed to resolve yields a read-only
-*  EMPTY store rather than falling back to the (writable) file store — a
-*  half-loaded read-only collection must never become writable. */
-function csvStoreFor(collection, opts) {
-	const file = collection.dataSourceFile;
-	const key = collection.schema.primaryKey;
-	const listAll = () => file === void 0 ? Promise.resolve({
-		items: [],
-		truncated: false
-	}) : csvList(file, key, opts.workspaceRoot);
-	return {
-		capabilities: {
-			writable: false,
-			nativeQuery: true,
-			nativePaging: false
-		},
-		list: () => listAll().then((result) => result.items),
-		page: (pageOpts = {}) => listAll().then((result) => pageFromFullRead(result.items, pageOpts, key, result.truncated)),
-		read: (itemId) => file === void 0 ? Promise.resolve(null) : csvRead(file, key, itemId, opts.workspaceRoot),
-		query: (query) => file === void 0 ? Promise.resolve([]) : csvRunQuery(file, key, query, opts.workspaceRoot),
-		...file === void 0 ? {} : { watch: async (onChange) => closerFor(await watchSingleFile(file, () => false, () => onChange({ kind: "collection" }))) }
-	};
-}
-/** The classic file store over `<dataDir>/<itemId>.json` records. */
-function fileStoreFor(collection, opts) {
-	const key = collection.schema.primaryKey;
-	const ioOpts = {
-		...opts,
-		slug: opts.slug ?? collection.slug
-	};
-	return {
-		capabilities: {
-			writable: true,
-			nativeQuery: false,
-			nativePaging: false
-		},
-		list: () => listItems(collection.dataDir, opts),
-		page: async (pageOpts = {}) => pageFromFullRead(sortByRecordId(await listItems(collection.dataDir, opts), key), pageOpts, key, false),
-		read: (itemId) => readItem(collection.dataDir, itemId, opts),
-		write: (itemId, item, writeOpts = {}) => writeItem(collection.dataDir, itemId, item, {
-			...ioOpts,
-			refuseOverwrite: writeOpts.refuseOverwrite
-		}),
-		delete: (itemId) => deleteItem(collection.dataDir, itemId, ioOpts),
-		watch: async (onChange) => closerFor(await watchDirectory(collection.dataDir, (name) => name.endsWith(".json") && !name.startsWith("."), (filename) => onChange(filename === null ? { kind: "collection" } : {
-			kind: "item",
-			itemId: filename.slice(0, -5)
-		})))
-	};
-}
-var storeFactories = /* @__PURE__ */ new Map([
-	["file", fileStoreFor],
-	["csv", csvStoreFor],
-	["sqlite", sqliteStoreFor],
-	["firestore", firestoreStoreFor]
-]);
-/** Pick the store implementation for a discovered collection via the
-*  factory registry. An unknown kind cannot normally reach here (the
-*  schema's `StorageZ` union gates it), so the throw is a loud invariant
-*  breach, not a user-facing path. */
-function storeFor(collection, opts = {}) {
-	const kind = storageKindFor(collection.schema);
-	const factory = storeFactories.get(kind);
-	if (!factory) throw new Error(`no store factory registered for storage kind '${kind}'`);
-	return factory(collection, opts);
-}
-/** 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/core/schemaRules.ts
-var declaredField = (fields, name) => Object.hasOwn(fields, name) ? fields[name] : void 0;
-var isDateLike = (type) => type === "date" || type === "datetime";
-var isTimeStringField = (type) => type === "string" || type === "text";
-var CODE_FIELD_TYPES = /* @__PURE__ */ new Set([
-	"string",
-	"text",
-	"enum"
-]);
-var namesStoredField = (fields, name, primaryKey) => {
-	const target = declaredField(fields, name);
-	return target !== void 0 && !COMPUTED_TYPES.has(target.type) && name !== primaryKey;
-};
-var hasUniqueIds = (entries) => entries === void 0 || new Set(entries.map((entry) => entry.id)).size === entries.length;
-/** Exactly one storage declaration: native records need `dataPath`, an external
-*  data file needs `dataSource`, an alternative backend needs `storage`. Zero
-*  (nowhere to read) and several (ambiguous which wins) are equally
-*  meaningless — fail loudly at load instead of picking silently. */
-function declaresExactlyOneStore(schema) {
-	return [
-		schema.dataPath,
-		schema.dataSource,
-		schema.storage
-	].filter((declared) => declared !== void 0).length === 1;
-}
-/** A `dataSource` collection is read-only by definition, so schema-level write
-*  machinery can never fire: `singleton` pins CREATES, `ingest` REFILLS
-*  records, `spawn` WRITES successor records. Rejecting them at validation
-*  kills whole classes of writes before any runtime guard. */
-function dataSourceDeclaresNoWriteMachinery(schema) {
-	if (schema.dataSource === void 0) return true;
-	return schema.singleton === void 0 && schema.ingest === void 0 && schema.spawn === void 0 && schema.googleCalendar === void 0;
-}
-/** Same rule for declarative host writes: a mutate action writes the record
-*  it's invoked on, which a read-only collection has no business doing. */
-function dataSourceDeclaresNoMutateAction(schema) {
-	if (schema.dataSource !== void 0) return [...schema.actions ?? [], ...schema.collectionActions ?? []].every((action) => action.kind !== "mutate");
-	return true;
-}
-/** Action ids must be unique so the dispatch route resolves unambiguously. */
-function actionIdsAreUnique(schema) {
-	return hasUniqueIds(schema.actions);
-}
-/** Collection-level action ids must likewise be unique. */
-function collectionActionIdsAreUnique(schema) {
-	return hasUniqueIds(schema.collectionActions);
-}
-/** A mutate action's `set` writes real STORED fields: a typo'd key would write
-*  a stray value forever, a computed/projected field is never persisted, and
-*  the primaryKey is the filename (renaming is not a mutation). */
-function mutateSetKeysNameStoredFields(schema) {
-	return (schema.actions ?? []).every((action) => action.kind !== "mutate" || Object.keys(action.set).every((key) => namesStoredField(schema.fields, key, schema.primaryKey)));
-}
-/** Every `$params.<name>` reference in `set` must name a declared param — an
-*  undeclared one would silently no-op the assignment. */
-function mutateParamRefsAreDeclared(schema) {
-	return (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;
-	}));
-}
-/** A collection-level action has no record to write. */
-function collectionActionsAreNotMutate(schema) {
-	return (schema.collectionActions ?? []).every((action) => action.kind !== "mutate");
-}
-/** The singleton value becomes a record id (and thus a `<id>.json` filename),
-*  so it must satisfy the SAME record-id rule the write path enforces —
-*  otherwise the create form would lock the primary key to a value the POST
-*  route then rejects, making the collection impossible to initialize. */
-function singletonIsAValidRecordId(schema) {
-	return schema.singleton === void 0 || isSafeRecordId(schema.singleton);
-}
-function collectCurrencyFieldRefs(fields) {
-	const refs = [];
-	for (const field of Object.values(fields)) {
-		if (typeof field.currencyField === "string" && field.currencyField.length > 0) refs.push(field.currencyField);
-		for (const sub of Object.values(field.of ?? {})) if (typeof sub.currencyField === "string" && sub.currencyField.length > 0) refs.push(sub.currencyField);
-	}
-	return refs;
-}
-/** A `currencyField` pointer must name a real top-level field that holds a code
-*  string — a typo (`curreny`) would otherwise pass the per-field check, then
-*  silently fall back to the literal / USD at render and mislabel amounts. */
-function currencyFieldRefsNameCodeFields(schema) {
-	return collectCurrencyFieldRefs(schema.fields).every((name) => CODE_FIELD_TYPES.has(declaredField(schema.fields, name)?.type ?? ""));
-}
-/** The pair must be declared together — one without the other is meaningless:
-*  the host would either never fire (no done values to compare against) or
-*  never clear (no field to read).
-*
-*  EXCEPTION: when `completionField` names a `flag` field, done ⇔ the flag's
-*  `where` matches, so `completionDoneValues` carries no information and MUST
-*  be omitted (declaring it would invite a contradictory second source of
-*  truth). */
-function completionPairIsCoherent(schema) {
-	if (schema.completionField !== void 0 && declaredField(schema.fields, schema.completionField)?.type === "flag") return schema.completionDoneValues === void 0;
-	return schema.completionField === void 0 === (schema.completionDoneValues === void 0);
-}
-/** `completionField` must name a real top-level field — a typo would silently
-*  disable the notification mechanism otherwise. */
-function completionFieldIsDeclared(schema) {
-	return schema.completionField === void 0 || declaredField(schema.fields, schema.completionField) !== void 0;
-}
-/** A flag named by `completionField` is evaluated against the RAW record — the
-*  reconciler (and spawn's fallback) read items straight off disk, BEFORE any
-*  `deriveAll` enrichment — so its `where` may only reference STORED fields. A
-*  condition over a computed sibling would see an absent key: `ne` matches
-*  vacuously, every other op reads false, and the bell would clear wrongly /
-*  never. General (non-completion) flags keep the full vocabulary — the UI
-*  evaluates them post-enrichment. */
-function completionFlagReadsOnlyStoredFields(schema) {
-	const spec = schema.completionField === void 0 ? void 0 : declaredField(schema.fields, schema.completionField);
-	if (spec?.type !== "flag") return true;
-	return spec.where.every((cond) => [cond.field, ...cond.valueFrom ? [cond.valueFrom.field] : []].every((name) => {
-		const target = declaredField(schema.fields, name);
-		return target !== void 0 && !COMPUTED_TYPES.has(target.type);
-	}));
-}
-/** `displayField`, like `completionField`, must name a real top-level field —
-*  a typo would silently fall back to the primaryKey forever. */
-function displayFieldIsDeclared(schema) {
-	return schema.displayField === void 0 || declaredField(schema.fields, schema.displayField) !== void 0;
-}
-/** A field's `when.field` gates its visibility against a sibling's value, so it
-*  must name a real top-level field — a typo would silently keep the field
-*  hidden forever (the gate never matches). */
-function fieldVisibilityGatesNameDeclaredFields(schema) {
-	return Object.values(schema.fields).every((field) => field.when === void 0 || declaredField(schema.fields, field.when.field) !== void 0);
-}
-/** A flag's `where` reads sibling fields (both `cond.field` and a same-record
-*  `valueFrom.field`), so each must name a real top-level field — a typo would
-*  silently pin the flag false forever (`ne`: true forever). */
-function flagConditionsNameDeclaredFields(schema) {
-	return Object.values(schema.fields).every((field) => field.type !== "flag" || field.where.every((cond) => declaredField(schema.fields, cond.field) !== void 0 && (cond.valueFrom === void 0 || declaredField(schema.fields, cond.valueFrom.field) !== void 0)));
-}
-/** An `embed`'s `idField` resolves the target record id from a sibling's value,
-*  so it must name a real top-level field — and one whose stored value is a
-*  plain id string. Only `ref` / `string` qualify: the editor writes the picked
-*  id into that field, so a non-persisted or composite type would either not
-*  round-trip on save or hold no usable id. */
-function embedIdFieldsNameIdBearingFields(schema) {
-	return Object.values(schema.fields).every((field) => {
-		if (field.type !== "embed" || field.idField === void 0) return true;
-		const target = declaredField(schema.fields, field.idField);
-		return target !== void 0 && (target.type === "ref" || target.type === "string");
-	});
-}
-/** The sync writes each mapped value into a declared field, and puts the Google
-*  event id in the primary field — so a map key that names no field (or names
-*  the primary) would silently drop data or fight the id. */
-function googleCalendarMapNamesStoredFields(schema) {
-	if (schema.googleCalendar === void 0) return true;
-	return Object.keys(schema.googleCalendar.map).every((key) => namesStoredField(schema.fields, key, schema.primaryKey));
-}
-/** A `toggle` field projects an `enum` field: its `field` must name a real
-*  top-level enum, and `onValue` / `offValue` must be members of that enum's
-*  `values` — otherwise toggling would write a value outside the closed set
-*  (and never appear "checked"). */
-function togglesProjectValidEnums(schema) {
-	const { fields } = schema;
-	for (const spec of Object.values(fields)) {
-		if (spec.type !== "toggle") continue;
-		const target = declaredField(fields, spec.field);
-		if (!target || target.type !== "enum") return false;
-		const allowed = new Set(target.values);
-		if (!allowed.has(spec.onValue) || !allowed.has(spec.offValue)) return false;
-	}
-	return true;
-}
-/** `triggerField` requires the completion pair: the time gate only suppresses
-*  the *completion* bell until the date, and the bell still clears via
-*  `completionDoneValues`. Without completion there is no bell to gate. */
-function triggerFieldRequiresCompletion(schema) {
-	return schema.triggerField === void 0 || schema.completionField !== void 0;
-}
-/** `triggerField` must name a real `date` field — the gate parses its value as
-*  `YYYY-MM-DD`; any other type can't be compared to the clock. */
-function triggerFieldIsADateField(schema) {
-	return schema.triggerField === void 0 || declaredField(schema.fields, schema.triggerField)?.type === "date";
-}
-/** `triggerLeadDays` only means something relative to a trigger date. */
-function triggerLeadDaysRequiresTriggerField(schema) {
-	return schema.triggerLeadDays === void 0 || schema.triggerField !== void 0;
-}
-/** `spawn` advances `triggerField` to compute the successor's trigger date, so
-*  the schema must declare one. */
-function spawnRequiresTriggerField(schema) {
-	return schema.spawn === void 0 || schema.triggerField !== void 0;
-}
-/** `spawn.when.field` must name a real top-level field — a typo would silently
-*  never match. */
-function spawnWhenFieldIsDeclared(schema) {
-	return schema.spawn?.when === void 0 || declaredField(schema.fields, schema.spawn.when.field) !== void 0;
-}
-/** Every `spawn.carry` entry must name a real top-level field — a typo would
-*  silently never copy. */
-function spawnCarryEntriesAreDeclared(schema) {
-	return (schema.spawn?.carry ?? []).every((name) => declaredField(schema.fields, name) !== void 0);
-}
-/** A successor must NOT be born already matching its own spawn predicate — it
-*  would re-spawn on its first reconcile, fanning out into an unbounded chain
-*  of records. The predicate field/values are `spawn.when` when given, else the
-*  completion-done pair. The successor's value for that field is `set[field]`
-*  if set, else the carried source value (which matched, by definition, when
-*  the spawn fired) if carried, else absent (safe). */
-function spawnSuccessorStartsInert(schema) {
-	const { spawn } = schema;
-	if (!spawn) return true;
-	const field = spawn.when?.field ?? schema.completionField;
-	const values = spawn.when?.in ?? schema.completionDoneValues;
-	if (!field || !values) return true;
-	if (spawn.set && Object.prototype.hasOwnProperty.call(spawn.set, field)) return !values.includes(String(spawn.set[field]));
-	return !(spawn.carry ?? []).includes(field);
-}
-/** `spawnSuccessorStartsInert` cannot see through a flag's `where` (the
-*  predicate would need full record evaluation against `set`/`carry`). So a
-*  schema whose completion is flag-form may only spawn with an explicit
-*  `spawn.when` — which that check CAN evaluate. */
-function flagCompletionSpawnDeclaresWhen(schema) {
-	return schema.spawn === void 0 || schema.spawn.when !== void 0 || declaredField(schema.fields, schema.completionField ?? "")?.type !== "flag";
-}
-function fieldDrivenSpawnEvery(schema) {
-	const every = schema.spawn?.every;
-	if (!every || !("fromField" in every)) return null;
-	return every;
-}
-/** §4.1 — `fromField` must name a real top-level `enum` field. The `map` keys
-*  are only meaningful against a closed value set, and the field renders as a
-*  form `<select>`; a non-enum target has no finite values to validate. */
-function fieldDrivenFromFieldIsEnum(schema) {
-	const driven = fieldDrivenSpawnEvery(schema);
-	if (!driven) return true;
-	return declaredField(schema.fields, driven.fromField)?.type === "enum";
-}
-/** §4.2 — `map` keys must EXACTLY cover the enum's `values` (no missing keys —
-*  a record could pick an unmapped frequency and silently stall; no extra keys
-*  — a stale map outliving an enum edit). */
-function fieldDrivenMapCoversValues(schema) {
-	const driven = fieldDrivenSpawnEvery(schema);
-	if (!driven) return true;
-	const target = declaredField(schema.fields, driven.fromField);
-	if (target?.type !== "enum") return true;
-	const values = new Set(target.values);
-	const keys = Object.keys(driven.map);
-	return keys.length === values.size && keys.every((key) => values.has(key));
-}
-/** §4.5 — `fromField` must reach the successor (via `carry` or `set`);
-*  otherwise the successor loses its frequency and the NEXT spawn along the
-*  chain can't resolve an interval, silently halting the recurrence.
-*
-*  `set` writes a FIXED value, so it must itself be a key of `map` (else the
-*  successor is born with an unresolvable driver and `resolveEvery` skips it —
-*  the exact silent-halt §4.5 exists to prevent). `carry` copies the source's
-*  own value, which — for a record that matched the spawn — is one of the
-*  enum's values, all of which `map` covers by §4.2; so a carried driver is
-*  always resolvable and needs no value check here. */
-function fieldDrivenFromFieldCarried(schema) {
-	const driven = fieldDrivenSpawnEvery(schema);
-	if (!driven) return true;
-	const { carry, set } = schema.spawn ?? {};
-	if (set && Object.prototype.hasOwnProperty.call(set, driven.fromField)) {
-		const raw = set[driven.fromField];
-		if (raw === void 0 || raw === null || raw === "") return false;
-		const key = fieldTextOrNull(raw);
-		return key !== null && Object.prototype.hasOwnProperty.call(driven.map, key);
-	}
-	return (carry ?? []).includes(driven.fromField);
-}
-/** `calendarField` must name a real `date`/`datetime` field — the calendar view
-*  parses its value to place records on the month grid (a `datetime` anchor
-*  also carries the clock for the day view). */
-function calendarFieldIsDateLike(schema) {
-	return schema.calendarField === void 0 || isDateLike(declaredField(schema.fields, schema.calendarField)?.type);
-}
-/** `calendarEndField` marks the end of a multi-day span, so it only means
-*  something alongside a start anchor. */
-function calendarEndFieldRequiresCalendarField(schema) {
-	return schema.calendarEndField === void 0 || schema.calendarField !== void 0;
-}
-/** `calendarEndField` must also name a real `date`/`datetime` field — same parse. */
-function calendarEndFieldIsDateLike(schema) {
-	return schema.calendarEndField === void 0 || isDateLike(declaredField(schema.fields, schema.calendarEndField)?.type);
-}
-/** `calendarTimeField` places records on the day view, so it only means
-*  something alongside a start anchor. */
-function calendarTimeFieldRequiresCalendarField(schema) {
-	return schema.calendarTimeField === void 0 || schema.calendarField !== void 0;
-}
-/** `calendarTimeField` must name a real top-level field (a free-form time
-*  string the day view parses). */
-function calendarTimeFieldIsDeclared(schema) {
-	return schema.calendarTimeField === void 0 || declaredField(schema.fields, schema.calendarTimeField) !== void 0;
-}
-/** …and that field must be string-backed — the day view parses its value as a
-*  time string, so a number/enum/date column can't drive it. */
-function calendarTimeFieldIsStringBacked(schema) {
-	return schema.calendarTimeField === void 0 || isTimeStringField(declaredField(schema.fields, schema.calendarTimeField)?.type);
-}
-/** `kanbanField` must name a real `enum` field — the board groups records into
-*  one column per declared enum value; any other type has no closed set of
-*  columns to group by. */
-function kanbanFieldIsAnEnum(schema) {
-	return schema.kanbanField === void 0 || declaredField(schema.fields, schema.kanbanField)?.type === "enum";
-}
-/** `notifyWhen` narrows the completion bell, so it only means something with
-*  completion tracking. */
-function notifyWhenRequiresCompletion(schema) {
-	return schema.notifyWhen === void 0 || schema.completionField !== void 0;
-}
-/** `notifyWhen.field` must name a real top-level field. */
-function notifyWhenFieldIsDeclared(schema) {
-	return schema.notifyWhen === void 0 || declaredField(schema.fields, schema.notifyWhen.field) !== void 0;
-}
-/** Every custom view `id` must be a valid slug — it doubles as the view-mode
-*  selector key (`custom:<id>`) and the capability-token clamp key, both of
-*  which expect a path-safe token. */
-function viewIdsAreSlugs(schema) {
-	return schema.views === void 0 || schema.views.every((view) => isSafeSlug(view.id));
-}
-/** Custom view ids must be unique so the selector + token clamp resolve
-*  unambiguously. */
-function viewIdsAreUnique(schema) {
-	return hasUniqueIds(schema.views);
-}
-//#endregion
-//#region src/collection/core/schemaZ.ts
-/** Optional visibility predicate shared by actions and fields: the target
-*  shows only when the open record's `field` (stringified) is one of `in`.
-*  Domain-free — `field` is any non-empty key, `in` a non-empty array of
-*  non-empty values; the host never interprets the meaning.
+//#region src/collection/core/schemaZ.ts
+/** Optional visibility predicate shared by actions and fields: the target
+*  shows only when the open record's `field` (stringified) is one of `in`.
+*  Domain-free — `field` is any non-empty key, `in` a non-empty array of
+*  non-empty values; the host never interprets the meaning.
 *
 *  `trim().min(1)` rather than bare `min(1)` so a whitespace-only string
 *  ("   ") fails validation — otherwise the cell formatter / dropdown would
@@ -2625,511 +1447,1689 @@ var DataSourceZ = z.object({
 	type: z.literal("csv"),
 	path: z.string().min(1)
 });
-/** Alternative WRITABLE storage backend for a collection's records —
-*  unlike `dataSource` (external read-only file), a `storage` collection
-*  behaves like a normal writable collection; only where the rows live
-*  changes. The store factory registry (`server/store.ts`) picks the
-*  implementation by `type` (plans/done/refactor-storage-virtualization.md).
+/** Alternative WRITABLE storage backend for a collection's records —
+*  unlike `dataSource` (external read-only file), a `storage` collection
+*  behaves like a normal writable collection; only where the rows live
+*  changes. The store factory registry (`server/store.ts`) picks the
+*  implementation by `type` (plans/done/refactor-storage-virtualization.md).
+*
+*  A discriminated union rather than one shape with optional keys, because
+*  only the sqlite variant is a workspace FILE: its `path` is
+*  workspace-relative and containment-checked exactly like `dataPath`, while
+*  the firestore variant has no path to check — its records are not on this
+*  machine at all. Optional keys would let each arm accept the other's, and
+*  the compiler would stop being the thing that tells you which. */
+var StorageZ = z.discriminatedUnion("type", [z.object({
+	type: z.literal("sqlite"),
+	path: z.string().min(1)
+}), z.object({ type: z.literal("firestore") }).strict()]);
+var BareCollectionSchemaZ = z.object({
+	title: z.string().min(1),
+	icon: z.string().min(1),
+	dataPath: z.string().min(1).optional(),
+	dataSource: DataSourceZ.optional(),
+	storage: StorageZ.optional(),
+	primaryKey: z.string().min(1),
+	singleton: z.string().trim().min(1).optional(),
+	fields: z.record(z.string(), FieldSpecZ),
+	actions: z.array(ActionSpecZ).optional(),
+	collectionActions: z.array(ActionSpecZ).optional(),
+	completionField: z.string().trim().min(1).optional(),
+	completionDoneValues: z.array(z.string().trim().min(1)).min(1).optional(),
+	displayField: z.string().trim().min(1).optional(),
+	triggerField: z.string().trim().min(1).optional(),
+	triggerLeadDays: z.number().int().min(0).optional(),
+	spawn: SpawnZ.optional(),
+	calendarField: z.string().trim().min(1).optional(),
+	calendarEndField: z.string().trim().min(1).optional(),
+	calendarTimeField: z.string().trim().min(1).optional(),
+	kanbanField: z.string().trim().min(1).optional(),
+	views: z.array(CustomViewZ).optional(),
+	notifyWhen: WhenZ.optional(),
+	ingest: IngestZ.optional(),
+	googleCalendar: GoogleCalendarSyncZ.optional(),
+	dynamicIcon: DynamicIconSpecZ.optional()
+}).refine(declaresExactlyOneStore, {
+	message: "declare exactly one of `dataPath` (native JSON records), `dataSource` (external read-only data file), or `storage` (alternative writable backend)",
+	path: ["dataPath"]
+}).refine(dataSourceDeclaresNoWriteMachinery, {
+	message: "a `dataSource` collection is read-only — it cannot declare `singleton`, `ingest`, `spawn`, or `googleCalendar` (all of them write records)",
+	path: ["dataSource"]
+}).refine(googleCalendarMapNamesStoredFields, {
+	message: "a `googleCalendar` map key must name a declared, non-computed field, and never the primaryKey (that always holds the Google event id)",
+	path: ["googleCalendar"]
+}).refine(dataSourceDeclaresNoMutateAction, {
+	message: "a `dataSource` collection is read-only — its actions cannot use `kind: \"mutate\"` (a host write); use `chat`/`agent` actions instead",
+	path: ["dataSource"]
+}).refine(singletonIsAValidRecordId, {
+	message: "schema `singleton` must be a valid item id (alphanumeric / hyphen / underscore / interior dot, no `..` or path separators)",
+	path: ["singleton"]
+}).refine(actionIdsAreUnique, {
+	message: "schema `actions` must have unique `id`s",
+	path: ["actions"]
+}).refine(collectionActionIdsAreUnique, {
+	message: "schema `collectionActions` must have unique `id`s",
+	path: ["collectionActions"]
+}).refine(mutateSetKeysNameStoredFields, {
+	message: "a mutate action's `set` keys must name declared, non-computed fields (and never the primaryKey)",
+	path: ["actions"]
+}).refine(mutateParamRefsAreDeclared, {
+	message: "a mutate action's `$params.<name>` references must name keys declared in its `params`",
+	path: ["actions"]
+}).refine(collectionActionsAreNotMutate, {
+	message: "`collectionActions` cannot contain `kind: \"mutate\"` — a collection-level action has no record to write",
+	path: ["collectionActions"]
+}).refine(currencyFieldRefsNameCodeFields, {
+	message: "a money field's `currencyField` must name a top-level `string`, `text`, or `enum` field that holds the currency code",
+	path: ["fields"]
+}).refine(completionPairIsCoherent, {
+	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted) — unless `completionField` names a `flag` field, in which case `completionDoneValues` must be omitted (done ⇔ the flag matches)",
+	path: ["completionField"]
+}).refine(completionFieldIsDeclared, {
+	message: "schema `completionField` must name a top-level field declared in `fields`",
+	path: ["completionField"]
+}).refine(displayFieldIsDeclared, {
+	message: "schema `displayField` must name a top-level field declared in `fields`",
+	path: ["displayField"]
+}).refine(fieldVisibilityGatesNameDeclaredFields, {
+	message: "a field's `when.field` must name a top-level field declared in `fields`",
+	path: ["fields"]
+}).refine(flagConditionsNameDeclaredFields, {
+	message: "a flag field's `where` conditions must name top-level fields declared in `fields` (both `field` and a same-record `valueFrom.field`)",
+	path: ["fields"]
+}).refine(completionFlagReadsOnlyStoredFields, {
+	message: "a `flag` named by `completionField` may only reference STORED fields in its `where` — completion is evaluated against the raw record (before deriveAll), where computed values (derived/rollup/toggle/flag/embed/backlinks) are absent",
+	path: ["completionField"]
+}).refine(flagCompletionSpawnDeclaresWhen, {
+	message: "a schema whose `completionField` names a `flag` field must declare an explicit `spawn.when` (the spawn-inert check cannot statically evaluate a flag's `where`)",
+	path: ["spawn"]
+}).refine(embedIdFieldsNameIdBearingFields, {
+	message: "an embed field's `idField` must name a top-level `ref` or `string` field declared in `fields`",
+	path: ["fields"]
+}).refine(triggerFieldRequiresCompletion, {
+	message: "schema `triggerField` requires `completionField` / `completionDoneValues` (the gated bell still clears via the done value)",
+	path: ["triggerField"]
+}).refine(triggerFieldIsADateField, {
+	message: "schema `triggerField` must name a top-level `date` field declared in `fields`",
+	path: ["triggerField"]
+}).refine(triggerLeadDaysRequiresTriggerField, {
+	message: "schema `triggerLeadDays` requires `triggerField` (it shifts when that field's bell fires)",
+	path: ["triggerLeadDays"]
+}).refine(spawnRequiresTriggerField, {
+	message: "schema `spawn` requires `triggerField` (the successor's trigger date is `triggerField` advanced by `spawn.every`)",
+	path: ["spawn"]
+}).refine(spawnWhenFieldIsDeclared, {
+	message: "schema `spawn.when.field` must name a top-level field declared in `fields`",
+	path: ["spawn"]
+}).refine(spawnCarryEntriesAreDeclared, {
+	message: "every `spawn.carry` entry must name a top-level field declared in `fields`",
+	path: ["spawn"]
+}).refine(spawnSuccessorStartsInert, {
+	message: "`spawn` must leave the successor in a non-matching state (e.g. `set` the status to a pending value); seeding the predicate field to a matching value via `set`/`carry` would respawn forever",
+	path: ["spawn"]
+}).refine(fieldDrivenFromFieldIsEnum, {
+	message: "`spawn.every.fromField` must name a top-level `enum` field declared in `fields`",
+	path: ["spawn"]
+}).refine(fieldDrivenMapCoversValues, {
+	message: "`spawn.every.map` keys must exactly cover the `values` of the `enum` named by `fromField` (no missing or extra keys)",
+	path: ["spawn"]
+}).refine(fieldDrivenFromFieldCarried, {
+	message: "`spawn.every.fromField` must appear in `spawn.carry`, or be written by `spawn.set` to a value present in `spawn.every.map`, so the successor keeps a resolvable recurrence interval",
+	path: ["spawn"]
+}).refine(calendarFieldIsDateLike, {
+	message: "schema `calendarField` must name a top-level `date` or `datetime` field declared in `fields`",
+	path: ["calendarField"]
+}).refine(calendarEndFieldRequiresCalendarField, {
+	message: "schema `calendarEndField` requires `calendarField` (it marks the end of the span that starts at `calendarField`)",
+	path: ["calendarEndField"]
+}).refine(calendarEndFieldIsDateLike, {
+	message: "schema `calendarEndField` must name a top-level `date` or `datetime` field declared in `fields`",
+	path: ["calendarEndField"]
+}).refine(calendarTimeFieldRequiresCalendarField, {
+	message: "schema `calendarTimeField` requires `calendarField` (it supplies the time-of-day for the calendar's day view)",
+	path: ["calendarTimeField"]
+}).refine(calendarTimeFieldIsDeclared, {
+	message: "schema `calendarTimeField` must name a top-level field declared in `fields`",
+	path: ["calendarTimeField"]
+}).refine(calendarTimeFieldIsStringBacked, {
+	message: "schema `calendarTimeField` must name a top-level `string` or `text` field declared in `fields`",
+	path: ["calendarTimeField"]
+}).refine(kanbanFieldIsAnEnum, {
+	message: "schema `kanbanField` must name a top-level `enum` field declared in `fields`",
+	path: ["kanbanField"]
+}).refine(togglesProjectValidEnums, {
+	message: "a `toggle` field's `field` must name a top-level `enum` field, and its `onValue`/`offValue` must be values of that enum",
+	path: ["fields"]
+}).refine(notifyWhenRequiresCompletion, {
+	message: "schema `notifyWhen` requires `completionField` (it narrows that bell)",
+	path: ["notifyWhen"]
+}).refine(notifyWhenFieldIsDeclared, {
+	message: "schema `notifyWhen.field` must name a top-level field declared in `fields`",
+	path: ["notifyWhen"]
+}).refine(viewIdsAreSlugs, {
+	message: "every `views[].id` must be a valid slug (alphanumeric / hyphen / underscore, no path separators)",
+	path: ["views"]
+}).refine(viewIdsAreUnique, {
+	message: "schema `views` must have unique `id`s",
+	path: ["views"]
+});
+var PROTOTYPE_KEYS = [
+	"__proto__",
+	"constructor",
+	"prototype"
+];
+/** The first own prototype-sensitive key of `value`, or null. */
+function ownPrototypeKey(value) {
+	if (value === null || typeof value !== "object") return null;
+	for (const key of PROTOTYPE_KEYS) if (Object.hasOwn(value, key)) return key;
+	return null;
+}
+/** Own enumerable entries of an object (arrays keyed by index), none for
+*  anything else — the raw input is unvalidated, so `fields` may be junk. */
+function ownEntries(value) {
+	if (isUnknownArray(value)) return value.map((entry, index) => [String(index), entry]);
+	return isRecord(value) ? Object.entries(value) : [];
+}
+/** The name-defining sub-record a raw field spec (`of`) or action (`params`)
+*  carries, or undefined when the holder isn't an object at all. */
+function nameDefiningSubRecord(holder, key) {
+	return isRecord(holder) ? holder[key] : void 0;
+}
+/** Dotted path of the first prototype-sensitive `params` name across both
+*  action lists, or null. */
+function prototypeActionParamPath(input) {
+	for (const [listName, list] of [["actions", input.actions], ["collectionActions", input.collectionActions]]) for (const action of isUnknownArray(list) ? list : []) {
+		const badParam = ownPrototypeKey(nameDefiningSubRecord(action, "params"));
+		if (badParam !== null) return `${listName}.params.${badParam}`;
+	}
+	return null;
+}
+/** Dotted path of the first prototype-sensitive field name in the raw
+*  schema input — top-level `fields`, each table field's `of`, and each
+*  action's `params` (the three records that DEFINE names) — or null. */
+function prototypeFieldKeyPath(input) {
+	if (!isRecord(input)) return null;
+	const bad = ownPrototypeKey(input.fields);
+	if (bad !== null) return `fields.${bad}`;
+	for (const [key, spec] of ownEntries(input.fields)) {
+		const badSub = ownPrototypeKey(nameDefiningSubRecord(spec, "of"));
+		if (badSub !== null) return `fields.${key}.of.${badSub}`;
+	}
+	return prototypeActionParamPath(input);
+}
+var CollectionSchemaZ = z.preprocess((input, ctx) => {
+	const bad = prototypeFieldKeyPath(input);
+	if (bad !== null) {
+		ctx.addIssue({
+			code: "custom",
+			message: `'${bad}': field names must not be prototype-sensitive keys (\`__proto__\`, \`constructor\`, \`prototype\`)`
+		});
+		return z.NEVER;
+	}
+	return input;
+}, BareCollectionSchemaZ);
+//#endregion
+//#region src/collection/server/discovery.ts
+function applyFeedSchemaDefaults(parsed, slug) {
+	if (!isRecord(parsed)) return parsed;
+	const icon = typeof parsed.icon === "string" && parsed.icon.trim().length > 0 ? parsed.icon : "dynamic_feed";
+	return {
+		...parsed,
+		icon,
+		dataPath: `data/feeds/${slug}`
+	};
+}
+/** The conventional per-slug records dir a `dataSource` / `storage` collection
+*  gets as its `dataDir` (records never live there, but archive/delete paths
+*  stay well-defined — same shape the registry's R3 normalization uses).
+*
+*  INVARIANT — this is NOT a default `dataPath`, and must not be used as one.
+*  It applies only to the two backends whose records are not per-file JSON. A
+*  normal collection declares its own location and exactly one of `dataPath` /
+*  `dataSource` / `storage`; a schema with none of the three is REJECTED, not
+*  quietly pointed here. Handing a per-file collection this path would silently
+*  relocate its records away from the folder the user (and its SKILL.md) sees. */
+function conventionalDataPath(slug) {
+	return `data/collections/${slug}/items`;
+}
+/** The declared field named by `primaryKey`, or `undefined` when the schema
+*  declares no such field. Own-property guarded: a `primaryKey` of `toString`
+*  / `constructor` / `__proto__` must miss here, not read an Object.prototype
+*  member and slip past the "is it a declared field?" gate into the wrong
+*  "add `primary: true`" advice. Shared with manageCollection's putSchema
+*  gate so both report the SAME reason. */
+function resolvePrimaryField(fields, primaryKey) {
+	return Object.hasOwn(fields, primaryKey) ? fields[primaryKey] : void 0;
+}
+/** The acceptance gates discovery applies AFTER `CollectionSchemaZ` parses,
+*  before a schema becomes a live collection:
+*
+*  - the `primaryKey` must be a declared field flagged `primary: true` —
+*    without the flag CollectionView renders the field editable, and a
+*    rename is silently pinned back to the URL itemId on save, so the user's
+*    edit is dropped with no error;
+*  - a `feed` schema must declare an `ingest` block (else it's a dead,
+*    non-refreshable card);
+*  - `dataPath` — or a `dataSource`'s `path` — must resolve INSIDE the
+*    workspace (same realpath containment for both).
+*
+*  Exported so `manageCollection`'s `putSchema` can run the SAME gates before
+*  it reports success — a schema that passes `CollectionSchemaZ` but fails one
+*  of these would otherwise write cleanly yet be skipped on the next discovery,
+*  hiding the collection (the exact failure that tool exists to prevent). */
+function acceptParsedSchema(schema, opts) {
+	const primaryField = resolvePrimaryField(schema.fields, schema.primaryKey);
+	if (!primaryField) return {
+		ok: false,
+		reason: `primaryKey '${schema.primaryKey}' is not one of the declared fields`
+	};
+	if (primaryField.primary !== true) return {
+		ok: false,
+		reason: `the primaryKey field '${schema.primaryKey}' must be flagged \`primary: true\``
+	};
+	if (opts.source === "feed" && !schema.ingest) return {
+		ok: false,
+		reason: "a feed schema must declare an `ingest` block"
+	};
+	if (schema.dataSource !== void 0) {
+		const dataSourceFile = resolveDataDir(schema.dataSource.path, opts.workspaceRoot);
+		if (dataSourceFile === null) return {
+			ok: false,
+			reason: `dataSource.path '${schema.dataSource.path}' escapes the workspace`
+		};
+		const dataDir = resolveDataDir(conventionalDataPath(opts.slug), opts.workspaceRoot);
+		if (dataDir === null) return {
+			ok: false,
+			reason: `slug '${opts.slug}' yields no workspace-contained data dir`
+		};
+		return {
+			ok: true,
+			dataDir,
+			dataSourceFile
+		};
+	}
+	if (schema.storage !== void 0) return acceptStorageSchema(schema.storage, opts);
+	const dataDir = resolveDataDir(schema.dataPath ?? "", opts.workspaceRoot);
+	if (dataDir === null) return {
+		ok: false,
+		reason: `dataPath '${schema.dataPath}' escapes the workspace`
+	};
+	return {
+		ok: true,
+		dataDir
+	};
+}
+/** The `storage` arm of the acceptance gate. Every storage backend gets the
+*  conventional phantom dataDir; what differs is what else has to resolve
+*  before the collection can exist at all.
+*
+*  A FILE-backed backend (sqlite) resolves and containment-checks a
+*  `storageFile`. A SHARED one (firestore) has no path on this machine — it
+*  resolves an IDENTITY instead: the `aid` from the repository's `app.json`,
+*  which together with the slug as `cid` names `apps/{aid}/collections/{cid}`.
+*
+*  Resolving it HERE, once, is the point. The store then receives a settled
+*  `(aid, cid)` and never reads `app.json` itself — otherwise the questions of
+*  caching, staleness and what to do when the file is missing would be decided
+*  inside a read path, where the only cheap answer is to return nothing, and
+*  "this collection is misconfigured" would reach the user as "this collection
+*  is empty". A missing or malformed `app.json` is a CONFIGURATION error, so it
+*  is reported the same way an escaping `storage.path` is: the schema is
+*  refused, with a reason naming the file to create. */
+function acceptStorageSchema(storage, opts) {
+	const dataDir = resolveDataDir(conventionalDataPath(opts.slug), opts.workspaceRoot);
+	if (dataDir === null) return {
+		ok: false,
+		reason: `slug '${opts.slug}' yields no workspace-contained data dir`
+	};
+	if (storage.type === "sqlite") {
+		const storageFile = resolveDataDir(storage.path, opts.workspaceRoot);
+		if (storageFile === null) return {
+			ok: false,
+			reason: `storage.path '${storage.path}' escapes the workspace`
+		};
+		return {
+			ok: true,
+			dataDir,
+			storageFile
+		};
+	}
+	const manifest = loadAppManifest(opts.workspaceRoot);
+	if (!manifest.ok) return {
+		ok: false,
+		reason: appManifestReason(manifest, opts.workspaceRoot)
+	};
+	return {
+		ok: true,
+		dataDir,
+		appId: manifest.manifest.aid
+	};
+}
+async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
+	const safeName = safeSlugName(slug);
+	if (safeName === null) return null;
+	const schemaPath = path.join(skillsRoot, safeName, SCHEMA_FILE);
+	let raw;
+	try {
+		if (!(await stat(schemaPath)).isFile()) return null;
+		raw = await readFile(schemaPath, "utf-8");
+	} catch (err) {
+		if (!isErrorWithCode(err) || err.code !== "ENOENT") log.warn("collections", "failed to read schema.json, skipping", {
+			slug: safeName,
+			path: schemaPath,
+			error: String(err)
+		});
+		return null;
+	}
+	let parsedJson;
+	try {
+		parsedJson = JSON.parse(raw);
+	} catch (err) {
+		log.warn("collections", "schema.json is not valid JSON, skipping", {
+			slug: safeName,
+			error: String(err)
+		});
+		return null;
+	}
+	const candidate = source === "feed" ? applyFeedSchemaDefaults(parsedJson, safeName) : parsedJson;
+	const parsed = CollectionSchemaZ.safeParse(candidate);
+	if (!parsed.success) {
+		log.warn("collections", "schema.json failed validation, skipping", {
+			slug: safeName,
+			issues: parsed.error.issues
+		});
+		return null;
+	}
+	const schema = parsed.data;
+	const acceptance = acceptParsedSchema(schema, {
+		source,
+		workspaceRoot,
+		slug: safeName
+	});
+	if (!acceptance.ok) {
+		log.warn("collections", "schema.json rejected after validation, skipping", {
+			slug: safeName,
+			reason: acceptance.reason
+		});
+		return null;
+	}
+	return {
+		slug: safeName,
+		source,
+		schema,
+		dataDir: acceptance.dataDir,
+		...acceptance.dataSourceFile !== void 0 ? { dataSourceFile: acceptance.dataSourceFile } : {},
+		...acceptance.storageFile !== void 0 ? { storageFile: acceptance.storageFile } : {},
+		...acceptance.appId !== void 0 ? { appId: acceptance.appId } : {},
+		skillDir: path.join(skillsRoot, safeName)
+	};
+}
+async function collectFromDir(skillsRoot, source, workspaceRoot) {
+	let entries;
+	try {
+		entries = await readdir(skillsRoot);
+	} catch (err) {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
+		log.warn("collections", "failed to list skills dir, returning empty", {
+			root: skillsRoot,
+			error: String(err)
+		});
+		return [];
+	}
+	const results = [];
+	for (const name of entries) {
+		if (name.startsWith(".")) continue;
+		const safeName = safeSlugName(name);
+		if (safeName === null) continue;
+		const dirPath = path.join(skillsRoot, safeName);
+		let dirStat;
+		try {
+			dirStat = await stat(dirPath);
+		} catch {
+			continue;
+		}
+		if (!dirStat.isDirectory()) continue;
+		const collection = await loadOneCollection(skillsRoot, safeName, source, workspaceRoot);
+		if (collection) results.push(collection);
+	}
+	return results;
+}
+/** The user-scope dir this call should scan, or `null` for none. The single
+*  place the "explicit override beats the host binding, and either may say
+*  none" rule is spelled — `??` cannot express it, because `undefined` there
+*  means "ask the host" and would silently re-enable a scope the caller
+*  passed `null` to switch off. */
+function resolveUserDir(opts, workspaceRoot) {
+	return opts.userSkillsDir !== void 0 ? opts.userSkillsDir : userSkillsDir(workspaceRoot);
+}
+/** Discover every schema-driven collection available to this
+*  workspace. Project-scope collections override user-scope on slug
+*  collision. The `workspaceRoot` override also flows into each
+*  collection's dataDir resolution so a tmpdir-scoped test gets
+*  dataDirs under the same tmpdir (Codex P1 review on PR #1489 —
+*  previously dataDir was always rooted at the live workspacePath
+*  regardless of override). */
+async function discoverCollections(opts = {}) {
+	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
+	const userDir = resolveUserDir(opts, workspaceRoot);
+	const projectDir = projectSkillsDir(workspaceRoot);
+	const feedCollections = await collectFromDir(feedsRoot(workspaceRoot), "feed", workspaceRoot);
+	const userCollections = userDir === null ? [] : await collectFromDir(userDir, "user", workspaceRoot);
+	const projectCollections = await collectFromDir(projectDir, "project", workspaceRoot);
+	const merged = /* @__PURE__ */ new Map();
+	for (const entry of feedCollections) merged.set(entry.slug, entry);
+	for (const entry of userCollections) merged.set(entry.slug, entry);
+	for (const entry of projectCollections) merged.set(entry.slug, entry);
+	return [...merged.values()].sort((left, right) => left.slug.localeCompare(right.slug));
+}
+/** Load one collection by slug. Returns null if the slug is invalid,
+*  no matching skill exists, or the schema is malformed. */
+async function loadCollection(slug, opts = {}) {
+	const safeName = safeSlugName(slug);
+	if (safeName === null) return null;
+	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
+	const userDir = resolveUserDir(opts, workspaceRoot);
+	const projectCollection = await loadOneCollection(projectSkillsDir(workspaceRoot), safeName, "project", workspaceRoot);
+	if (projectCollection) return projectCollection;
+	const userCollection = userDir === null ? null : await loadOneCollection(userDir, safeName, "user", workspaceRoot);
+	if (userCollection) return userCollection;
+	return loadOneCollection(feedsRoot(workspaceRoot), safeName, "feed", workspaceRoot);
+}
+function toSummary(collection) {
+	return {
+		slug: collection.slug,
+		title: collection.schema.title,
+		icon: collection.schema.icon,
+		source: collection.source,
+		...collection.schema.dataSource !== void 0 ? { readonly: true } : {},
+		...collection.appId !== void 0 ? { appId: collection.appId } : {}
+	};
+}
+function toDetail(collection) {
+	return {
+		...toSummary(collection),
+		schema: collection.schema
+	};
+}
+//#endregion
+//#region src/collection/server/io.ts
+/** True iff `filePath` exists and is a regular file (NOT a symlink).
+*  Defends `listItems` / `readItem` against `*.json` symlinks placed
+*  inside an otherwise-contained data dir — without this, a record
+*  file could symlink to /etc/passwd and the detail endpoint would
+*  happily serve it. Returns false on ENOENT and on any other lstat
+*  failure so the caller's "missing" branch covers those cases too.
+*  Exported so `ontology.ts`'s record COUNT classifies entries with the
+*  SAME lstat logic — the two must agree on what a record file is. */
+async function isRegularFile(filePath) {
+	try {
+		return (await lstat(filePath)).isFile();
+	} catch {
+		return false;
+	}
+}
+/** Read one JSON record file. Returns null when the file is missing,
+*  is a symlink (file-disclosure defense), parses to a non-object,
+*  or has a read/parse error. Caller logs the per-entry skip — this
+*  helper just classifies. Split out to keep `listItems` under the
+*  `sonarjs/cognitive-complexity` threshold. */
+/** Parse a record file's text into a plain-object `CollectionItem`, or
+*  null when it isn't a JSON object (array / scalar / null). */
+function parseRecordJson(raw) {
+	const parsed = JSON.parse(raw);
+	return isRecord(parsed) ? parsed : null;
+}
+async function tryReadRecord(filePath) {
+	if (!await isRegularFile(filePath)) return null;
+	try {
+		return parseRecordJson(await readFile(filePath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+/** Read every record under `dataDir`. Returns [] if the dir doesn't
+*  exist yet (legitimate first-use state). Malformed JSON files and
+*  symlinked records are skipped (the latter is a file-disclosure
+*  defense — see `isRegularFile`). Re-validates the realpath
+*  containment to defend against a symlinked data dir appearing
+*  between discovery and use. */
+async function listItems(dataDir, opts = {}) {
+	if (!isContainedInRoot(dataDir, opts.workspaceRoot ?? getWorkspaceRoot())) {
+		log.warn("collections", "listItems refused: dataDir escapes workspace via symlink", { dataDir });
+		return [];
+	}
+	let entries;
+	try {
+		entries = await readdir(dataDir);
+	} catch (err) {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
+		throw err;
+	}
+	const results = [];
+	for (const name of entries) {
+		if (!name.endsWith(".json")) continue;
+		if (name.startsWith(".")) continue;
+		const filePath = path.join(dataDir, name);
+		const record = await tryReadRecord(filePath);
+		if (record === null) {
+			log.warn("collections", "skipping record (missing, symlink, or unreadable)", { path: filePath });
+			continue;
+		}
+		results.push(record);
+	}
+	return results;
+}
+/** Read one record by id. Returns null when the file is missing,
+*  when the resolved path escapes the workspace via a symlink, or
+*  when the record file itself is a symlink (file-disclosure
+*  defense — see `isRegularFile`). */
+async function readItem(dataDir, itemId, opts = {}) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return null;
+	if (!isContainedInRoot(dataDir, opts.workspaceRoot ?? getWorkspaceRoot())) return null;
+	const filePath = itemFilePath(dataDir, safeId);
+	if (!await isRegularFile(filePath)) return null;
+	try {
+		return parseRecordJson(await readFile(filePath, "utf-8"));
+	} catch (err) {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+/** The symlink-containment refusal every record path shares: one check, one
+*  warn, one answer. Extracted because this is a security RULE applied at
+*  three sites (write pre-mkdir, write post-mkdir, delete) — a fix to the
+*  check must not be able to land at only one of them.
 *
-*  A discriminated union rather than one shape with optional keys, because
-*  only the sqlite variant is a workspace FILE: its `path` is
-*  workspace-relative and containment-checked exactly like `dataPath`, while
-*  the firestore variant has no path to check — its records are not on this
-*  machine at all. Optional keys would let each arm accept the other's, and
-*  the compiler would stop being the thing that tells you which. */
-var StorageZ = z.discriminatedUnion("type", [z.object({
-	type: z.literal("sqlite"),
-	path: z.string().min(1)
-}), z.object({ type: z.literal("firestore") }).strict()]);
-var BareCollectionSchemaZ = z.object({
-	title: z.string().min(1),
-	icon: z.string().min(1),
-	dataPath: z.string().min(1).optional(),
-	dataSource: DataSourceZ.optional(),
-	storage: StorageZ.optional(),
-	primaryKey: z.string().min(1),
-	singleton: z.string().trim().min(1).optional(),
-	fields: z.record(z.string(), FieldSpecZ),
-	actions: z.array(ActionSpecZ).optional(),
-	collectionActions: z.array(ActionSpecZ).optional(),
-	completionField: z.string().trim().min(1).optional(),
-	completionDoneValues: z.array(z.string().trim().min(1)).min(1).optional(),
-	displayField: z.string().trim().min(1).optional(),
-	triggerField: z.string().trim().min(1).optional(),
-	triggerLeadDays: z.number().int().min(0).optional(),
-	spawn: SpawnZ.optional(),
-	calendarField: z.string().trim().min(1).optional(),
-	calendarEndField: z.string().trim().min(1).optional(),
-	calendarTimeField: z.string().trim().min(1).optional(),
-	kanbanField: z.string().trim().min(1).optional(),
-	views: z.array(CustomViewZ).optional(),
-	notifyWhen: WhenZ.optional(),
-	ingest: IngestZ.optional(),
-	googleCalendar: GoogleCalendarSyncZ.optional(),
-	dynamicIcon: DynamicIconSpecZ.optional()
-}).refine(declaresExactlyOneStore, {
-	message: "declare exactly one of `dataPath` (native JSON records), `dataSource` (external read-only data file), or `storage` (alternative writable backend)",
-	path: ["dataPath"]
-}).refine(dataSourceDeclaresNoWriteMachinery, {
-	message: "a `dataSource` collection is read-only — it cannot declare `singleton`, `ingest`, `spawn`, or `googleCalendar` (all of them write records)",
-	path: ["dataSource"]
-}).refine(googleCalendarMapNamesStoredFields, {
-	message: "a `googleCalendar` map key must name a declared, non-computed field, and never the primaryKey (that always holds the Google event id)",
-	path: ["googleCalendar"]
-}).refine(dataSourceDeclaresNoMutateAction, {
-	message: "a `dataSource` collection is read-only — its actions cannot use `kind: \"mutate\"` (a host write); use `chat`/`agent` actions instead",
-	path: ["dataSource"]
-}).refine(singletonIsAValidRecordId, {
-	message: "schema `singleton` must be a valid item id (alphanumeric / hyphen / underscore / interior dot, no `..` or path separators)",
-	path: ["singleton"]
-}).refine(actionIdsAreUnique, {
-	message: "schema `actions` must have unique `id`s",
-	path: ["actions"]
-}).refine(collectionActionIdsAreUnique, {
-	message: "schema `collectionActions` must have unique `id`s",
-	path: ["collectionActions"]
-}).refine(mutateSetKeysNameStoredFields, {
-	message: "a mutate action's `set` keys must name declared, non-computed fields (and never the primaryKey)",
-	path: ["actions"]
-}).refine(mutateParamRefsAreDeclared, {
-	message: "a mutate action's `$params.<name>` references must name keys declared in its `params`",
-	path: ["actions"]
-}).refine(collectionActionsAreNotMutate, {
-	message: "`collectionActions` cannot contain `kind: \"mutate\"` — a collection-level action has no record to write",
-	path: ["collectionActions"]
-}).refine(currencyFieldRefsNameCodeFields, {
-	message: "a money field's `currencyField` must name a top-level `string`, `text`, or `enum` field that holds the currency code",
-	path: ["fields"]
-}).refine(completionPairIsCoherent, {
-	message: "schema `completionField` and `completionDoneValues` must be declared together (both set, or both omitted) — unless `completionField` names a `flag` field, in which case `completionDoneValues` must be omitted (done ⇔ the flag matches)",
-	path: ["completionField"]
-}).refine(completionFieldIsDeclared, {
-	message: "schema `completionField` must name a top-level field declared in `fields`",
-	path: ["completionField"]
-}).refine(displayFieldIsDeclared, {
-	message: "schema `displayField` must name a top-level field declared in `fields`",
-	path: ["displayField"]
-}).refine(fieldVisibilityGatesNameDeclaredFields, {
-	message: "a field's `when.field` must name a top-level field declared in `fields`",
-	path: ["fields"]
-}).refine(flagConditionsNameDeclaredFields, {
-	message: "a flag field's `where` conditions must name top-level fields declared in `fields` (both `field` and a same-record `valueFrom.field`)",
-	path: ["fields"]
-}).refine(completionFlagReadsOnlyStoredFields, {
-	message: "a `flag` named by `completionField` may only reference STORED fields in its `where` — completion is evaluated against the raw record (before deriveAll), where computed values (derived/rollup/toggle/flag/embed/backlinks) are absent",
-	path: ["completionField"]
-}).refine(flagCompletionSpawnDeclaresWhen, {
-	message: "a schema whose `completionField` names a `flag` field must declare an explicit `spawn.when` (the spawn-inert check cannot statically evaluate a flag's `where`)",
-	path: ["spawn"]
-}).refine(embedIdFieldsNameIdBearingFields, {
-	message: "an embed field's `idField` must name a top-level `ref` or `string` field declared in `fields`",
-	path: ["fields"]
-}).refine(triggerFieldRequiresCompletion, {
-	message: "schema `triggerField` requires `completionField` / `completionDoneValues` (the gated bell still clears via the done value)",
-	path: ["triggerField"]
-}).refine(triggerFieldIsADateField, {
-	message: "schema `triggerField` must name a top-level `date` field declared in `fields`",
-	path: ["triggerField"]
-}).refine(triggerLeadDaysRequiresTriggerField, {
-	message: "schema `triggerLeadDays` requires `triggerField` (it shifts when that field's bell fires)",
-	path: ["triggerLeadDays"]
-}).refine(spawnRequiresTriggerField, {
-	message: "schema `spawn` requires `triggerField` (the successor's trigger date is `triggerField` advanced by `spawn.every`)",
-	path: ["spawn"]
-}).refine(spawnWhenFieldIsDeclared, {
-	message: "schema `spawn.when.field` must name a top-level field declared in `fields`",
-	path: ["spawn"]
-}).refine(spawnCarryEntriesAreDeclared, {
-	message: "every `spawn.carry` entry must name a top-level field declared in `fields`",
-	path: ["spawn"]
-}).refine(spawnSuccessorStartsInert, {
-	message: "`spawn` must leave the successor in a non-matching state (e.g. `set` the status to a pending value); seeding the predicate field to a matching value via `set`/`carry` would respawn forever",
-	path: ["spawn"]
-}).refine(fieldDrivenFromFieldIsEnum, {
-	message: "`spawn.every.fromField` must name a top-level `enum` field declared in `fields`",
-	path: ["spawn"]
-}).refine(fieldDrivenMapCoversValues, {
-	message: "`spawn.every.map` keys must exactly cover the `values` of the `enum` named by `fromField` (no missing or extra keys)",
-	path: ["spawn"]
-}).refine(fieldDrivenFromFieldCarried, {
-	message: "`spawn.every.fromField` must appear in `spawn.carry`, or be written by `spawn.set` to a value present in `spawn.every.map`, so the successor keeps a resolvable recurrence interval",
-	path: ["spawn"]
-}).refine(calendarFieldIsDateLike, {
-	message: "schema `calendarField` must name a top-level `date` or `datetime` field declared in `fields`",
-	path: ["calendarField"]
-}).refine(calendarEndFieldRequiresCalendarField, {
-	message: "schema `calendarEndField` requires `calendarField` (it marks the end of the span that starts at `calendarField`)",
-	path: ["calendarEndField"]
-}).refine(calendarEndFieldIsDateLike, {
-	message: "schema `calendarEndField` must name a top-level `date` or `datetime` field declared in `fields`",
-	path: ["calendarEndField"]
-}).refine(calendarTimeFieldRequiresCalendarField, {
-	message: "schema `calendarTimeField` requires `calendarField` (it supplies the time-of-day for the calendar's day view)",
-	path: ["calendarTimeField"]
-}).refine(calendarTimeFieldIsDeclared, {
-	message: "schema `calendarTimeField` must name a top-level field declared in `fields`",
-	path: ["calendarTimeField"]
-}).refine(calendarTimeFieldIsStringBacked, {
-	message: "schema `calendarTimeField` must name a top-level `string` or `text` field declared in `fields`",
-	path: ["calendarTimeField"]
-}).refine(kanbanFieldIsAnEnum, {
-	message: "schema `kanbanField` must name a top-level `enum` field declared in `fields`",
-	path: ["kanbanField"]
-}).refine(togglesProjectValidEnums, {
-	message: "a `toggle` field's `field` must name a top-level `enum` field, and its `onValue`/`offValue` must be values of that enum",
-	path: ["fields"]
-}).refine(notifyWhenRequiresCompletion, {
-	message: "schema `notifyWhen` requires `completionField` (it narrows that bell)",
-	path: ["notifyWhen"]
-}).refine(notifyWhenFieldIsDeclared, {
-	message: "schema `notifyWhen.field` must name a top-level field declared in `fields`",
-	path: ["notifyWhen"]
-}).refine(viewIdsAreSlugs, {
-	message: "every `views[].id` must be a valid slug (alphanumeric / hyphen / underscore, no path separators)",
-	path: ["views"]
-}).refine(viewIdsAreUnique, {
-	message: "schema `views` must have unique `id`s",
-	path: ["views"]
+*  `stage` names the call site so the warn stays as diagnosable as the three
+*  hand-written copies were.
+*
+*  Scope, stated explicitly because a reviewer asks every time: this catches
+*  a symlink that EXISTS when we look — `isContainedInRoot` realpaths the
+*  closest existing ancestor, so a pre-planted escape is refused. It does not
+*  and cannot close the check-then-use race, where an ancestor is swapped for
+*  a symlink between this call and the `mkdir` / `open` / `unlink` that
+*  follows. Closing that needs directory-handle I/O anchored at the workspace
+*  (`openat` + `O_NOFOLLOW`), which `node:fs` does not expose — it would mean
+*  a different I/O layer, not a tighter check here.
+*
+*  That race is deliberately outside this app's threat model: the process is
+*  loopback-bound and bearer-authed, so anyone able to swap directories inside
+*  the workspace is already the workspace owner — the same trust principal the
+*  writes belong to. Revisit if collections ever serve a lower-trust caller. */
+function escapesWorkspace(dataDir, workspaceRoot, itemId, stage) {
+	if (isContainedInRoot(dataDir, workspaceRoot)) return false;
+	log.warn("collections", `${stage} refused: dataDir escapes workspace via symlink`, {
+		dataDir,
+		itemId
+	});
+	return true;
+}
+/** Write a record. Ensures the directory exists, validates the id,
+*  re-checks symlink containment after mkdir, and writes atomically.
+*
+*  Create path (`refuseOverwrite: true`) uses an O_EXCL `wx` open
+*  rather than `stat` + `writeFileAtomic` to close a check-then-write
+*  race: two concurrent POSTs would otherwise both pass the existence
+*  check and one would silently overwrite the other. The trade-off
+*  is that the create path is not crash-atomic (a partial file could
+*  remain if the process dies mid-write); acceptable here because
+*  records are small JSON blobs and the next read either parses or
+*  is skipped via the "malformed JSON" branch in `listItems`.
+*
+*  Update path (`refuseOverwrite: false`) uses `writeFileAtomic` so
+*  PUT remains crash-atomic. No race there — the URL pins the id. */
+async function writeItem(dataDir, itemId, item, opts = {}) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return {
+		kind: "invalid-id",
+		itemId
+	};
+	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
+	if (escapesWorkspace(dataDir, workspaceRoot, safeId, "writeItem (pre-mkdir)")) return {
+		kind: "path-escape",
+		itemId: safeId
+	};
+	await mkdir(dataDir, { recursive: true });
+	if (escapesWorkspace(dataDir, workspaceRoot, safeId, "writeItem (post-mkdir)")) return {
+		kind: "path-escape",
+		itemId: safeId
+	};
+	const filePath = itemFilePath(dataDir, safeId);
+	const payload = `${JSON.stringify(item, null, 2)}\n`;
+	if (opts.refuseOverwrite) {
+		let handle;
+		try {
+			handle = await open(filePath, "wx");
+		} catch (err) {
+			if (isErrorWithCode(err) && err.code === "EEXIST") return {
+				kind: "conflict",
+				itemId: safeId
+			};
+			throw err;
+		}
+		try {
+			await handle.writeFile(payload);
+		} finally {
+			await handle.close();
+		}
+	} else await writeFileAtomic(filePath, payload);
+	if (opts.slug) publishCollectionChange(collectionChangePayload({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "upsert"
+	}, opts.workspaceRoot));
+	return {
+		kind: "ok",
+		itemId: safeId,
+		item
+	};
+}
+async function deleteItem(dataDir, itemId, opts = {}) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return {
+		kind: "invalid-id",
+		itemId
+	};
+	if (escapesWorkspace(dataDir, opts.workspaceRoot ?? getWorkspaceRoot(), safeId, "deleteItem")) return {
+		kind: "path-escape",
+		itemId: safeId
+	};
+	const filePath = itemFilePath(dataDir, safeId);
+	try {
+		await unlink(filePath);
+		if (opts.slug) publishCollectionChange(collectionChangePayload({
+			slug: opts.slug,
+			ids: [safeId],
+			op: "delete"
+		}, opts.workspaceRoot));
+		return {
+			kind: "ok",
+			itemId: safeId
+		};
+	} catch (err) {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return {
+			kind: "not-found",
+			itemId: safeId
+		};
+		throw err;
+	}
+}
+/** Generate a short random hex id. Used by POST when the form doesn't
+*  carry a primary-key value (UI shortcut — Claude normally derives a
+*  semantic id from the record's name). */
+function generateItemId() {
+	return randomBytes(4).toString("hex");
+}
+/** The item id a CREATE should use for `schema`, or null when the
+*  caller should generate one. A singleton collection pins every
+*  create to its fixed `schema.singleton` id, so the "at most one
+*  record" contract is enforced server-side (a second create targets
+*  the same file and hits `writeItem`'s refuseOverwrite conflict) —
+*  not only in the UI. Otherwise the record's own primaryKey value
+*  wins, falling back to a generated id (null = "generate"). */
+function resolveCreateItemId(schema, record) {
+	if (schema.singleton) return schema.singleton;
+	const primaryRaw = record[schema.primaryKey];
+	return typeof primaryRaw === "string" && primaryRaw.length > 0 ? primaryRaw : null;
+}
+//#endregion
+//#region src/collection/core/queryZ.ts
+/** Result-column aliases double as SQL identifiers and JSON keys — keep
+*  them to a conservative identifier charset so neither side needs
+*  escaping gymnastics. */
+var SAFE_ALIAS_PATTERN = /^[A-Za-z_]\w{0,63}$/;
+/** Hard ceiling on returned rows; `limit` clamps below it. A group-by on
+*  a near-unique column would otherwise return one row per source row —
+*  the exact materialization the aggregate path exists to avoid. */
+var MAX_QUERY_ROWS = 1e4;
+/** Default row cap when the query declares no `limit`. */
+var DEFAULT_QUERY_ROWS = 1e3;
+/** One aggregate column: `count` (rows; `column` optional to count
+*  non-null cells) or `sum`/`avg`/`min`/`max` over a named CSV column. */
+var QueryAggregateZ = z.object({
+	op: z.enum([
+		"count",
+		"sum",
+		"avg",
+		"min",
+		"max"
+	]),
+	column: z.string().min(1).optional()
+}).refine((aggregate) => aggregate.op === "count" || aggregate.column !== void 0, {
+	message: "`column` is required for every aggregate op except `count`",
+	path: ["column"]
 });
-var PROTOTYPE_KEYS = [
-	"__proto__",
-	"constructor",
-	"prototype"
-];
-/** The first own prototype-sensitive key of `value`, or null. */
-function ownPrototypeKey(value) {
-	if (value === null || typeof value !== "object") return null;
-	for (const key of PROTOTYPE_KEYS) if (Object.hasOwn(value, key)) return key;
-	return null;
+/** One filter condition. Same op vocabulary as the schema-level `where`
+*  (`core/where.ts`) so authors learn one set; values may be typed
+*  (number / boolean) since CSV columns are. `in` requires an array
+*  value, every other op a scalar. */
+var QueryWhereZ = z.object({
+	field: z.string().min(1),
+	op: z.enum([
+		"eq",
+		"ne",
+		"in",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"contains"
+	]),
+	value: z.union([
+		z.string(),
+		z.number(),
+		z.boolean(),
+		z.array(z.union([
+			z.string(),
+			z.number(),
+			z.boolean()
+		])).min(1).max(100)
+	])
+}).refine((cond) => cond.op === "in" === Array.isArray(cond.value), {
+	message: "`in` requires an array value (the allowed set); every other op requires a scalar value",
+	path: ["value"]
+});
+var QueryOrderZ = z.object({
+	/** A `groupBy` column or an aggregate alias — membership enforced by
+	*  the whole-query refine below. */
+	field: z.string().min(1),
+	dir: z.enum(["asc", "desc"]).optional()
+});
+/** The whole query. At least one of `groupBy` / `aggregates` must be
+*  present: bare `groupBy` is a DISTINCT listing, bare `aggregates` a
+*  whole-file scalar row, together a grouped aggregation. */
+var CollectionQueryZ = z.object({
+	groupBy: z.array(z.string().min(1)).max(8).refine((columns) => new Set(columns.map((column) => column.toLowerCase())).size === columns.length, { message: "`groupBy` columns must be unique (case-insensitively — SQL identifiers ignore case)" }).optional(),
+	aggregates: z.record(z.string().regex(SAFE_ALIAS_PATTERN, "aggregate aliases must be simple identifiers (letters/digits/underscore)"), QueryAggregateZ).optional(),
+	where: z.array(QueryWhereZ).max(16).optional(),
+	orderBy: z.array(QueryOrderZ).max(4).optional(),
+	limit: z.number().int().min(1).max(MAX_QUERY_ROWS).optional()
+}).refine((query) => (query.groupBy?.length ?? 0) > 0 || Object.keys(query.aggregates ?? {}).length > 0, {
+	message: "declare at least one of `groupBy` (columns to bucket by) or `aggregates` (values to compute)",
+	path: ["groupBy"]
+}).refine((query) => Object.keys(query.aggregates ?? {}).length <= 32, {
+	message: `\`aggregates\` supports at most 32 entries`,
+	path: ["aggregates"]
+}).refine((query) => {
+	const groupLower = new Set((query.groupBy ?? []).map((column) => column.toLowerCase()));
+	const seen = /* @__PURE__ */ new Set();
+	return Object.keys(query.aggregates ?? {}).every((alias) => {
+		const lower = alias.toLowerCase();
+		if (groupLower.has(lower) || seen.has(lower)) return false;
+		seen.add(lower);
+		return true;
+	});
+}, {
+	message: "aggregate aliases must be unique and must not collide with `groupBy` column names (case-insensitively — SQL identifiers ignore case)",
+	path: ["aggregates"]
+}).refine((query) => {
+	const sortable = /* @__PURE__ */ new Set([...query.groupBy ?? [], ...Object.keys(query.aggregates ?? {})]);
+	return (query.orderBy ?? []).every((order) => sortable.has(order.field));
+}, {
+	message: "every `orderBy.field` must be a `groupBy` column or an aggregate alias",
+	path: ["orderBy"]
+});
+//#endregion
+//#region src/collection/server/csvQuery.ts
+/** Double-quote a SQL identifier (CSV column name / result alias). */
+function quoteIdent(name) {
+	return `"${name.replaceAll("\"", "\"\"")}"`;
+}
+/** Single-quote a SQL string literal (a `types={...}` struct key). */
+function quoteLiteral(value) {
+	return `'${value.replaceAll("'", "''")}'`;
+}
+/** The `read_csv` argument list shared by every CSV query: the (prepared)
+*  path plus a `types` pin forcing the key column to VARCHAR — without it
+*  DuckDB's sniffer turns `001` into BIGINT 1, so leading zeros vanish
+*  and distinct keys collapse. */
+function readCsvArgs(primaryKey) {
+	return `?, types={${quoteLiteral(primaryKey)}: 'VARCHAR'}`;
+}
+/** One aggregate's SQL expression. `sum`/`avg` TRY_CAST to DOUBLE so a
+*  column the sniffer kept as VARCHAR (mixed values) aggregates over its
+*  numeric cells instead of erroring; non-numeric cells become NULL and
+*  are skipped — standard BI tolerance. `min`/`max` stay native (they are
+*  meaningful on strings and dates too). */
+function aggregateExpr(aggregate) {
+	const { op, column } = aggregate;
+	if (op === "count") return column === void 0 ? "count(*)" : `count(${quoteIdent(column)})`;
+	if (op === "sum" || op === "avg") return `${op}(TRY_CAST(${quoteIdent(column ?? "")} AS DOUBLE))`;
+	return `${op}(${quoteIdent(column ?? "")})`;
+}
+/** One where condition → SQL fragment + its bound parameters. String
+*  equality compares against `CAST(col AS VARCHAR)` so a sniffer-typed
+*  column still matches its textual value; numeric/boolean values compare
+*  natively (DuckDB coerces the column side). */
+function whereFragment(cond) {
+	const column = quoteIdent(cond.field);
+	const asText = `CAST(${column} AS VARCHAR)`;
+	if (cond.op === "in") {
+		const values = arrayValue(cond);
+		return {
+			sql: `${values.every((value) => typeof value === "string") ? asText : column} IN (${values.map(() => "?").join(", ")})`,
+			params: values
+		};
+	}
+	if (cond.op === "contains") return {
+		sql: `contains(${asText}, ?)`,
+		params: [String(scalarValue(cond))]
+	};
+	const operator = {
+		eq: "=",
+		ne: "<>",
+		gt: ">",
+		gte: ">=",
+		lt: "<",
+		lte: "<="
+	}[cond.op];
+	return {
+		sql: `${typeof cond.value === "string" && (cond.op === "eq" || cond.op === "ne") ? asText : column} ${operator} ?`,
+		params: [scalarValue(cond)]
+	};
+}
+/** Mirror of `scalarValue` for the one op that takes a set: a scalar under
+*  `in` also means the query skipped `CollectionQueryZ`. Left unchecked it
+*  failed as `values.every is not a function`, naming neither the field nor
+*  the op. */
+function arrayValue(cond) {
+	if (!Array.isArray(cond.value)) throw new Error(`where condition on '${cond.field}' uses op 'in', which requires an array value, not a scalar`);
+	return cond.value;
+}
+/** `CollectionQueryZ` refines "`in` ⇔ array value", so an array reaching a
+*  scalar op means the query was compiled without being validated first —
+*  binding it would send an array to a single `?`. */
+function scalarValue(cond) {
+	if (Array.isArray(cond.value)) throw new Error(`where condition on '${cond.field}' uses op '${cond.op}', which requires a scalar value, not an array`);
+	return cond.value;
 }
-/** Own enumerable entries of an object (arrays keyed by index), none for
-*  anything else — the raw input is unvalidated, so `fields` may be junk. */
-function ownEntries(value) {
-	if (isUnknownArray(value)) return value.map((entry, index) => [String(index), entry]);
-	return isRecord(value) ? Object.entries(value) : [];
+/** Compile a validated query against `fromSql` (a table-function call
+*  whose FIRST placeholder is the source path — the executor binds it).
+*  Returns the SQL and the where-value parameters that follow the path.
+*  Callers MUST have run `CollectionQueryZ` first; this function trusts
+*  the shape (aliases already charset-checked, orderBy membership already
+*  enforced). */
+function compileQuery(query, fromSql) {
+	const groupBy = query.groupBy ?? [];
+	const aggregates = Object.entries(query.aggregates ?? {});
+	const selectList = [...groupBy.map(quoteIdent), ...aggregates.map(([alias, aggregate]) => `${aggregateExpr(aggregate)} AS ${quoteIdent(alias)}`)];
+	const where = (query.where ?? []).map(whereFragment);
+	const clauses = [`SELECT ${selectList.join(", ")}`, `FROM ${fromSql}`];
+	if (where.length > 0) clauses.push(`WHERE ${where.map((fragment) => fragment.sql).join(" AND ")}`);
+	if (groupBy.length > 0) clauses.push(`GROUP BY ${groupBy.map(quoteIdent).join(", ")}`);
+	const orderBy = (query.orderBy ?? []).map((order) => quoteIdent(order.field) + (order.dir === "desc" ? " DESC" : " ASC"));
+	if (orderBy.length > 0) clauses.push(`ORDER BY ${orderBy.join(", ")}`);
+	clauses.push(`LIMIT ${query.limit ?? 1e3}`);
+	return {
+		sql: clauses.join(" "),
+		params: where.flatMap((fragment) => fragment.params)
+	};
 }
-/** The name-defining sub-record a raw field spec (`of`) or action (`params`)
-*  carries, or undefined when the holder isn't an object at all. */
-function nameDefiningSubRecord(holder, key) {
-	return isRecord(holder) ? holder[key] : void 0;
+/** Compile against a CSV file (the dataSource store's engine). */
+function compileCsvQuery(query, primaryKey) {
+	return compileQuery(query, `read_csv(${readCsvArgs(primaryKey)})`);
 }
-/** Dotted path of the first prototype-sensitive `params` name across both
-*  action lists, or null. */
-function prototypeActionParamPath(input) {
-	for (const [listName, list] of [["actions", input.actions], ["collectionActions", input.collectionActions]]) for (const action of isUnknownArray(list) ? list : []) {
-		const badParam = ownPrototypeKey(nameDefiningSubRecord(action, "params"));
-		if (badParam !== null) return `${listName}.params.${badParam}`;
+/** Compile against a JSONL file of ENRICHED records — the file-backed
+*  collections' engine (see `jsonlQuery.ts`). No VARCHAR key pin needed:
+*  enriched record ids are already strings. `sample_size=-1` makes the
+*  schema inference scan EVERY line — with the default sample, a sparse
+*  optional/derived field first appearing past the sample would not be
+*  inferred as a column and the query would binder-error on it (Codex P2
+*  on #2165). The full scan costs nothing extra here: aggregation reads
+*  the whole file anyway. */
+function compileJsonlQuery(query) {
+	return compileQuery(query, `read_json(?, format='newline_delimited', sample_size=-1)`);
+}
+//#endregion
+//#region src/collection/server/csvStore.ts
+/** `list()` row cap. Over-cap files are truncated with a warn — the v1
+*  contract is "browse + per-record views", not full-table analytics. */
+var MAX_CSV_ROWS = 5e3;
+/** Record ids minted from non-safe key values: `id0x` + utf-8 hex. Raw key
+*  values that themselves match this pattern are ALSO encoded, so the
+*  encoded namespace never collides with a raw value (injective mapping). */
+var ENCODED_ID_PATTERN = /^id0x([0-9a-f]+)$/;
+/** A CSV key value → the record id it's addressed by. Safe values pass
+*  through untouched; everything else (and anything shaped like an encoded
+*  id) becomes `id0x<hex>`. Pure + exported for unit tests. */
+function encodeCsvRecordId(rawKey) {
+	if (safeRecordId(rawKey) === rawKey && !ENCODED_ID_PATTERN.test(rawKey)) return rawKey;
+	return `id0x${Buffer.from(rawKey, "utf-8").toString("hex")}`;
+}
+/** A record id → the CSV key value to look up. Inverse of
+*  `encodeCsvRecordId` for encoded ids; anything else is already the raw
+*  value. Pure + exported for unit tests. */
+function decodeCsvRecordId(itemId) {
+	const hex = ENCODED_ID_PATTERN.exec(itemId)?.[1];
+	if (hex === void 0) return itemId;
+	return Buffer.from(hex, "hex").toString("utf-8");
+}
+/** Normalize one DuckDB JS value into a JSON-safe record value: BigInt →
+*  number (string beyond the safe range), DATE/TIMESTAMP → ISO string
+*  (date-only when the clock is exactly UTC midnight, matching the `date`
+*  field contract), exotic DuckDB values → their string form. Pure +
+*  exported for unit tests. */
+/** `JSON.stringify` restricted to what a CSV cell can survive. Returns the
+*  serialised value, or `String(value)` when serialisation is impossible —
+*  losing the content of one cell is bad, failing the entire query is worse. */
+function safeJsonCell(value) {
+	try {
+		return JSON.stringify(value, (_key, entry) => typeof entry === "bigint" ? entry.toString() : entry) ?? String(value);
+	} catch {
+		return String(value);
 	}
-	return null;
 }
-/** Dotted path of the first prototype-sensitive field name in the raw
-*  schema input — top-level `fields`, each table field's `of`, and each
-*  action's `params` (the three records that DEFINE names) — or null. */
-function prototypeFieldKeyPath(input) {
-	if (!isRecord(input)) return null;
-	const bad = ownPrototypeKey(input.fields);
-	if (bad !== null) return `fields.${bad}`;
-	for (const [key, spec] of ownEntries(input.fields)) {
-		const badSub = ownPrototypeKey(nameDefiningSubRecord(spec, "of"));
-		if (badSub !== null) return `fields.${key}.of.${badSub}`;
+function normalizeCsvValue(value) {
+	if (typeof value === "bigint") return value <= BigInt(Number.MAX_SAFE_INTEGER) && value >= BigInt(-Number.MAX_SAFE_INTEGER) ? Number(value) : value.toString();
+	if (value instanceof Date) {
+		const iso = value.toISOString();
+		return iso.endsWith("T00:00:00.000Z") ? iso.slice(0, 10) : iso;
+	}
+	if (value !== null && typeof value === "object") return safeJsonCell(value);
+	return value;
+}
+/** One raw DuckDB row → a CollectionItem, or null when the key cell is
+*  missing/empty (the row can't be addressed). The primaryKey field is
+*  OVERWRITTEN with the (possibly encoded) record id so `item[primaryKey]`
+*  and the record's address never drift — same invariant the file store's
+*  write path enforces. Pure + exported for unit tests. */
+function csvRowToItem(row, primaryKey) {
+	const normalized = Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)]));
+	const rawKey = normalized[primaryKey];
+	const keyText = fieldTextOrNull(rawKey);
+	if (keyText === null || keyText === "") return null;
+	return {
+		...normalized,
+		[primaryKey]: encodeCsvRecordId(keyText)
+	};
+}
+/** Dedupe by record id, LAST row wins (matches `csvRead`'s last-match
+*  pick). Returns the surviving items in first-seen order. Pure +
+*  exported for unit tests. */
+function dedupeByRecordId(items, primaryKey) {
+	const byId = /* @__PURE__ */ new Map();
+	for (const item of items) byId.set(String(item[primaryKey]), item);
+	return {
+		items: [...byId.values()],
+		duplicates: items.length - byId.size
+	};
+}
+/** True when a thrown DuckDB error is the `types` pin naming a column the
+*  CSV doesn't have — the schema/file-mismatch case the caller downgrades
+*  to "empty collection + warn" instead of a 500. */
+function isMissingKeyColumnError(err) {
+	return String(err).includes("do not exist in the CSV");
+}
+/** Bytes sniffed for UTF-8 validity. The trailing 3 bytes of the sample
+*  are dropped so a multibyte char split at the boundary can't produce a
+*  false negative on a valid file. */
+var SNIFF_BYTES = 1048576;
+function isValidUtf8(buf) {
+	try {
+		new TextDecoder("utf-8", { fatal: true }).decode(buf);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Detect the (best-effort) encoding of a non-UTF-8 buffer. BOMs decide
+*  UTF-16; otherwise cp932 (the Shift_JIS superset — Excel-exported
+*  Japanese CSVs are the primary non-UTF-8 case this feature serves). */
+function fallbackEncoding(buf) {
+	if (buf.length >= 2 && buf[0] === 255 && buf[1] === 254) return "utf-16le";
+	if (buf.length >= 2 && buf[0] === 254 && buf[1] === 255) return "utf-16be";
+	return "cp932";
+}
+function cacheDir() {
+	return path.join(tmpdir(), "mulmoclaude-csv-utf8");
+}
+/** Read only the first `bytes` of a file — the encoding sniff must not
+*  pull a multi-hundred-MB CSV into memory on the (common) UTF-8 path. */
+async function readHead(absPath, bytes) {
+	const handle = await open(absPath, "r");
+	try {
+		const { size } = await handle.stat();
+		const buf = Buffer.alloc(Math.min(bytes, size));
+		await handle.read(buf, 0, buf.length, 0);
+		return buf;
+	} finally {
+		await handle.close();
+	}
+}
+/** Decode the whole file into a UTF-8 cache copy and return its path.
+*  Cache key = (path, mtime, size), so a replaced CSV re-decodes and an
+*  unchanged one never does. */
+async function pathExists(target) {
+	try {
+		await stat(target);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Best-effort removal of older decode-cache entries for the same source
+*  path — a frequently-replaced large CSV would otherwise accumulate one
+*  full copy per (mtime, size) forever. Runs AFTER the current copy is
+*  published; a concurrent reader holding an old fd is unaffected
+*  (unlink-while-open is safe on POSIX). */
+async function evictSupersededCache(key, keepBasename) {
+	try {
+		const entries = await readdir(cacheDir());
+		await Promise.all(entries.filter((name) => name.startsWith(`${key}-`) && name !== keepBasename).map((name) => unlink(path.join(cacheDir(), name)).catch(() => void 0)));
+	} catch {}
+}
+/** Decode the whole file into a UTF-8 cache copy and return its path.
+*  Cache key = (path, mtime, size), so a replaced CSV re-decodes and an
+*  unchanged one never does; superseded copies are evicted. The cache
+*  lives in the SHARED OS tmpdir, so the dir is 0700 and files 0600 —
+*  decoded rows must not be readable by other local users. */
+async function decodeToCache(absPath, info) {
+	const key = createHash("sha256").update(absPath).digest("hex").slice(0, 16);
+	const cached = path.join(cacheDir(), `${key}-${Math.trunc(info.mtimeMs)}-${info.size}.csv`);
+	if (!await pathExists(cached)) {
+		const whole = await readFile(absPath);
+		const encoding = fallbackEncoding(whole);
+		const text = iconv.decode(whole, encoding);
+		await mkdir(cacheDir(), {
+			recursive: true,
+			mode: 448
+		});
+		const tmp = `${cached}.${randomBytes(4).toString("hex")}.tmp`;
+		await writeFile(tmp, text, {
+			encoding: "utf-8",
+			mode: 384
+		});
+		await rename(tmp, cached);
+		log.info("collections", "decoded non-UTF-8 dataSource file to cache", {
+			path: absPath,
+			encoding
+		});
+		await evictSupersededCache(key, path.basename(cached));
+	}
+	return cached;
+}
+/** Re-validate the dataSource file at READ time, mirroring the JSON
+*  store's per-read defenses: realpath containment (a symlink swapped in
+*  after discovery must not walk out of the workspace) and an lstat
+*  regular-file check (a symlink leaf is refused outright, even one
+*  pointing inside the workspace — same rule as `isRegularFile` on
+*  record files). Returns the stat info, or null for "no readable file"
+*  (ENOENT / refused), which callers render as an empty collection. */
+async function safeCsvStat(absPath, workspaceRoot) {
+	if (!isContainedInRoot(absPath, workspaceRoot)) {
+		log.warn("collections", "dataSource read refused: path escapes workspace", { path: absPath });
+		return null;
+	}
+	let info;
+	try {
+		info = await lstat(absPath);
+	} catch (err) {
+		if (isErrorWithCode(err) && err.code === "ENOENT") return null;
+		throw err;
+	}
+	if (!info.isFile()) {
+		log.warn("collections", "dataSource read refused: not a regular file (symlink?)", { path: absPath });
+		return null;
+	}
+	return info;
+}
+/** Return a path DuckDB can read as UTF-8: the original file when it
+*  already is UTF-8 (the cheap, common case — only the head is sniffed),
+*  else a decoded cache copy (see `decodeToCache`). Returns null when
+*  there is no readable file (missing, symlink, or containment-refused —
+*  see `safeCsvStat`), which callers render as an empty collection. */
+async function ensureUtf8CsvPath(absPath, workspaceRoot) {
+	const info = await safeCsvStat(absPath, workspaceRoot);
+	if (info === null) return null;
+	const head = await readHead(absPath, SNIFF_BYTES);
+	const sample = head.length === SNIFF_BYTES ? head.subarray(0, 1048573) : head;
+	if (!(head.length >= 2 && (head[0] === 255 && head[1] === 254 || head[0] === 254 && head[1] === 255)) && isValidUtf8(sample)) return absPath;
+	return decodeToCache(absPath, info);
+}
+var instancePromise = null;
+/** Lazily create one shared in-memory DuckDB instance. The dynamic import
+*  keeps the native module OUT of core's load path — a platform where the
+*  prebuilt binding is missing degrades to a per-query error on dataSource
+*  collections only, never a broken core. A failed init is retried on the
+*  next call (the promise is reset). */
+async function duckDbInstance() {
+	if (instancePromise === null) instancePromise = import("@duckdb/node-api").then((mod) => mod.DuckDBInstance.create(":memory:"));
+	try {
+		return await instancePromise;
+	} catch (err) {
+		instancePromise = null;
+		throw new BackendUnavailableError(`DuckDB is unavailable on this host (@duckdb/node-api failed to load: ${String(err)}) — dataSource collections cannot be read`);
 	}
-	return prototypeActionParamPath(input);
 }
-var CollectionSchemaZ = z.preprocess((input, ctx) => {
-	const bad = prototypeFieldKeyPath(input);
-	if (bad !== null) {
-		ctx.addIssue({
-			code: "custom",
-			message: `'${bad}': field names must not be prototype-sensitive keys (\`__proto__\`, \`constructor\`, \`prototype\`)`
-		});
-		return z.NEVER;
+async function queryCsv(sql, params) {
+	const connection = await (await duckDbInstance()).connect();
+	try {
+		return (await connection.runAndReadAll(sql, params)).getRowObjectsJS();
+	} finally {
+		connection.disconnectSync();
 	}
-	return input;
-}, BareCollectionSchemaZ);
-//#endregion
-//#region src/collection/server/discovery.ts
-function applyFeedSchemaDefaults(parsed, slug) {
-	if (!isRecord(parsed)) return parsed;
-	const icon = typeof parsed.icon === "string" && parsed.icon.trim().length > 0 ? parsed.icon : "dynamic_feed";
-	return {
-		...parsed,
-		icon,
-		dataPath: `data/feeds/${slug}`
-	};
-}
-/** The conventional per-slug records dir a `dataSource` / `storage` collection
-*  gets as its `dataDir` (records never live there, but archive/delete paths
-*  stay well-defined — same shape the registry's R3 normalization uses).
-*
-*  INVARIANT — this is NOT a default `dataPath`, and must not be used as one.
-*  It applies only to the two backends whose records are not per-file JSON. A
-*  normal collection declares its own location and exactly one of `dataPath` /
-*  `dataSource` / `storage`; a schema with none of the three is REJECTED, not
-*  quietly pointed here. Handing a per-file collection this path would silently
-*  relocate its records away from the folder the user (and its SKILL.md) sees. */
-function conventionalDataPath(slug) {
-	return `data/collections/${slug}/items`;
-}
-/** The declared field named by `primaryKey`, or `undefined` when the schema
-*  declares no such field. Own-property guarded: a `primaryKey` of `toString`
-*  / `constructor` / `__proto__` must miss here, not read an Object.prototype
-*  member and slip past the "is it a declared field?" gate into the wrong
-*  "add `primary: true`" advice. Shared with manageCollection's putSchema
-*  gate so both report the SAME reason. */
-function resolvePrimaryField(fields, primaryKey) {
-	return Object.hasOwn(fields, primaryKey) ? fields[primaryKey] : void 0;
 }
-/** The acceptance gates discovery applies AFTER `CollectionSchemaZ` parses,
-*  before a schema becomes a live collection:
-*
-*  - the `primaryKey` must be a declared field flagged `primary: true` —
-*    without the flag CollectionView renders the field editable, and a
-*    rename is silently pinned back to the URL itemId on save, so the user's
-*    edit is dropped with no error;
-*  - a `feed` schema must declare an `ingest` block (else it's a dead,
-*    non-refreshable card);
-*  - `dataPath` — or a `dataSource`'s `path` — must resolve INSIDE the
-*    workspace (same realpath containment for both).
-*
-*  Exported so `manageCollection`'s `putSchema` can run the SAME gates before
-*  it reports success — a schema that passes `CollectionSchemaZ` but fails one
-*  of these would otherwise write cleanly yet be skipped on the next discovery,
-*  hiding the collection (the exact failure that tool exists to prevent). */
-function acceptParsedSchema(schema, opts) {
-	const primaryField = resolvePrimaryField(schema.fields, schema.primaryKey);
-	if (!primaryField) return {
-		ok: false,
-		reason: `primaryKey '${schema.primaryKey}' is not one of the declared fields`
-	};
-	if (primaryField.primary !== true) return {
-		ok: false,
-		reason: `the primaryKey field '${schema.primaryKey}' must be flagged \`primary: true\``
-	};
-	if (opts.source === "feed" && !schema.ingest) return {
-		ok: false,
-		reason: "a feed schema must declare an `ingest` block"
+async function csvList(absPath, primaryKey, workspaceRoot) {
+	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
+	if (utf8Path === null) return {
+		items: [],
+		truncated: false
 	};
-	if (schema.dataSource !== void 0) {
-		const dataSourceFile = resolveDataDir(schema.dataSource.path, opts.workspaceRoot);
-		if (dataSourceFile === null) return {
-			ok: false,
-			reason: `dataSource.path '${schema.dataSource.path}' escapes the workspace`
-		};
-		const dataDir = resolveDataDir(conventionalDataPath(opts.slug), opts.workspaceRoot);
-		if (dataDir === null) return {
-			ok: false,
-			reason: `slug '${opts.slug}' yields no workspace-contained data dir`
-		};
+	let rows;
+	try {
+		rows = await queryCsv(`SELECT * FROM read_csv(${readCsvArgs(primaryKey)}) LIMIT 5001`, [utf8Path]);
+	} catch (err) {
+		if (!isMissingKeyColumnError(err)) throw err;
+		log.warn("collections", "dataSource CSV has no primaryKey column — every row is skipped", {
+			path: absPath,
+			primaryKey
+		});
 		return {
-			ok: true,
-			dataDir,
-			dataSourceFile
+			items: [],
+			truncated: false
 		};
 	}
-	if (schema.storage !== void 0) return acceptStorageSchema(schema.storage, opts);
-	const dataDir = resolveDataDir(schema.dataPath ?? "", opts.workspaceRoot);
-	if (dataDir === null) return {
-		ok: false,
-		reason: `dataPath '${schema.dataPath}' escapes the workspace`
-	};
+	const truncated = rows.length > MAX_CSV_ROWS;
+	if (truncated) {
+		log.warn("collections", "dataSource CSV truncated to row cap", {
+			path: absPath,
+			cap: MAX_CSV_ROWS
+		});
+		rows.length = MAX_CSV_ROWS;
+	}
+	const items = rows.map((row) => csvRowToItem(row, primaryKey)).filter((item) => item !== null);
+	const skipped = rows.length - items.length;
+	if (skipped > 0) log.warn("collections", "dataSource CSV rows skipped (empty key cell)", {
+		path: absPath,
+		skipped
+	});
+	const deduped = dedupeByRecordId(items, primaryKey);
+	if (deduped.duplicates > 0) log.warn("collections", "dataSource CSV has duplicate key values (last row wins)", {
+		path: absPath,
+		duplicates: deduped.duplicates
+	});
 	return {
-		ok: true,
-		dataDir
+		items: deduped.items,
+		truncated
 	};
 }
-/** The `storage` arm of the acceptance gate. Every storage backend gets the
-*  conventional phantom dataDir; what differs is what else has to resolve
-*  before the collection can exist at all.
+/** The scan-order ordinal column the last-match read adds. Underscore
+*  prefix keeps it out of any plausible CSV header namespace; it is
+*  stripped from the returned record either way. */
+var ROW_ORDINAL = "__mc_row";
+/** One record by id. The comparison value rides as a prepared-statement
+*  parameter, and the LAST matching row is selected IN DuckDB (scan-order
+*  ordinal + LIMIT 1) — a CSV with thousands of duplicate keys must not
+*  materialize them all for one detail read. Consistent with csvList's
+*  last-wins dedupe. */
+async function csvRead(absPath, primaryKey, itemId, workspaceRoot) {
+	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
+	if (utf8Path === null) return null;
+	const rawKey = decodeCsvRecordId(itemId);
+	const last = (await queryCsv(`SELECT * FROM (SELECT *, row_number() OVER () AS ${quoteIdent(ROW_ORDINAL)} FROM read_csv(${readCsvArgs(primaryKey)})) WHERE CAST(${quoteIdent(primaryKey)} AS VARCHAR) = ? ORDER BY ${quoteIdent(ROW_ORDINAL)} DESC LIMIT 1`, [utf8Path, rawKey])).at(0);
+	if (last === void 0) return null;
+	const { [ROW_ORDINAL]: __ordinal, ...record } = last;
+	return csvRowToItem(record, primaryKey);
+}
+/** Run a validated aggregation query (the structured DSL — see
+*  `core/queryZ.ts`) over the WHOLE file: no row cap on the scan (a
+*  capped aggregate would be a wrong number), only the result-row LIMIT
+*  the compiler emits. Values are normalized like list/read rows so a
+*  chart consumer gets plain JSON scalars. */
+async function csvRunQuery(absPath, primaryKey, query, workspaceRoot) {
+	const utf8Path = await ensureUtf8CsvPath(absPath, workspaceRoot ?? getWorkspaceRoot());
+	if (utf8Path === null) return [];
+	const { sql, params } = compileCsvQuery(query, primaryKey);
+	return (await queryCsv(sql, [utf8Path, ...params])).map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, normalizeCsvValue(value)])));
+}
+//#endregion
+//#region src/collection/server/watchFs.ts
+/** An atomic file replace (editor save, `mv` over the target) surfaces as
+*  2-3 events. Collapse them so one user action reports one change. */
+var REPLACE_DEBOUNCE_MS = 300;
+/** The path to hand `watch()`, with Windows 8.3 short names resolved away.
 *
-*  A FILE-backed backend (sqlite) resolves and containment-checks a
-*  `storageFile`. A SHARED one (firestore) has no path on this machine — it
-*  resolves an IDENTITY instead: the `aid` from the repository's `app.json`,
-*  which together with the slug as `cid` names `apps/{aid}/collections/{cid}`.
+*  ReadDirectoryChangesW reports filenames against the LONG path, but a watch
+*  opened on a short path (`C:\Users\RUNNER~1\…` — what `os.tmpdir()` returns
+*  on GitHub's Windows runners) keeps the short form. libuv's
+*  `assert(!_wcsnicmp(filename, dir, dirlen))` in `src/win/fs-event.c` then
+*  aborts the PROCESS on the first event — a native assert, so neither
+*  `watcher.on("error")` nor a try/catch can contain it.
 *
-*  Resolving it HERE, once, is the point. The store then receives a settled
-*  `(aid, cid)` and never reads `app.json` itself — otherwise the questions of
-*  caching, staleness and what to do when the file is missing would be decided
-*  inside a read path, where the only cheap answer is to return nothing, and
-*  "this collection is misconfigured" would reach the user as "this collection
-*  is empty". A missing or malformed `app.json` is a CONFIGURATION error, so it
-*  is reported the same way an escaping `storage.path` is: the schema is
-*  refused, with a reason naming the file to create. */
-function acceptStorageSchema(storage, opts) {
-	const dataDir = resolveDataDir(conventionalDataPath(opts.slug), opts.workspaceRoot);
-	if (dataDir === null) return {
-		ok: false,
-		reason: `slug '${opts.slug}' yields no workspace-contained data dir`
-	};
-	if (storage.type === "sqlite") {
-		const storageFile = resolveDataDir(storage.path, opts.workspaceRoot);
-		if (storageFile === null) return {
-			ok: false,
-			reason: `storage.path '${storage.path}' escapes the workspace`
-		};
-		return {
-			ok: true,
-			dataDir,
-			storageFile
-		};
-	}
-	const manifest = loadAppManifest(opts.workspaceRoot);
-	if (!manifest.ok) return {
-		ok: false,
-		reason: appManifestReason(manifest, opts.workspaceRoot)
-	};
-	return {
-		ok: true,
-		dataDir,
-		appId: manifest.manifest.aid
-	};
+*  POSIX is deliberately left alone: `realpath` there also collapses symlinks
+*  (`/var` → `/private/var` on macOS), which we neither need nor want to
+*  change. A failure falls back to the original path — worst case we are no
+*  worse off than before. */
+function watchablePath(dir) {
+	if (process.platform !== "win32") return dir;
+	try {
+		return realpathSync.native(dir);
+	} catch {
+		return dir;
+	}
 }
-async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
-	const safeName = safeSlugName(slug);
-	if (safeName === null) return null;
-	const schemaPath = path.join(skillsRoot, safeName, SCHEMA_FILE);
-	let raw;
+/** Watch `dir`, reporting each accepted filename. `accept` decides what is
+*  noise; a null filename always passes (the platform didn't tell us which
+*  file, so the caller must assume the worst). */
+async function watchDirectory(dir, accept, onHit) {
 	try {
-		if (!(await stat(schemaPath)).isFile()) return null;
-		raw = await readFile(schemaPath, "utf-8");
+		await mkdir(dir, { recursive: true });
+		const watcher = watch(watchablePath(dir), { persistent: false }, (_eventType, rawFilename) => {
+			const filename = rawFilename === null ? null : String(rawFilename);
+			if (filename !== null && !accept(filename)) return;
+			onHit(filename);
+		});
+		watcher.on("error", (err) => {
+			log.warn("collections", "fs watch error", {
+				dir,
+				error: String(err)
+			});
+		});
+		return { close: () => watcher.close() };
 	} catch (err) {
-		if (!isErrorWithCode(err) || err.code !== "ENOENT") log.warn("collections", "failed to read schema.json, skipping", {
-			slug: safeName,
-			path: schemaPath,
+		log.warn("collections", "fs watch start failed", {
+			dir,
 			error: String(err)
 		});
 		return null;
 	}
-	let parsedJson;
+}
+/** Watch the single file `absPath` by watching its PARENT directory, so an
+*  atomic replace can't strand the watch on a dead inode. `alsoAccept`
+*  widens the filter beyond the exact basename (sqlite's `-wal`/`-journal`
+*  sidecars). Reports are debounced: one replace, one call. */
+async function watchSingleFile(absPath, alsoAccept, onChange) {
+	const dir = path.dirname(absPath);
+	const base = path.basename(absPath);
+	let timer = null;
+	const fire = () => {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = null;
+			onChange();
+		}, REPLACE_DEBOUNCE_MS);
+		timer.unref?.();
+	};
+	const handle = await watchDirectory(dir, (filename) => filename === base || alsoAccept(base, filename), fire);
+	if (!handle) return null;
+	return { close: () => {
+		if (timer) clearTimeout(timer);
+		timer = null;
+		handle.close();
+	} };
+}
+/** An `FsWatchHandle` as a bare unsubscribe — `null` straight through, so an
+*  unarmed watch stays distinguishable from an armed one. Lives here rather
+*  than beside the store contract so both `store.ts` and the backends it
+*  registers can reach it without importing each other. */
+function closerFor(handle) {
+	return handle === null ? null : () => handle.close();
+}
+//#endregion
+//#region src/collection/server/sqliteStore.ts
+/** A constructor's parameter and return types are not observable at runtime,
+*  so the check stops at "DatabaseSync is constructible" — the only member of
+*  the module this store ever touches. */
+function isSqliteModule(mod) {
+	return isRecord(mod) && typeof mod.DatabaseSync === "function";
+}
+var sqliteModule = null;
+/** Drops the memo first so a later call can retry (e.g. tests stubbing the
+*  runtime), then reports why the backend is unusable. */
+function sqliteUnavailable(reason) {
+	sqliteModule = null;
+	throw new BackendUnavailableError(`sqlite storage needs the node:sqlite module (Node.js >= 22.5) — this runtime cannot load it: ${reason}`);
+}
+/** Lazy-load node:sqlite once. A runtime without it (Node < 22.5) throws a
+*  clearly-worded error the caller surfaces — never a bare MODULE_NOT_FOUND. */
+function loadSqlite() {
+	sqliteModule ??= import("node:sqlite").then((mod) => isSqliteModule(mod) ? mod : sqliteUnavailable("the module exposes no DatabaseSync constructor"), (err) => sqliteUnavailable(String(err)));
+	return sqliteModule;
+}
+/** The db file's on-disk state. A symlink or non-regular file is refused
+*  (file-disclosure defense, same rule as io.ts record files); ENOENT is
+*  just "no records yet". Any OTHER lstat failure (EACCES, EIO, …) is
+*  rethrown so reads surface a real filesystem problem instead of
+*  silently reporting an empty collection. */
+async function dbFileState(absPath) {
 	try {
-		parsedJson = JSON.parse(raw);
+		return (await lstat(absPath)).isFile() ? "file" : "refused";
 	} catch (err) {
-		log.warn("collections", "schema.json is not valid JSON, skipping", {
-			slug: safeName,
-			error: String(err)
-		});
-		return null;
+		if (isErrorWithCode(err) && err.code === "ENOENT") return "missing";
+		throw err;
 	}
-	const candidate = source === "feed" ? applyFeedSchemaDefaults(parsedJson, safeName) : parsedJson;
-	const parsed = CollectionSchemaZ.safeParse(candidate);
-	if (!parsed.success) {
-		log.warn("collections", "schema.json failed validation, skipping", {
-			slug: safeName,
-			issues: parsed.error.issues
-		});
-		return null;
+}
+var CREATE_TABLE = "CREATE TABLE IF NOT EXISTS records (id TEXT PRIMARY KEY, record TEXT NOT NULL)";
+/** Open the database for one operation, classifying the two unavailable
+*  states so callers can map them honestly (`refused` ⇒ path-escape,
+*  `missing` ⇒ empty / not-found — conflating them would misreport a
+*  containment escape as "item not found"). The containment pre-check runs
+*  BEFORE mkdir even when the file is missing — `isContainedInRoot`
+*  resolves through the closest existing ancestor, so a symlinked-away
+*  parent can never make the recursive mkdir create directories outside
+*  the workspace (same pre/post belt-and-suspenders as io.ts writes). */
+async function openDb(absPath, workspaceRoot, mode) {
+	const state = await dbFileState(absPath);
+	if (state === "refused") {
+		log.warn("collections", "sqlite database refused: not a regular file", { path: absPath });
+		return { kind: "refused" };
 	}
-	const schema = parsed.data;
-	const acceptance = acceptParsedSchema(schema, {
-		source,
-		workspaceRoot,
-		slug: safeName
-	});
-	if (!acceptance.ok) {
-		log.warn("collections", "schema.json rejected after validation, skipping", {
-			slug: safeName,
-			reason: acceptance.reason
-		});
-		return null;
+	if (!isContainedInRoot(path.dirname(absPath), workspaceRoot)) {
+		log.warn("collections", "sqlite refused: database dir escapes workspace via symlink", { path: absPath });
+		return { kind: "refused" };
+	}
+	if (mode === "read" && state === "missing") return { kind: "missing" };
+	if (mode === "write") {
+		await mkdir(path.dirname(absPath), { recursive: true });
+		if (!isContainedInRoot(path.dirname(absPath), workspaceRoot)) {
+			log.warn("collections", "sqlite write refused: database dir escapes workspace via symlink (post-mkdir)", { path: absPath });
+			return { kind: "refused" };
+		}
 	}
+	const { DatabaseSync } = await loadSqlite();
+	const database = new DatabaseSync(absPath);
+	database.exec("PRAGMA busy_timeout = 5000");
+	database.exec(CREATE_TABLE);
 	return {
-		slug: safeName,
-		source,
-		schema,
-		dataDir: acceptance.dataDir,
-		...acceptance.dataSourceFile !== void 0 ? { dataSourceFile: acceptance.dataSourceFile } : {},
-		...acceptance.storageFile !== void 0 ? { storageFile: acceptance.storageFile } : {},
-		...acceptance.appId !== void 0 ? { appId: acceptance.appId } : {},
-		skillDir: path.join(skillsRoot, safeName)
+		kind: "ok",
+		database
+	};
+}
+/** Run `operation` against the database and always close it; unavailable
+*  states resolve through `onUnavailable` so each caller maps `missing`
+*  vs `refused` to its own result kind. */
+async function withDb(absPath, workspaceRoot, mode, onUnavailable, operation) {
+	const handle = await openDb(absPath, workspaceRoot, mode);
+	if (handle.kind !== "ok") return onUnavailable(handle.kind);
+	try {
+		return await operation(handle.database);
+	} finally {
+		handle.database.close();
+	}
+}
+var SQLITE_CONSTRAINT_PRIMARYKEY = 1555;
+var SQLITE_CONSTRAINT_UNIQUE = 2067;
+/** node:sqlite throws ERR_SQLITE_ERROR with the SQLite extended result
+*  code on `errcode`. Checked structurally (message text kept only as a
+*  fallback for runtimes that don't expose `errcode`). */
+function isUniqueConstraintError(err) {
+	if (hasNumberProp(err, "errcode")) return err.errcode === SQLITE_CONSTRAINT_PRIMARYKEY || err.errcode === SQLITE_CONSTRAINT_UNIQUE;
+	return String(err).includes("UNIQUE constraint");
+}
+function parseRow(raw) {
+	if (typeof raw !== "string") return null;
+	try {
+		const parsed = JSON.parse(raw);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/** One column of a result row. node:sqlite types rows as `unknown`, so a
+*  value that is not a row object yields no column at all. */
+function readColumn(row, column) {
+	return isRecord(row) ? row[column] : void 0;
+}
+function rowsToItems(rows) {
+	return rows.map((row) => parseRow(readColumn(row, "record"))).filter((item) => item !== null);
+}
+/** node:sqlite hands back an integer column as `number`, or as `bigint` once
+*  it leaves the safe-integer range — COUNT(*) can be either. */
+function countRecords(database) {
+	const count = readColumn(database.prepare("SELECT COUNT(*) AS n FROM records").get(), "n");
+	if (typeof count === "number") return count;
+	if (typeof count === "bigint") return Number(count);
+	throw new Error(`sqlite COUNT(*) returned no numeric row count (got ${typeof count})`);
+}
+async function sqliteList(absPath, workspaceRoot) {
+	return withDb(absPath, workspaceRoot, "read", () => [], (database) => rowsToItems(database.prepare("SELECT record FROM records ORDER BY id").all()));
+}
+async function sqlitePage(absPath, primaryKey, opts, workspaceRoot) {
+	const emptyPage = {
+		items: [],
+		total: 0,
+		truncated: false
+	};
+	return withDb(absPath, workspaceRoot, "read", () => emptyPage, (database) => {
+		const total = countRecords(database);
+		const offset = Math.max(0, opts.offset ?? 0);
+		const limit = opts.limit === void 0 ? -1 : Math.max(0, opts.limit);
+		return {
+			items: projectItemFields(rowsToItems(database.prepare("SELECT record FROM records ORDER BY id LIMIT ? OFFSET ?").all(limit, offset)), opts.fields, primaryKey),
+			total,
+			truncated: false
+		};
+	});
+}
+async function sqliteRead(absPath, itemId, workspaceRoot) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return null;
+	return withDb(absPath, workspaceRoot, "read", () => null, (database) => {
+		return parseRow(readColumn(database.prepare("SELECT record FROM records WHERE id = ?").get(safeId), "record"));
+	});
+}
+async function sqliteWrite(absPath, itemId, item, opts) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return {
+		kind: "invalid-id",
+		itemId
+	};
+	const outcome = await withDb(absPath, opts.workspaceRoot, "write", () => ({
+		kind: "path-escape",
+		itemId: safeId
+	}), (database) => {
+		const payload = JSON.stringify(item);
+		if (opts.refuseOverwrite) try {
+			database.prepare("INSERT INTO records (id, record) VALUES (?, ?)").run(safeId, payload);
+		} catch (err) {
+			if (isUniqueConstraintError(err)) return {
+				kind: "conflict",
+				itemId: safeId
+			};
+			throw err;
+		}
+		else database.prepare("INSERT INTO records (id, record) VALUES (?, ?) ON CONFLICT(id) DO UPDATE SET record = excluded.record").run(safeId, payload);
+		return {
+			kind: "ok",
+			itemId: safeId,
+			item
+		};
+	});
+	if (outcome.kind === "ok" && opts.slug) publishCollectionChange(collectionChangePayload({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "upsert"
+	}, opts.publishRoot));
+	return outcome;
+}
+async function sqliteDelete(absPath, itemId, opts) {
+	const safeId = safeRecordId(itemId);
+	if (safeId === null) return {
+		kind: "invalid-id",
+		itemId
 	};
+	const outcome = await withDb(absPath, opts.workspaceRoot, "read", (reason) => reason === "refused" ? {
+		kind: "path-escape",
+		itemId: safeId
+	} : {
+		kind: "not-found",
+		itemId: safeId
+	}, (database) => {
+		const { changes } = database.prepare("DELETE FROM records WHERE id = ?").run(safeId);
+		return Number(changes) === 0 ? {
+			kind: "not-found",
+			itemId: safeId
+		} : {
+			kind: "ok",
+			itemId: safeId
+		};
+	});
+	if (outcome.kind === "ok" && opts.slug) publishCollectionChange(collectionChangePayload({
+		slug: opts.slug,
+		ids: [safeId],
+		op: "delete"
+	}, opts.publishRoot));
+	return outcome;
 }
-async function collectFromDir(skillsRoot, source, workspaceRoot) {
-	let entries;
+/** Best-effort full WAL checkpoint so the MAIN db file alone is a
+*  complete snapshot (committed pages in `<db>-wal` are folded in and the
+*  WAL truncated). Used by `deleteCollection` before archiving. Returns
+*  false on any failure (runtime without node:sqlite, locked db, missing
+*  file) — the caller then archives the sidecar files alongside the db so
+*  no committed data is lost either way. */
+async function checkpointSqliteDatabase(absPath) {
 	try {
-		entries = await readdir(skillsRoot);
-	} catch (err) {
-		if (isErrorWithCode(err) && err.code === "ENOENT") return [];
-		log.warn("collections", "failed to list skills dir, returning empty", {
-			root: skillsRoot,
-			error: String(err)
-		});
-		return [];
-	}
-	const results = [];
-	for (const name of entries) {
-		if (name.startsWith(".")) continue;
-		const safeName = safeSlugName(name);
-		if (safeName === null) continue;
-		const dirPath = path.join(skillsRoot, safeName);
-		let dirStat;
+		const { DatabaseSync } = await loadSqlite();
+		const database = new DatabaseSync(absPath);
 		try {
-			dirStat = await stat(dirPath);
-		} catch {
-			continue;
+			database.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+		} finally {
+			database.close();
 		}
-		if (!dirStat.isDirectory()) continue;
-		const collection = await loadOneCollection(skillsRoot, safeName, source, workspaceRoot);
-		if (collection) results.push(collection);
+		return true;
+	} catch {
+		return false;
 	}
-	return results;
 }
-/** The user-scope dir this call should scan, or `null` for none. The single
-*  place the "explicit override beats the host binding, and either may say
-*  none" rule is spelled — `??` cannot express it, because `undefined` there
-*  means "ask the host" and would silently re-enable a scope the caller
-*  passed `null` to switch off. */
-function resolveUserDir(opts, workspaceRoot) {
-	return opts.userSkillsDir !== void 0 ? opts.userSkillsDir : userSkillsDir(workspaceRoot);
+/** A `storage: sqlite` store over `collection.storageFile`. A schema whose
+*  `storageFile` failed to resolve yields a read-only EMPTY store rather
+*  than a writable one — same fail-closed rule as the CSV store. */
+function sqliteStoreFor(collection, opts) {
+	const file = collection.storageFile;
+	const key = collection.schema.primaryKey;
+	const slug = opts.slug ?? collection.slug;
+	const root = () => opts.workspaceRoot ?? getWorkspaceRoot();
+	const publishRoot = opts.workspaceRoot;
+	if (file === void 0) return {
+		capabilities: {
+			writable: false,
+			nativeQuery: false,
+			nativePaging: false
+		},
+		list: () => Promise.resolve([]),
+		page: () => Promise.resolve({
+			items: [],
+			total: 0,
+			truncated: false
+		}),
+		read: () => Promise.resolve(null)
+	};
+	return {
+		capabilities: {
+			writable: true,
+			nativeQuery: false,
+			nativePaging: true
+		},
+		list: () => sqliteList(file, root()),
+		page: (pageOpts = {}) => sqlitePage(file, key, pageOpts, root()),
+		read: (itemId) => sqliteRead(file, itemId, root()),
+		write: (itemId, item, writeOpts = {}) => sqliteWrite(file, itemId, item, {
+			workspaceRoot: root(),
+			publishRoot,
+			slug,
+			refuseOverwrite: writeOpts.refuseOverwrite
+		}),
+		delete: (itemId) => sqliteDelete(file, itemId, {
+			workspaceRoot: root(),
+			publishRoot,
+			slug
+		}),
+		watch: async (onChange) => closerFor(await watchSingleFile(file, (base, name) => name.startsWith(base), () => onChange({ kind: "collection" })))
+	};
 }
-/** Discover every schema-driven collection available to this
-*  workspace. Project-scope collections override user-scope on slug
-*  collision. The `workspaceRoot` override also flows into each
-*  collection's dataDir resolution so a tmpdir-scoped test gets
-*  dataDirs under the same tmpdir (Codex P1 review on PR #1489 —
-*  previously dataDir was always rooted at the live workspacePath
-*  regardless of override). */
-async function discoverCollections(opts = {}) {
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const userDir = resolveUserDir(opts, workspaceRoot);
-	const projectDir = projectSkillsDir(workspaceRoot);
-	const feedCollections = await collectFromDir(feedsRoot(workspaceRoot), "feed", workspaceRoot);
-	const userCollections = userDir === null ? [] : await collectFromDir(userDir, "user", workspaceRoot);
-	const projectCollections = await collectFromDir(projectDir, "project", workspaceRoot);
-	const merged = /* @__PURE__ */ new Map();
-	for (const entry of feedCollections) merged.set(entry.slug, entry);
-	for (const entry of userCollections) merged.set(entry.slug, entry);
-	for (const entry of projectCollections) merged.set(entry.slug, entry);
-	return [...merged.values()].sort((left, right) => left.slug.localeCompare(right.slug));
+//#endregion
+//#region src/collection/server/store.ts
+/** The file store's stable order: lexicographic by record id (codepoint
+*  compare — locale-independent). `listItems` returns readdir order, which
+*  is filesystem-dependent; paging needs determinism. */
+function sortByRecordId(items, primaryKey) {
+	return [...items].sort((left, right) => {
+		const leftId = fieldText(left[primaryKey]);
+		const rightId = fieldText(right[primaryKey]);
+		if (leftId < rightId) return -1;
+		return leftId > rightId ? 1 : 0;
+	});
 }
-/** Load one collection by slug. Returns null if the slug is invalid,
-*  no matching skill exists, or the schema is malformed. */
-async function loadCollection(slug, opts = {}) {
-	const safeName = safeSlugName(slug);
-	if (safeName === null) return null;
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	const userDir = resolveUserDir(opts, workspaceRoot);
-	const projectCollection = await loadOneCollection(projectSkillsDir(workspaceRoot), safeName, "project", workspaceRoot);
-	if (projectCollection) return projectCollection;
-	const userCollection = userDir === null ? null : await loadOneCollection(userDir, safeName, "user", workspaceRoot);
-	if (userCollection) return userCollection;
-	return loadOneCollection(feedsRoot(workspaceRoot), safeName, "feed", workspaceRoot);
+/** True when the collection accepts UI/tool writes. A `dataSource`
+*  collection is read-only: updates happen by editing/replacing the
+*  data file itself. Every write entry point checks this BEFORE calling
+*  `writeItem`/`deleteItem` — server-enforced, not just UI-hidden. */
+function collectionWritable(collection) {
+	return !isReadOnlySchema(collection.schema);
 }
-function toSummary(collection) {
+/** The one-line refusal write paths surface (HTTP 405 / MCP error text). */
+function readOnlyRefusal(slug) {
+	return `collection '${slug}' is read-only (backed by an external dataSource) — update the data file itself instead`;
+}
+/** A `dataSource` store over `file` (CSV row order; DuckDB-native query).
+*  A schema whose `dataSourceFile` failed to resolve yields a read-only
+*  EMPTY store rather than falling back to the (writable) file store — a
+*  half-loaded read-only collection must never become writable. */
+function csvStoreFor(collection, opts) {
+	const file = collection.dataSourceFile;
+	const key = collection.schema.primaryKey;
+	const listAll = () => file === void 0 ? Promise.resolve({
+		items: [],
+		truncated: false
+	}) : csvList(file, key, opts.workspaceRoot);
 	return {
-		slug: collection.slug,
-		title: collection.schema.title,
-		icon: collection.schema.icon,
-		source: collection.source,
-		...collection.schema.dataSource !== void 0 ? { readonly: true } : {},
-		...collection.appId !== void 0 ? { appId: collection.appId } : {}
+		capabilities: {
+			writable: false,
+			nativeQuery: true,
+			nativePaging: false
+		},
+		list: () => listAll().then((result) => result.items),
+		page: (pageOpts = {}) => listAll().then((result) => pageFromFullRead(result.items, pageOpts, key, result.truncated)),
+		read: (itemId) => file === void 0 ? Promise.resolve(null) : csvRead(file, key, itemId, opts.workspaceRoot),
+		query: (query) => file === void 0 ? Promise.resolve([]) : csvRunQuery(file, key, query, opts.workspaceRoot),
+		...file === void 0 ? {} : { watch: async (onChange) => closerFor(await watchSingleFile(file, () => false, () => onChange({ kind: "collection" }))) }
 	};
 }
-function toDetail(collection) {
+/** The classic file store over `<dataDir>/<itemId>.json` records. */
+function fileStoreFor(collection, opts) {
+	const key = collection.schema.primaryKey;
+	const ioOpts = {
+		...opts,
+		slug: opts.slug ?? collection.slug
+	};
 	return {
-		...toSummary(collection),
-		schema: collection.schema
+		capabilities: {
+			writable: true,
+			nativeQuery: false,
+			nativePaging: false
+		},
+		list: () => listItems(collection.dataDir, opts),
+		page: async (pageOpts = {}) => pageFromFullRead(sortByRecordId(await listItems(collection.dataDir, opts), key), pageOpts, key, false),
+		read: (itemId) => readItem(collection.dataDir, itemId, opts),
+		write: (itemId, item, writeOpts = {}) => writeItem(collection.dataDir, itemId, item, {
+			...ioOpts,
+			refuseOverwrite: writeOpts.refuseOverwrite
+		}),
+		delete: (itemId) => deleteItem(collection.dataDir, itemId, ioOpts),
+		watch: async (onChange) => closerFor(await watchDirectory(collection.dataDir, (name) => name.endsWith(".json") && !name.startsWith("."), (filename) => onChange(filename === null ? { kind: "collection" } : {
+			kind: "item",
+			itemId: filename.slice(0, -5)
+		})))
 	};
 }
+var storeFactories = /* @__PURE__ */ new Map([
+	["file", fileStoreFor],
+	["csv", csvStoreFor],
+	["sqlite", sqliteStoreFor],
+	["firestore", firestoreStoreFor]
+]);
+/** Pick the store implementation for a discovered collection via the
+*  factory registry. An unknown kind cannot normally reach here (the
+*  schema's `StorageZ` union gates it), so the throw is a loud invariant
+*  breach, not a user-facing path. */
+function storeFor(collection, opts = {}) {
+	const kind = storageKindFor(collection.schema);
+	const factory = storeFactories.get(kind);
+	if (!factory) throw new Error(`no store factory registered for storage kind '${kind}'`);
+	return factory(collection, opts);
+}
 //#endregion
-export { collectionsRegistriesConfigPath as $, readItem as A, SCHEMA_FILE as B, CollectionQueryZ as C, generateItemId as D, deleteItem as E, loadAppManifest as F, safeRecordId as G, itemFilePath as H, parseAppManifest as I, isBackendUnavailable as J, safeSlugName as K, sharedItemsPath as L, writeItem as M, APP_MANIFEST_FILE as N, isRegularFile as O, appManifestReason as P, collectionChangePayload as Q, pageFromFullRead as R, compileJsonlQuery as S, MAX_QUERY_ROWS as T, resolveDataDir as U, isContainedInRoot as V, resolveTemplatePath as W, archiveDir as X, COLLECTION_ROOT_REQUIRED as Y, collectionChangeKey as Z, dedupeByRecordId as _, toDetail as a, log as at, queryCsv as b, resolveMutateSet as c, publishCollectionChange as ct, storeFor as d, sharedCollectionChangePayload as dt, configureCollectionHost as et, checkpointSqliteDatabase as f, skillsStagingDir as ft, decodeCsvRecordId as g, csvRowToItem as h, createHostSlot as ht, resolvePrimaryField as i, localCollectionKey as it, resolveCreateItemId as j, listItems as k, collectionWritable as l, setCollectionChangePublisher as lt, cacheDir as m, createForwardingLogger as mt, discoverCollections as n, getWorkspaceRoot as nt, toSummary as o, peekWorkspaceRoot as ot, MAX_CSV_ROWS as p, stagingSkillDir as pt, BackendUnavailableError as q, loadCollection as r, isPresetSlug as rt, CollectionSchemaZ as s, projectSkillsDir as st, acceptParsedSchema as t, firestoreHandle as tt, readOnlyRefusal as u, setFirestoreAccessor as ut, encodeCsvRecordId as v, DEFAULT_QUERY_ROWS as w, compileCsvQuery as x, normalizeCsvValue as y, projectItemFields as z };
+export { collectionsRegistriesConfigPath as $, toSummary as A, SCHEMA_FILE as B, resolveCreateItemId as C, loadCollection as D, discoverCollections as E, loadAppManifest as F, safeRecordId as G, itemFilePath as H, parseAppManifest as I, isBackendUnavailable as J, safeSlugName as K, sharedItemsPath as L, resolveMutateSet as M, APP_MANIFEST_FILE as N, resolvePrimaryField as O, appManifestReason as P, collectionChangePayload as Q, pageFromFullRead as R, readItem as S, acceptParsedSchema as T, resolveDataDir as U, isContainedInRoot as V, resolveTemplatePath as W, archiveDir as X, COLLECTION_ROOT_REQUIRED as Y, collectionChangeKey as Z, MAX_QUERY_ROWS as _, MAX_CSV_ROWS as a, log as at, isRegularFile as b, decodeCsvRecordId as c, publishCollectionChange as ct, normalizeCsvValue as d, sharedCollectionChangePayload as dt, configureCollectionHost as et, queryCsv as f, skillsStagingDir as ft, DEFAULT_QUERY_ROWS as g, CollectionQueryZ as h, createHostSlot as ht, checkpointSqliteDatabase as i, localCollectionKey as it, CollectionSchemaZ as j, toDetail as k, dedupeByRecordId as l, setCollectionChangePublisher as lt, compileJsonlQuery as m, createForwardingLogger as mt, readOnlyRefusal as n, getWorkspaceRoot as nt, cacheDir as o, peekWorkspaceRoot as ot, compileCsvQuery as p, stagingSkillDir as pt, BackendUnavailableError as q, storeFor as r, isPresetSlug as rt, csvRowToItem as s, projectSkillsDir as st, collectionWritable as t, firestoreHandle as tt, encodeCsvRecordId as u, setFirestoreAccessor as ut, deleteItem as v, writeItem as w, listItems as x, generateItemId as y, projectItemFields as z };
 
-//# sourceMappingURL=discovery-CdkaURVY.js.map
+//# sourceMappingURL=store-_61sO8K8.js.map