@vercel/factory 0.0.17 → 0.0.19

package/dist/store/indexed-engine.d.mts

@@ -0,0 +1,57 @@
+import { StoreDriver } from "./driver.mjs";
+import { IndexedStore } from "./indexed.mjs";
+import { CreateStoresOptions, FactoryStores } from "./engine.mjs";
+import { ApprovalStore } from "./approvals.mjs";
+import { ConversationProjectionOptions, ConversationStore } from "./conversations.mjs";
+import { FactoryIndexScope, FactoryRecordSummary } from "./indexed-projections.mjs";
+//#region src/store/indexed-engine.d.ts
+/** Storage and workflow configuration for fresh indexed state; images use a separate object store. */
+interface CreateIndexedStoresOptions extends Omit<CreateStoresOptions, "driver"> {
+  /** Authoritative structured persistence, with no historical backend or fallback. */
+  readonly store: IndexedStore;
+  /** Explicit operator read-model routing and automatic-work owner. */
+  readonly conversations?: ConversationProjectionOptions;
+  /** Object storage used exclusively for uploaded image bytes; never receives structured state. */
+  readonly images: Pick<StoreDriver, "get" | "insert">;
+}
+/** One validated compact summary and the canonical record version that produced it. */
+interface FactoryIndexedEntry {
+  readonly summary: FactoryRecordSummary;
+  readonly version: number;
+}
+/** Bounded source-summary page; cursors continue only the same scope and ordering. */
+interface FactoryIndexedPage {
+  readonly entries: readonly FactoryIndexedEntry[];
+  readonly nextCursor: string | null;
+}
+/** Engine write operations and point reads, with bounded queries replacing unbounded catalog-list methods. */
+interface IndexedFactoryStores extends FactoryStores {
+  readonly conversations: ConversationStore;
+  readonly approvals: ApprovalStore;
+  /** Trusted source queries. Source attention counts are not deduplicated conversation counts. */
+  readonly indexes: {
+    query(input: {
+      scope: FactoryIndexScope;
+      limit: number;
+      cursor?: string;
+      order?: "asc" | "desc";
+    }): Promise<FactoryIndexedPage>;
+    count(scope: FactoryIndexScope): Promise<number>;
+  };
+}
+/**
+ * Creates the validating Factory write engine over atomic indexed persistence.
+ *
+ * @remarks
+ * New canonical state and its compact memberships/counts commit together. No catalog shards,
+ * Blob fallback, backfill, or unbounded list methods exist on the returned API. Images alone use the
+ * supplied object store. Authentication and query-scope authorization remain the application's
+ * responsibility. Repository membership does not grant access to a multi-repository record.
+ * The Postgres adapter's record/summary/membership bounds apply; source attention counts must not
+ * be presented as deduplicated conversation counts. Configure application conversation projections
+ * for the operator API; growing histories use bounded pages.
+ */
+declare function createIndexedStores(options: CreateIndexedStoresOptions): IndexedFactoryStores;
+//#endregion
+export { CreateIndexedStoresOptions, FactoryIndexedEntry, FactoryIndexedPage, IndexedFactoryStores, createIndexedStores };
+//# sourceMappingURL=indexed-engine.d.mts.map

package/dist/store/indexed-engine.mjs

