@mulmoclaude/core 4.1.1 → 4.3.0

package/dist/{discovery-D88x2DmW.js → discovery-P64fgtuD.js}

@@ -1,6 +1,6 @@
 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 isSafeSlug, B as fieldText, D as SAFE_SLUG_PATTERN, E as SAFE_RECORD_ID_PATTERN, F as INGEST_KINDS, M as AGENT_INGEST_KIND, N as COMPUTED_TYPES, P as FEED_SCHEDULES, R as isReadOnlySchema, S as localCollectionKeyOf, T as sharedCollectionKey, V as fieldTextOrNull, k as isSafeRecordId, t as newItemId, x as isValidCollectionName, z as storageKindFor } from "./itemId-DfTm08jm.js";
+import { B as COMPUTED_TYPES, G as isReadOnlySchema, H as INGEST_KINDS, I as isSafeRecordId, J as fieldTextOrNull, K as storageKindFor, L as isSafeSlug, M as sharedCollectionKey, N as SAFE_RECORD_ID_PATTERN, O as isValidCollectionName, P as SAFE_SLUG_PATTERN, V as FEED_SCHEDULES, _ as decodeRecordTimes, k as localCollectionKeyOf, q as fieldText, t as newItemId, y as encodeRecordTimes, z as AGENT_INGEST_KIND } from "./itemId-BY2YPBkT.js";
 import { n as projectRecordFields } from "./project-B0j_Vf_Q.js";
 import { n as backoffDelayMs, r as classifyListenerError } from "./listen-D5av7GzB.js";
 import { n as isSafeCustomViewI18nPath, r as isSafeCustomViewPath, t as isSafeActionTemplatePath } from "./templatePath-k_WNbL_Q.js";
