@vercel/factory 0.0.16 → 0.0.18

package/dist/postgres/indexed-codec.mjs

@@ -0,0 +1,137 @@
+import { InvalidStoreQueryError } from "../store/indexed.mjs";
+import { createHash } from "node:crypto";
+import { z } from "zod";
+//#region src/postgres/indexed-codec.ts
+const collections = {
+	approvalRecords: true,
+	applicationState: true,
+	applicationChunks: true,
+	conversations: true,
+	conversationQuestions: true,
+	conversationExecutions: true,
+	repositories: true,
+	signals: true,
+	tasks: true,
+	changes: true,
+	receipts: true,
+	budgets: true,
+	answers: true,
+	sessions: true,
+	externalSessions: true,
+	sessionContinuations: true,
+	sessionNotifications: true,
+	transcripts: true,
+	transcriptBlocks: true,
+	transcriptChunks: true,
+	images: true,
+	questionRoutes: true,
+	taskCatalogs: true,
+	changeCatalogs: true,
+	sessionCatalogs: true,
+	externalSessionCatalogs: true,
+	taskRoutes: true,
+	outboxQueues: true,
+	outboxDeliveries: true,
+	communicationSettings: true,
+	taskGraphs: true,
+	taskMessages: true,
+	taskEffects: true,
+	taskInboxes: true,
+	taskMessageProcessing: true,
+	taskMessageDecisions: true,
+	taskMessageDiscards: true,
+	plannerActivations: true,
+	plannerCancellations: true
+};
+const collectionNameSchema = z.custom((value) => typeof value === "string" && Object.hasOwn(collections, value), "Expected a Factory storage collection");
+function textKey(maxBytes) {
+	return z.string().min(1).max(maxBytes).refine((value) => !/[\0\uD800-\uDFFF]/u.test(value) && Buffer.byteLength(value) <= maxBytes, "Storage key exceeds its UTF-8 limit or contains invalid PostgreSQL text");
+}
+const namespaceSchema = textKey(128);
+const indexKeySchema = textKey(400);
+const recordIdSchema = textKey(200);
+const sortKeySchema = textKey(128);
+const versionSchema = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+function digest(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function canonicalJson(value, maxBytes) {
+	const ancestors = /* @__PURE__ */ new Set();
+	let nodes = 0;
+	let bytes = 0;
+	function addBytes(count) {
+		bytes += count;
+		if (bytes > maxBytes) throw new Error(`Storage JSON exceeds ${maxBytes} bytes`);
+	}
+	function stringBytes(value) {
+		if (value.length > maxBytes) throw new Error(`Storage JSON exceeds ${maxBytes} bytes`);
+		return Buffer.byteLength(JSON.stringify(value));
+	}
+	function visit(entry, depth) {
+		if (++nodes > maxBytes || depth > 32) throw new Error("JSON exceeds storage bounds");
+		if (entry === null || typeof entry === "boolean" || typeof entry === "number" && Number.isFinite(entry)) {
+			addBytes(JSON.stringify(entry).length);
+			return entry;
+		}
+		if (typeof entry === "string" && !/[\0\uD800-\uDFFF]/u.test(entry)) {
+			addBytes(stringBytes(entry));
+			return entry;
+		}
+		if (typeof entry !== "object" || entry === null || ancestors.has(entry)) throw new Error("Storage values must be finite, acyclic JSON");
+		const array = Array.isArray(entry);
+		const prototype = Object.getPrototypeOf(entry);
+		if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null) throw new Error("Storage values must contain only JSON objects and arrays");
+		ancestors.add(entry);
+		addBytes(2);
+		const keys = Reflect.ownKeys(entry);
+		if (keys.length > maxBytes) throw new Error("JSON exceeds storage bounds");
+		if (array && (entry.length > maxBytes || keys.length !== entry.length + 1)) throw new Error("Storage JSON cannot contain sparse or augmented arrays");
+		const entries = [];
+		for (const key of keys) {
+			if (array && key === "length") continue;
+			if (typeof key !== "string" || /[\0\uD800-\uDFFF]/u.test(key)) throw new Error("Storage JSON properties must be valid PostgreSQL text");
+			const descriptor = Object.getOwnPropertyDescriptor(entry, key);
+			if (!descriptor.enumerable || !("value" in descriptor)) throw new Error("Storage JSON cannot contain accessors or non-enumerable properties");
+			if (entries.length > 0) addBytes(1);
+			if (!array) addBytes(stringBytes(key) + 1);
+			entries.push([key, visit(descriptor.value, depth + 1)]);
+		}
+		let result;
+		if (array) {
+			for (let index = 0; index < entry.length; index++) if (!Object.hasOwn(entry, index)) throw new Error("Storage JSON cannot contain array holes");
+			result = entries.map(([, item]) => item);
+		} else {
+			entries.sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+			result = Object.fromEntries(entries);
+		}
+		ancestors.delete(entry);
+		return result;
+	}
+	return JSON.stringify(visit(value, 0));
+}
+const cursorSchema = z.strictObject({
+	version: z.literal(1),
+	namespace: namespaceSchema,
+	index: indexKeySchema,
+	order: z.enum(["asc", "desc"]),
+	sortKey: sortKeySchema,
+	collection: collectionNameSchema,
+	id: recordIdSchema
+});
+function encodeCursor(value) {
+	return Buffer.from(JSON.stringify(value)).toString("base64url");
+}
+function decodeCursor(cursor, namespace, index, order) {
+	try {
+		if (cursor.length > 8192 || !/^[A-Za-z0-9_-]+$/u.test(cursor)) throw new InvalidStoreQueryError();
+		const decoded = cursorSchema.parse(JSON.parse(Buffer.from(cursor, "base64url").toString("utf8")));
+		if (decoded.namespace !== namespace || decoded.index !== index || decoded.order !== order) throw new InvalidStoreQueryError();
+		return decoded;
+	} catch {
+		throw new InvalidStoreQueryError();
+	}
+}
+//#endregion
+export { canonicalJson, collectionNameSchema, decodeCursor, digest, encodeCursor, indexKeySchema, namespaceSchema, recordIdSchema, sortKeySchema, versionSchema };
+
+//# sourceMappingURL=indexed-codec.mjs.map

