@mulmoclaude/core 3.5.0 → 3.6.0

package/dist/collection/firestore.js

@@ -0,0 +1,50 @@
+import { collection, doc, getDoc, getDocs, orderBy, query, runTransaction, setDoc } from "firebase/firestore";
+//#region src/collection/server/firestoreDocs.ts
+/** The real implementation over the modular SDK.
+*
+*  THE RECORD IS THE DOCUMENT. Its fields are written at the top level, not
+*  nested under a `data` key. This is not a matter of taste: the deployed
+*  security rules read `request.resource.data.<field>` and
+*  `resource.data[submit.emailField]` — a wrapper would put every field one
+*  level down, so the required-field checks, the status state machine and the
+*  "your own row" predicate would all read absent values and fail closed. A
+*  shared record's shape is part of the authorization contract.
+*
+*  `orderBy("__name__")` orders by DOCUMENT ID. Ordering by a record field
+*  would silently EXCLUDE documents missing that field (the trap
+*  `remote-host/server/hostRunner.ts:158-169` documents), turning a read into a
+*  partial one; the document id is always present and gives the stable order
+*  the store contract requires. */
+function createFirestoreDocs(database) {
+	return {
+		list: async (collectionPath) => {
+			return (await getDocs(query(collection(database, collectionPath), orderBy("__name__")))).docs.map((entry) => ({
+				id: entry.id,
+				data: entry.data()
+			}));
+		},
+		get: async (collectionPath, docId) => {
+			const snapshot = await getDoc(doc(database, collectionPath, docId));
+			return snapshot.exists() ? snapshot.data() : null;
+		},
+		set: async (collectionPath, docId, data) => {
+			await setDoc(doc(database, collectionPath, docId), data);
+		},
+		create: (collectionPath, docId, data) => runTransaction(database, async (transaction) => {
+			const ref = doc(database, collectionPath, docId);
+			if ((await transaction.get(ref)).exists()) return false;
+			transaction.set(ref, data);
+			return true;
+		}),
+		delete: (collectionPath, docId) => runTransaction(database, async (transaction) => {
+			const ref = doc(database, collectionPath, docId);
+			if (!(await transaction.get(ref)).exists()) return false;
+			transaction.delete(ref);
+			return true;
+		})
+	};
+}
+//#endregion
+export { createFirestoreDocs };
+
+//# sourceMappingURL=firestore.js.map