@@ -8,6 +8,7 @@ import { readFileSync, realpathSync, watch } from "node:fs";
 import path from "node:path";
 import { createHash, randomBytes } from "node:crypto";
 import { lstat, mkdir, open, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { Timestamp } from "firebase/firestore";
 import { tmpdir } from "node:os";
 import iconv from "iconv-lite";
 import { z } from "zod";
@@ -473,10 +474,10 @@ async function guarded(key, email, run) {
 *  It also removes the reason a submit path would have had to accept the
 *  primary key as a `createField` at all — a submission that cannot name its
 *  own id is exactly right when the id is the thing being assigned. */
-function toItem(data, docId, primaryKey) {
+function toItem(data, docId, schema) {
 	return isRecord(data) ? {
-		...data,
-		[primaryKey]: docId
+		...decodeRecordTimes(data, schema),
+		[schema.primaryKey]: docId
 	} : null;
 }
 /** Record ids are validated with the SAME helper every other backend uses.
@@ -488,26 +489,26 @@ function withSafeId(itemId, onInvalid, run) {
 	if (safeId === null) return onInvalid();
 	return run(safeId, requireHandle());
 }
-async function firestoreList(key, primaryKey) {
+async function firestoreList(key, schema) {
 	const { docs, email } = requireHandle();
-	return (await guarded(key, email, () => docs.list(sharedItemsPath(key)))).map((entry) => toItem(entry.data, entry.id, primaryKey)).filter((item) => item !== null);
+	return (await guarded(key, email, () => docs.list(sharedItemsPath(key)))).map((entry) => toItem(entry.data, entry.id, schema)).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, primaryKey);
+async function firestorePage(key, schema, opts) {
+	const items = await firestoreList(key, schema);
 	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),
+		items: projectItemFields(opts.limit === void 0 ? items.slice(offset) : items.slice(offset, offset + Math.max(0, opts.limit)), opts.fields, schema.primaryKey),
 		total: items.length,
 		truncated: false
 	};
 }
-async function firestoreRead(key, itemId, primaryKey) {
-	return withSafeId(itemId, () => Promise.resolve(null), async (safeId, { docs, email }) => toItem(await guarded(key, email, () => docs.get(sharedItemsPath(key), safeId)), safeId, primaryKey));
+async function firestoreRead(key, itemId, schema) {
+	return withSafeId(itemId, () => Promise.resolve(null), async (safeId, { docs, email }) => toItem(await guarded(key, email, () => docs.get(sharedItemsPath(key), safeId)), safeId, schema));
 }
 /** Publish the "records changed" ping for a shared collection.
 *
@@ -522,18 +523,35 @@ function publishShared(key, ids, operation) {
 		op: operation
 	}, key.aid));
 }
-async function firestoreWrite(key, itemId, item, opts) {
+/** The write half of the decode above, and it is not optional.
+*
+*  A record is read, edited and written back WHOLE — `putItems`' upsert
+*  replaces the document — so a decoded stamp would return to Firestore as a
+*  string. The rules freeze that field by comparing `diff().affectedKeys()`, so
+*  that write is refused and so is every later one: the record becomes
+*  permanently unupdatable. Dropping the key instead does not help, because a
+*  removed key is an affected key too.
+*
+*  Only a `datetime` field carrying the exact canonical form is converted, and
+*  that form is only ever produced by the decode — so the pair is closed over
+*  its own output and cannot re-type a value somebody else wrote. */
+async function firestoreWrite(key, itemId, item, schema, opts) {
 	return withSafeId(itemId, () => Promise.resolve({
 		kind: "invalid-id",
 		itemId
 	}), async (safeId, { docs, email }) => {
 		const collectionPath = sharedItemsPath(key);
+		const asTimestamp = (parts) => new Timestamp(parts.seconds, parts.nanoseconds);
 		if (opts.refuseOverwrite) {
-			if (!await guarded(key, email, () => docs.create(collectionPath, safeId, item))) return {
+			if (!await guarded(key, email, () => docs.create(collectionPath, safeId, encodeRecordTimes(item, null, asTimestamp)))) return {
 				kind: "conflict",
 				itemId: safeId
 			};
-		} else await guarded(key, email, () => docs.set(collectionPath, safeId, item));
+		} else {
+			const previous = await guarded(key, email, () => docs.get(collectionPath, safeId));
+			const stored = encodeRecordTimes(item, isRecord(previous) ? previous : null, asTimestamp);
+			await guarded(key, email, () => docs.set(collectionPath, safeId, stored));
+		}
 		if (opts.slug) publishShared(key, [safeId], "upsert");
 		return {
 			kind: "ok",
@@ -666,7 +684,7 @@ function armSharedWatch(key, onChange) {
 /** 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 { schema } = collection;
 	const ioOpts = {
 		...opts,
 		slug: opts.slug ?? collection.slug
@@ -677,10 +695,10 @@ function firestoreStoreFor(collection, opts) {
 			nativeQuery: false,
 			nativePaging: false
 		},
-		list: async () => firestoreList(keyOf(collection), primaryKey),
-		page: async (pageOpts = {}) => firestorePage(keyOf(collection), primaryKey, pageOpts),
-		read: async (itemId) => firestoreRead(keyOf(collection), itemId, primaryKey),
-		write: async (itemId, item, writeOpts = {}) => firestoreWrite(keyOf(collection), itemId, item, {
+		list: async () => firestoreList(keyOf(collection), schema),
+		page: async (pageOpts = {}) => firestorePage(keyOf(collection), schema, pageOpts),
+		read: async (itemId) => firestoreRead(keyOf(collection), itemId, schema),
+		write: async (itemId, item, writeOpts = {}) => firestoreWrite(keyOf(collection), itemId, item, schema, {
 			...ioOpts,
 			refuseOverwrite: writeOpts.refuseOverwrite
 		}),
@@ -3315,4 +3333,4 @@ function toDetail(collection) {
 //#endregion
 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 _, createHostSlot as _t, toDetail as a, localCollectionKey as at, queryCsv as b, resolveMutateSet as c, projectSkillsDir as ct, storeFor as d, setFirestoreAccessor as dt, configureCollectionHost as et, checkpointSqliteDatabase as f, setSharedCollectionsSupport as ft, decodeCsvRecordId as g, createForwardingLogger as gt, csvRowToItem as h, stagingSkillDir as ht, resolvePrimaryField as i, isPresetSlug as it, resolveCreateItemId as j, listItems as k, collectionWritable as l, publishCollectionChange as lt, cacheDir as m, skillsStagingDir as mt, discoverCollections as n, getWorkspaceRoot as nt, toSummary as o, log as ot, MAX_CSV_ROWS as p, sharedCollectionChangePayload as pt, BackendUnavailableError as q, loadCollection as r, hostSupportsSharedCollections as rt, CollectionSchemaZ as s, peekWorkspaceRoot as st, acceptParsedSchema as t, firestoreHandle as tt, readOnlyRefusal as u, setCollectionChangePublisher as ut, encodeCsvRecordId as v, DEFAULT_QUERY_ROWS as w, compileCsvQuery as x, normalizeCsvValue as y, projectItemFields as z };
 
-//# sourceMappingURL=discovery-D88x2DmW.js.map
+//# sourceMappingURL=discovery-P64fgtuD.js.map