package/dist/postgres/indexed-codec.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-codec.mjs","names":[],"sources":["../../src/postgres/indexed-codec.ts"],"sourcesContent":["import { InvalidStoreQueryError } from \"../store/indexed\";\nimport { createHash } from \"node:crypto\";\nimport { z } from \"zod\";\nimport type { CollectionName } from \"../store/driver\";\n\nconst collections = {\n  approvalRecords: true,\n  applicationState: true,\n  applicationChunks: true,\n  conversations: true,\n  conversationQuestions: true,\n  conversationExecutions: true,\n  repositories: true,\n  signals: true,\n  tasks: true,\n  changes: true,\n  receipts: true,\n  budgets: true,\n  answers: true,\n  sessions: true,\n  externalSessions: true,\n  sessionContinuations: true,\n  sessionNotifications: true,\n  transcripts: true,\n  transcriptBlocks: true,\n  transcriptChunks: true,\n  images: true,\n  questionRoutes: true,\n  taskCatalogs: true,\n  changeCatalogs: true,\n  sessionCatalogs: true,\n  externalSessionCatalogs: true,\n  taskRoutes: true,\n  outboxQueues: true,\n  outboxDeliveries: true,\n  communicationSettings: true,\n  taskGraphs: true,\n  taskMessages: true,\n  taskEffects: true,\n  taskInboxes: true,\n  taskMessageProcessing: true,\n  taskMessageDecisions: true,\n  taskMessageDiscards: true,\n  plannerActivations: true,\n  plannerCancellations: true,\n} satisfies Record<CollectionName, true>;\n\nexport const collectionNameSchema = z.custom<CollectionName>(\n  (value) => typeof value === \"string\" && Object.hasOwn(collections, value),\n  \"Expected a Factory storage collection\",\n);\n\nfunction textKey(maxBytes: number) {\n  return z\n    .string()\n    .min(1)\n    .max(maxBytes)\n    .refine(\n      (value) => !/[\\0\\uD800-\\uDFFF]/u.test(value) && Buffer.byteLength(value) <= maxBytes,\n      \"Storage key exceeds its UTF-8 limit or contains invalid PostgreSQL text\",\n    );\n}\n\nexport const namespaceSchema = textKey(128);\nexport const indexKeySchema = textKey(400);\nexport const recordIdSchema = textKey(200);\nexport const sortKeySchema = textKey(128);\nexport const versionSchema = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);\n\nexport function digest(value: string): string {\n  return createHash(\"sha256\").update(value).digest(\"hex\");\n}\n\nexport function canonicalJson(value: unknown, maxBytes: number): string {\n  const ancestors = new Set<object>();\n  let nodes = 0;\n  let bytes = 0;\n  function addBytes(count: number) {\n    bytes += count;\n    if (bytes > maxBytes) throw new Error(`Storage JSON exceeds ${maxBytes} bytes`);\n  }\n  function stringBytes(value: string) {\n    if (value.length > maxBytes) throw new Error(`Storage JSON exceeds ${maxBytes} bytes`);\n    return Buffer.byteLength(JSON.stringify(value));\n  }\n  function visit(entry: unknown, depth: number): unknown {\n    if (++nodes > maxBytes || depth > 32) throw new Error(\"JSON exceeds storage bounds\");\n    if (\n      entry === null ||\n      typeof entry === \"boolean\" ||\n      (typeof entry === \"number\" && Number.isFinite(entry))\n    ) {\n      addBytes(JSON.stringify(entry).length);\n      return entry;\n    }\n    if (typeof entry === \"string\" && !/[\\0\\uD800-\\uDFFF]/u.test(entry)) {\n      addBytes(stringBytes(entry));\n      return entry;\n    }\n    if (typeof entry !== \"object\" || entry === null || ancestors.has(entry))\n      throw new Error(\"Storage values must be finite, acyclic JSON\");\n    const array = Array.isArray(entry);\n    const prototype: unknown = Object.getPrototypeOf(entry);\n    if (\n      array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null\n    )\n      throw new Error(\"Storage values must contain only JSON objects and arrays\");\n    ancestors.add(entry);\n    addBytes(2);\n    const keys = Reflect.ownKeys(entry);\n    if (keys.length > maxBytes) throw new Error(\"JSON exceeds storage bounds\");\n    if (array && (entry.length > maxBytes || keys.length !== entry.length + 1))\n      throw new Error(\"Storage JSON cannot contain sparse or augmented arrays\");\n    const entries: [string, unknown][] = [];\n    for (const key of keys) {\n      if (array && key === \"length\") continue;\n      if (typeof key !== \"string\" || /[\\0\\uD800-\\uDFFF]/u.test(key))\n        throw new Error(\"Storage JSON properties must be valid PostgreSQL text\");\n      const descriptor = Object.getOwnPropertyDescriptor(entry, key)!;\n      if (!descriptor.enumerable || !(\"value\" in descriptor))\n        throw new Error(\"Storage JSON cannot contain accessors or non-enumerable properties\");\n      if (entries.length > 0) addBytes(1);\n      if (!array) addBytes(stringBytes(key) + 1);\n      entries.push([key, visit(descriptor.value, depth + 1)]);\n    }\n    let result: unknown;\n    if (array) {\n      for (let index = 0; index < entry.length; index++)\n        if (!Object.hasOwn(entry, index))\n          throw new Error(\"Storage JSON cannot contain array holes\");\n      result = entries.map(([, item]) => item);\n    } else {\n      entries.sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0));\n      result = Object.fromEntries(entries);\n    }\n    ancestors.delete(entry);\n    return result;\n  }\n  return JSON.stringify(visit(value, 0));\n}\n\nconst cursorSchema = z.strictObject({\n  version: z.literal(1),\n  namespace: namespaceSchema,\n  index: indexKeySchema,\n  order: z.enum([\"asc\", \"desc\"]),\n  sortKey: sortKeySchema,\n  collection: collectionNameSchema,\n  id: recordIdSchema,\n});\n\nexport function encodeCursor(value: z.infer<typeof cursorSchema>): string {\n  return Buffer.from(JSON.stringify(value)).toString(\"base64url\");\n}\n\nexport function decodeCursor(cursor: string, namespace: string, index: string, order: string) {\n  try {\n    if (cursor.length > 8192 || !/^[A-Za-z0-9_-]+$/u.test(cursor))\n      throw new InvalidStoreQueryError();\n    const decoded = cursorSchema.parse(\n      JSON.parse(Buffer.from(cursor, \"base64url\").toString(\"utf8\")),\n    );\n    if (decoded.namespace !== namespace || decoded.index !== index || decoded.order !== order)\n      throw new InvalidStoreQueryError();\n    return decoded;\n  } catch {\n    throw new InvalidStoreQueryError();\n  }\n}\n"],"mappings":"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"}