package/dist/collection/firestore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.js","names":[],"sources":["../../src/collection/server/firestoreDocs.ts"],"sourcesContent":["// The seam between the firestore store and the Firestore SDK.\n//\n// The modular SDK is function-based (`getDocs(query(collection(db, …)))`), so a\n// store that imported those functions directly could not be tested without a\n// real backend — a fake `db` would still be handed to the real functions.\n// Narrowing to this interface makes the backend swappable: core ships\n// `createFirestoreDocs` over the real SDK, and the tests inject an in-memory\n// fake that satisfies the same shape. That is what lets this repository's tests\n// run with no API key and no network.\n//\n// Deliberately minimal and id-keyed: no query builder, no field ordering, no\n// cursors. Everything the store needs is \"the documents of one collection path,\n// ordered by document id\" — see the store header for why field ordering is\n// avoided entirely.\n//\n// The collection path is an ARGUMENT, not something this module composes. It\n// owns the SDK calls; `firestoreStore` owns where the documents live.\n\nimport {\n  collection as firestoreCollection,\n  doc,\n  getDoc,\n  getDocs,\n  orderBy,\n  query as firestoreQuery,\n  runTransaction,\n  setDoc,\n  type Firestore,\n} from \"firebase/firestore\";\n\n/** One stored record document. `data` is the document's own fields — the\n *  record itself, not a wrapper around it; see `set` below. The store\n *  validates its shape, because a document written by hand could be\n *  anything. */\nexport interface FirestoreDoc {\n  id: string;\n  data: unknown;\n}\n\nexport interface FirestoreDocs {\n  /** Every document under `collectionPath`, ordered by document id. */\n  list: (collectionPath: string) => Promise<FirestoreDoc[]>;\n  /** One document's fields, or null when it doesn't exist. */\n  get: (collectionPath: string, docId: string) => Promise<unknown | null>;\n  /** Create or replace. */\n  set: (collectionPath: string, docId: string, data: Record<string, unknown>) => Promise<void>;\n  /** Create only. Returns false when the id already exists — atomic, so two\n   *  concurrent creates can't both observe \"missing\". */\n  create: (collectionPath: string, docId: string, data: Record<string, unknown>) => Promise<boolean>;\n  /** Delete. Returns false when the id didn't exist, so a caller can tell a\n   *  real delete from a typo'd id. */\n  delete: (collectionPath: string, docId: string) => Promise<boolean>;\n}\n\n/** The real implementation over the modular SDK.\n *\n *  THE RECORD IS THE DOCUMENT. Its fields are written at the top level, not\n *  nested under a `data` key. This is not a matter of taste: the deployed\n *  security rules read `request.resource.data.<field>` and\n *  `resource.data[submit.emailField]` — a wrapper would put every field one\n *  level down, so the required-field checks, the status state machine and the\n *  \"your own row\" predicate would all read absent values and fail closed. A\n *  shared record's shape is part of the authorization contract.\n *\n *  `orderBy(\"__name__\")` orders by DOCUMENT ID. Ordering by a record field\n *  would silently EXCLUDE documents missing that field (the trap\n *  `remote-host/server/hostRunner.ts:158-169` documents), turning a read into a\n *  partial one; the document id is always present and gives the stable order\n *  the store contract requires. */\nexport function createFirestoreDocs(database: Firestore): FirestoreDocs {\n  return {\n    list: async (collectionPath) => {\n      const snapshot = await getDocs(firestoreQuery(firestoreCollection(database, collectionPath), orderBy(\"__name__\")));\n      return snapshot.docs.map((entry) => ({ id: entry.id, data: entry.data() }));\n    },\n    get: async (collectionPath, docId) => {\n      const snapshot = await getDoc(doc(database, collectionPath, docId));\n      return snapshot.exists() ? snapshot.data() : null;\n    },\n    set: async (collectionPath, docId, data) => {\n      await setDoc(doc(database, collectionPath, docId), data);\n    },\n    create: (collectionPath, docId, data) =>\n      runTransaction(database, async (transaction) => {\n        const ref = doc(database, collectionPath, docId);\n        const existing = await transaction.get(ref);\n        if (existing.exists()) return false;\n        transaction.set(ref, data);\n        return true;\n      }),\n    // Firestore's deleteDoc succeeds on a missing document, so an existence\n    // check is what makes \"deleted\" distinguishable from \"there was nothing\".\n    // It runs INSIDE the transaction (like `create`): a plain get-then-delete\n    // would report `true` for a document a concurrent client had already\n    // removed, i.e. claim a delete this call never performed.\n    delete: (collectionPath, docId) =>\n      runTransaction(database, async (transaction) => {\n        const ref = doc(database, collectionPath, docId);\n        const existing = await transaction.get(ref);\n        if (!existing.exists()) return false;\n        transaction.delete(ref);\n        return true;\n      }),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAqEA,SAAgB,oBAAoB,UAAoC;CACtE,OAAO;EACL,MAAM,OAAO,mBAAmB;GAE9B,QAAO,MADgB,QAAQ,MAAe,WAAoB,UAAU,cAAc,GAAG,QAAQ,UAAU,CAAC,CAAC,EAAA,CACjG,KAAK,KAAK,WAAW;IAAE,IAAI,MAAM;IAAI,MAAM,MAAM,KAAK;GAAE,EAAE;EAC5E;EACA,KAAK,OAAO,gBAAgB,UAAU;GACpC,MAAM,WAAW,MAAM,OAAO,IAAI,UAAU,gBAAgB,KAAK,CAAC;GAClE,OAAO,SAAS,OAAO,IAAI,SAAS,KAAK,IAAI;EAC/C;EACA,KAAK,OAAO,gBAAgB,OAAO,SAAS;GAC1C,MAAM,OAAO,IAAI,UAAU,gBAAgB,KAAK,GAAG,IAAI;EACzD;EACA,SAAS,gBAAgB,OAAO,SAC9B,eAAe,UAAU,OAAO,gBAAgB;GAC9C,MAAM,MAAM,IAAI,UAAU,gBAAgB,KAAK;GAE/C,KAAI,MADmB,YAAY,IAAI,GAAG,EAAA,CAC7B,OAAO,GAAG,OAAO;GAC9B,YAAY,IAAI,KAAK,IAAI;GACzB,OAAO;EACT,CAAC;EAMH,SAAS,gBAAgB,UACvB,eAAe,UAAU,OAAO,gBAAgB;GAC9C,MAAM,MAAM,IAAI,UAAU,gBAAgB,KAAK;GAE/C,IAAI,EAAC,MADkB,YAAY,IAAI,GAAG,EAAA,CAC5B,OAAO,GAAG,OAAO;GAC/B,YAAY,OAAO,GAAG;GACtB,OAAO;EACT,CAAC;CACL;AACF"}

