@mulmoclaude/core 3.4.0 → 3.6.0

package/dist/collection/core/schemaZ.d.ts

@@ -59,9 +59,9 @@ export declare const SubFieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
+        date: "date";
         text: "text";
         email: "email";
-        date: "date";
         datetime: "datetime";
         markdown: "markdown";
     }>;
@@ -94,13 +94,13 @@ export declare const FieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
         string: "string";
         number: "number";
         boolean: "boolean";
+        date: "date";
+        file: "file";
         text: "text";
         email: "email";
-        date: "date";
         datetime: "datetime";
         markdown: "markdown";
         image: "image";
-        file: "file";
     }>;
 }, z.core.$strip>, z.ZodObject<{
     to: z.ZodString;
@@ -141,9 +141,9 @@ export declare const FieldSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
             string: "string";
             number: "number";
             boolean: "boolean";
+            date: "date";
             text: "text";
             email: "email";
-            date: "date";
             datetime: "datetime";
             markdown: "markdown";
         }>;
@@ -308,9 +308,9 @@ export declare const ActionSpecZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
             string: "string";
             number: "number";
             boolean: "boolean";
+            date: "date";
             text: "text";
             email: "email";
-            date: "date";
             datetime: "datetime";
             markdown: "markdown";
         }>;
@@ -672,15 +672,21 @@ export declare const DataSourceZ: z.ZodObject<{
 /** 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). */
-export declare const StorageZ: z.ZodObject<{
+ *  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. */
+export declare const StorageZ: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"sqlite">;
     path: z.ZodString;
-}, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"firestore">;
+}, z.core.$strict>], "type">;
 /** The schema's SHAPE, before any cross-field rule runs. Named so the rules in
  *  `./schemaRules` can type their argument against it — they receive whatever
  *  this parses to, and nothing narrower. */
@@ -692,10 +698,12 @@ declare const CollectionObjectZ: z.ZodObject<{
         type: z.ZodLiteral<"csv">;
         path: z.ZodString;
     }, z.core.$strip>>;
-    storage: z.ZodOptional<z.ZodObject<{
+    storage: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"sqlite">;
         path: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"firestore">;
+    }, z.core.$strict>], "type">>;
     primaryKey: z.ZodString;
     singleton: z.ZodOptional<z.ZodString>;
     fields: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -710,13 +718,13 @@ declare const CollectionObjectZ: z.ZodObject<{
             string: "string";
             number: "number";
             boolean: "boolean";
+            date: "date";
+            file: "file";
             text: "text";
             email: "email";
-            date: "date";
             datetime: "datetime";
             markdown: "markdown";
             image: "image";
-            file: "file";
         }>;
     }, z.core.$strip>, z.ZodObject<{
         to: z.ZodString;
@@ -757,9 +765,9 @@ declare const CollectionObjectZ: z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                date: "date";
                 text: "text";
                 email: "email";
-                date: "date";
                 datetime: "datetime";
                 markdown: "markdown";
             }>;
@@ -920,9 +928,9 @@ declare const CollectionObjectZ: z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                date: "date";
                 text: "text";
                 email: "email";
-                date: "date";
                 datetime: "datetime";
                 markdown: "markdown";
             }>;
@@ -975,9 +983,9 @@ declare const CollectionObjectZ: z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                date: "date";
                 text: "text";
                 email: "email";
-                date: "date";
                 datetime: "datetime";
                 markdown: "markdown";
             }>;
@@ -1171,10 +1179,12 @@ export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
         type: z.ZodLiteral<"csv">;
         path: z.ZodString;
     }, z.core.$strip>>;
-    storage: z.ZodOptional<z.ZodObject<{
+    storage: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"sqlite">;
         path: z.ZodString;
-    }, z.core.$strip>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"firestore">;
+    }, z.core.$strict>], "type">>;
     primaryKey: z.ZodString;
     singleton: z.ZodOptional<z.ZodString>;
     fields: z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1189,13 +1199,13 @@ export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
             string: "string";
             number: "number";
             boolean: "boolean";
+            date: "date";
+            file: "file";
             text: "text";
             email: "email";
-            date: "date";
             datetime: "datetime";
             markdown: "markdown";
             image: "image";