package/dist/postgres/indexed-schema.mjs

@@ -0,0 +1,99 @@
+import { bigint, jsonb, pgTable, primaryKey, text, uniqueIndex } from "drizzle-orm/pg-core";
+//#region src/postgres/indexed-schema.ts
+const indexedRecords = pgTable("factory_indexed_records", {
+	namespace: text("namespace").notNull(),
+	collection: text("collection").$type().notNull(),
+	id: text("id").notNull(),
+	value: jsonb("value").$type().notNull(),
+	version: bigint("version", { mode: "number" }).notNull()
+}, (table) => [primaryKey({ columns: [
+	table.namespace,
+	table.collection,
+	table.id
+] })]);
+const indexedEntries = pgTable("factory_indexed_entries", {
+	namespace: text("namespace").notNull(),
+	index: text("index_key").notNull(),
+	sortKey: text("sort_key").notNull(),
+	collection: text("collection").$type().notNull(),
+	id: text("id").notNull(),
+	version: bigint("version", { mode: "number" }).notNull(),
+	summary: jsonb("summary").$type().notNull()
+}, (table) => [primaryKey({ columns: [
+	table.namespace,
+	table.index,
+	table.sortKey,
+	table.collection,
+	table.id
+] }), uniqueIndex("factory_indexed_entries_record").on(table.namespace, table.collection, table.id, table.index)]);
+const indexedCounts = pgTable("factory_indexed_counts", {
+	namespace: text("namespace").notNull(),
+	index: text("index_key").notNull(),
+	count: bigint("count", { mode: "number" }).notNull(),
+	group: text("group_key"),
+	attributes: jsonb("attributes").$type()
+}, (table) => [primaryKey({ columns: [table.namespace, table.index] })]);
+const indexedOperations = pgTable("factory_indexed_operations", {
+	namespace: text("namespace").notNull(),
+	operationId: text("operation_id").notNull(),
+	fingerprint: text("fingerprint").notNull(),
+	version: bigint("version", { mode: "number" }).notNull()
+}, (table) => [primaryKey({ columns: [table.namespace, table.operationId] })]);
+const indexedMigration = {
+	tag: "0001_indexed_storage",
+	statements: [
+		`CREATE TABLE IF NOT EXISTS "factory_indexed_records" (
+      "namespace" text COLLATE "C" NOT NULL,
+      "collection" text COLLATE "C" NOT NULL,
+      "id" text COLLATE "C" NOT NULL,
+      "value" jsonb NOT NULL,
+      "version" bigint NOT NULL CHECK ("version" BETWEEN 1 AND 9007199254740991),
+      PRIMARY KEY ("namespace", "collection", "id")
+    )`,
+		`CREATE TABLE IF NOT EXISTS "factory_indexed_entries" (
+      "namespace" text COLLATE "C" NOT NULL,
+      "index_key" text COLLATE "C" NOT NULL,
+      "sort_key" text COLLATE "C" NOT NULL,
+      "collection" text COLLATE "C" NOT NULL,
+      "id" text COLLATE "C" NOT NULL,
+      "version" bigint NOT NULL CHECK ("version" BETWEEN 1 AND 9007199254740991),
+      "summary" jsonb NOT NULL,
+      PRIMARY KEY ("namespace", "index_key", "sort_key", "collection", "id"),
+      FOREIGN KEY ("namespace", "collection", "id")
+        REFERENCES "factory_indexed_records" ("namespace", "collection", "id")
+    )`,
+		`CREATE UNIQUE INDEX IF NOT EXISTS "factory_indexed_entries_record"
+      ON "factory_indexed_entries" ("namespace", "collection", "id", "index_key")`,
+		`CREATE TABLE IF NOT EXISTS "factory_indexed_counts" (
+      "namespace" text COLLATE "C" NOT NULL,
+      "index_key" text COLLATE "C" NOT NULL,
+      "count" bigint NOT NULL CHECK ("count" BETWEEN 0 AND 9007199254740991),
+      PRIMARY KEY ("namespace", "index_key")
+    )`,
+		`CREATE TABLE IF NOT EXISTS "factory_indexed_operations" (
+      "namespace" text COLLATE "C" NOT NULL,
+      "operation_id" text COLLATE "C" NOT NULL,
+      "fingerprint" text NOT NULL,
+      "version" bigint NOT NULL CHECK ("version" BETWEEN 1 AND 9007199254740991),
+      PRIMARY KEY ("namespace", "operation_id")
+    )`
+	]
+};
+const indexedReadsMigration = {
+	tag: "0002_indexed_reads",
+	statements: [
+		`ALTER TABLE "factory_indexed_counts" ADD COLUMN IF NOT EXISTS "group_key" text COLLATE "C"`,
+		`ALTER TABLE "factory_indexed_counts" ADD COLUMN IF NOT EXISTS "attributes" jsonb`,
+		`CREATE INDEX IF NOT EXISTS "factory_indexed_counts_group" ON "factory_indexed_counts" ("namespace", "group_key")`,
+		`CREATE INDEX IF NOT EXISTS "factory_indexed_counts_attributes" ON "factory_indexed_counts" USING gin ("attributes" jsonb_path_ops)`,
+		`CREATE INDEX IF NOT EXISTS "factory_conversation_search"
+      ON "factory_indexed_records" USING gin (to_tsvector('simple', coalesce("value"->>'searchText', '')))
+      WHERE "collection" = 'conversations'`,
+		`CREATE INDEX IF NOT EXISTS "factory_indexed_records_value"
+      ON "factory_indexed_records" USING gin ("value" jsonb_path_ops)`
+	]
+};
+//#endregion
+export { indexedCounts, indexedEntries, indexedMigration, indexedOperations, indexedReadsMigration, indexedRecords };
+
+//# sourceMappingURL=indexed-schema.mjs.map