package/dist/collection/registry/server/index.cjs

@@ -4,9 +4,9 @@ const require_dist = require("../../../dist-CsgSfWwR.cjs");
 const require_root = require("../../../root-rPH6FGDT.cjs");
 const require_relPath = require("../../../relPath-CTAjGdCL.cjs");
 const require_utils_fetch = require("../../../utils/fetch.cjs");
-const require_discovery = require("../../../discovery-Ck4AqikY.cjs");
+const require_discovery = require("../../../discovery-Cw5xWzZD.cjs");
 const require_templatePath = require("../../../templatePath-27vUZowm.cjs");
-const require_server = require("../../../server-5EMj3naj.cjs");
+const require_server = require("../../../server-9mFaGLdq.cjs");
 const require_skill_bridge_index = require("../../../skill-bridge/index.cjs");
 const require_types = require("../../../types-CNqkLT4M.cjs");
 let node_fs = require("node:fs");

package/dist/collection/registry/server/index.js

@@ -2,9 +2,9 @@ import { t as errorMessage } from "../../../dist-D8zokgGo.js";
 import { n as writeFileAtomic } from "../../../root-BMroU_mB.js";
 import { n as toPosixRelPath } from "../../../relPath-DW8MC8VO.js";
 import { fetchWithTimeout } from "../../../utils/fetch.js";
-import { $ as log, H as safeRecordId, J as collectionsRegistriesConfigPath, X as getWorkspaceRoot, at as skillsStagingDir, r as loadCollection, s as CollectionSchemaZ, t as acceptParsedSchema, tt as projectSkillsDir } from "../../../discovery-DH9wweuj.js";
+import { $ as collectionsRegistriesConfigPath, G as safeRecordId, at as log, ft as skillsStagingDir, nt as getWorkspaceRoot, r as loadCollection, s as CollectionSchemaZ, st as projectSkillsDir, t as acceptParsedSchema } from "../../../discovery-CdkaURVY.js";
 import { t as isSafeActionTemplatePath } from "../../../templatePath-k_WNbL_Q.js";
-import { g as ONE_SECOND_MS } from "../../../server-BiRLLMpW.js";
+import { g as ONE_SECOND_MS } from "../../../server-DdHaX_Uu.js";
 import { claudeSkillDir, dataSkillDir, mirrorSkillWrite } from "../../../skill-bridge/index.js";
 import { n as parseRegistryIndex, r as isRecord, t as OFFICIAL_REGISTRY_NAME } from "../../../types-BKVZrtyc.js";
 import { readFileSync } from "node:fs";

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

@@ -0,0 +1,53 @@
+/** The app declaration's filename, at the repository root. */
+export declare const APP_MANIFEST_FILE = "app.json";
+/** What this step reads out of `app.json`. Deliberately one field: every key
+ *  added here is a key `publish` and this loader could disagree about. */
+export interface AppManifest {
+    /** The app id — the `{aid}` in `apps/{aid}/collections/{cid}/items`. */
+    aid: string;
+}
+/** Why a root has no usable `aid`. Returned rather than thrown because the
+ *  caller is an acceptance gate whose whole job is to turn this into a
+ *  one-line reason a collection was skipped. */
+export type AppManifestFailure = {
+    kind: "missing";
+} | {
+    kind: "unreadable";
+    detail: string;
+} | {
+    kind: "malformed";
+    detail: string;
+};
+export type AppManifestResult = {
+    ok: true;
+    manifest: AppManifest;
+} | ({
+    ok: false;
+} & AppManifestFailure);
+/** 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. */
+export declare function loadAppManifest(root: string): AppManifestResult;
+/** 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. */
+export declare function parseAppManifest(raw: string): AppManifestResult;
+/** 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. */
+export declare function appManifestReason(failure: AppManifestFailure, root: string): string;

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