@@ -0,0 +1,155 @@
+import { taskSchema } from "../schema/task.mjs";
+import { agentSessionSchema } from "../schema/session.mjs";
+import { factoryIndexKey, factoryIndexScopeSchema, factoryRecordSummarySchema, projectIndexedRecord } from "./indexed-projections.mjs";
+import { createIndexedTranscriptStore } from "./transcripts.mjs";
+import { createStoreEngine } from "./engine.mjs";
+import { createApprovalStore, projectApproval } from "./approvals.mjs";
+import { conversationTaskMemberships, createConversationStore, refreshConversations } from "./conversations.mjs";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region src/store/indexed-engine.ts
+const catalogs = /* @__PURE__ */ new Set([
+	"taskCatalogs",
+	"changeCatalogs",
+	"sessionCatalogs",
+	"externalSessionCatalogs",
+	"taskRoutes"
+]);
+function storedJson(value) {
+	const json = JSON.stringify(value, function(_key, entry) {
+		if (entry === void 0 && Array.isArray(this)) throw new Error("Undefined array element");
+		if (typeof entry === "number" && !Number.isFinite(entry)) throw new Error("Non-finite storage number");
+		if (typeof entry === "bigint" || typeof entry === "function" || typeof entry === "symbol") throw new Error("Storage requires JSON values");
+		return entry;
+	});
+	if (json === void 0) throw new Error("Storage requires a JSON value");
+	return JSON.parse(json);
+}
+/**
+* Creates the validating Factory write engine over atomic indexed persistence.
+*
+* @remarks
+* New canonical state and its compact memberships/counts commit together. No catalog shards,
+* Blob fallback, backfill, or unbounded list methods exist on the returned API. Images alone use the
+* supplied object store. Authentication and query-scope authorization remain the application's
+* responsibility. Repository membership does not grant access to a multi-repository record.
+* The Postgres adapter's record/summary/membership bounds apply; source attention counts must not
+* be presented as deduplicated conversation counts. Configure application conversation projections
+* for the operator API; growing histories use bounded pages.
+*/
+function createIndexedStores(options) {
+	return indexedStores(options, true);
+}
+function indexedStores(options, observe) {
+	const { images } = options;
+	function observingStore(raw) {
+		const projectionOptions = options.conversations;
+		return {
+			...raw,
+			transaction: (run) => raw.transaction((tx) => run(observingStore(tx))),
+			write: (input) => raw.transaction(async (tx) => {
+				const canonical = indexedStores({
+					...options,
+					store: tx,
+					conversations: void 0
+				}, false);
+				const memberships = input.collection === "tasks" ? await conversationTaskMemberships(canonical, taskSchema.parse(input.value)) : [];
+				const result = await tx.write({
+					...input,
+					indexes: [...input.indexes, ...memberships]
+				});
+				const execution = input.collection === "tasks" ? taskSchema.parse(input.value).execution : input.collection === "sessions" || input.collection === "externalSessions" ? agentSessionSchema.parse(input.value).execution : void 0;
+				if (execution && await canonical.transcripts.head(execution) === null) await canonical.transcripts.put(execution, {
+					blocks: [],
+					inputs: [],
+					cursor: 0,
+					state: "connecting",
+					tokens: 0
+				});
+				if (input.collection === "tasks") await projectApproval(tx, canonical, input.value);
+				if (projectionOptions) await refreshConversations(tx, canonical, input.collection, input.id, input.value, projectionOptions);
+				return result;
+			})
+		};
+	}
+	const store = observe ? observingStore(options.store) : options.store;
+	function assertCanonical(collection) {
+		if (catalogs.has(collection)) throw new Error("Catalog persistence is unavailable in indexed stores");
+	}
+	async function write(collection, id, value, expectedVersion) {
+		assertCanonical(collection);
+		if (collection === "images") throw new Error("Images must use object storage");
+		const canonical = storedJson(value);
+		const intent = {
+			collection,
+			id,
+			value: canonical,
+			expectedVersion,
+			indexes: projectIndexedRecord(collection, id, canonical).map((entry) => ({
+				...entry,
+				summary: storedJson(entry.summary)
+			}))
+		};
+		const operationId = randomUUID();
+		await store.write({
+			...intent,
+			operationId
+		});
+	}
+	const driver = {
+		name: store.name,
+		async get(collection, id) {
+			assertCanonical(collection);
+			return collection === "images" ? images.get(collection, id) : store.get(collection, id);
+		},
+		async insert(input) {
+			if (input.collection === "images") return images.insert(input);
+			await write(input.collection, input.id, input.value, 0);
+		},
+		async update(input) {
+			await write(input.collection, input.id, input.value, input.expectedVersion);
+		},
+		async list() {
+			throw new Error("Indexed stores require bounded queries instead of collection lists");
+		}
+	};
+	return {
+		...createStoreEngine({
+			...options,
+			driver
+		}, store),
+		conversations: createConversationStore(store),
+		approvals: createApprovalStore(store),
+		transcripts: createIndexedTranscriptStore(store, options.now ?? (() => (/* @__PURE__ */ new Date()).toISOString())),
+		indexes: {
+			async query(input) {
+				const scope = factoryIndexScopeSchema.parse(input.scope);
+				const index = factoryIndexKey(scope);
+				const page = await store.query({
+					index,
+					limit: input.limit,
+					cursor: input.cursor,
+					order: input.order
+				});
+				return {
+					entries: page.entries.map((entry) => {
+						const summary = factoryRecordSummarySchema.parse(entry.summary);
+						if (entry.index !== index || entry.collection !== scope.collection || summary.collection !== entry.collection || summary.id !== entry.id) throw new Error("Indexed summary identity mismatch");
+						return {
+							summary,
+							version: z.number().int().positive().parse(entry.version)
+						};
+					}),
+					nextCursor: page.nextCursor
+				};
+			},
+			count(scope) {
+				return store.count(factoryIndexKey(scope));
+			}
+		}
+	};
+}
+//#endregion
+export { createIndexedStores };
+
+//# sourceMappingURL=indexed-engine.mjs.map

