@mulmoclaude/core 3.5.0 → 3.7.0

package/dist/{discovery-Ck4AqikY.cjs → store-5_P_NsGa.cjs}

@@ -9,10 +9,10 @@ let node_path = require("node:path");
 node_path = require_rolldown_runtime.__toESM(node_path, 1);
 let node_crypto = require("node:crypto");
 let node_fs_promises = require("node:fs/promises");
+let zod = require("zod");
 let node_os = require("node:os");
 let iconv_lite = require("iconv-lite");
 iconv_lite = require_rolldown_runtime.__toESM(iconv_lite, 1);
-let zod = require("zod");
 //#region src/host/hostSlot.ts
 function createHostSlot(name) {
 	let current = null;
@@ -106,6 +106,7 @@ function collectionChangeKey(payload, fallbackRoot) {
 }
 var hostSlot = createHostSlot("@mulmoclaude/core/collection/server: configureCollectionHost()");
 var changePublisher = null;
+var firestoreAccessor = null;
 /** Wire the engine to a host. Call once at server startup, before any
 *  collection storage operation. Re-binding to a *different* host throws —
 *  silently redirecting later filesystem operations to another workspace
@@ -129,6 +130,25 @@ function setCollectionChangePublisher(publish) {
 function publishCollectionChange(payload) {
 	changePublisher?.(payload);
 }
+/** Wire the accessor for the host's authenticated Firestore session.
+*
+*  Separate from `configureCollectionHost` for the same reason
+*  `setCollectionChangePublisher` is: the host binding is set at the top of
+*  server startup, but this session doesn't exist until the user connects
+*  remote-host (and closes again on disconnect), so it cannot be part of a
+*  one-shot binding. Optional — left unwired, only shared collections are
+*  affected, and they report "not connected". Pass `null` to detach. */
+function setFirestoreAccessor(accessor) {
+	firestoreAccessor = accessor;
+}
+/** The host's live Firestore access, or null when there is no session (or the
+*  host never wired one — every non-shared backend leaves it unset).
+*  Callers MUST surface null as an actionable "connect remote-host first",
+*  never as an empty result: silence would be indistinguishable from a
+*  collection that genuinely has no records. */
+function firestoreHandle() {
+	return firestoreAccessor?.() ?? null;
+}
 function requireHost() {
 	return hostSlot.get();
 }
@@ -193,6 +213,18 @@ function isPresetSlug(slug) {
 *  without a workspace root. */
 var log = createForwardingLogger(() => hostSlot.peek()?.log ?? null);
 //#endregion
+//#region src/collection/server/backendAvailability.ts
+/** Thrown by a store when its engine or session cannot serve the request. */
+var BackendUnavailableError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "BackendUnavailableError";
+	}
+};
+function isBackendUnavailable(err) {
+	return err instanceof BackendUnavailableError;
+}
+//#endregion
 //#region src/collection/server/paths.ts
 var SCHEMA_FILE = "schema.json";
 /** Sanitise a user-supplied slug into a safe directory-name leaf.
@@ -304,1571 +336,636 @@ function resolveTemplatePath(skillDir, templateRelPath) {
 	return resolved;
 }
 //#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 (0, node_fs_promises.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 require_dist.isRecord(parsed) ? parsed : null;
+//#region src/collection/server/storePage.ts
+/** Project `fields` (+ the primary key, always) out of each record. Thin
+*  server-typed alias over the shared isomorphic `projectRecordFields`
+*  (../core/project.ts) — kept as the store layer's exported name. */
+function projectItemFields(items, fields, primaryKey) {
+	return require_project.projectRecordFields(items, fields, primaryKey);
 }