package/dist/postgres/indexed-schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexed-schema.mjs","names":[],"sources":["../../src/postgres/indexed-schema.ts"],"sourcesContent":["import { bigint, jsonb, pgTable, primaryKey, text, uniqueIndex } from \"drizzle-orm/pg-core\";\nimport type { CollectionName } from \"../store/driver\";\nimport type { FactoryMigration } from \"./index\";\n\nexport const indexedRecords = pgTable(\n  \"factory_indexed_records\",\n  {\n    namespace: text(\"namespace\").notNull(),\n    collection: text(\"collection\").$type<CollectionName>().notNull(),\n    id: text(\"id\").notNull(),\n    value: jsonb(\"value\").$type<unknown>().notNull(),\n    version: bigint(\"version\", { mode: \"number\" }).notNull(),\n  },\n  (table) => [primaryKey({ columns: [table.namespace, table.collection, table.id] })],\n);\n\nexport const indexedEntries = pgTable(\n  \"factory_indexed_entries\",\n  {\n    namespace: text(\"namespace\").notNull(),\n    index: text(\"index_key\").notNull(),\n    sortKey: text(\"sort_key\").notNull(),\n    collection: text(\"collection\").$type<CollectionName>().notNull(),\n    id: text(\"id\").notNull(),\n    version: bigint(\"version\", { mode: \"number\" }).notNull(),\n    summary: jsonb(\"summary\").$type<unknown>().notNull(),\n  },\n  (table) => [\n    primaryKey({\n      columns: [table.namespace, table.index, table.sortKey, table.collection, table.id],\n    }),\n    uniqueIndex(\"factory_indexed_entries_record\").on(\n      table.namespace,\n      table.collection,\n      table.id,\n      table.index,\n    ),\n  ],\n);\n\nexport const indexedCounts = pgTable(\n  \"factory_indexed_counts\",\n  {\n    namespace: text(\"namespace\").notNull(),\n    index: text(\"index_key\").notNull(),\n    count: bigint(\"count\", { mode: \"number\" }).notNull(),\n    group: text(\"group_key\"),\n    attributes: jsonb(\"attributes\").$type<unknown>(),\n  },\n  (table) => [primaryKey({ columns: [table.namespace, table.index] })],\n);\n\nexport const indexedOperations = pgTable(\n  \"factory_indexed_operations\",\n  {\n    namespace: text(\"namespace\").notNull(),\n    operationId: text(\"operation_id\").notNull(),\n    fingerprint: text(\"fingerprint\").notNull(),\n    version: bigint(\"version\", { mode: \"number\" }).notNull(),\n  },\n  (table) => [primaryKey({ columns: [table.namespace, table.operationId] })],\n);\n\nexport const indexedMigration: FactoryMigration = {\n  tag: \"0001_indexed_storage\",\n  statements: [\n    `CREATE TABLE IF NOT EXISTS \"factory_indexed_records\" (\n      \"namespace\" text COLLATE \"C\" NOT NULL,\n      \"collection\" text COLLATE \"C\" NOT NULL,\n      \"id\" text COLLATE \"C\" NOT NULL,\n      \"value\" jsonb NOT NULL,\n      \"version\" bigint NOT NULL CHECK (\"version\" BETWEEN 1 AND 9007199254740991),\n      PRIMARY KEY (\"namespace\", \"collection\", \"id\")\n    )`,\n    `CREATE TABLE IF NOT EXISTS \"factory_indexed_entries\" (\n      \"namespace\" text COLLATE \"C\" NOT NULL,\n      \"index_key\" text COLLATE \"C\" NOT NULL,\n      \"sort_key\" text COLLATE \"C\" NOT NULL,\n      \"collection\" text COLLATE \"C\" NOT NULL,\n      \"id\" text COLLATE \"C\" NOT NULL,\n      \"version\" bigint NOT NULL CHECK (\"version\" BETWEEN 1 AND 9007199254740991),\n      \"summary\" jsonb NOT NULL,\n      PRIMARY KEY (\"namespace\", \"index_key\", \"sort_key\", \"collection\", \"id\"),\n      FOREIGN KEY (\"namespace\", \"collection\", \"id\")\n        REFERENCES \"factory_indexed_records\" (\"namespace\", \"collection\", \"id\")\n    )`,\n    `CREATE UNIQUE INDEX IF NOT EXISTS \"factory_indexed_entries_record\"\n      ON \"factory_indexed_entries\" (\"namespace\", \"collection\", \"id\", \"index_key\")`,\n    `CREATE TABLE IF NOT EXISTS \"factory_indexed_counts\" (\n      \"namespace\" text COLLATE \"C\" NOT NULL,\n      \"index_key\" text COLLATE \"C\" NOT NULL,\n      \"count\" bigint NOT NULL CHECK (\"count\" BETWEEN 0 AND 9007199254740991),\n      PRIMARY KEY (\"namespace\", \"index_key\")\n    )`,\n    `CREATE TABLE IF NOT EXISTS \"factory_indexed_operations\" (\n      \"namespace\" text COLLATE \"C\" NOT NULL,\n      \"operation_id\" text COLLATE \"C\" NOT NULL,\n      \"fingerprint\" text NOT NULL,\n      \"version\" bigint NOT NULL CHECK (\"version\" BETWEEN 1 AND 9007199254740991),\n      PRIMARY KEY (\"namespace\", \"operation_id\")\n    )`,\n  ],\n};\n\nexport const indexedReadsMigration: FactoryMigration = {\n  tag: \"0002_indexed_reads\",\n  statements: [\n    `ALTER TABLE \"factory_indexed_counts\" ADD COLUMN IF NOT EXISTS \"group_key\" text COLLATE \"C\"`,\n    `ALTER TABLE \"factory_indexed_counts\" ADD COLUMN IF NOT EXISTS \"attributes\" jsonb`,\n    `CREATE INDEX IF NOT EXISTS \"factory_indexed_counts_group\" ON \"factory_indexed_counts\" (\"namespace\", \"group_key\")`,\n    `CREATE INDEX IF NOT EXISTS \"factory_indexed_counts_attributes\" ON \"factory_indexed_counts\" USING gin (\"attributes\" jsonb_path_ops)`,\n    `CREATE INDEX IF NOT EXISTS \"factory_conversation_search\"\n      ON \"factory_indexed_records\" USING gin (to_tsvector('simple', coalesce(\"value\"->>'searchText', '')))\n      WHERE \"collection\" = 'conversations'`,\n    `CREATE INDEX IF NOT EXISTS \"factory_indexed_records_value\"\n      ON \"factory_indexed_records\" USING gin (\"value\" jsonb_path_ops)`,\n  ],\n};\n"],"mappings":";;AAIA,MAAa,iBAAiB,QAC5B,2BACA;CACE,WAAW,KAAK,WAAW,CAAC,CAAC,QAAQ;CACrC,YAAY,KAAK,YAAY,CAAC,CAAC,MAAsB,CAAC,CAAC,QAAQ;CAC/D,IAAI,KAAK,IAAI,CAAC,CAAC,QAAQ;CACvB,OAAO,MAAM,OAAO,CAAC,CAAC,MAAe,CAAC,CAAC,QAAQ;CAC/C,SAAS,OAAO,WAAW,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,QAAQ;AACzD,IACC,UAAU,CAAC,WAAW,EAAE,SAAS;CAAC,MAAM;CAAW,MAAM;CAAY,MAAM;AAAE,EAAE,CAAC,CAAC,CACpF;AAEA,MAAa,iBAAiB,QAC5B,2BACA;CACE,WAAW,KAAK,WAAW,CAAC,CAAC,QAAQ;CACrC,OAAO,KAAK,WAAW,CAAC,CAAC,QAAQ;CACjC,SAAS,KAAK,UAAU,CAAC,CAAC,QAAQ;CAClC,YAAY,KAAK,YAAY,CAAC,CAAC,MAAsB,CAAC,CAAC,QAAQ;CAC/D,IAAI,KAAK,IAAI,CAAC,CAAC,QAAQ;CACvB,SAAS,OAAO,WAAW,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,QAAQ;CACvD,SAAS,MAAM,SAAS,CAAC,CAAC,MAAe,CAAC,CAAC,QAAQ;AACrD,IACC,UAAU,CACT,WAAW,EACT,SAAS;CAAC,MAAM;CAAW,MAAM;CAAO,MAAM;CAAS,MAAM;CAAY,MAAM;AAAE,EACnF,CAAC,GACD,YAAY,gCAAgC,CAAC,CAAC,GAC5C,MAAM,WACN,MAAM,YACN,MAAM,IACN,MAAM,KACR,CACF,CACF;AAEA,MAAa,gBAAgB,QAC3B,0BACA;CACE,WAAW,KAAK,WAAW,CAAC,CAAC,QAAQ;CACrC,OAAO,KAAK,WAAW,CAAC,CAAC,QAAQ;CACjC,OAAO,OAAO,SAAS,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,QAAQ;CACnD,OAAO,KAAK,WAAW;CACvB,YAAY,MAAM,YAAY,CAAC,CAAC,MAAe;AACjD,IACC,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,MAAM,WAAW,MAAM,KAAK,EAAE,CAAC,CAAC,CACrE;AAEA,MAAa,oBAAoB,QAC/B,8BACA;CACE,WAAW,KAAK,WAAW,CAAC,CAAC,QAAQ;CACrC,aAAa,KAAK,cAAc,CAAC,CAAC,QAAQ;CAC1C,aAAa,KAAK,aAAa,CAAC,CAAC,QAAQ;CACzC,SAAS,OAAO,WAAW,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,QAAQ;AACzD,IACC,UAAU,CAAC,WAAW,EAAE,SAAS,CAAC,MAAM,WAAW,MAAM,WAAW,EAAE,CAAC,CAAC,CAC3E;AAEA,MAAa,mBAAqC;CAChD,KAAK;CACL,YAAY;EACV;;;;;;;;EAQA;;;;;;;;;;;;EAYA;;EAEA;;;;;;EAMA;;;;;;;CAOF;AACF;AAEA,MAAa,wBAA0C;CACrD,KAAK;CACL,YAAY;EACV;EACA;EACA;EACA;EACA;;;EAGA;;CAEF;AACF"}