package/dist/store/indexed-engine.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-engine.mjs","names":[],"sources":["../../src/store/indexed-engine.ts"],"sourcesContent":["import { createApprovalStore, projectApproval, type ApprovalStore } from \"./approvals\";\nimport {\n  createConversationStore,\n  refreshConversations,\n  conversationTaskMemberships,\n  type ConversationProjectionOptions,\n  type ConversationStore,\n} from \"./conversations\";\nimport { taskSchema } from \"../schema/task\";\nimport { agentSessionSchema } from \"../schema/session\";\nimport { randomUUID } from \"node:crypto\";\nimport { z } from \"zod\";\nimport { createStoreEngine, type CreateStoresOptions, type FactoryStores } from \"./engine\";\nimport type { CollectionName, StoreDriver, StoredRecord } from \"./driver\";\nimport type { IndexedStore } from \"./indexed\";\nimport { createIndexedTranscriptStore } from \"./transcripts\";\nimport {\n  factoryIndexKey,\n  factoryIndexScopeSchema,\n  factoryRecordSummarySchema,\n  projectIndexedRecord,\n  type FactoryIndexScope,\n  type FactoryRecordSummary,\n} from \"./indexed-projections\";\n\n/** Storage and workflow configuration for fresh indexed state; images use a separate object store. */\nexport interface CreateIndexedStoresOptions extends Omit<CreateStoresOptions, \"driver\"> {\n  /** Authoritative structured persistence, with no historical backend or fallback. */\n  readonly store: IndexedStore;\n  /** Explicit operator read-model routing and automatic-work owner. */\n  readonly conversations?: ConversationProjectionOptions;\n  /** Object storage used exclusively for uploaded image bytes; never receives structured state. */\n  readonly images: Pick<StoreDriver, \"get\" | \"insert\">;\n}\n\n/** One validated compact summary and the canonical record version that produced it. */\nexport interface FactoryIndexedEntry {\n  readonly summary: FactoryRecordSummary;\n  readonly version: number;\n}\n\n/** Bounded source-summary page; cursors continue only the same scope and ordering. */\nexport interface FactoryIndexedPage {\n  readonly entries: readonly FactoryIndexedEntry[];\n  readonly nextCursor: string | null;\n}\n\n/** Engine write operations and point reads, with bounded queries replacing unbounded catalog-list methods. */\nexport interface IndexedFactoryStores extends FactoryStores {\n  readonly conversations: ConversationStore;\n  readonly approvals: ApprovalStore;\n  /** Trusted source queries. Source attention counts are not deduplicated conversation counts. */\n  readonly indexes: {\n    query(input: {\n      scope: FactoryIndexScope;\n      limit: number;\n      cursor?: string;\n      order?: \"asc\" | \"desc\";\n    }): Promise<FactoryIndexedPage>;\n    count(scope: FactoryIndexScope): Promise<number>;\n  };\n}\n\nconst catalogs = new Set<CollectionName>([\n  \"taskCatalogs\",\n  \"changeCatalogs\",\n  \"sessionCatalogs\",\n  \"externalSessionCatalogs\",\n  \"taskRoutes\",\n]);\n\n// Engine schemas may retain optional undefined properties. JSON persistence omits those properties,\n// but must not silently turn non-finite numbers or missing array elements into null.\nfunction storedJson(value: unknown): unknown {\n  const json = JSON.stringify(value, function (_key, entry: unknown) {\n    if (entry === undefined && Array.isArray(this)) throw new Error(\"Undefined array element\");\n    if (typeof entry === \"number\" && !Number.isFinite(entry))\n      throw new Error(\"Non-finite storage number\");\n    if (typeof entry === \"bigint\" || typeof entry === \"function\" || typeof entry === \"symbol\")\n      throw new Error(\"Storage requires JSON values\");\n    return entry;\n  });\n  if (json === undefined) throw new Error(\"Storage requires a JSON value\");\n  return JSON.parse(json) as unknown;\n}\n\n/**\n * Creates the validating Factory write engine over atomic indexed persistence.\n *\n * @remarks\n * New canonical state and its compact memberships/counts commit together. No catalog shards,\n * Blob fallback, backfill, or unbounded list methods exist on the returned API. Images alone use the\n * supplied object store. Authentication and query-scope authorization remain the application's\n * responsibility. Repository membership does not grant access to a multi-repository record.\n * The Postgres adapter's record/summary/membership bounds apply; source attention counts must not\n * be presented as deduplicated conversation counts. Configure application conversation projections\n * for the operator API; growing histories use bounded pages.\n */\nexport function createIndexedStores(options: CreateIndexedStoresOptions): IndexedFactoryStores {\n  return indexedStores(options, true);\n}\n\nfunction indexedStores(\n  options: CreateIndexedStoresOptions,\n  observe: boolean,\n): IndexedFactoryStores {\n  const { images } = options;\n  function observingStore(raw: IndexedStore): IndexedStore {\n    const projectionOptions = options.conversations;\n    return {\n      ...raw,\n      transaction: (run) => raw.transaction((tx) => run(observingStore(tx))),\n      write: (input) =>\n        raw.transaction(async (tx) => {\n          const canonical = indexedStores(\n            { ...options, store: tx, conversations: undefined },\n            false,\n          );\n          const memberships =\n            input.collection === \"tasks\"\n              ? await conversationTaskMemberships(canonical, taskSchema.parse(input.value))\n              : [];\n          const result = await tx.write({ ...input, indexes: [...input.indexes, ...memberships] });\n          const execution =\n            input.collection === \"tasks\"\n              ? taskSchema.parse(input.value).execution\n              : input.collection === \"sessions\" || input.collection === \"externalSessions\"\n                ? agentSessionSchema.parse(input.value).execution\n                : undefined;\n          if (execution && (await canonical.transcripts.head(execution)) === null)\n            await canonical.transcripts.put(execution, {\n              blocks: [],\n              inputs: [],\n              cursor: 0,\n              state: \"connecting\",\n              tokens: 0,\n            });\n          if (input.collection === \"tasks\") await projectApproval(tx, canonical, input.value);\n          if (projectionOptions)\n            await refreshConversations(\n              tx,\n              canonical,\n              input.collection,\n              input.id,\n              input.value,\n              projectionOptions,\n            );\n          return result;\n        }),\n    };\n  }\n  const store = observe ? observingStore(options.store) : options.store;\n  function assertCanonical(collection: CollectionName) {\n    if (catalogs.has(collection))\n      throw new Error(\"Catalog persistence is unavailable in indexed stores\");\n  }\n  async function write(\n    collection: CollectionName,\n    id: string,\n    value: unknown,\n    expectedVersion: number,\n  ) {\n    assertCanonical(collection);\n    if (collection === \"images\") throw new Error(\"Images must use object storage\");\n    const canonical = storedJson(value);\n    const indexes = projectIndexedRecord(collection, id, canonical).map((entry) => ({\n      ...entry,\n      summary: storedJson(entry.summary),\n    }));\n    const intent = { collection, id, value: canonical, expectedVersion, indexes };\n    // Driver calls retain insert/CAS conflict semantics. The indexed adapter uses this identity\n    // to reconcile an ambiguous response within this call, not to replay a later engine call.\n    const operationId = randomUUID();\n    await store.write({ ...intent, operationId });\n  }\n  const driver: StoreDriver = {\n    name: store.name,\n    async get(collection, id): Promise<StoredRecord | null> {\n      assertCanonical(collection);\n      return collection === \"images\" ? images.get(collection, id) : store.get(collection, id);\n    },\n    async insert(input) {\n      if (input.collection === \"images\") return images.insert(input);\n      await write(input.collection, input.id, input.value, 0);\n    },\n    async update(input) {\n      await write(input.collection, input.id, input.value, input.expectedVersion);\n    },\n    async list() {\n      throw new Error(\"Indexed stores require bounded queries instead of collection lists\");\n    },\n  };\n  const stores = createStoreEngine({ ...options, driver }, store);\n  return {\n    ...stores,\n    conversations: createConversationStore(store),\n    approvals: createApprovalStore(store),\n    transcripts: createIndexedTranscriptStore(\n      store,\n      options.now ?? (() => new Date().toISOString()),\n    ),\n    indexes: {\n      async query(input) {\n        const scope = factoryIndexScopeSchema.parse(input.scope);\n        const index = factoryIndexKey(scope);\n        const page = await store.query({\n          index,\n          limit: input.limit,\n          cursor: input.cursor,\n          order: input.order,\n        });\n        return {\n          entries: page.entries.map((entry) => {\n            const summary = factoryRecordSummarySchema.parse(entry.summary);\n            if (\n              entry.index !== index ||\n              entry.collection !== scope.collection ||\n              summary.collection !== entry.collection ||\n              summary.id !== entry.id\n            )\n              throw new Error(\"Indexed summary identity mismatch\");\n            return { summary, version: z.number().int().positive().parse(entry.version) };\n          }),\n          nextCursor: page.nextCursor,\n        };\n      },\n      count(scope) {\n        return store.count(factoryIndexKey(scope));\n      },\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/store/indexed-memory.d.mts

