@mulmoclaude/core 3.5.0 → 3.6.0

package/dist/{discovery-DH9wweuj.js → discovery-CdkaURVY.js}

@@ -1,9 +1,9 @@
 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";
@@ -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,6 +333,280 @@ function resolveTemplatePath(skillDir, templateRelPath) {
 	return resolved;
 }
 //#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);
+}
+/** 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
+	};
+}
+//#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 {
+		return await run();
+	} catch (err) {
+		if (!isPermissionDenied(err)) throw err;
+		throw new BackendUnavailableError(deniedMessage(key, email));
+	}
+}
+/** A stored document's fields → a record. A document written by hand (or by an
+*  older version) can hold anything, so a non-object is dropped rather than
+*  surfaced as a broken record — the same fail-soft the file store applies to
+*  an unparseable `.json`. */
+function toItem(data) {
+	return 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 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
+	};
+}
+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))));
+}
+/** Publish the "records changed" ping for a shared collection.
+*
+*  `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
+	}), 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
+			};
+		} 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 firestoreDelete(key, itemId, opts) {
+	return withSafeId(itemId, () => Promise.resolve({
+		kind: "invalid-id",
+		itemId
+	}), 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 {
+			ok: false,
+			kind: "missing"
+		};
+		return {
+			ok: false,
+			kind: "unreadable",
+			detail: String(err)
+		};
+	}
+	return parseAppManifest(raw);
+}
+/** 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 {
+			ok: false,
+			kind: "malformed",
+			detail: `not valid JSON (${String(err)})`
+		};
+	}
+	if (!isRecord(parsed)) return {
+		ok: false,
+		kind: "malformed",
+		detail: "is not a JSON object"
+	};
+	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`
+	};
+	return {
+		ok: true,
+		manifest: { aid }
+	};
+}
+/** 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}`;
+}
+//#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
@@ -523,18 +829,6 @@ function resolveCreateItemId(schema, record) {
 	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
@@ -1128,26 +1422,6 @@ 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);
-}
-/** 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
-	};
-}
-//#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
@@ -1497,7 +1771,8 @@ function fileStoreFor(collection, opts) {
 var storeFactories = /* @__PURE__ */ new Map([
 	["file", fileStoreFor],
 	["csv", csvStoreFor],
-	["sqlite", sqliteStoreFor]
+	["sqlite", sqliteStoreFor],
+	["firestore", firestoreStoreFor]
 ]);
 /** Pick the store implementation for a discovered collection via the
 *  factory registry. An unknown kind cannot normally reach here (the
@@ -2353,15 +2628,19 @@ var DataSourceZ = z.object({
 /** Alternative WRITABLE storage backend for a collection's records —
 *  unlike `dataSource` (external read-only file), a `storage` collection
 *  behaves like a normal writable collection; only where the rows live
-*  changes. v1: `sqlite` — records in a single SQLite database file
-*  (`node:sqlite`, one JSON record per row keyed by the primaryKey).
-*  `path` is workspace-relative and containment-checked exactly like
-*  `dataPath`. The store factory registry (`server/store.ts`) picks the
-*  implementation by `type` (plans/done/refactor-storage-virtualization.md). */
-var StorageZ = z.object({
+*  changes. The store factory registry (`server/store.ts`) picks the
+*  implementation by `type` (plans/done/refactor-storage-virtualization.md).
+*
+*  A discriminated union rather than one shape with optional keys, because
+*  only the sqlite variant is a workspace FILE: its `path` is
+*  workspace-relative and containment-checked exactly like `dataPath`, while
+*  the firestore variant has no path to check — its records are not on this
+*  machine at all. Optional keys would let each arm accept the other's, and
+*  the compiler would stop being the thing that tells you which. */
+var StorageZ = 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),
@@ -2647,16 +2926,45 @@ function acceptParsedSchema(schema, opts) {
 			dataSourceFile
 		};
 	}
-	if (schema.storage !== void 0) {
-		const storageFile = resolveDataDir(schema.storage.path, opts.workspaceRoot);
+	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 '${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`
+			reason: `storage.path '${storage.path}' escapes the workspace`
 		};
 		return {
 			ok: true,
@@ -2664,14 +2972,15 @@ function acceptParsedSchema(schema, opts) {
 			storageFile
 		};
 	}
-	const dataDir = resolveDataDir(schema.dataPath ?? "", opts.workspaceRoot);
-	if (dataDir === null) return {
+	const manifest = loadAppManifest(opts.workspaceRoot);
+	if (!manifest.ok) return {
 		ok: false,
-		reason: `dataPath '${schema.dataPath}' escapes the workspace`
+		reason: appManifestReason(manifest, opts.workspaceRoot)
 	};
 	return {
 		ok: true,
-		dataDir
+		dataDir,
+		appId: manifest.manifest.aid
 	};
 }
 async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
@@ -2729,6 +3038,7 @@ async function loadOneCollection(skillsRoot, slug, source, workspaceRoot) {
 		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)
 	};
 }
@@ -2809,7 +3119,8 @@ function toSummary(collection) {
 		title: collection.schema.title,
 		icon: collection.schema.icon,
 		source: collection.source,
-		...collection.schema.dataSource !== void 0 ? { readonly: true } : {}
+		...collection.schema.dataSource !== void 0 ? { readonly: true } : {},
+		...collection.appId !== void 0 ? { appId: collection.appId } : {}
 	};
 }
 function toDetail(collection) {
@@ -2819,6 +3130,6 @@ function toDetail(collection) {
 	};
 }
 //#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 $, readItem as A, SCHEMA_FILE as B, CollectionQueryZ as C, generateItemId as D, deleteItem as E, loadAppManifest as F, safeRecordId as G, itemFilePath as H, parseAppManifest as I, isBackendUnavailable as J, safeSlugName as K, sharedItemsPath as L, writeItem as M, APP_MANIFEST_FILE as N, isRegularFile as O, appManifestReason as P, collectionChangePayload as Q, pageFromFullRead as R, compileJsonlQuery as S, MAX_QUERY_ROWS as T, resolveDataDir as U, isContainedInRoot as V, resolveTemplatePath as W, archiveDir as X, COLLECTION_ROOT_REQUIRED as Y, collectionChangeKey as Z, dedupeByRecordId as _, toDetail as a, log as at, queryCsv as b, resolveMutateSet as c, publishCollectionChange as ct, storeFor as d, sharedCollectionChangePayload as dt, configureCollectionHost as et, checkpointSqliteDatabase as f, skillsStagingDir as ft, decodeCsvRecordId as g, csvRowToItem as h, createHostSlot as ht, resolvePrimaryField as i, localCollectionKey as it, resolveCreateItemId as j, listItems as k, collectionWritable as l, setCollectionChangePublisher as lt, cacheDir as m, createForwardingLogger as mt, discoverCollections as n, getWorkspaceRoot as nt, toSummary as o, peekWorkspaceRoot as ot, MAX_CSV_ROWS as p, stagingSkillDir as pt, BackendUnavailableError as q, loadCollection as r, isPresetSlug as rt, CollectionSchemaZ as s, projectSkillsDir as st, acceptParsedSchema as t, firestoreHandle as tt, readOnlyRefusal as u, setFirestoreAccessor as ut, encodeCsvRecordId as v, DEFAULT_QUERY_ROWS as w, compileCsvQuery as x, normalizeCsvValue as y, projectItemFields as z };
 
-//# sourceMappingURL=discovery-DH9wweuj.js.map
+//# sourceMappingURL=discovery-CdkaURVY.js.map