package/dist/postgres/indexed.d.mts

@@ -0,0 +1,28 @@
+import { IndexedStore } from "../store/indexed.mjs";
+import { FactoryDatabase } from "./index.mjs";
+//#region src/postgres/indexed.d.ts
+/** Customer-owned transactional Postgres connection and isolated generation of Factory state. */
+interface PostgresIndexedStoreOptions {
+  /** Drizzle database supporting interactive transactions, such as node-postgres or Neon Pool. */
+  readonly db: FactoryDatabase;
+  /** Separate environments and fresh cutovers must use distinct namespaces. */
+  readonly namespace: string;
+}
+/**
+ * Creates bounded Postgres persistence with atomic record, summary, count, and retry-receipt writes.
+ *
+ * @remarks
+ * Apply `applyFactoryMigrations` explicitly using a migration role first. Runtime access needs only
+ * SELECT/INSERT on all four indexed tables, UPDATE on records/counts, and DELETE on entries.
+ * Use a primary connection with interactive transactions; Neon HTTP is not supported. Callers own
+ * connection limits/timeouts, schema validation, authorization, and complete index memberships.
+ * Records are limited to 256 KiB, summaries to 8 KiB, and memberships to 32 per record. Queries
+ * fetch at most limit + 1 compact rows using a scoped B-tree seek; counts use a point read.
+ * Operation receipts persist indefinitely. Retry an uncertain write with the identical operation
+ * ID and intent. Pages/counts from separate calls are not a shared snapshot. This opt-in store
+ * has no list/scan, automatic migration, or Blob fallback and cannot replace StoreDriver unchanged.
+ */
+declare function createPostgresIndexedStore(options: PostgresIndexedStoreOptions): IndexedStore;
+//#endregion
+export { PostgresIndexedStoreOptions, createPostgresIndexedStore };
+//# sourceMappingURL=indexed.d.mts.map

