@mulmoclaude/core 3.5.0 → 3.7.0

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

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