@@ -0,0 +1,7 @@
+import { IndexedStore } from "./indexed.mjs";
+//#region src/store/indexed-memory.d.ts
+/** Creates an isolated transactional indexed store for local fixtures and tests. */
+declare function createInMemoryIndexedStore(): IndexedStore;
+//#endregion
+export { createInMemoryIndexedStore };
+//# sourceMappingURL=indexed-memory.d.mts.map

package/dist/store/indexed-memory.mjs

@@ -0,0 +1,200 @@
+import { RecordExistsError, RecordNotFoundError, VersionConflictError } from "./driver.mjs";
+import { compareStorageText, matchesRecord, queryIdentity, recordQuerySchema } from "./query.mjs";
+import { StoreOperationConflictError } from "./indexed.mjs";
+import { canonicalJson, collectionNameSchema, decodeCursor, digest, encodeCursor, indexKeySchema, recordIdSchema, sortKeySchema } from "../postgres/indexed-codec.mjs";
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+//#region src/store/indexed-memory.ts
+/** Creates an isolated transactional indexed store for local fixtures and tests. */
+function createInMemoryIndexedStore() {
+	const namespace = randomUUID();
+	let state = {
+		countAttributes: /* @__PURE__ */ new Map(),
+		records: /* @__PURE__ */ new Map(),
+		entries: /* @__PURE__ */ new Map(),
+		operations: /* @__PURE__ */ new Map(),
+		byIndex: /* @__PURE__ */ new Map()
+	};
+	let available = Promise.resolve();
+	function key(collection, id) {
+		return JSON.stringify([collectionNameSchema.parse(collection), recordIdSchema.parse(id)]);
+	}
+	function ordered(left, right) {
+		return compareStorageText(left.sortKey, right.sortKey) || compareStorageText(left.collection, right.collection) || compareStorageText(left.id, right.id);
+	}
+	function pageRows(rows, index, order, limit, encoded) {
+		const cursor = encoded === void 0 ? void 0 : decodeCursor(encoded, namespace, index, order);
+		const sign = order === "asc" ? 1 : -1;
+		const filtered = rows.filter((row) => !cursor || sign * ordered(row, {
+			...cursor,
+			summary: null,
+			version: 0
+		}) > 0).sort((left, right) => sign * ordered(left, right));
+		const entries = filtered.slice(0, limit);
+		const last = entries.at(-1);
+		return {
+			entries: structuredClone(entries),
+			nextCursor: filtered.length > entries.length && last ? encodeCursor({
+				version: 1,
+				namespace,
+				index,
+				order,
+				sortKey: last.sortKey,
+				collection: last.collection,
+				id: last.id
+			}) : null
+		};
+	}
+	function create(snapshot) {
+		const current = () => snapshot ?? state;
+		const changedIndexes = /* @__PURE__ */ new Set();
+		function writableIndex(index) {
+			if (!snapshot) throw new Error("Index writes require a transaction");
+			if (!changedIndexes.has(index)) {
+				snapshot.byIndex.set(index, new Map(snapshot.byIndex.get(index)));
+				changedIndexes.add(index);
+			}
+			return snapshot.byIndex.get(index);
+		}
+		const store = {
+			name: "memory",
+			async transaction(run) {
+				if (snapshot) return run(store);
+				const preceding = available;
+				let release;
+				available = new Promise((resolve) => {
+					release = resolve;
+				});
+				await preceding;
+				try {
+					const next = {
+						records: new Map(state.records),
+						entries: new Map(state.entries),
+						operations: new Map(state.operations),
+						countAttributes: new Map(state.countAttributes),
+						byIndex: new Map(state.byIndex)
+					};
+					const value = await run(create(next));
+					state = next;
+					return value;
+				} finally {
+					release();
+				}
+			},
+			async get(collection, id) {
+				return structuredClone(current().records.get(key(collection, id)) ?? null);
+			},
+			async write(input) {
+				if (!snapshot) return store.transaction((transaction) => transaction.write(input));
+				const recordKey = key(input.collection, input.id);
+				const operationId = recordIdSchema.parse(input.operationId);
+				const expectedVersion = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER - 1).parse(input.expectedVersion);
+				if (input.indexes.length > 32) throw new Error("A record can belong to at most 32 indexes");
+				const indexes = input.indexes.map((entry) => ({
+					index: indexKeySchema.parse(entry.index),
+					sortKey: sortKeySchema.parse(entry.sortKey),
+					summary: JSON.parse(canonicalJson(entry.summary, 8192)),
+					...entry.countGroup ? { countGroup: {
+						group: indexKeySchema.parse(entry.countGroup.group),
+						attributes: JSON.parse(canonicalJson(entry.countGroup.attributes, 8192))
+					} } : {}
+				})).sort((a, b) => compareStorageText(a.index, b.index));
+				if (new Set(indexes.map((entry) => entry.index)).size !== indexes.length) throw new Error("Duplicate index membership");
+				const value = JSON.parse(canonicalJson(input.value, 262144));
+				const fingerprint = digest(canonicalJson({
+					collection: input.collection,
+					id: input.id,
+					expectedVersion,
+					value,
+					indexes
+				}, 614400));
+				const previous = snapshot.operations.get(operationId);
+				if (previous) {
+					if (previous.fingerprint !== fingerprint) throw new StoreOperationConflictError(operationId);
+					return { version: previous.version };
+				}
+				const existing = snapshot.records.get(recordKey);
+				if (expectedVersion === 0 && existing) throw new RecordExistsError(input.collection, input.id);
+				if (expectedVersion > 0 && !existing) throw new RecordNotFoundError(input.collection, input.id);
+				if (existing && existing.version !== expectedVersion) throw new VersionConflictError(input.collection, input.id, expectedVersion);
+				for (const entry of indexes) {
+					const attributes = canonicalJson(entry.countGroup ?? null, 16384);
+					const previous = snapshot.countAttributes.get(entry.index);
+					if (previous !== void 0 && previous !== attributes) throw new Error("Index count attributes are immutable");
+					snapshot.countAttributes.set(entry.index, attributes);
+				}
+				const version = expectedVersion + 1;
+				snapshot.records.set(recordKey, {
+					value,
+					version
+				});
+				for (const entry of snapshot.entries.get(recordKey) ?? []) writableIndex(entry.index).delete(recordKey);
+				const entries = indexes.map((entry) => ({
+					...entry,
+					collection: input.collection,
+					id: input.id,
+					version
+				}));
+				for (const entry of entries) writableIndex(entry.index).set(recordKey, entry);
+				snapshot.entries.set(recordKey, entries);
+				snapshot.operations.set(operationId, {
+					fingerprint,
+					version
+				});
+				return { version };
+			},
+			async query(input) {
+				const index = indexKeySchema.parse(input.index);
+				const limit = z.number().int().min(1).max(100).parse(input.limit);
+				const order = z.enum(["asc", "desc"]).parse(input.order ?? "desc");
+				return pageRows([...current().byIndex.get(index)?.values() ?? []], index, order, limit, input.cursor);
+			},
+			async queryRecords({ sources: inputSources, ...input }) {
+				const sources = z.array(z.strictObject({
+					collection: collectionNameSchema,
+					index: indexKeySchema
+				})).min(1).max(8).parse(inputSources).sort((a, b) => compareStorageText(a.collection, b.collection));
+				if (new Set(sources.map((source) => source.collection)).size !== sources.length) throw new Error("Record queries require exactly one source index per collection");
+				const query = recordQuerySchema.parse(input);
+				const index = `records:${queryIdentity(JSON.stringify(sources), query)}`;
+				const records = current();
+				const rows = sources.flatMap((source) => [...records.byIndex.get(source.index)?.values() ?? []].filter((entry) => entry.collection === source.collection)).filter((entry) => matchesRecord(records.records.get(key(entry.collection, entry.id)).value, {
+					...query,
+					since: void 0,
+					until: void 0
+				}) && (!query.since || entry.sortKey >= query.since) && (!query.until || entry.sortKey < query.until));
+				const page = pageRows(rows, index, query.order, query.limit, query.cursor);
+				return {
+					...query.includeTotal ? { totalCount: rows.length } : {},
+					entries: page.entries.map((entry) => ({
+						collection: entry.collection,
+						id: entry.id,
+						record: structuredClone(records.records.get(key(entry.collection, entry.id)))
+					})),
+					nextCursor: page.nextCursor
+				};
+			},
+			async sumCounts(group, query) {
+				let total = 0;
+				for (const [index, attributes] of current().countAttributes) {
+					const metadata = JSON.parse(attributes);
+					if (metadata?.group === group && matchesRecord(metadata.attributes, {
+						...query,
+						limit: 1
+					})) total += current().byIndex.get(index)?.size ?? 0;
+				}
+				return total;
+			},
+			async count(index) {
+				indexKeySchema.parse(index);
+				return current().byIndex.get(index)?.size ?? 0;
+			}
+		};
+		return store;
+	}
+	return create();
+}
+//#endregion
+export { createInMemoryIndexedStore };
+
+//# sourceMappingURL=indexed-memory.mjs.map