package/dist/postgres/indexed.mjs

@@ -0,0 +1,277 @@
+import { RecordExistsError, RecordNotFoundError, VersionConflictError } from "../store/driver.mjs";
+import { compareStorageText, queryIdentity, recordQuerySchema } from "../store/query.mjs";
+import { StoreOperationConflictError } from "../store/indexed.mjs";
+import { canonicalJson, collectionNameSchema, decodeCursor, digest, encodeCursor, indexKeySchema, namespaceSchema, recordIdSchema, sortKeySchema, versionSchema } from "./indexed-codec.mjs";
+import { indexedCounts, indexedEntries, indexedOperations, indexedRecords } from "./indexed-schema.mjs";
+import { recordPredicates } from "./record-predicates.mjs";
+import { z } from "zod";
+import { and, asc, count, desc, eq, gte, inArray, lt, or, sql } from "drizzle-orm";
+import { setTimeout } from "node:timers/promises";
+//#region src/postgres/indexed.ts
+/**
+* Creates bounded Postgres persistence with atomic record, summary, count, and retry-receipt writes.
+*
+* @remarks
+* Apply `applyFactoryMigrations` explicitly using a migration role first. Runtime access needs only
+* SELECT/INSERT on all four indexed tables, UPDATE on records/counts, and DELETE on entries.
+* Use a primary connection with interactive transactions; Neon HTTP is not supported. Callers own
+* connection limits/timeouts, schema validation, authorization, and complete index memberships.
+* Records are limited to 256 KiB, summaries to 8 KiB, and memberships to 32 per record. Queries
+* fetch at most limit + 1 compact rows using a scoped B-tree seek; counts use a point read.
+* Operation receipts persist indefinitely. Retry an uncertain write with the identical operation
+* ID and intent. Pages/counts from separate calls are not a shared snapshot. This opt-in store
+* has no list/scan, automatic migration, or Blob fallback and cannot replace StoreDriver unchanged.
+*/
+function createPostgresIndexedStore(options) {
+	return createIndexedStore(options);
+}
+function retryableTransaction(error) {
+	const seen = /* @__PURE__ */ new Set();
+	let current = error;
+	while (current !== null && typeof current === "object" && !seen.has(current)) {
+		seen.add(current);
+		const code = Reflect.get(current, "code");
+		if (code === "40001" || code === "40P01") return true;
+		current = Reflect.get(current, "cause");
+	}
+	return false;
+}
+function createIndexedStore(options, transactional = false) {
+	const { db } = options;
+	const namespace = namespaceSchema.parse(options.namespace);
+	const recordWhere = (collection, id) => and(eq(indexedRecords.namespace, namespace), eq(indexedRecords.collection, collectionNameSchema.parse(collection)), eq(indexedRecords.id, recordIdSchema.parse(id)));
+	const operationWhere = (operationId) => and(eq(indexedOperations.namespace, namespace), eq(indexedOperations.operationId, operationId));
+	function replay(receipt, fingerprint, operationId) {
+		if (receipt.fingerprint !== fingerprint) throw new StoreOperationConflictError(operationId);
+		return { version: versionSchema.parse(receipt.version) };
+	}
+	const store = {
+		name: "postgres",
+		async transaction(run) {
+			if (transactional) return run(store);
+			for (let attempt = 0;; attempt++) try {
+				return await db.transaction((tx) => run(createIndexedStore({
+					...options,
+					db: tx
+				}, true)), { isolationLevel: "serializable" });
+			} catch (error) {
+				if (attempt >= 4 || !retryableTransaction(error)) throw error;
+				await setTimeout(5 * 2 ** attempt);
+			}
+		},
+		async get(collection, id) {
+			const [record] = await db.select({
+				value: indexedRecords.value,
+				version: indexedRecords.version
+			}).from(indexedRecords).where(recordWhere(collection, id)).limit(1);
+			return record ?? null;
+		},
+		async write(input) {
+			const collection = collectionNameSchema.parse(input.collection);
+			const id = recordIdSchema.parse(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: canonicalJson(entry.summary, 8192),
+				...entry.countGroup ? { countGroup: {
+					group: indexKeySchema.parse(entry.countGroup.group),
+					attributes: canonicalJson(entry.countGroup.attributes, 8192)
+				} } : {}
+			})).sort((left, right) => left.index < right.index ? -1 : left.index > right.index ? 1 : 0);
+			if (new Set(indexes.map((entry) => entry.index)).size !== indexes.length) throw new Error("Duplicate index membership");
+			const value = canonicalJson(input.value, 262144);
+			const fingerprint = digest(JSON.stringify({
+				collection,
+				id,
+				expectedVersion,
+				value,
+				indexes
+			}));
+			const version = expectedVersion + 1;
+			try {
+				const commit = async (tx) => {
+					if ((await tx.insert(indexedOperations).values({
+						namespace,
+						operationId,
+						fingerprint,
+						version
+					}).onConflictDoNothing().returning({ version: indexedOperations.version })).length === 0) {
+						const [receipt] = await tx.select().from(indexedOperations).where(operationWhere(operationId)).limit(1);
+						if (!receipt) throw new Error("Committed operation receipt is missing");
+						return replay(receipt, fingerprint, operationId);
+					}
+					if (expectedVersion === 0) {
+						if ((await tx.insert(indexedRecords).values({
+							namespace,
+							collection,
+							id,
+							version,
+							value: sql`${value}::jsonb`
+						}).onConflictDoNothing().returning({ id: indexedRecords.id })).length === 0) throw new RecordExistsError(collection, id);
+					} else if ((await tx.update(indexedRecords).set({
+						value: sql`${value}::jsonb`,
+						version
+					}).where(and(recordWhere(collection, id), eq(indexedRecords.version, expectedVersion))).returning({ id: indexedRecords.id })).length === 0) {
+						const [existing] = await tx.select({ id: indexedRecords.id }).from(indexedRecords).where(recordWhere(collection, id)).limit(1);
+						if (!existing) throw new RecordNotFoundError(collection, id);
+						throw new VersionConflictError(collection, id, expectedVersion);
+					}
+					const entryWhere = and(eq(indexedEntries.namespace, namespace), eq(indexedEntries.collection, collection), eq(indexedEntries.id, id));
+					const previous = await tx.select({ index: indexedEntries.index }).from(indexedEntries).where(entryWhere).limit(33);
+					if (previous.length > 32) throw new Error("Stored index memberships exceed the write bound");
+					const oldIndexes = new Set(previous.map((entry) => entry.index));
+					const newIndexes = new Set(indexes.map((entry) => entry.index));
+					const retained = indexes.filter((entry) => oldIndexes.has(entry.index));
+					if (retained.length) {
+						const counts = await tx.select({
+							index: indexedCounts.index,
+							group: indexedCounts.group,
+							attributes: indexedCounts.attributes
+						}).from(indexedCounts).where(and(eq(indexedCounts.namespace, namespace), inArray(indexedCounts.index, retained.map((entry) => entry.index))));
+						for (const entry of retained) {
+							const count = counts.find((row) => row.index === entry.index);
+							if (!count || count.group !== (entry.countGroup?.group ?? null) || canonicalJson(count.attributes, 8192) !== (entry.countGroup?.attributes ?? "null")) throw new Error("Index count attributes are immutable");
+						}
+					}
+					for (const index of [.../* @__PURE__ */ new Set([...oldIndexes, ...newIndexes])].sort()) {
+						if (oldIndexes.has(index) && newIndexes.has(index)) continue;
+						if (newIndexes.has(index)) {
+							const facet = indexes.find((entry) => entry.index === index)?.countGroup;
+							const group = facet?.group ?? null;
+							const attributes = facet ? sql`${facet.attributes}::jsonb` : sql`NULL::jsonb`;
+							const increment = oldIndexes.has(index) ? 0 : 1;
+							if ((await tx.insert(indexedCounts).values({
+								namespace,
+								index,
+								count: increment,
+								group,
+								attributes
+							}).onConflictDoUpdate({
+								target: [indexedCounts.namespace, indexedCounts.index],
+								set: { count: sql`${indexedCounts.count} + ${increment}` },
+								setWhere: and(sql`${indexedCounts.group} IS NOT DISTINCT FROM ${group}::text`, sql`${indexedCounts.attributes} IS NOT DISTINCT FROM ${attributes}`)
+							}).returning({ index: indexedCounts.index })).length !== 1) throw new Error("Index count attributes are immutable");
+						} else if ((await tx.update(indexedCounts).set({ count: sql`${indexedCounts.count} - 1` }).where(and(eq(indexedCounts.namespace, namespace), eq(indexedCounts.index, index), gte(indexedCounts.count, 1))).returning({ count: indexedCounts.count })).length !== 1) throw new Error("Index count invariant failed");
+					}
+					await tx.delete(indexedEntries).where(entryWhere);
+					if (indexes.length) await tx.insert(indexedEntries).values(indexes.map((entry) => ({
+						namespace,
+						collection,
+						id,
+						version,
+						index: entry.index,
+						sortKey: entry.sortKey,
+						summary: sql`${entry.summary}::jsonb`
+					})));
+					return { version };
+				};
+				return transactional ? await commit(db) : await db.transaction(commit, { isolationLevel: "read committed" });
+			} catch (error) {
+				if (transactional) throw error;
+				const [receipt] = await db.select().from(indexedOperations).where(operationWhere(operationId)).limit(1).catch(() => []);
+				if (receipt) return replay(receipt, fingerprint, operationId);
+				throw error;
+			}
+		},
+		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");
+			const cursor = input.cursor === void 0 ? void 0 : decodeCursor(input.cursor, namespace, index, order);
+			const position = sql`(${indexedEntries.sortKey}, ${indexedEntries.collection}, ${indexedEntries.id})`;
+			const boundary = cursor ? sql`(${cursor.sortKey}, ${cursor.collection}, ${cursor.id})` : void 0;
+			const direction = order === "asc" ? asc : desc;
+			const rows = await db.select({
+				index: indexedEntries.index,
+				sortKey: indexedEntries.sortKey,
+				collection: indexedEntries.collection,
+				id: indexedEntries.id,
+				version: indexedEntries.version,
+				summary: indexedEntries.summary
+			}).from(indexedEntries).where(and(eq(indexedEntries.namespace, namespace), eq(indexedEntries.index, index), boundary ? order === "asc" ? sql`${position} > ${boundary}` : sql`${position} < ${boundary}` : void 0)).orderBy(direction(indexedEntries.sortKey), direction(indexedEntries.collection), direction(indexedEntries.id)).limit(limit + 1);
+			const entries = rows.slice(0, limit);
+			const last = entries.at(-1);
+			return {
+				entries,
+				nextCursor: rows.length > limit && last ? encodeCursor({
+					version: 1,
+					namespace,
+					index,
+					order,
+					sortKey: last.sortKey,
+					collection: last.collection,
+					id: last.id
+				}) : null
+			};
+		},
+		async queryRecords({ sources: sourceScopes, ...input }) {
+			const sources = z.array(z.strictObject({
+				collection: collectionNameSchema,
+				index: indexKeySchema
+			})).min(1).max(8).parse(sourceScopes).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 cursorScope = `records:${queryIdentity(JSON.stringify(sources), query)}`;
+			const cursor = query.cursor === void 0 ? void 0 : decodeCursor(query.cursor, namespace, cursorScope, query.order);
+			const direction = query.order === "asc" ? asc : desc;
+			const position = sql`(${indexedEntries.sortKey}, ${indexedEntries.collection}, ${indexedEntries.id})`;
+			const boundary = cursor ? sql`(${cursor.sortKey}, ${cursor.collection}, ${cursor.id})` : void 0;
+			const membershipConditions = and(eq(indexedEntries.namespace, namespace), or(...sources.map(({ collection, index }) => and(eq(indexedEntries.collection, collection), eq(indexedEntries.index, index)))), query.since ? gte(indexedEntries.sortKey, query.since) : void 0, query.until ? lt(indexedEntries.sortKey, query.until) : void 0);
+			const conditions = and(membershipConditions, recordPredicates(indexedRecords.value, query));
+			const [{ totalCount } = {}] = query.includeTotal ? await db.select({ totalCount: count() }).from(indexedEntries).innerJoin(indexedRecords, and(eq(indexedRecords.namespace, indexedEntries.namespace), eq(indexedRecords.collection, indexedEntries.collection), eq(indexedRecords.id, indexedEntries.id))).where(conditions) : [];
+			const selectedRecord = db.select({
+				value: indexedRecords.value,
+				version: indexedRecords.version
+			}).from(indexedRecords).where(and(eq(indexedRecords.namespace, indexedEntries.namespace), eq(indexedRecords.collection, indexedEntries.collection), eq(indexedRecords.id, indexedEntries.id), recordPredicates(indexedRecords.value, query))).limit(1).as("selected_record");
+			const rows = await db.select({
+				id: indexedEntries.id,
+				collection: indexedEntries.collection,
+				sortKey: indexedEntries.sortKey,
+				value: selectedRecord.value,
+				version: selectedRecord.version
+			}).from(indexedEntries).innerJoinLateral(selectedRecord, sql`true`).where(and(membershipConditions, boundary ? query.order === "asc" ? sql`${position} > ${boundary}` : sql`${position} < ${boundary}` : void 0)).orderBy(direction(indexedEntries.sortKey), direction(indexedEntries.collection), direction(indexedEntries.id)).limit(query.limit + 1);
+			const page = rows.slice(0, query.limit);
+			const last = page.at(-1);
+			return {
+				...totalCount === void 0 ? {} : { totalCount },
+				entries: page.map(({ collection, id, value, version }) => ({
+					collection,
+					id,
+					record: {
+						value,
+						version
+					}
+				})),
+				nextCursor: rows.length > page.length && last ? encodeCursor({
+					version: 1,
+					namespace,
+					index: cursorScope,
+					order: query.order,
+					collection: last.collection,
+					sortKey: last.sortKey,
+					id: last.id
+				}) : null
+			};
+		},
+		async sumCounts(group, input) {
+			const query = recordQuerySchema.parse({
+				...input,
+				limit: 1
+			});
+			const [row] = await db.select({ total: sql`coalesce(sum(${indexedCounts.count}), 0)` }).from(indexedCounts).where(and(eq(indexedCounts.namespace, namespace), eq(indexedCounts.group, indexKeySchema.parse(group)), recordPredicates(indexedCounts.attributes, query)));
+			return z.coerce.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).parse(row?.total ?? 0);
+		},
+		async count(index) {
+			const [row] = await db.select({ count: indexedCounts.count }).from(indexedCounts).where(and(eq(indexedCounts.namespace, namespace), eq(indexedCounts.index, indexKeySchema.parse(index)))).limit(1);
+			return row?.count ?? 0;
+		}
+	};
+	return store;
+}
+//#endregion
+export { createPostgresIndexedStore };
+
+//# sourceMappingURL=indexed.mjs.map