-async function tryReadRecord(filePath) {
-	if (!await isRegularFile(filePath)) return null;
-	try {
-		return parseRecordJson(await (0, node_fs_promises.readFile)(filePath, "utf-8"));
-	} catch {
-		return null;
-	}
+/** Slice + project an already-ordered full read into a `ListPage` — the
+*  shared emulation for stores without native paging. Pure, exported for
+*  tests. `limit: 0` is a valid "count only" page. */
+function pageFromFullRead(items, opts, primaryKey, truncated) {
+	const offset = Math.max(0, opts.offset ?? 0);
+	const end = opts.limit === void 0 ? items.length : offset + Math.max(0, opts.limit);
+	return {
+		items: projectItemFields(items.slice(offset, end), opts.fields, primaryKey),
+		total: items.length,
+		truncated
+	};
 }
-/** 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;
+//#endregion
+//#region src/collection/server/firestoreStore.ts
+/** What every operation throws when there is no live session. Worded as an
+*  instruction because it surfaces straight to the user and the agent. */
+var NOT_CONNECTED = "shared collection unavailable: connect remote-host first — these records live in the app's Firestore, not in the workspace, so nothing can be read or written while the session is closed";
+/** What a schema declaring `storage.type: "firestore"` must have had resolved
+*  for it before it can be served. Its absence is a programming error here, not
+*  a user-facing state: discovery REFUSES such a schema when the repository
+*  declares no `aid`, so a collection that reached this store has one. */
+var NO_APP = "shared collection has no app id — discovery should have refused this schema; check that the repository's app.json declares an `aid`";
+/** The records subcollection of one shared collection.
+*
+*  Takes a KEY, never loose strings, and the key is the only way to reach this
+*  function. `sharedCollectionKey` is where the name rule lives (the charset a
+*  Firestore document id, a pubsub channel segment and the completion-bell id
+*  must all survive), so building a path cannot be a way around it. */
+function sharedItemsPath(key) {
+	return `apps/${key.aid}/collections/${key.cid}/items`;
+}
+/** The collection's identity, from what discovery resolved. Throws on a
+*  missing `appId` — see NO_APP. */
+function keyOf(collection) {
+	if (collection.appId === void 0) throw new Error(NO_APP);
+	return require_calendarGrid.sharedCollectionKey(collection.appId, collection.slug);
+}
+function requireHandle() {
+	const handle = firestoreHandle();
+	if (handle === null) throw new BackendUnavailableError(NOT_CONNECTED);
+	return handle;
+}
+/** Firestore's own refusal, named.
+*
+*  `permission-denied` is the failure a shared collection has most often and
+*  the one the SDK explains worst ("Missing or insufficient permissions") — it
+*  says nothing about WHO was refused, which is the only fact that leads to a
+*  fix. Authorization here is the app's member roster, keyed by email, so the
+*  signed-in address is what the app's owner needs in order to add it. This is
+*  the whole reason `FirestoreHandle` carries `email`.
+*
+*  Reported as a `BackendUnavailableError` deliberately, even though it is a
+*  refusal rather than an outage: the layers above catch broadly, and without a
+*  type to test, `store.read(...).catch(() => null)` reports "record missing"
+*  and an ontology count reports 0 — a denial would read as an empty
+*  collection, which is the exact confusion this backend refuses to create. */
+function isPermissionDenied(err) {
+	return require_dist.isRecord(err) && err.code === "permission-denied";
+}
+function deniedMessage(key, email) {
+	return `permission denied on shared collection '${key.cid}' of app '${key.aid}' — signed in as ${email}. A shared collection is authorized by the app's member roster (by email), so this address needs a role for '${key.cid}' (or '*'); only the app's owner can add it.`;
+}
+/** Run one SDK call, translating a roster denial. Every read and write goes
+*  through this — a denial reaching one path and not another would mean the
+*  message a user sees depends on which screen they were on. */
+async function guarded(key, email, run) {
 	try {
-		entries = await (0, node_fs_promises.readdir)(dataDir);
+		return await run();
 	} catch (err) {
-		if (require_dist.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 = node_path.default.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 = {}) {
+		if (!isPermissionDenied(err)) throw err;
+		throw new BackendUnavailableError(deniedMessage(key, email));
+	}
+}
+/** A stored document's fields → a record. A document written by hand (or by an
+*  older version) can hold anything, so a non-object is dropped rather than
+*  surfaced as a broken record — the same fail-soft the file store applies to
+*  an unparseable `.json`. */
+function toItem(data) {
+	return require_dist.isRecord(data) ? data : null;
+}
+/** Record ids are validated with the SAME helper every other backend uses.
+*  Firestore would accept ids the file store refuses, but a record should stay
+*  portable between backends — and an id that can't round-trip to a filename
+*  would break an export back to a file collection. */
+function withSafeId(itemId, onInvalid, run) {
 	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 (0, node_fs_promises.readFile)(filePath, "utf-8"));
-	} catch (err) {
-		if (require_dist.isErrorWithCode(err) && err.code === "ENOENT") return null;
-		throw err;
-	}
+	if (safeId === null) return onInvalid();
+	return run(safeId, requireHandle());
+}
+async function firestoreList(key) {
+	const { docs, email } = requireHandle();
+	return (await guarded(key, email, () => docs.list(sharedItemsPath(key)))).map((entry) => toItem(entry.data)).filter((item) => item !== null);
+}
+/** Paging is emulated over a full ordered read rather than pushed into
+*  Firestore: `offset` has no server-side form there (the cursor API needs the
+*  preceding document, which a stateless offset/limit call doesn't have), and
+*  `total` needs the full count anyway. Hence `nativePaging: false` — the
+*  capability is honest about the cost. */
+async function firestorePage(key, primaryKey, opts) {
+	const items = await firestoreList(key);
+	const offset = Math.max(0, opts.offset ?? 0);
+	return {
+		items: projectItemFields(opts.limit === void 0 ? items.slice(offset) : items.slice(offset, offset + Math.max(0, opts.limit)), opts.fields, primaryKey),
+		total: items.length,
+		truncated: false
+	};
 }