package/dist/store/indexed-memory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-memory.mjs","names":[],"sources":["../../src/store/indexed-memory.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport { z } from \"zod\";\nimport {\n  canonicalJson,\n  collectionNameSchema,\n  decodeCursor,\n  digest,\n  encodeCursor,\n  indexKeySchema,\n  recordIdSchema,\n  sortKeySchema,\n} from \"../postgres/indexed-codec\";\nimport {\n  RecordExistsError,\n  RecordNotFoundError,\n  VersionConflictError,\n  type StoredRecord,\n} from \"./driver\";\nimport { StoreOperationConflictError, type IndexedStore, type StoreIndexRecord } from \"./indexed\";\nimport { compareStorageText, matchesRecord, queryIdentity, recordQuerySchema } from \"./query\";\n\ninterface MemoryState {\n  countAttributes: Map<string, string>;\n  records: Map<string, StoredRecord>;\n  entries: Map<string, StoreIndexRecord[]>;\n  operations: Map<string, { fingerprint: string; version: number }>;\n  byIndex: Map<string, Map<string, StoreIndexRecord>>;\n}\n\n/** Creates an isolated transactional indexed store for local fixtures and tests. */\nexport function createInMemoryIndexedStore(): IndexedStore {\n  const namespace = randomUUID();\n  let state: MemoryState = {\n    countAttributes: new Map(),\n    records: new Map(),\n    entries: new Map(),\n    operations: new Map(),\n    byIndex: new Map(),\n  };\n  let available = Promise.resolve();\n  function key(collection: string, id: string) {\n    return JSON.stringify([collectionNameSchema.parse(collection), recordIdSchema.parse(id)]);\n  }\n  function ordered(left: StoreIndexRecord, right: StoreIndexRecord) {\n    return (\n      compareStorageText(left.sortKey, right.sortKey) ||\n      compareStorageText(left.collection, right.collection) ||\n      compareStorageText(left.id, right.id)\n    );\n  }\n  function pageRows(\n    rows: StoreIndexRecord[],\n    index: string,\n    order: \"asc\" | \"desc\",\n    limit: number,\n    encoded?: string,\n  ) {\n    const cursor =\n      encoded === undefined ? undefined : decodeCursor(encoded, namespace, index, order);\n    const sign = order === \"asc\" ? 1 : -1;\n    const filtered = rows\n      .filter((row) => !cursor || sign * ordered(row, { ...cursor, summary: null, version: 0 }) > 0)\n      .sort((left, right) => sign * ordered(left, right));\n    const entries = filtered.slice(0, limit);\n    const last = entries.at(-1);\n    return {\n      entries: structuredClone(entries),\n      nextCursor:\n        filtered.length > entries.length && last\n          ? encodeCursor({\n              version: 1,\n              namespace,\n              index,\n              order,\n              sortKey: last.sortKey,\n              collection: last.collection,\n              id: last.id,\n            })\n          : null,\n    };\n  }\n  function create(snapshot?: MemoryState): IndexedStore {\n    const current = () => snapshot ?? state;\n    const changedIndexes = new Set<string>();\n    function writableIndex(index: string) {\n      if (!snapshot) throw new Error(\"Index writes require a transaction\");\n      if (!changedIndexes.has(index)) {\n        snapshot.byIndex.set(index, new Map(snapshot.byIndex.get(index)));\n        changedIndexes.add(index);\n      }\n      return snapshot.byIndex.get(index)!;\n    }\n    const store: IndexedStore = {\n      name: \"memory\",\n      async transaction(run) {\n        if (snapshot) return run(store);\n        const preceding = available;\n        let release!: () => void;\n        available = new Promise<void>((resolve) => {\n          release = resolve;\n        });\n        await preceding;\n        try {\n          // Values are replaced on write and cloned at every public read boundary.\n          const next: MemoryState = {\n            records: new Map(state.records),\n            entries: new Map(state.entries),\n            operations: new Map(state.operations),\n            countAttributes: new Map(state.countAttributes),\n            byIndex: new Map(state.byIndex),\n          };\n          const value = await run(create(next));\n          state = next;\n          return value;\n        } finally {\n          release();\n        }\n      },\n      async get(collection, id) {\n        return structuredClone(current().records.get(key(collection, id)) ?? null);\n      },\n      async write(input) {\n        if (!snapshot) return store.transaction((transaction) => transaction.write(input));\n        const recordKey = key(input.collection, input.id);\n        const operationId = recordIdSchema.parse(input.operationId);\n        const expectedVersion = z\n          .number()\n          .int()\n          .min(0)\n          .max(Number.MAX_SAFE_INTEGER - 1)\n          .parse(input.expectedVersion);\n        if (input.indexes.length > 32) throw new Error(\"A record can belong to at most 32 indexes\");\n        const indexes = input.indexes\n          .map((entry) => ({\n            index: indexKeySchema.parse(entry.index),\n            sortKey: sortKeySchema.parse(entry.sortKey),\n            summary: JSON.parse(canonicalJson(entry.summary, 8 * 1024)) as unknown,\n            ...(entry.countGroup\n              ? {\n                  countGroup: {\n                    group: indexKeySchema.parse(entry.countGroup.group),\n                    attributes: JSON.parse(\n                      canonicalJson(entry.countGroup.attributes, 8 * 1024),\n                    ) as unknown,\n                  },\n                }\n              : {}),\n          }))\n          .sort((a, b) => compareStorageText(a.index, b.index));\n        if (new Set(indexes.map((entry) => entry.index)).size !== indexes.length)\n          throw new Error(\"Duplicate index membership\");\n        const value = JSON.parse(canonicalJson(input.value, 256 * 1024)) as unknown;\n        const fingerprint = digest(\n          canonicalJson(\n            { collection: input.collection, id: input.id, expectedVersion, value, indexes },\n            600 * 1024,\n          ),\n        );\n        const previous = snapshot.operations.get(operationId);\n        if (previous) {\n          if (previous.fingerprint !== fingerprint)\n            throw new StoreOperationConflictError(operationId);\n          return { version: previous.version };\n        }\n        const existing = snapshot.records.get(recordKey);\n        if (expectedVersion === 0 && existing)\n          throw new RecordExistsError(input.collection, input.id);\n        if (expectedVersion > 0 && !existing)\n          throw new RecordNotFoundError(input.collection, input.id);\n        if (existing && existing.version !== expectedVersion)\n          throw new VersionConflictError(input.collection, input.id, expectedVersion);\n        for (const entry of indexes) {\n          const attributes = canonicalJson(entry.countGroup ?? null, 16 * 1024);\n          const previous = snapshot.countAttributes.get(entry.index);\n          if (previous !== undefined && previous !== attributes)\n            throw new Error(\"Index count attributes are immutable\");\n          snapshot.countAttributes.set(entry.index, attributes);\n        }\n        const version = expectedVersion + 1;\n        snapshot.records.set(recordKey, { value, version });\n        for (const entry of snapshot.entries.get(recordKey) ?? [])\n          writableIndex(entry.index).delete(recordKey);\n        const entries = indexes.map((entry) => ({\n          ...entry,\n          collection: input.collection,\n          id: input.id,\n          version,\n        }));\n        for (const entry of entries) writableIndex(entry.index).set(recordKey, entry);\n        snapshot.entries.set(recordKey, entries);\n        snapshot.operations.set(operationId, { fingerprint, version });\n        return { version };\n      },\n      async query(input) {\n        const index = indexKeySchema.parse(input.index);\n        const limit = z.number().int().min(1).max(100).parse(input.limit);\n        const order = z.enum([\"asc\", \"desc\"]).parse(input.order ?? \"desc\");\n        return pageRows(\n          [...(current().byIndex.get(index)?.values() ?? [])],\n          index,\n          order,\n          limit,\n          input.cursor,\n        );\n      },\n      async queryRecords({ sources: inputSources, ...input }) {\n        const sources = z\n          .array(z.strictObject({ collection: collectionNameSchema, index: indexKeySchema }))\n          .min(1)\n          .max(8)\n          .parse(inputSources)\n          .sort((a, b) => compareStorageText(a.collection, b.collection));\n        if (new Set(sources.map((source) => source.collection)).size !== sources.length)\n          throw new Error(\"Record queries require exactly one source index per collection\");\n        const query = recordQuerySchema.parse(input);\n        const index = `records:${queryIdentity(JSON.stringify(sources), query)}`;\n        const records = current();\n        const rows = sources\n          .flatMap((source) =>\n            [...(records.byIndex.get(source.index)?.values() ?? [])].filter(\n              (entry) => entry.collection === source.collection,\n            ),\n          )\n          .filter(\n            (entry) =>\n              matchesRecord(records.records.get(key(entry.collection, entry.id))!.value, {\n                ...query,\n                since: undefined,\n                until: undefined,\n              }) &&\n              (!query.since || entry.sortKey >= query.since) &&\n              (!query.until || entry.sortKey < query.until),\n          );\n        const page = pageRows(rows, index, query.order, query.limit, query.cursor);\n        return {\n          ...(query.includeTotal ? { totalCount: rows.length } : {}),\n          entries: page.entries.map((entry) => ({\n            collection: entry.collection,\n            id: entry.id,\n            record: structuredClone(records.records.get(key(entry.collection, entry.id))!),\n          })),\n          nextCursor: page.nextCursor,\n        };\n      },\n      async sumCounts(group, query) {\n        let total = 0;\n        for (const [index, attributes] of current().countAttributes) {\n          const metadata = JSON.parse(attributes) as StoreIndexRecord[\"countGroup\"] | null;\n          if (\n            metadata?.group === group &&\n            matchesRecord(metadata.attributes, { ...query, limit: 1 })\n          )\n            total += current().byIndex.get(index)?.size ?? 0;\n        }\n        return total;\n      },\n      async count(index) {\n        indexKeySchema.parse(index);\n        return current().byIndex.get(index)?.size ?? 0;\n      },\n    };\n    return store;\n  }\n  return create();\n}\n"],"mappings":"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"}