-            file: "file";
         }>;
     }, z.core.$strip>, z.ZodObject<{
         to: z.ZodString;
@@ -1236,9 +1246,9 @@ export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                date: "date";
                 text: "text";
                 email: "email";
-                date: "date";
                 datetime: "datetime";
                 markdown: "markdown";
             }>;
@@ -1399,9 +1409,9 @@ export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                date: "date";
                 text: "text";
                 email: "email";
-                date: "date";
                 datetime: "datetime";
                 markdown: "markdown";
             }>;
@@ -1454,9 +1464,9 @@ export declare const CollectionSchemaZ: z.ZodPreprocess<z.ZodObject<{
                 string: "string";
                 number: "number";
                 boolean: "boolean";
+                date: "date";
                 text: "text";
                 email: "email";
-                date: "date";
                 datetime: "datetime";
                 markdown: "markdown";
             }>;

package/dist/collection/firestore.cjs

@@ -0,0 +1,51 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let firebase_firestore = require("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 (0, firebase_firestore.getDocs)((0, firebase_firestore.query)((0, firebase_firestore.collection)(database, collectionPath), (0, firebase_firestore.orderBy)("__name__")))).docs.map((entry) => ({
+				id: entry.id,
+				data: entry.data()
+			}));
+		},
+		get: async (collectionPath, docId) => {
+			const snapshot = await (0, firebase_firestore.getDoc)((0, firebase_firestore.doc)(database, collectionPath, docId));
+			return snapshot.exists() ? snapshot.data() : null;
+		},
+		set: async (collectionPath, docId, data) => {
+			await (0, firebase_firestore.setDoc)((0, firebase_firestore.doc)(database, collectionPath, docId), data);
+		},
+		create: (collectionPath, docId, data) => (0, firebase_firestore.runTransaction)(database, async (transaction) => {
+			const ref = (0, firebase_firestore.doc)(database, collectionPath, docId);
+			if ((await transaction.get(ref)).exists()) return false;
+			transaction.set(ref, data);
+			return true;
+		}),
+		delete: (collectionPath, docId) => (0, firebase_firestore.runTransaction)(database, async (transaction) => {
+			const ref = (0, firebase_firestore.doc)(database, collectionPath, docId);
+			if (!(await transaction.get(ref)).exists()) return false;
+			transaction.delete(ref);
+			return true;
+		})
+	};
+}
+//#endregion
+exports.createFirestoreDocs = createFirestoreDocs;
+
+//# sourceMappingURL=firestore.cjs.map

package/dist/collection/firestore.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"firestore.cjs","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,OAAA,GADgB,mBAAA,QAAA,EAAA,GAAQ,mBAAA,MAAA,EAAA,GAAe,mBAAA,WAAA,CAAoB,UAAU,cAAc,IAAA,GAAG,mBAAA,QAAA,CAAQ,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,OAAA,GAAM,mBAAA,OAAA,EAAA,GAAO,mBAAA,IAAA,CAAI,UAAU,gBAAgB,KAAK,CAAC;GAClE,OAAO,SAAS,OAAO,IAAI,SAAS,KAAK,IAAI;EAC/C;EACA,KAAK,OAAO,gBAAgB,OAAO,SAAS;GAC1C,OAAA,GAAM,mBAAA,OAAA,EAAA,GAAO,mBAAA,IAAA,CAAI,UAAU,gBAAgB,KAAK,GAAG,IAAI;EACzD;EACA,SAAS,gBAAgB,OAAO,UAAA,GAC9B,mBAAA,eAAA,CAAe,UAAU,OAAO,gBAAgB;GAC9C,MAAM,OAAA,GAAM,mBAAA,IAAA,CAAI,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,WAAA,GACvB,mBAAA,eAAA,CAAe,UAAU,OAAO,gBAAgB;GAC9C,MAAM,OAAA,GAAM,mBAAA,IAAA,CAAI,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/firestore.d.ts

@@ -0,0 +1 @@
+export { createFirestoreDocs, type FirestoreDoc, type FirestoreDocs } from './server/firestoreDocs';

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/index.cjs

@@ -1,8 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_dist = require("../dist-CsgSfWwR.cjs");
-const require_calendarGrid = require("../calendarGrid-p8K-7cuB.cjs");
+const require_calendarGrid = require("../calendarGrid-DGILaVxI.cjs");
 const require_project = require("../project-C1ep9pvo.cjs");