-/** 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
-	});
-	return true;
+async function firestoreRead(key, itemId) {
+	return withSafeId(itemId, () => Promise.resolve(null), async (safeId, { docs, email }) => toItem(await guarded(key, email, () => docs.get(sharedItemsPath(key), safeId))));
 }
-/** 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`.
+/** Publish the "records changed" ping for a shared collection.
 *
-*  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 {
+*  `sharedCollectionChangePayload` NEVER stamps a root, and that matters beyond
+*  tidiness: this payload is relayed to the browser and on into an
+*  LLM-generated custom-view iframe, so a filesystem path on it would be a
+*  disclosure. The type makes it unreachable rather than trusting the caller. */
+function publishShared(key, ids, operation) {
+	publishCollectionChange(sharedCollectionChangePayload({
+		slug: key.cid,
+		ids,
+		op: operation
+	}, key.aid));
+}
+async function firestoreWrite(key, itemId, item, opts) {
+	return withSafeId(itemId, () => Promise.resolve({
 		kind: "invalid-id",
 		itemId
-	};
-	const workspaceRoot = opts.workspaceRoot ?? getWorkspaceRoot();
-	if (escapesWorkspace(dataDir, workspaceRoot, safeId, "writeItem (pre-mkdir)")) return {
-		kind: "path-escape",
-		itemId: safeId
-	};
-	await (0, node_fs_promises.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 (0, node_fs_promises.open)(filePath, "wx");
-		} catch (err) {
-			if (require_dist.isErrorWithCode(err) && err.code === "EEXIST") return {
+	}), async (safeId, { docs, email }) => {
+		const collectionPath = sharedItemsPath(key);
+		if (opts.refuseOverwrite) {
+			if (!await guarded(key, email, () => docs.create(collectionPath, safeId, item))) return {
 				kind: "conflict",
 				itemId: safeId
 			};
-			throw err;
-		}
-		try {
-			await handle.writeFile(payload);
-		} finally {
-			await handle.close();
-		}
-	} else await require_root.writeFileAtomic(filePath, payload);
-	if (opts.slug) publishCollectionChange(collectionChangePayload({
-		slug: opts.slug,
-		ids: [safeId],
-		op: "upsert"
-	}, opts.workspaceRoot));
-	return {
-		kind: "ok",
-		itemId: safeId,
-		item
-	};
+		} else await guarded(key, email, () => docs.set(collectionPath, safeId, item));
+		if (opts.slug) publishShared(key, [safeId], "upsert");
+		return {
+			kind: "ok",
+			itemId: safeId,
+			item
+		};
+	});
 }