@@ -15,6 +15,16 @@ export type DeleteCollectionResult = {
 } | {
     kind: "path-escape";
     slug: string;
+}
+/** A `storage: firestore` collection: its records are documents of a SHARED
+ *  app, which this delete can neither archive nor remove. Deleting the skill
+ *  would leave them in `apps/{aid}/collections/{cid}/items` with no
+ *  collection left to reach them through — and they are not only this
+ *  machine's: other members' live views are served from the same documents.
+ *  Refused outright rather than done partially. */
+ | {
+    kind: "unsupported-backend";
+    slug: string;
 };
 type DeleteRefusal = Exclude<DeleteCollectionResult, {
     kind: "ok";

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

@@ -24,6 +24,16 @@ export interface LoadedCollection {
      *  `storage.path`, e.g. a SQLite database — same containment as dataDir).
      *  Present iff the schema declares `storage`. */
     storageFile?: string;
+    /** The app id this collection's records belong to, from the repository's
+     *  `app.json`. Present iff the schema declares `storage.type: "firestore"` —
+     *  a shared collection's identity is `(appId, slug)`, and the store builds
+     *  `apps/{appId}/collections/{slug}/items` from it.
+     *
+     *  Resolved by discovery, exactly like `storageFile`, so the identity is
+     *  settled ONCE and the store never reads `app.json` on a read path. Absent
+     *  is not a fallback: a firestore schema whose root declares no `aid` is
+     *  REFUSED at discovery, so this is present whenever the backend needs it. */
+    appId?: string;
     /** Absolute path to the skill directory this collection was loaded from
      *  (`<skillsRoot>/<slug>/`). Action templates are read from here, path-safely. */
     skillDir: string;

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

@@ -10,6 +10,7 @@ export type SchemaAcceptance = {
     dataDir: string;
     dataSourceFile?: string;
     storageFile?: string;
+    appId?: string;
 } | {
     ok: false;
     reason: string;

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

@@ -0,0 +1,39 @@
+import { Firestore } from 'firebase/firestore';
+/** One stored record document. `data` is the document's own fields — the
+ *  record itself, not a wrapper around it; see `set` below. The store
+ *  validates its shape, because a document written by hand could be
+ *  anything. */
+export interface FirestoreDoc {
+    id: string;
+    data: unknown;
+}
+export interface FirestoreDocs {
+    /** Every document under `collectionPath`, ordered by document id. */
+    list: (collectionPath: string) => Promise<FirestoreDoc[]>;
+    /** One document's fields, or null when it doesn't exist. */
+    get: (collectionPath: string, docId: string) => Promise<unknown | null>;
+    /** Create or replace. */
+    set: (collectionPath: string, docId: string, data: Record<string, unknown>) => Promise<void>;
+    /** Create only. Returns false when the id already exists — atomic, so two
+     *  concurrent creates can't both observe "missing". */
+    create: (collectionPath: string, docId: string, data: Record<string, unknown>) => Promise<boolean>;
+    /** Delete. Returns false when the id didn't exist, so a caller can tell a
+     *  real delete from a typo'd id. */
+    delete: (collectionPath: string, docId: string) => Promise<boolean>;
+}
+/** The real implementation over the modular SDK.
+ *
+ *  THE RECORD IS THE DOCUMENT. Its fields are written at the top level, not
+ *  nested under a `data` key. This is not a matter of taste: the deployed
+ *  security rules read `request.resource.data.<field>` and
+ *  `resource.data[submit.emailField]` — a wrapper would put every field one
+ *  level down, so the required-field checks, the status state machine and the
+ *  "your own row" predicate would all read absent values and fail closed. A
+ *  shared record's shape is part of the authorization contract.
+ *
+ *  `orderBy("__name__")` orders by DOCUMENT ID. Ordering by a record field
+ *  would silently EXCLUDE documents missing that field (the trap
+ *  `remote-host/server/hostRunner.ts:158-169` documents), turning a read into a
+ *  partial one; the document id is always present and gives the stable order
+ *  the store contract requires. */
+export declare function createFirestoreDocs(database: Firestore): FirestoreDocs;

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

@@ -0,0 +1,14 @@
+import { SharedCollectionKey } from '../core/collectionKey';
+import { LoadedCollection } from './discoveredCollection';
+import { IoOptions } from './io';
+import { CollectionStore } from './store';
+/** 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. */
+export declare function sharedItemsPath(key: SharedCollectionKey): string;
+/** The store factory registered for `storage.type === "firestore"`.
+ *  Synchronous and connection-agnostic by contract — see the header. */
+export declare function firestoreStoreFor(collection: LoadedCollection, opts: IoOptions): CollectionStore;

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

@@ -1,6 +1,7 @@
 import { canonicalRoot } from '../../files/root.js';
 import { CollectionKey } from '../core/collectionKey.js';
 import { StructuredLogger } from '../../host/hostSlot.js';
+import { FirestoreDocs } from './firestoreDocs';
 /** Public alias of the shared `StructuredLogger` — keeps the domain surface name-stable. */
 export type CollectionLogger = StructuredLogger;
 /** Re-exported so collection-engine callers (the watcher, the reconciler) keep
@@ -96,6 +97,31 @@ export interface CollectionHost {
     /** True for a preset-skill slug (host-owned naming convention). */
     isPresetSlug: (slug: string) => boolean;
 }
+/** The authenticated Firestore access a shared collection is served through.
+ *
+ *  It carries NO uid, and that is a decision rather than an omission. Nothing
+ *  about a shared collection is keyed by uid any more: the documents live at
+ *  `apps/{aid}/collections/{cid}/items`, and the deployed rules authorize on
+ *  `request.auth.token.email` against the app's member roster. A uid kept
+ *  "just for identity" would be a value nothing checks, sitting next to a path
+ *  it no longer determines — which is how a later reader ends up deriving a
+ *  path from it again.
+ *
+ *  `email` is what the rules actually evaluate, so it is what makes a refusal
+ *  explainable: `permission-denied` is the most common failure a shared
+ *  collection has and the least informative, and naming the principal turns it
+ *  into "signed in as a@b — this app's roster may not list you". A session with
+ *  no verified email is NOT a session here (the accessor answers null): public
+ *  anonymous submission is a visitor's path through the published web app, not
+ *  the host's.
+ *
+ *  `docs` is the narrow document interface rather than a raw `Firestore` so the
+ *  backend stays testable: core ships `createFirestoreDocs` over the real SDK
+ *  (`firestoreDocs.ts`) and tests inject an in-memory fake. */
+export interface FirestoreHandle {
+    docs: FirestoreDocs;
+    email: string;
+}
 /** A collection's records changed on disk. Carries the `slug` so the host can
  *  publish on a per-collection channel; `ids` lists the affected record ids
  *  when known (a consumer may ignore them and refetch the whole collection),
@@ -173,6 +199,21 @@ export declare function setCollectionChangePublisher(publish: CollectionChangePu
  *  expected to be fire-and-forget (it wraps its own pubsub call in try/catch),
  *  so this stays a thin pass-through and never throws into the write. */
 export declare function publishCollectionChange(payload: CollectionChangePayload): void;
+/** 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. */
+export declare function setFirestoreAccessor(accessor: (() => FirestoreHandle | null) | null): void;
+/** 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. */
+export declare function firestoreHandle(): FirestoreHandle | null;
 /** The configured workspace root. Throws if the host never configured one —
  *  and, under an explicit-root binding (`workspaceRoot: null`), throws rather
  *  than guessing, which is the whole point of that mode: on a multi-root host

package/dist/collection/server/index.cjs

@@ -1,9 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_root = require("../../root-rPH6FGDT.cjs");
 const require_calendarGrid = require("../../calendarGrid-DGILaVxI.cjs");
-const require_discovery = require("../../discovery-Ck4AqikY.cjs");
+const require_discovery = require("../../discovery-Cw5xWzZD.cjs");
 const require_templatePath = require("../../templatePath-27vUZowm.cjs");
-const require_server = require("../../server-5EMj3naj.cjs");
+const require_server = require("../../server-9mFaGLdq.cjs");
+exports.APP_MANIFEST_FILE = require_discovery.APP_MANIFEST_FILE;
 exports.BackendUnavailableError = require_discovery.BackendUnavailableError;
 exports.COLLECTION_ROOT_REQUIRED = require_discovery.COLLECTION_ROOT_REQUIRED;
 exports.COMPUTED_TYPES = require_calendarGrid.COMPUTED_TYPES;
@@ -17,6 +18,7 @@ exports.MAX_UNSELECTIVE_ITEMS = require_server.MAX_UNSELECTIVE_ITEMS;
 exports.SCHEMA_FILE = require_discovery.SCHEMA_FILE;
 exports.acceptParsedSchema = require_discovery.acceptParsedSchema;
 exports.advanceTriggerDate = require_server.advanceTriggerDate;
+exports.appManifestReason = require_discovery.appManifestReason;
 exports.applyMutateAction = require_server.applyMutateAction;
 exports.buildActionSeedPrompt = require_server.buildActionSeedPrompt;
 exports.buildCollectionActionSeedPrompt = require_server.buildCollectionActionSeedPrompt;
@@ -42,6 +44,7 @@ exports.deleteItem = require_discovery.deleteItem;
 exports.discoverCollections = require_discovery.discoverCollections;
 exports.encodeCsvRecordId = require_discovery.encodeCsvRecordId;
 exports.enrichItems = require_server.enrichItems;
+exports.firestoreHandle = require_discovery.firestoreHandle;
 exports.firstMutateParamProblem = require_server.firstMutateParamProblem;
 exports.formatCivil = require_server.formatCivil;
 exports.generateItemId = require_discovery.generateItemId;
@@ -56,6 +59,7 @@ exports.isSafeTemplatePath = require_templatePath.isSafeTemplatePath;
 exports.isTriggerDue = require_server.isTriggerDue;
 exports.itemFilePath = require_discovery.itemFilePath;
 exports.listItems = require_discovery.listItems;
+exports.loadAppManifest = require_discovery.loadAppManifest;
 exports.loadCollection = require_discovery.loadCollection;
 exports.localCollectionKey = require_discovery.localCollectionKey;
 exports.log = require_discovery.log;
@@ -63,6 +67,7 @@ exports.makeManageCollectionTool = require_server.makeManageCollectionTool;
 exports.maybeSpawnSuccessor = require_server.maybeSpawnSuccessor;
 exports.normalizeCsvValue = require_discovery.normalizeCsvValue;
 exports.pageFromFullRead = require_discovery.pageFromFullRead;
+exports.parseAppManifest = require_discovery.parseAppManifest;
 exports.parseCivil = require_server.parseCivil;
 exports.peekWorkspaceRoot = require_discovery.peekWorkspaceRoot;
 exports.projectItemFields = require_discovery.projectItemFields;
@@ -85,7 +90,9 @@ exports.safeRecordId = require_discovery.safeRecordId;
 exports.safeSlugName = require_discovery.safeSlugName;
 exports.schemaRelations = require_server.schemaRelations;
 exports.setCollectionChangePublisher = require_discovery.setCollectionChangePublisher;
+exports.setFirestoreAccessor = require_discovery.setFirestoreAccessor;
 exports.sharedCollectionChangePayload = require_discovery.sharedCollectionChangePayload;
+exports.sharedItemsPath = require_discovery.sharedItemsPath;
 exports.storeFor = require_discovery.storeFor;
 exports.successorId = require_server.successorId;
 exports.toDetail = require_discovery.toDetail;

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

@@ -1,4 +1,7 @@
-export { configureCollectionHost, canonicalRoot, getWorkspaceRoot, peekWorkspaceRoot, COLLECTION_ROOT_REQUIRED, log, setCollectionChangePublisher, publishCollectionChange, collectionChangePayload, sharedCollectionChangePayload, collectionChangeKey, localCollectionKey, type CollectionHost, type CollectionLogger, type CollectionChangePayload, type LocalCollectionChange, type SharedCollectionChange, } from './host';
+export { configureCollectionHost, canonicalRoot, getWorkspaceRoot, peekWorkspaceRoot, COLLECTION_ROOT_REQUIRED, log, setCollectionChangePublisher, publishCollectionChange, collectionChangePayload, sharedCollectionChangePayload, collectionChangeKey, localCollectionKey, type CollectionHost, type CollectionLogger, type CollectionChangePayload, firestoreHandle, setFirestoreAccessor, type FirestoreHandle, type LocalCollectionChange, type SharedCollectionChange, } from './host';
+export type { FirestoreDoc, FirestoreDocs } from './firestoreDocs';
+export { sharedItemsPath } from './firestoreStore';
+export { loadAppManifest, parseAppManifest, appManifestReason, APP_MANIFEST_FILE, type AppManifest, type AppManifestResult } from './appManifest';
 export type { LoadedCollection } from './discoveredCollection';
 export * from './paths';
 export * from './templatePath';

package/dist/collection/server/index.js

@@ -1,6 +1,6 @@
 import { t as canonicalRoot } from "../../root-BMroU_mB.js";
 import { j as COMPUTED_TYPES } from "../../calendarGrid-CQ8MVSRb.js";
-import { $ as log, A as deleteItem, B as resolveDataDir, C as compileCsvQuery, D as MAX_QUERY_ROWS, E as DEFAULT_QUERY_ROWS, F as resolveCreateItemId, H as safeRecordId, I as writeItem, K as collectionChangeKey, L as SCHEMA_FILE, M as isRegularFile, N as listItems, O as BackendUnavailableError, P as readItem, Q as localCollectionKey, R as isContainedInRoot, T as CollectionQueryZ, U as safeSlugName, V as resolveTemplatePath, W as COLLECTION_ROOT_REQUIRED, X as getWorkspaceRoot, Y as configureCollectionHost, _ as csvRowToItem, a as toDetail, b as encodeCsvRecordId, d as storeFor, et as peekWorkspaceRoot, h as MAX_CSV_ROWS, i as resolvePrimaryField, it as sharedCollectionChangePayload, j as generateItemId, k as isBackendUnavailable, l as collectionWritable, m as projectItemFields, n as discoverCollections, nt as publishCollectionChange, o as toSummary, p as pageFromFullRead, q as collectionChangePayload, r as loadCollection, rt as setCollectionChangePublisher, s as CollectionSchemaZ, t as acceptParsedSchema, u as readOnlyRefusal, v as decodeCsvRecordId, w as compileJsonlQuery, x as normalizeCsvValue, y as dedupeByRecordId, z as itemFilePath } from "../../discovery-DH9wweuj.js";
+import { A as readItem, B as SCHEMA_FILE, C as CollectionQueryZ, D as generateItemId, E as deleteItem, F as loadAppManifest, G as safeRecordId, H as itemFilePath, I as parseAppManifest, J as isBackendUnavailable, K as safeSlugName, L as sharedItemsPath, M as writeItem, N as APP_MANIFEST_FILE, O as isRegularFile, P as appManifestReason, Q as collectionChangePayload, R as pageFromFullRead, S as compileJsonlQuery, T as MAX_QUERY_ROWS, U as resolveDataDir, V as isContainedInRoot, W as resolveTemplatePath, Y as COLLECTION_ROOT_REQUIRED, Z as collectionChangeKey, _ as dedupeByRecordId, a as toDetail, at as log, ct as publishCollectionChange, d as storeFor, dt as sharedCollectionChangePayload, et as configureCollectionHost, g as decodeCsvRecordId, h as csvRowToItem, i as resolvePrimaryField, it as localCollectionKey, j as resolveCreateItemId, k as listItems, l as collectionWritable, lt as setCollectionChangePublisher, n as discoverCollections, nt as getWorkspaceRoot, o as toSummary, ot as peekWorkspaceRoot, p as MAX_CSV_ROWS, q as BackendUnavailableError, r as loadCollection, s as CollectionSchemaZ, t as acceptParsedSchema, tt as firestoreHandle, u as readOnlyRefusal, ut as setFirestoreAccessor, v as encodeCsvRecordId, w as DEFAULT_QUERY_ROWS, x as compileCsvQuery, y as normalizeCsvValue, z as projectItemFields } from "../../discovery-CdkaURVY.js";
 import { i as isSafeTemplatePath, n as isSafeCustomViewI18nPath, r as isSafeCustomViewPath, t as isSafeActionTemplatePath } from "../../templatePath-k_WNbL_Q.js";
-import { A as buildCollectionActionSeedPrompt, C as validateRecordObject, D as enrichItems, E as runCollectionQuery, M as readCustomViewHtml, N as readCustomViewI18n, O as runQueryOverRows, P as readSkillTemplate, S as validateCollectionRecords, T as recordFieldProblem, _ as computeCollectionIcon, a as deleteCollection, b as applyMutateAction, c as computeSuccessor, d as isTriggerDue, f as maybeSpawnSuccessor, h as successorId, i as deleteCustomView, j as promptPathsFor, k as buildActionSeedPrompt, l as daysInMonth, m as resolveEvery, n as MAX_UNSELECTIVE_ITEMS, o as deleteCollectionRefusalMessage, p as parseCivil, r as makeManageCollectionTool, s as advanceTriggerDate, t as MAX_SCHEMA_ISSUES, u as formatCivil, v as buildWorkspaceOntology, w as compileRecordZ, x as firstMutateParamProblem, y as schemaRelations } from "../../server-BiRLLMpW.js";
-export { BackendUnavailableError, COLLECTION_ROOT_REQUIRED, COMPUTED_TYPES, CollectionQueryZ, CollectionSchemaZ, DEFAULT_QUERY_ROWS, MAX_CSV_ROWS, MAX_QUERY_ROWS, MAX_SCHEMA_ISSUES, MAX_UNSELECTIVE_ITEMS, SCHEMA_FILE, acceptParsedSchema, advanceTriggerDate, applyMutateAction, buildActionSeedPrompt, buildCollectionActionSeedPrompt, buildWorkspaceOntology, canonicalRoot, collectionChangeKey, collectionChangePayload, collectionWritable, compileCsvQuery, compileJsonlQuery, compileRecordZ, computeCollectionIcon, computeSuccessor, configureCollectionHost, csvRowToItem, daysInMonth, decodeCsvRecordId, dedupeByRecordId, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, encodeCsvRecordId, enrichItems, firstMutateParamProblem, formatCivil, generateItemId, getWorkspaceRoot, isBackendUnavailable, isContainedInRoot, isRegularFile, isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadCollection, localCollectionKey, log, makeManageCollectionTool, maybeSpawnSuccessor, normalizeCsvValue, pageFromFullRead, parseCivil, peekWorkspaceRoot, projectItemFields, promptPathsFor, publishCollectionChange, readCustomViewHtml, readCustomViewI18n, readItem, readOnlyRefusal, readSkillTemplate, recordFieldProblem, resolveCreateItemId, resolveDataDir, resolveEvery, resolvePrimaryField, resolveTemplatePath, runCollectionQuery, runQueryOverRows, safeRecordId, safeSlugName, schemaRelations, setCollectionChangePublisher, sharedCollectionChangePayload, storeFor, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };
+import { A as buildCollectionActionSeedPrompt, C as validateRecordObject, D as enrichItems, E as runCollectionQuery, M as readCustomViewHtml, N as readCustomViewI18n, O as runQueryOverRows, P as readSkillTemplate, S as validateCollectionRecords, T as recordFieldProblem, _ as computeCollectionIcon, a as deleteCollection, b as applyMutateAction, c as computeSuccessor, d as isTriggerDue, f as maybeSpawnSuccessor, h as successorId, i as deleteCustomView, j as promptPathsFor, k as buildActionSeedPrompt, l as daysInMonth, m as resolveEvery, n as MAX_UNSELECTIVE_ITEMS, o as deleteCollectionRefusalMessage, p as parseCivil, r as makeManageCollectionTool, s as advanceTriggerDate, t as MAX_SCHEMA_ISSUES, u as formatCivil, v as buildWorkspaceOntology, w as compileRecordZ, x as firstMutateParamProblem, y as schemaRelations } from "../../server-DdHaX_Uu.js";
+export { APP_MANIFEST_FILE, BackendUnavailableError, COLLECTION_ROOT_REQUIRED, COMPUTED_TYPES, CollectionQueryZ, CollectionSchemaZ, DEFAULT_QUERY_ROWS, MAX_CSV_ROWS, MAX_QUERY_ROWS, MAX_SCHEMA_ISSUES, MAX_UNSELECTIVE_ITEMS, SCHEMA_FILE, acceptParsedSchema, advanceTriggerDate, appManifestReason, applyMutateAction, buildActionSeedPrompt, buildCollectionActionSeedPrompt, buildWorkspaceOntology, canonicalRoot, collectionChangeKey, collectionChangePayload, collectionWritable, compileCsvQuery, compileJsonlQuery, compileRecordZ, computeCollectionIcon, computeSuccessor, configureCollectionHost, csvRowToItem, daysInMonth, decodeCsvRecordId, dedupeByRecordId, deleteCollection, deleteCollectionRefusalMessage, deleteCustomView, deleteItem, discoverCollections, encodeCsvRecordId, enrichItems, firestoreHandle, firstMutateParamProblem, formatCivil, generateItemId, getWorkspaceRoot, isBackendUnavailable, isContainedInRoot, isRegularFile, isSafeActionTemplatePath, isSafeCustomViewI18nPath, isSafeCustomViewPath, isSafeTemplatePath, isTriggerDue, itemFilePath, listItems, loadAppManifest, loadCollection, localCollectionKey, log, makeManageCollectionTool, maybeSpawnSuccessor, normalizeCsvValue, pageFromFullRead, parseAppManifest, parseCivil, peekWorkspaceRoot, projectItemFields, promptPathsFor, publishCollectionChange, readCustomViewHtml, readCustomViewI18n, readItem, readOnlyRefusal, readSkillTemplate, recordFieldProblem, resolveCreateItemId, resolveDataDir, resolveEvery, resolvePrimaryField, resolveTemplatePath, runCollectionQuery, runQueryOverRows, safeRecordId, safeSlugName, schemaRelations, setCollectionChangePublisher, setFirestoreAccessor, sharedCollectionChangePayload, sharedItemsPath, storeFor, successorId, toDetail, toSummary, validateCollectionRecords, validateRecordObject, writeItem };