-const require_promptSafety = require("../promptSafety-CNEW3_qS.cjs");
+const require_promptSafety = require("../promptSafety-NNGViiCr.cjs");
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
 /** Stamp a host's opaque project scope onto a card payload. The ONLY way a
@@ -665,6 +665,8 @@ exports.chipMatches = require_promptSafety.chipMatches;
 exports.coerceInlineValue = coerceInlineValue;
 exports.coerceNumeric = require_promptSafety.coerceNumeric;
 exports.collectionCardKey = collectionCardKey;
+exports.collectionKeyId = require_calendarGrid.collectionKeyId;
+exports.collectionKeyName = require_calendarGrid.collectionKeyName;
 exports.compareSortValues = compareSortValues;
 exports.compareYmd = require_calendarGrid.compareYmd;
 exports.completionCoveredByFieldChip = require_promptSafety.completionCoveredByFieldChip;
@@ -691,21 +693,26 @@ exports.firstMissingRequiredField = firstMissingRequiredField;
 exports.flagFieldValue = require_promptSafety.flagFieldValue;
 exports.generateUniqueId = require_calendarGrid.generateUniqueId;
 exports.isFieldDrivenEvery = require_calendarGrid.isFieldDrivenEvery;
+exports.isLocalCollectionKey = require_calendarGrid.isLocalCollectionKey;
 exports.isReadOnlySchema = require_calendarGrid.isReadOnlySchema;
 exports.isSafeRecordId = require_calendarGrid.isSafeRecordId;
 exports.isSafeSlug = require_calendarGrid.isSafeSlug;
+exports.isSharedCollectionKey = require_calendarGrid.isSharedCollectionKey;
 exports.isSortableField = isSortableField;
+exports.isValidCollectionName = require_calendarGrid.isValidCollectionName;
 exports.itemIdOf = itemIdOf;
 exports.itemIsDone = require_promptSafety.itemIsDone;
 exports.itemLabelOf = itemLabelOf;
 exports.itemMatchesQuery = itemMatchesQuery;
 exports.labelFieldFor = labelFieldFor;
+exports.localCollectionKeyOf = require_calendarGrid.localCollectionKeyOf;
 exports.matchesWhere = require_promptSafety.matchesWhere;
 exports.mergeIntoExisting = require_project.mergeIntoExisting;
 exports.monthAnchorDate = require_calendarGrid.monthAnchorDate;
 exports.nextSortDirection = nextSortDirection;
 exports.nextUniqueItemId = require_calendarGrid.nextUniqueItemId;
 exports.numericSortValue = numericSortValue;
+exports.parseCollectionKeyId = require_calendarGrid.parseCollectionKeyId;
 exports.parseIsoDate = require_calendarGrid.parseIsoDate;
 exports.parseIsoDateTime = require_calendarGrid.parseIsoDateTime;
 exports.parseTimeRange = require_calendarGrid.parseTimeRange;
@@ -719,8 +726,10 @@ exports.rollupValue = require_promptSafety.rollupValue;
 exports.rowFromItem = rowFromItem;
 exports.rowIdOf = rowIdOf;
 exports.sameCollectionCard = sameCollectionCard;
+exports.sameCollectionKey = require_calendarGrid.sameCollectionKey;
 exports.scalarSortValue = scalarSortValue;
 exports.selectDynamicRecord = require_promptSafety.selectDynamicRecord;
+exports.sharedCollectionKey = require_calendarGrid.sharedCollectionKey;
 exports.shortHexId = shortHexId;
 exports.skillCommandSeed = skillCommandSeed;
 exports.snapshotEmptyEnums = snapshotEmptyEnums;

package/dist/collection/index.d.ts

@@ -1,6 +1,7 @@
 export * from './core/schema';
 export type { CollectionQuery, CollectionQueryAggregate, CollectionQueryOrder, CollectionQueryWhere } from './core/queryZ';
 export * from './core/ids';
+export * from './core/collectionKey';
 export * from './core/fieldText';
 export * from './core/project';
 export * from './core/uiTypes';

package/dist/collection/index.js

@@ -1,7 +1,7 @@
 import { t as errorMessage } from "../dist-D8zokgGo.js";
-import { A as fieldTextOrNull, C as FEED_SCHEDULES, D as isReadOnlySchema, E as isFieldDrivenEvery, O as storageKindFor, S as COMPUTED_TYPES, T as embedTargetId, _ as generateUniqueId, a as compareYmd, b as nextUniqueItemId, c as monthAnchorDate, d as parseTimeRange, f as recordSpan, g as SAFE_SLUG_PATTERN, h as SAFE_RECORD_ID_PATTERN, i as buildMonthGrid, k as fieldText, l as parseIsoDate, m as ymdKey, n as assignLanes, o as dateOf, p as spanCoversDay, r as bucketRecords, s as daySlice, t as MINUTES_PER_DAY, u as parseIsoDateTime, v as isSafeRecordId, w as INGEST_KINDS, x as AGENT_INGEST_KIND, y as isSafeSlug } from "../calendarGrid-Csy2rpjp.js";
+import { A as AGENT_INGEST_KIND, C as sharedCollectionKey, D as isSafeRecordId, E as generateUniqueId, F as isFieldDrivenEvery, I as isReadOnlySchema, L as storageKindFor, M as FEED_SCHEDULES, N as INGEST_KINDS, O as isSafeSlug, P as embedTargetId, R as fieldText, S as sameCollectionKey, T as SAFE_SLUG_PATTERN, _ as isLocalCollectionKey, a as compareYmd, b as localCollectionKeyOf, c as monthAnchorDate, d as parseTimeRange, f as recordSpan, g as collectionKeyName, h as collectionKeyId, i as buildMonthGrid, j as COMPUTED_TYPES, k as nextUniqueItemId, l as parseIsoDate, m as ymdKey, n as assignLanes, o as dateOf, p as spanCoversDay, r as bucketRecords, s as daySlice, t as MINUTES_PER_DAY, u as parseIsoDateTime, v as isSharedCollectionKey, w as SAFE_RECORD_ID_PATTERN, x as parseCollectionKeyId, y as isValidCollectionName, z as fieldTextOrNull } from "../calendarGrid-CQ8MVSRb.js";
 import { n as projectRecordFields, t as mergeIntoExisting } from "../project-B0j_Vf_Q.js";
-import { C as actionVisible, E as whenMatches, S as viaMatches, T as fieldVisible, _ as uniqueRefTargets, a as evaluateDerived, b as projectBacklinkRow, c as selectDynamicRecord, d as flagFieldValue, f as itemIsDone, g as uniqueEmbedTargets, h as uniqueBacklinkSources, l as chipMatches, m as matchesWhere, n as deriveAll, o as firstDateField, p as toggleChecked, r as resolveRowRefs, s as resolveIcon, t as defangForPrompt, u as completionCoveredByFieldChip, v as backlinkRows, w as agentActionRunKey, x as rollupValue, y as coerceNumeric } from "../promptSafety-ACXw_2Yu.js";
+import { C as actionVisible, E as whenMatches, S as viaMatches, T as fieldVisible, _ as uniqueRefTargets, a as evaluateDerived, b as projectBacklinkRow, c as selectDynamicRecord, d as flagFieldValue, f as itemIsDone, g as uniqueEmbedTargets, h as uniqueBacklinkSources, l as chipMatches, m as matchesWhere, n as deriveAll, o as firstDateField, p as toggleChecked, r as resolveRowRefs, s as resolveIcon, t as defangForPrompt, u as completionCoveredByFieldChip, v as backlinkRows, w as agentActionRunKey, x as rollupValue, y as coerceNumeric } from "../promptSafety-CpiME8pj.js";
 //#region src/collection/core/presentCollection.ts
 var TOOL_NAME = "presentCollection";
 /** Stamp a host's opaque project scope onto a card payload. The ONLY way a
@@ -638,6 +638,6 @@ var buildOntologyGraph = (entries) => {
 	};
 };
 //#endregion
-export { AGENT_INGEST_KIND, COMPUTED_TYPES, ENUM_ALERT, ENUM_NEUTRAL, ENUM_NUDGE, FEED_SCHEDULES, INGEST_KINDS, MINUTES_PER_DAY, SAFE_RECORD_ID_PATTERN, SAFE_SLUG_PATTERN, TOOL_DEFINITION, TOOL_NAME, actionVisible, agentActionRunKey, assignLanes, backlinkRows, boolSortValue, bucketRecords, buildMonthGrid, buildOntologyGraph, buildUpdatedRecord, cellKey, chipMatches, coerceInlineValue, coerceNumeric, collectionCardKey, compareSortValues, compareYmd, completionCoveredByFieldChip, dateOf, dateSortValue, daySlice, defangForPrompt, deriveAll, derivedSortValue, draftToRecord, embedTargetId, emptyRow, enumColorClasses, enumSortValue, enumValueIndex, errorMessage, evaluateDerived, executePresentCollection, fieldText, fieldTextOrNull, fieldVisible, firstDateField, firstMissingRequiredField, flagFieldValue, generateUniqueId, isFieldDrivenEvery, isReadOnlySchema, isSafeRecordId, isSafeSlug, isSortableField, itemIdOf, itemIsDone, itemLabelOf, itemMatchesQuery, labelFieldFor, matchesWhere, mergeIntoExisting, monthAnchorDate, nextSortDirection, nextUniqueItemId, numericSortValue, parseIsoDate, parseIsoDateTime, parseTimeRange, projectBacklinkRow, projectRecordFields, recordSpan, resolveEnumColor, resolveIcon, resolveRowRefs, rollupValue, rowFromItem, rowIdOf, sameCollectionCard, scalarSortValue, selectDynamicRecord, shortHexId, skillCommandSeed, snapshotEmptyEnums, sortItems, sortValueOf, spanCoversDay, storageKindFor, stringSortValue, toPresentCollectionData, toggleChecked, uniqueBacklinkSources, uniqueEmbedTargets, uniqueRefTargets, viaMatches, whenMatches, withCardScope, ymdKey };
+export { AGENT_INGEST_KIND, COMPUTED_TYPES, ENUM_ALERT, ENUM_NEUTRAL, ENUM_NUDGE, FEED_SCHEDULES, INGEST_KINDS, MINUTES_PER_DAY, SAFE_RECORD_ID_PATTERN, SAFE_SLUG_PATTERN, TOOL_DEFINITION, TOOL_NAME, actionVisible, agentActionRunKey, assignLanes, backlinkRows, boolSortValue, bucketRecords, buildMonthGrid, buildOntologyGraph, buildUpdatedRecord, cellKey, chipMatches, coerceInlineValue, coerceNumeric, collectionCardKey, collectionKeyId, collectionKeyName, compareSortValues, compareYmd, completionCoveredByFieldChip, dateOf, dateSortValue, daySlice, defangForPrompt, deriveAll, derivedSortValue, draftToRecord, embedTargetId, emptyRow, enumColorClasses, enumSortValue, enumValueIndex, errorMessage, evaluateDerived, executePresentCollection, fieldText, fieldTextOrNull, fieldVisible, firstDateField, firstMissingRequiredField, flagFieldValue, generateUniqueId, isFieldDrivenEvery, isLocalCollectionKey, isReadOnlySchema, isSafeRecordId, isSafeSlug, isSharedCollectionKey, isSortableField, isValidCollectionName, itemIdOf, itemIsDone, itemLabelOf, itemMatchesQuery, labelFieldFor, localCollectionKeyOf, matchesWhere, mergeIntoExisting, monthAnchorDate, nextSortDirection, nextUniqueItemId, numericSortValue, parseCollectionKeyId, parseIsoDate, parseIsoDateTime, parseTimeRange, projectBacklinkRow, projectRecordFields, recordSpan, resolveEnumColor, resolveIcon, resolveRowRefs, rollupValue, rowFromItem, rowIdOf, sameCollectionCard, sameCollectionKey, scalarSortValue, selectDynamicRecord, sharedCollectionKey, shortHexId, skillCommandSeed, snapshotEmptyEnums, sortItems, sortValueOf, spanCoversDay, storageKindFor, stringSortValue, toPresentCollectionData, toggleChecked, uniqueBacklinkSources, uniqueEmbedTargets, uniqueRefTargets, viaMatches, whenMatches, withCardScope, ymdKey };
 
 //# sourceMappingURL=index.js.map

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-CrA_EqUJ.cjs");
+const require_discovery = require("../../../discovery-Cw5xWzZD.cjs");
 const require_templatePath = require("../../../templatePath-27vUZowm.cjs");
-const require_server = require("../../../server-CorfPQVQ.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 projectSkillsDir, H as safeRecordId, Y as getWorkspaceRoot, Z as log, nt as skillsStagingDir, q as collectionsRegistriesConfigPath, r as loadCollection, s as CollectionSchemaZ, t as acceptParsedSchema } from "../../../discovery-D7LCN8gJ.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-D6QY853r.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;