-async function deleteItem(dataDir, itemId, opts = {}) {
-	const safeId = safeRecordId(itemId);
-	if (safeId === null) return {
+async function firestoreDelete(key, itemId, opts) {
+	return withSafeId(itemId, () => Promise.resolve({
 		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 (0, node_fs_promises.unlink)(filePath);
-		if (opts.slug) publishCollectionChange(collectionChangePayload({
-			slug: opts.slug,
-			ids: [safeId],
-			op: "delete"
-		}, opts.workspaceRoot));
+	}), async (safeId, { docs, email }) => {
+		if (!await guarded(key, email, () => docs.delete(sharedItemsPath(key), safeId))) return {
+			kind: "not-found",
+			itemId: safeId
+		};
+		if (opts.slug) publishShared(key, [safeId], "delete");
 		return {
 			kind: "ok",
 			itemId: safeId
 		};
+	});
+}
+/** The store factory registered for `storage.type === "firestore"`.
+*  Synchronous and connection-agnostic by contract — see the header. */
+function firestoreStoreFor(collection, opts) {
+	const { primaryKey } = collection.schema;
+	const ioOpts = {
+		...opts,
+		slug: opts.slug ?? collection.slug
+	};
+	return {
+		capabilities: {
+			writable: true,
+			nativeQuery: false,
+			nativePaging: false
+		},
+		list: async () => firestoreList(keyOf(collection)),
+		page: async (pageOpts = {}) => firestorePage(keyOf(collection), primaryKey, pageOpts),
+		read: async (itemId) => firestoreRead(keyOf(collection), itemId),
+		write: async (itemId, item, writeOpts = {}) => firestoreWrite(keyOf(collection), itemId, item, {
+			...ioOpts,
+			refuseOverwrite: writeOpts.refuseOverwrite
+		}),
+		delete: async (itemId) => firestoreDelete(keyOf(collection), itemId, ioOpts)
+	};
+}
+//#endregion
+//#region src/collection/server/appManifest.ts
+/** The app declaration's filename, at the repository root. */
+var APP_MANIFEST_FILE = "app.json";
+/** Read `<root>/app.json` and return its `aid`.
+*
+*  SYNCHRONOUS on purpose. The caller is `acceptParsedSchema`, which is sync
+*  and is shared by discovery and `manageCollection`'s `putSchema` precisely so
+*  that a schema which would be skipped on the next discovery cannot be written
+*  as if it were fine. Making this async would split that gate in two, and the
+*  half that lost the check is the half the author sees. The file is a few
+*  hundred bytes and is read once per firestore collection per discovery pass.
+*
+*  Never cached. `app.json` is edited by hand and by the agent, and a cache
+*  here would mean the app a collection points at is whatever it was when the
+*  server started. */
+function loadAppManifest(root) {
+	let raw;
+	try {
+		raw = (0, node_fs.readFileSync)(node_path.default.join(root, APP_MANIFEST_FILE), "utf-8");
 	} catch (err) {
 		if (require_dist.isErrorWithCode(err) && err.code === "ENOENT") return {
-			kind: "not-found",
-			itemId: safeId
+			ok: false,
+			kind: "missing"
+		};
+		return {
+			ok: false,
+			kind: "unreadable",
+			detail: String(err)
 		};
-		throw err;
 	}
+	return parseAppManifest(raw);
 }
-/** 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 (0, node_crypto.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/server/backendAvailability.ts
-/** Thrown by a store when its engine or session cannot serve the request. */
-var BackendUnavailableError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "BackendUnavailableError";
-	}
-};
-function isBackendUnavailable(err) {
-	return err instanceof BackendUnavailableError;
-}
-//#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 = zod.z.object({
-	op: zod.z.enum([
-		"count",
-		"sum",
-		"avg",
-		"min",
-		"max"
-	]),
-	column: zod.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 = zod.z.object({
-	field: zod.z.string().min(1),
-	op: zod.z.enum([
-		"eq",
-		"ne",
-		"in",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"contains"
-	]),
-	value: zod.z.union([
-		zod.z.string(),
-		zod.z.number(),
-		zod.z.boolean(),
-		zod.z.array(zod.z.union([
-			zod.z.string(),
-			zod.z.number(),
-			zod.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 = zod.z.object({
-	/** A `groupBy` column or an aggregate alias — membership enforced by
-	*  the whole-query refine below. */
-	field: zod.z.string().min(1),
-	dir: zod.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 = zod.z.object({
-	groupBy: zod.z.array(zod.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: zod.z.record(zod.z.string().regex(SAFE_ALIAS_PATTERN, "aggregate aliases must be simple identifiers (letters/digits/underscore)"), QueryAggregateZ).optional(),
-	where: zod.z.array(QueryWhereZ).max(16).optional(),
-	orderBy: zod.z.array(QueryOrderZ).max(4).optional(),
-	limit: zod.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);
+/** The parse half, exported so it can be tested without a filesystem.
+*
+*  `aid` is validated with `isValidCollectionName` — the SAME predicate the
+*  `CollectionKey` constructors apply — rather than a rule of its own. An `aid`
+*  is re-encoded downstream as a Firestore document id, a pubsub channel
+*  segment and a cache key, each with a different character that would break
+*  it; one rule, stated once, is what keeps those layers from disagreeing.
+*  Rejecting here rather than at `sharedCollectionKey` only changes WHERE the
+*  author is told: a reason on the collection they wrote, instead of a throw
+*  from inside a store call. */
+function parseAppManifest(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (err) {
 		return {
-			sql: `${values.every((value) => typeof value === "string") ? asText : column} IN (${values.map(() => "?").join(", ")})`,
-			params: values
+			ok: false,
+			kind: "malformed",
+			detail: `not valid JSON (${String(err)})`
 		};
 	}
-	if (cond.op === "contains") return {
-		sql: `contains(${asText}, ?)`,
-		params: [String(scalarValue(cond))]
+	if (!require_dist.isRecord(parsed)) return {
+		ok: false,
+		kind: "malformed",
+		detail: "is not a JSON object"
 	};
-	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)]
+	const { aid } = parsed;
+	if (typeof aid !== "string" || aid.length === 0) return {
+		ok: false,
+		kind: "malformed",
+		detail: "declares no `aid` string"
+	};
+	if (!require_calendarGrid.isValidCollectionName(aid)) return {
+		ok: false,
+		kind: "malformed",
+		detail: `\`aid\` '${aid}' is not a valid app id`
 	};
-}
-/** 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;
-}
-/** 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)
+		ok: true,
+		manifest: { aid }
 	};
 }
-/** Compile against a CSV file (the dataSource store's engine). */
-function compileCsvQuery(query, primaryKey) {
-	return compileQuery(query, `read_csv(${readCsvArgs(primaryKey)})`);
+/** The failure as the one line an author can act on. Kept next to the failure
+*  type so a new variant cannot be added without wording it. */
+function appManifestReason(failure, root) {
+	const manifestPath = node_path.default.join(root, APP_MANIFEST_FILE);
+	if (failure.kind === "missing") return `a shared collection needs an app: create ${manifestPath} declaring an \`aid\``;
+	if (failure.kind === "unreadable") return `cannot read ${manifestPath}: ${failure.detail}`;
+	return `${manifestPath} ${failure.detail}`;
 }
-/** 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)`);
+/** 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);
 }
-//#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")}`;
+/** 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;
 }
-/** 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");
+//#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 && !require_calendarGrid.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;
 }
-/** 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);
-	}
+/** 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;
 }
-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;
+/** 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;
 }
-/** 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 = require_calendarGrid.fieldTextOrNull(rawKey);
-	if (keyText === null || keyText === "") return null;
-	return {
-		...normalized,
-		[primaryKey]: encodeCsvRecordId(keyText)
-	};
+/** Action ids must be unique so the dispatch route resolves unambiguously. */
+function actionIdsAreUnique(schema) {
+	return hasUniqueIds(schema.actions);
 }
-/** 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
-	};
+/** Collection-level action ids must likewise be unique. */
+function collectionActionIdsAreUnique(schema) {
+	return hasUniqueIds(schema.collectionActions);
 }
-/** 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");
+/** 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)));
 }
-/** 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;
-	}
+/** 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;
+	}));
 }
-/** 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";
+/** A collection-level action has no record to write. */
+function collectionActionsAreNotMutate(schema) {
+	return (schema.collectionActions ?? []).every((action) => action.kind !== "mutate");
 }
-function cacheDir() {
-	return node_path.default.join((0, node_os.tmpdir)(), "mulmoclaude-csv-utf8");
+/** 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 || require_calendarGrid.isSafeRecordId(schema.singleton);
 }
-/** 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 (0, node_fs_promises.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();
+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;
 }
-/** 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 (0, node_fs_promises.stat)(target);
-		return true;
-	} catch {
-		return false;
-	}
+/** 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 ?? ""));
 }
-/** 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 (0, node_fs_promises.readdir)(cacheDir());
-		await Promise.all(entries.filter((name) => name.startsWith(`${key}-`) && name !== keepBasename).map((name) => (0, node_fs_promises.unlink)(node_path.default.join(cacheDir(), name)).catch(() => void 0)));
-	} catch {}
+/** 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);
 }
-/** 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 = (0, node_crypto.createHash)("sha256").update(absPath).digest("hex").slice(0, 16);
-	const cached = node_path.default.join(cacheDir(), `${key}-${Math.trunc(info.mtimeMs)}-${info.size}.csv`);
-	if (!await pathExists(cached)) {
-		const whole = await (0, node_fs_promises.readFile)(absPath);
-		const encoding = fallbackEncoding(whole);
-		const text = iconv_lite.default.decode(whole, encoding);
-		await (0, node_fs_promises.mkdir)(cacheDir(), {
-			recursive: true,
-			mode: 448
-		});
-		const tmp = `${cached}.${(0, node_crypto.randomBytes)(4).toString("hex")}.tmp`;
-		await (0, node_fs_promises.writeFile)(tmp, text, {
-			encoding: "utf-8",
-			mode: 384
-		});
-		await (0, node_fs_promises.rename)(tmp, cached);
-		log.info("collections", "decoded non-UTF-8 dataSource file to cache", {
-			path: absPath,
-			encoding
-		});
-		await evictSupersededCache(key, node_path.default.basename(cached));
-	}
-	return cached;
+/** `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;
 }
-/** 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 (0, node_fs_promises.lstat)(absPath);
-	} catch (err) {
-		if (require_dist.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;
+/** 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 && !require_calendarGrid.COMPUTED_TYPES.has(target.type);
+	}));
 }
-/** 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);
+/** `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;
 }
-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`);
-	}
+/** 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);
 }
-async function queryCsv(sql, params) {
-	const connection = await (await duckDbInstance()).connect();
-	try {
-		return (await connection.runAndReadAll(sql, params)).getRowObjectsJS();
-	} finally {
-		connection.disconnectSync();
-	}
+/** 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)));
 }
-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
+/** 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");
 	});
-	return {
-		items: deduped.items,
-		truncated
-	};
 }
-/** 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)])));
+/** 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));
 }
-//#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 node_fs.realpathSync.native(dir);
-	} catch {
-		return dir;
+/** 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;
 }
-/** 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 (0, node_fs_promises.mkdir)(dir, { recursive: true });
-		const watcher = (0, node_fs.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;
-	}
+/** `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;
 }
-/** 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 = node_path.default.dirname(absPath);
-	const base = node_path.default.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();
-	} };
+/** `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";
 }
-/** 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/storePage.ts
-/** Project `fields` (+ the primary key, always) out of each record. Thin
-*  server-typed alias over the shared isomorphic `projectRecordFields`
-*  (../core/project.ts) — kept as the store layer's exported name. */
-function projectItemFields(items, fields, primaryKey) {
-	return require_project.projectRecordFields(items, fields, primaryKey);
+/** `triggerLeadDays` only means something relative to a trigger date. */
+function triggerLeadDaysRequiresTriggerField(schema) {
+	return schema.triggerLeadDays === void 0 || schema.triggerField !== void 0;
 }
-/** Slice + project an already-ordered full read into a `ListPage` — the
-*  shared emulation for stores without native paging. Pure, exported for
-*  tests. `limit: 0` is a valid "count only" page. */
-function pageFromFullRead(items, opts, primaryKey, truncated) {
-	const offset = Math.max(0, opts.offset ?? 0);
-	const end = opts.limit === void 0 ? items.length : offset + Math.max(0, opts.limit);
-	return {
-		items: projectItemFields(items.slice(offset, end), opts.fields, primaryKey),
-		total: items.length,
-		truncated
-	};
+/** `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;
 }
-//#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 require_dist.isRecord(mod) && typeof mod.DatabaseSync === "function";
+/** `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;
 }
-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}`);
+/** 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);
 }
-/** 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;
+/** 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);
 }
-/** 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 (0, node_fs_promises.lstat)(absPath)).isFile() ? "file" : "refused";
-	} catch (err) {
-		if (require_dist.isErrorWithCode(err) && err.code === "ENOENT") return "missing";
-		throw err;
-	}
+/** `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";
 }
-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(node_path.default.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 (0, node_fs_promises.mkdir)(node_path.default.dirname(absPath), { recursive: true });
-		if (!isContainedInRoot(node_path.default.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
-	};
+function fieldDrivenSpawnEvery(schema) {
+	const every = schema.spawn?.every;
+	if (!every || !("fromField" in every)) return null;
+	return every;
 }
-/** 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();
-	}
+/** §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";
 }
-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 (require_dist.hasNumberProp(err, "errcode")) return err.errcode === SQLITE_CONSTRAINT_PRIMARYKEY || err.errcode === SQLITE_CONSTRAINT_UNIQUE;
-	return String(err).includes("UNIQUE constraint");
+/** §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));
 }
-function parseRow(raw) {
-	if (typeof raw !== "string") return null;
-	try {
-		const parsed = JSON.parse(raw);
-		return require_dist.isRecord(parsed) ? parsed : null;
-	} catch {
-		return null;
+/** §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 = require_calendarGrid.fieldTextOrNull(raw);
+		return key !== null && Object.prototype.hasOwnProperty.call(driven.map, key);
 	}
+	return (carry ?? []).includes(driven.fromField);
 }
-/** 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 require_dist.isRecord(row) ? row[column] : void 0;
+/** `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);
 }
-function rowsToItems(rows) {
-	return rows.map((row) => parseRow(readColumn(row, "record"))).filter((item) => item !== null);
+/** `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;
 }
-/** 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})`);
+/** `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 sqliteList(absPath, workspaceRoot) {
-	return withDb(absPath, workspaceRoot, "read", () => [], (database) => rowsToItems(database.prepare("SELECT record FROM records ORDER BY id").all()));
+/** `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;
 }
-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
-		};
-	});
+/** `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;
 }
-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"));
-	});
+/** …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);
 }
-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 = require_calendarGrid.fieldText(left[primaryKey]);
-		const rightId = require_calendarGrid.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 !require_calendarGrid.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`;
+/** `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";
 }
-/** 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" }))) }
-	};
+/** `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;
 }
-/** 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)
-		})))
-	};
+/** `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;
 }
-var storeFactories = /* @__PURE__ */ new Map([
-	["file", fileStoreFor],
-	["csv", csvStoreFor],
-	["sqlite", sqliteStoreFor]
-]);
-/** 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 = require_calendarGrid.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);
+/** 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) => require_calendarGrid.isSafeSlug(view.id));
 }
-/** 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;
+/** 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/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 && !require_calendarGrid.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 || require_calendarGrid.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 && !require_calendarGrid.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 = require_calendarGrid.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) => require_calendarGrid.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
@@ -2356,15 +1453,19 @@ var DataSourceZ = zod.z.object({
 /** 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. v1: `sqlite` — records in a single SQLite database file
-*  (`node:sqlite`, one JSON record per row keyed by the primaryKey).
-*  `path` is workspace-relative and containment-checked exactly like
-*  `dataPath`. The store factory registry (`server/store.ts`) picks the
-*  implementation by `type` (plans/done/refactor-storage-virtualization.md). */
-var StorageZ = zod.z.object({
+*  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 = zod.z.discriminatedUnion("type", [zod.z.object({
 	type: zod.z.literal("sqlite"),
 	path: zod.z.string().min(1)
-});
+}), zod.z.object({ type: zod.z.literal("firestore") }).strict()]);
 var BareCollectionSchemaZ = zod.z.object({
 	title: zod.z.string().min(1),
 	icon: zod.z.string().min(1),
@@ -2526,302 +1627,1518 @@ function ownPrototypeKey(value) {
 	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 (require_dist.isUnknownArray(value)) return value.map((entry, index) => [String(index), entry]);
-	return require_dist.isRecord(value) ? Object.entries(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 (require_dist.isUnknownArray(value)) return value.map((entry, index) => [String(index), entry]);
+	return require_dist.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 require_dist.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 require_dist.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 (!require_dist.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 = zod.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 zod.z.NEVER;
+	}
+	return input;
+}, BareCollectionSchemaZ);
+//#endregion
+//#region src/collection/server/discovery.ts
+function applyFeedSchemaDefaults(parsed, slug) {
+	if (!require_dist.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 = node_path.default.join(skillsRoot, safeName, SCHEMA_FILE);
+	let raw;
+	try {
+		if (!(await (0, node_fs_promises.stat)(schemaPath)).isFile()) return null;
+		raw = await (0, node_fs_promises.readFile)(schemaPath, "utf-8");
+	} catch (err) {
+		if (!require_dist.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: node_path.default.join(skillsRoot, safeName)
+	};
+}
+async function collectFromDir(skillsRoot, source, workspaceRoot) {
+	let entries;
+	try {
+		entries = await (0, node_fs_promises.readdir)(skillsRoot);
+	} catch (err) {
+		if (require_dist.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 = node_path.default.join(skillsRoot, safeName);
+		let dirStat;
+		try {
+			dirStat = await (0, node_fs_promises.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 (0, node_fs_promises.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 require_dist.isRecord(parsed) ? parsed : null;
+}
+async function tryReadRecord(filePath) {
+	if (!await isRegularFile(filePath)) return null;
+	try {
+		return parseRecordJson(await (0, node_fs_promises.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 (0, node_fs_promises.readdir)(dataDir);
+	} catch (err) {
+		if (require_dist.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 = node_path.default.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 (0, node_fs_promises.readFile)(filePath, "utf-8"));
+	} catch (err) {
+		if (require_dist.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.
+*
+*  `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 (0, node_fs_promises.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 (0, node_fs_promises.open)(filePath, "wx");
+		} catch (err) {
+			if (require_dist.isErrorWithCode(err) && err.code === "EEXIST") return {
+				kind: "conflict",
+				itemId: safeId
+			};
+			throw err;
+		}
+		try {
+			await handle.writeFile(payload);
+		} finally {
+			await handle.close();
+		}
+	} else await require_root.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 (0, node_fs_promises.unlink)(filePath);
+		if (opts.slug) publishCollectionChange(collectionChangePayload({
+			slug: opts.slug,
+			ids: [safeId],
+			op: "delete"
+		}, opts.workspaceRoot));
+		return {
+			kind: "ok",
+			itemId: safeId
+		};
+	} catch (err) {
+		if (require_dist.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 (0, node_crypto.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 = zod.z.object({
+	op: zod.z.enum([
+		"count",
+		"sum",
+		"avg",
+		"min",
+		"max"
+	]),
+	column: zod.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 = zod.z.object({
+	field: zod.z.string().min(1),
+	op: zod.z.enum([
+		"eq",
+		"ne",
+		"in",
+		"gt",
+		"gte",
+		"lt",
+		"lte",
+		"contains"
+	]),
+	value: zod.z.union([
+		zod.z.string(),
+		zod.z.number(),
+		zod.z.boolean(),
+		zod.z.array(zod.z.union([
+			zod.z.string(),
+			zod.z.number(),
+			zod.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 = zod.z.object({
+	/** A `groupBy` column or an aggregate alias — membership enforced by
+	*  the whole-query refine below. */
+	field: zod.z.string().min(1),
+	dir: zod.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 = zod.z.object({
+	groupBy: zod.z.array(zod.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: zod.z.record(zod.z.string().regex(SAFE_ALIAS_PATTERN, "aggregate aliases must be simple identifiers (letters/digits/underscore)"), QueryAggregateZ).optional(),
+	where: zod.z.array(QueryWhereZ).max(16).optional(),
+	orderBy: zod.z.array(QueryOrderZ).max(4).optional(),
+	limit: zod.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;
+}
+/** 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)
+	};
+}
+/** Compile against a CSV file (the dataSource store's engine). */
+function compileCsvQuery(query, primaryKey) {
+	return compileQuery(query, `read_csv(${readCsvArgs(primaryKey)})`);
+}
+/** 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);
+	}
+}
+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 = require_calendarGrid.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 node_path.default.join((0, node_os.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 (0, node_fs_promises.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 (0, node_fs_promises.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 (0, node_fs_promises.readdir)(cacheDir());
+		await Promise.all(entries.filter((name) => name.startsWith(`${key}-`) && name !== keepBasename).map((name) => (0, node_fs_promises.unlink)(node_path.default.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 = (0, node_crypto.createHash)("sha256").update(absPath).digest("hex").slice(0, 16);
+	const cached = node_path.default.join(cacheDir(), `${key}-${Math.trunc(info.mtimeMs)}-${info.size}.csv`);
+	if (!await pathExists(cached)) {
+		const whole = await (0, node_fs_promises.readFile)(absPath);
+		const encoding = fallbackEncoding(whole);
+		const text = iconv_lite.default.decode(whole, encoding);
+		await (0, node_fs_promises.mkdir)(cacheDir(), {
+			recursive: true,
+			mode: 448
+		});
+		const tmp = `${cached}.${(0, node_crypto.randomBytes)(4).toString("hex")}.tmp`;
+		await (0, node_fs_promises.writeFile)(tmp, text, {
+			encoding: "utf-8",
+			mode: 384
+		});
+		await (0, node_fs_promises.rename)(tmp, cached);
+		log.info("collections", "decoded non-UTF-8 dataSource file to cache", {
+			path: absPath,
+			encoding
+		});
+		await evictSupersededCache(key, node_path.default.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 (0, node_fs_promises.lstat)(absPath);
+	} catch (err) {
+		if (require_dist.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`);
+	}
+}
+async function queryCsv(sql, params) {
+	const connection = await (await duckDbInstance()).connect();
+	try {
+		return (await connection.runAndReadAll(sql, params)).getRowObjectsJS();
+	} finally {
+		connection.disconnectSync();
+	}
+}
+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
+	};
+}
+/** 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);
 }
-/** 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 require_dist.isRecord(holder) ? holder[key] : 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)])));
 }
-/** 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 require_dist.isUnknownArray(list) ? list : []) {
-		const badParam = ownPrototypeKey(nameDefiningSubRecord(action, "params"));
-		if (badParam !== null) return `${listName}.params.${badParam}`;
+//#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 node_fs.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 (0, node_fs_promises.mkdir)(dir, { recursive: true });
+		const watcher = (0, node_fs.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 = node_path.default.dirname(absPath);
+	const base = node_path.default.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 require_dist.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 (0, node_fs_promises.lstat)(absPath)).isFile() ? "file" : "refused";
+	} catch (err) {
+		if (require_dist.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(node_path.default.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 (0, node_fs_promises.mkdir)(node_path.default.dirname(absPath), { recursive: true });
+		if (!isContainedInRoot(node_path.default.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 (require_dist.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 require_dist.isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
 	}
-	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 (!require_dist.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);
+/** 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 require_dist.isRecord(row) ? row[column] : void 0;
 }
-var CollectionSchemaZ = zod.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 zod.z.NEVER;
-	}
-	return input;
-}, BareCollectionSchemaZ);
-//#endregion
-//#region src/collection/server/discovery.ts
-function applyFeedSchemaDefaults(parsed, slug) {
-	if (!require_dist.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}`
-	};
+function rowsToItems(rows) {
+	return rows.map((row) => parseRow(readColumn(row, "record"))).filter((item) => item !== null);
 }
-/** 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`;
+/** 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})`);
 }
-/** 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;
+async function sqliteList(absPath, workspaceRoot) {
+	return withDb(absPath, workspaceRoot, "read", () => [], (database) => rowsToItems(database.prepare("SELECT record FROM records ORDER BY id").all()));
 }
-/** 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 sqlitePage(absPath, primaryKey, opts, workspaceRoot) {
+	const emptyPage = {
+		items: [],
+		total: 0,
+		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`
-		};
+	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 {
-			ok: true,
-			dataDir,
-			dataSourceFile
-		};
-	}
-	if (schema.storage !== void 0) {
-		const storageFile = resolveDataDir(schema.storage.path, opts.workspaceRoot);
-		if (storageFile === null) return {
-			ok: false,
-			reason: `storage.path '${schema.storage.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`
+			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 {
-			ok: true,
-			dataDir,
-			storageFile
+			kind: "ok",
+			itemId: safeId,
+			item
 		};
-	}
-	const dataDir = resolveDataDir(schema.dataPath ?? "", opts.workspaceRoot);
-	if (dataDir === null) return {
-		ok: false,
-		reason: `dataPath '${schema.dataPath}' escapes the workspace`
-	};
-	return {
-		ok: true,
-		dataDir
-	};
-}
-async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
-	const safeName = safeSlugName(slug);
-	if (safeName === null) return null;
-	const schemaPath = node_path.default.join(skillsRoot, safeName, SCHEMA_FILE);
-	let raw;
-	try {
-		if (!(await (0, node_fs_promises.stat)(schemaPath)).isFile()) return null;
-		raw = await (0, node_fs_promises.readFile)(schemaPath, "utf-8");
-	} catch (err) {
-		if (!require_dist.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 } : {},
-		skillDir: node_path.default.join(skillsRoot, safeName)
+	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 (0, node_fs_promises.readdir)(skillsRoot);
-	} catch (err) {
-		if (require_dist.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 = node_path.default.join(skillsRoot, safeName);
-		let dirStat;
+		const { DatabaseSync } = await loadSqlite();
+		const database = new DatabaseSync(absPath);
 		try {
-			dirStat = await (0, node_fs_promises.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 = require_calendarGrid.fieldText(left[primaryKey]);
+		const rightId = require_calendarGrid.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 !require_calendarGrid.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 } : {}
+		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 = require_calendarGrid.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
+Object.defineProperty(exports, "APP_MANIFEST_FILE", {
+	enumerable: true,
+	get: function() {
+		return APP_MANIFEST_FILE;
+	}
+});
 Object.defineProperty(exports, "BackendUnavailableError", {
 	enumerable: true,
 	get: function() {
@@ -2876,6 +3193,12 @@ Object.defineProperty(exports, "acceptParsedSchema", {
 		return acceptParsedSchema;
 	}
 });
+Object.defineProperty(exports, "appManifestReason", {
+	enumerable: true,
+	get: function() {
+		return appManifestReason;
+	}
+});
 Object.defineProperty(exports, "archiveDir", {
 	enumerable: true,
 	get: function() {
@@ -2984,6 +3307,12 @@ Object.defineProperty(exports, "encodeCsvRecordId", {
 		return encodeCsvRecordId;
 	}
 });
+Object.defineProperty(exports, "firestoreHandle", {
+	enumerable: true,
+	get: function() {
+		return firestoreHandle;
+	}
+});
 Object.defineProperty(exports, "generateItemId", {
 	enumerable: true,
 	get: function() {
@@ -3032,6 +3361,12 @@ Object.defineProperty(exports, "listItems", {
 		return listItems;
 	}
 });
+Object.defineProperty(exports, "loadAppManifest", {
+	enumerable: true,
+	get: function() {
+		return loadAppManifest;
+	}
+});
 Object.defineProperty(exports, "loadCollection", {
 	enumerable: true,
 	get: function() {
@@ -3062,6 +3397,12 @@ Object.defineProperty(exports, "pageFromFullRead", {
 		return pageFromFullRead;
 	}
 });
+Object.defineProperty(exports, "parseAppManifest", {
+	enumerable: true,
+	get: function() {
+		return parseAppManifest;
+	}
+});
 Object.defineProperty(exports, "peekWorkspaceRoot", {
 	enumerable: true,
 	get: function() {
@@ -3152,12 +3493,24 @@ Object.defineProperty(exports, "setCollectionChangePublisher", {
 		return setCollectionChangePublisher;
 	}
 });
+Object.defineProperty(exports, "setFirestoreAccessor", {
+	enumerable: true,
+	get: function() {
+		return setFirestoreAccessor;
+	}
+});
 Object.defineProperty(exports, "sharedCollectionChangePayload", {
 	enumerable: true,
 	get: function() {
 		return sharedCollectionChangePayload;
 	}
 });
+Object.defineProperty(exports, "sharedItemsPath", {
+	enumerable: true,
+	get: function() {
+		return sharedItemsPath;
+	}
+});
 Object.defineProperty(exports, "skillsStagingDir", {
 	enumerable: true,
 	get: function() {
@@ -3195,4 +3548,4 @@ Object.defineProperty(exports, "writeItem", {
 	}
 });
 
-//# sourceMappingURL=discovery-Ck4AqikY.cjs.map
+//# sourceMappingURL=store-5_P_NsGa.cjs.map