@supalive/core 1.9.0 → 1.11.0

package/dist/overlap-checker-DvRqQOTe.js

@@ -0,0 +1,265 @@
+import { n as utf8Decode, t as bytesEqual } from "./bytes-AuEkyxeU.js";
+import { a as jsonPathExtract, i as jsonPathExists, r as jsonContains } from "./query-ur-jCtVr.js";
+import { C as normalizeIdToBytes } from "./types_db-B039N8Em.js";
+//#region src/server/overlap-checker.ts
+function mapReadEntryToRaw(entry) {
+	if (entry.kind === "point") return {
+		kind: "point",
+		tableId: entry.tableId,
+		id: normalizeIdToBytes(entry.id),
+		table: entry.table
+	};
+	else return {
+		kind: "range",
+		tableId: entry.tableId,
+		table: entry.table,
+		predicate: entry.predicate,
+		columns: entry.columns,
+		offset: entry.offset,
+		orderBy: entry.orderBy,
+		limit: entry.limit
+	};
+}
+function mapReadSetToRaw(readSet) {
+	return readSet.map(mapReadEntryToRaw);
+}
+function mapWriteEntryToRaw(entry) {
+	return {
+		table: entry.table,
+		tableId: entry.tableId,
+		id: normalizeIdToBytes(entry.id),
+		op: entry.op,
+		data: entry.data,
+		prevData: entry.prevData
+	};
+}
+function mapWriteSetToRaw(writeSet) {
+	return writeSet.map(mapWriteEntryToRaw);
+}
+function evaluatePredicateAgainstRow(rowData, predicate) {
+	switch (predicate.kind) {
+		case "and": {
+			let hasUnknown = false;
+			for (const child of predicate.children) {
+				const r = evaluatePredicateAgainstRow(rowData, child);
+				if (r === "no") return "no";
+				if (r === "unknown") hasUnknown = true;
+			}
+			return hasUnknown ? "unknown" : "yes";
+		}
+		case "or": {
+			let hasUnknown = false;
+			for (const child of predicate.children) {
+				const r = evaluatePredicateAgainstRow(rowData, child);
+				if (r === "yes") return "yes";
+				if (r === "unknown") hasUnknown = true;
+			}
+			return hasUnknown ? "unknown" : "no";
+		}
+		case "leaf": {
+			if (!(predicate.column in rowData)) return "unknown";
+			const val = rowData[predicate.column];
+			switch (predicate.operator) {
+				case "=": return val === predicate.value ? "yes" : "no";
+				case "!=": return val !== predicate.value ? "yes" : "no";
+				case ">": return val > predicate.value ? "yes" : "no";
+				case ">=": return val >= predicate.value ? "yes" : "no";
+				case "<": return val < predicate.value ? "yes" : "no";
+				case "<=": return val <= predicate.value ? "yes" : "no";
+				case "between": return val >= predicate.value && val <= predicate.value2 ? "yes" : "no";
+				case "in": return Array.isArray(predicate.value) && predicate.value.includes(val) ? "yes" : "no";
+				case "like":
+				case "contains":
+				case "ilike":
+				case "icontains": {
+					if (typeof val !== "string" || typeof predicate.value !== "string") return "no";
+					const haystack = predicate.operator === "ilike" || predicate.operator === "icontains" ? val.toLowerCase() : val;
+					const needle = predicate.operator === "ilike" || predicate.operator === "icontains" ? predicate.value.toLowerCase() : predicate.value;
+					const pattern = predicate.operator === "contains" || predicate.operator === "icontains" ? `%${needle}%` : needle;
+					return new RegExp("^" + pattern.replace(/%/g, ".*").replace(/_/g, ".") + "$").test(haystack) ? "yes" : "no";
+				}
+				case "jsonContains": {
+					const candidate = decodeJsonLeafValue(predicate);
+					const target = predicate.path !== void 0 ? jsonPathExtract(val, predicate.path) : val;
+					if (target === void 0) return "no";
+					return jsonContains(target, candidate) ? "yes" : "no";
+				}
+				case "jsonContainedBy": {
+					const candidate = decodeJsonLeafValue(predicate);
+					const target = predicate.path !== void 0 ? jsonPathExtract(val, predicate.path) : val;
+					if (target === void 0) return "no";
+					return jsonContains(candidate, target) ? "yes" : "no";
+				}
+				case "jsonHasKey": {
+					if (predicate.mode && Array.isArray(predicate.value)) {
+						const paths = predicate.value;
+						if (paths.length === 0) return "no";
+						return (predicate.mode === "all" ? paths.every((p) => jsonPathExists(val, p)) : paths.some((p) => jsonPathExists(val, p))) ? "yes" : "no";
+					}
+					if (predicate.raw) return jsonPathExists(val, predicate.value) ? "yes" : "no";
+					const key = predicate.value;
+					if (val === null || typeof val !== "object") return "no";
+					if (Array.isArray(val)) return val.includes(key) ? "yes" : "no";
+					return key in val ? "yes" : "no";
+				}
+				case "jsonArrayContains": {
+					const candidate = decodeJsonLeafValue(predicate);
+					const target = predicate.path !== void 0 ? jsonPathExtract(val, predicate.path) : val;
+					if (!Array.isArray(target)) return "no";
+					return target.some((el) => jsonContains(el, candidate)) ? "yes" : "no";
+				}
+				case "isNull": return val === null ? "yes" : "no";
+				case "isNotNull": return val !== null ? "yes" : "no";
+				default: return "unknown";
+			}
+		}
+	}
+}
+function decodeJsonLeafValue(leaf) {
+	if (!leaf.raw) return leaf.value;
+	if (typeof leaf.value !== "string") return leaf.value;
+	try {
+		return JSON.parse(leaf.value);
+	} catch {
+		return leaf.value;
+	}
+}
+function parseLogData(log) {
+	if (log._parsedData !== void 0) return log._parsedData;
+	const data = log.data.length > 0 ? JSON.parse(utf8Decode(log.data)) : null;
+	log._parsedData = data;
+	return data;
+}
+function checkLogsAffectReadSet(logs, rawReadSet) {
+	for (const log of logs) for (const rawRead of rawReadSet) {
+		if (!bytesEqual(log.tableId, rawRead.tableId)) continue;
+		if (rawRead.kind === "point" ? checkPointReadOverlap(log, rawRead) : checkRangeReadOverlap(log, rawRead)) return true;
+	}
+	return false;
+}
+/**
+* Stateless freshness check shared by the subscription worker's `register` and
+* the main server's one-shot query path. Decides whether a query's cached
+* result (described by `metadata`) is still valid at `currentTs`.
+*
+* It is a pure function of Redis (`metadata`, `minRetainedTs`) + the DB
+* commit-log probes (`hasCommitForPoints` for point-only tables,
+* `getCommitLogsBetweenTs` for range tables) + the read set — it holds no
+* worker-local state, so it is safe to run outside the sub-manager.
+*
+* `minRetainedTs` is the retention watermark: the oldest commit-log ts still
+* retained after prune.
+*
+* Two ways a cache entry is deemed stale:
+*   1. **Retention guard** — `metadata.lastSnapshotTs < minRetainedTs` (or the
+*      watermark is unknown). The between-ts scan would start below the oldest
+*      retained commit log, so it could silently miss pruned commits → we cannot
+*      prove freshness and must recompute. This is the case that a one-shot
+*      (untracked by any subscription, so nothing holds the retention watermark
+*      down) can hit.
+*   2. **Overlap** — a commit in `(lastSnapshotTs, currentTs]` touched the read
+*      set.
+*/
+async function evaluateCacheFreshness(db, metadata, currentTs, minRetainedTs) {
+	if (!metadata) return {
+		fresh: false,
+		readSet: [],
+		rawReadSet: []
+	};
+	const readSet = metadata.readSet;
+	const rawReadSet = mapReadSetToRaw(readSet);
+	if (minRetainedTs === null || metadata.lastSnapshotTs < minRetainedTs) return {
+		fresh: false,
+		readSet,
+		rawReadSet
+	};
+	if (rawReadSet.length === 0) return {
+		fresh: true,
+		readSet,
+		rawReadSet
+	};
+	const beginTs = metadata.lastSnapshotTs + 1n;
+	const endTs = currentTs + 1n;
+	const rangeTables = /* @__PURE__ */ new Map();
+	for (const r of rawReadSet) if (r.kind === "range") rangeTables.set(tableKey(r.tableId), r.tableId);
+	const pointProbes = [];
+	for (const r of rawReadSet) if (r.kind === "point" && !rangeTables.has(tableKey(r.tableId))) pointProbes.push({
+		tableId: r.tableId,
+		id: r.id
+	});
+	if (pointProbes.length > 0) {
+		if (await db.hasCommitForPoints(beginTs, endTs, pointProbes)) return {
+			fresh: false,
+			readSet,
+			rawReadSet
+		};
+	}
+	if (rangeTables.size > 0) {
+		if (checkLogsAffectReadSet(await db.getCommitLogsBetweenTs(beginTs, endTs, [...rangeTables.values()]), rawReadSet)) return {
+			fresh: false,
+			readSet,
+			rawReadSet
+		};
+	}
+	return {
+		fresh: true,
+		readSet,
+		rawReadSet
+	};
+}
+/** Stable hex key for a table-id byte string, for use as a Map/Set key (byte
+* arrays compare by identity, not value). */
+function tableKey(bytes) {
+	let s = "";
+	for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, "0");
+	return s;
+}
+function checkPointReadOverlap(log, rawRead) {
+	return bytesEqual(log.id, rawRead.id);
+}
+function checkRangeReadOverlap(log, rawRead) {
+	const logData = parseLogData(log);
+	if (!logData) return true;
+	const op = logData.op ?? "update";
+	const data = logData.data;
+	const prevData = logData.prevData;
+	return checkRowWriteAffectsRange(op, prevData, data, rawRead.predicate);
+}
+function checkWriteSetAffectsReadSet(writeSet, rawReadSet) {
+	for (const write of writeSet) for (const rawRead of rawReadSet) {
+		if (!bytesEqual(write.tableId, rawRead.tableId)) continue;
+		if (checkWriteAffectsRawReadEntry(write, rawRead)) return true;
+	}
+	return false;
+}
+function checkWriteAffectsRawReadEntry(write, rawRead) {
+	if (rawRead.kind === "point") return bytesEqual(write.id, rawRead.id);
+	return checkRowWriteAffectsRange(write.op, write.prevData, write.data, rawRead.predicate);
+}
+/**
+* Evaluate whether a write affects a range subscription, given the row's
+* prior and post state. The write is considered affecting if EITHER side
+* matched the predicate — that catches:
+*   - rows entering the result set (prev "no", post "yes")
+*   - rows leaving the result set (prev "yes", post "no")
+*   - rows changing while still in the set (prev "yes", post "yes")
+* Skipped only if both sides are a definite "no".
+*
+* When prevData is missing (e.g. inserts, or commit logs predating this
+* change), we fall back to conservative "unknown" on that side.
+*/
+function checkRowWriteAffectsRange(op, prevData, data, predicate) {
+	const prevVerdict = prevData ? evaluatePredicateAgainstRow(prevData, predicate) : op === "insert" ? "no" : "unknown";
+	let postVerdict;
+	if (op === "delete") postVerdict = "no";
+	else if (data) postVerdict = evaluatePredicateAgainstRow(prevData ? {
+		...prevData,
+		...data
+	} : data, predicate);
+	else postVerdict = "unknown";
+	return prevVerdict !== "no" || postVerdict !== "no";
+}
+//#endregion
+export { mapWriteSetToRaw as a, mapReadSetToRaw as i, checkWriteSetAffectsReadSet as n, evaluateCacheFreshness as r, checkLogsAffectReadSet as t };
+
+//# sourceMappingURL=overlap-checker-DvRqQOTe.js.map

package/dist/overlap-checker-DvRqQOTe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"overlap-checker-DvRqQOTe.js","names":[],"sources":["../src/server/overlap-checker.ts"],"sourcesContent":["import type {\n  ReadEntry, CommitLogEntry,\n  Predicate, WriteEntry, WriteOp,\n  RawReadEntry, RawPointRead, RawRangeRead, LeafPredicate,\n  QueryCacheMetadata,\n} from \"../db/types_db\";\nimport { normalizeIdToBytes } from \"../db/types_db\";\nimport { bytesEqual, utf8Decode } from \"../db/bytes\";\nimport { jsonContains, jsonPathExists, jsonPathExtract } from \"../db/query\";\nimport type { Database } from \"../db/db\";\n\nexport interface RawWriteEntry {\n  table: string;\n  tableId: Uint8Array;\n  id: Uint8Array;\n  op: WriteOp;\n  data?: Record<string, unknown>;\n  prevData?: Record<string, unknown>;\n}\n\nexport function mapReadEntryToRaw(entry: ReadEntry): RawReadEntry {\n  if (entry.kind === \"point\") {\n    return {\n      kind: \"point\",\n      tableId: entry.tableId,\n      id: normalizeIdToBytes(entry.id),\n      table: entry.table,\n    };\n  } else {\n    return {\n      kind: \"range\",\n      tableId: entry.tableId,\n      table: entry.table,\n      predicate: entry.predicate,\n      columns: entry.columns,\n      offset: entry.offset,\n      orderBy: entry.orderBy,\n      limit: entry.limit,\n    };\n  }\n}\n\nexport function mapReadSetToRaw(readSet: ReadEntry[]): RawReadEntry[] {\n  return readSet.map(mapReadEntryToRaw);\n}\n\nexport function mapWriteEntryToRaw(entry: WriteEntry): RawWriteEntry {\n  return {\n    table: entry.table,\n    tableId: entry.tableId,\n    id: normalizeIdToBytes(entry.id),\n    op: entry.op,\n    data: entry.data,\n    prevData: entry.prevData,\n  };\n}\n\nexport function mapWriteSetToRaw(writeSet: WriteEntry[]): RawWriteEntry[] {\n  return writeSet.map(mapWriteEntryToRaw);\n}\n\nexport type OverlapVerdict = \"yes\" | \"no\" | \"unknown\";\n\nexport function evaluatePredicateAgainstRow(\n  rowData: Record<string, unknown>,\n  predicate: Predicate\n): OverlapVerdict {\n  switch (predicate.kind) {\n    case \"and\": {\n      let hasUnknown = false;\n      for (const child of predicate.children) {\n        const r = evaluatePredicateAgainstRow(rowData, child);\n        if (r === \"no\") return \"no\";\n        if (r === \"unknown\") hasUnknown = true;\n      }\n      return hasUnknown ? \"unknown\" : \"yes\";\n    }\n    case \"or\": {\n      let hasUnknown = false;\n      for (const child of predicate.children) {\n        const r = evaluatePredicateAgainstRow(rowData, child);\n        if (r === \"yes\") return \"yes\";\n        if (r === \"unknown\") hasUnknown = true;\n      }\n      return hasUnknown ? \"unknown\" : \"no\";\n    }\n    case \"leaf\": {\n      if (!(predicate.column in rowData)) return \"unknown\";\n      const val = rowData[predicate.column];\n      switch (predicate.operator) {\n        case \"=\": return val === predicate.value ? \"yes\" : \"no\";\n        case \"!=\": return val !== predicate.value ? \"yes\" : \"no\";\n        case \">\": return (val as number) > (predicate.value as number) ? \"yes\" : \"no\";\n        case \">=\": return (val as number) >= (predicate.value as number) ? \"yes\" : \"no\";\n        case \"<\": return (val as number) < (predicate.value as number) ? \"yes\" : \"no\";\n        case \"<=\": return (val as number) <= (predicate.value as number) ? \"yes\" : \"no\";\n        case \"between\":\n          return (val as number) >= (predicate.value as number) &&\n            (val as number) <= (predicate.value2 as number) ? \"yes\" : \"no\";\n        case \"in\":\n          return Array.isArray(predicate.value) && (predicate.value as unknown[]).includes(val) ? \"yes\" : \"no\";\n        case \"like\":\n        case \"contains\":\n        case \"ilike\":\n        case \"icontains\": {\n          if (typeof val !== \"string\" || typeof predicate.value !== \"string\") return \"no\";\n          const haystack = (predicate.operator === \"ilike\" || predicate.operator === \"icontains\")\n            ? val.toLowerCase() : val;\n          const needle = (predicate.operator === \"ilike\" || predicate.operator === \"icontains\")\n            ? (predicate.value as string).toLowerCase() : predicate.value as string;\n          const pattern = (predicate.operator === \"contains\" || predicate.operator === \"icontains\")\n            ? `%${needle}%` : needle;\n          const regex = new RegExp(\"^\" + pattern.replace(/%/g, \".*\").replace(/_/g, \".\") + \"$\");\n          return regex.test(haystack) ? \"yes\" : \"no\";\n        }\n        case \"jsonContains\": {\n          const candidate = decodeJsonLeafValue(predicate);\n          const target = predicate.path !== undefined ? jsonPathExtract(val, predicate.path) : val;\n          if (target === undefined) return \"no\";\n          return jsonContains(target, candidate) ? \"yes\" : \"no\";\n        }\n        case \"jsonContainedBy\": {\n          const candidate = decodeJsonLeafValue(predicate);\n          const target = predicate.path !== undefined ? jsonPathExtract(val, predicate.path) : val;\n          if (target === undefined) return \"no\";\n          return jsonContains(candidate, target) ? \"yes\" : \"no\";\n        }\n        case \"jsonHasKey\": {\n          if (predicate.mode && Array.isArray(predicate.value)) {\n            const paths = predicate.value as string[];\n            if (paths.length === 0) return \"no\";\n            const verdict = predicate.mode === \"all\"\n              ? paths.every(p => jsonPathExists(val, p))\n              : paths.some(p => jsonPathExists(val, p));\n            return verdict ? \"yes\" : \"no\";\n          }\n          if (predicate.raw) {\n            return jsonPathExists(val, predicate.value as string) ? \"yes\" : \"no\";\n          }\n          const key = predicate.value as string;\n          if (val === null || typeof val !== \"object\") return \"no\";\n          if (Array.isArray(val)) return (val as unknown[]).includes(key) ? \"yes\" : \"no\";\n          return key in (val as object) ? \"yes\" : \"no\";\n        }\n        case \"jsonArrayContains\": {\n          const candidate = decodeJsonLeafValue(predicate);\n          const target = predicate.path !== undefined ? jsonPathExtract(val, predicate.path) : val;\n          if (!Array.isArray(target)) return \"no\";\n          return (target as unknown[]).some(el => jsonContains(el, candidate)) ? \"yes\" : \"no\";\n        }\n        case \"isNull\": return val === null ? \"yes\" : \"no\";\n        case \"isNotNull\": return val !== null ? \"yes\" : \"no\";\n        default: return \"unknown\";\n      }\n    }\n  }\n}\n\nfunction decodeJsonLeafValue(leaf: LeafPredicate): unknown {\n  if (!leaf.raw) return leaf.value;\n  if (typeof leaf.value !== \"string\") return leaf.value;\n  try { return JSON.parse(leaf.value); } catch { return leaf.value; }\n}\n\nfunction parseLogData(log: CommitLogEntry): Record<string, unknown> | null {\n  if (log._parsedData !== undefined) {\n    return log._parsedData;\n  }\n  const data = log.data.length > 0\n    ? JSON.parse(utf8Decode(log.data)) as Record<string, unknown>\n    : null;\n  log._parsedData = data;\n  return data;\n}\n\n\nexport function checkLogsAffectReadSet(\n  logs: CommitLogEntry[],\n  rawReadSet: RawReadEntry[]\n): boolean {\n  for (const log of logs) {\n    for (const rawRead of rawReadSet) {\n      if (!bytesEqual(log.tableId, rawRead.tableId)) continue;\n\n      const res = rawRead.kind === \"point\" ?\n        checkPointReadOverlap(log, rawRead) :\n        checkRangeReadOverlap(log, rawRead);\n\n      if (res) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nexport interface CacheFreshness {\n  /** true → the cached data for this key is still valid as of `currentTs`. */\n  fresh: boolean;\n  /** The cached read set (empty when there is no usable metadata). */\n  readSet: ReadEntry[];\n  rawReadSet: RawReadEntry[];\n}\n\n/**\n * Stateless freshness check shared by the subscription worker's `register` and\n * the main server's one-shot query path. Decides whether a query's cached\n * result (described by `metadata`) is still valid at `currentTs`.\n *\n * It is a pure function of Redis (`metadata`, `minRetainedTs`) + the DB\n * commit-log probes (`hasCommitForPoints` for point-only tables,\n * `getCommitLogsBetweenTs` for range tables) + the read set — it holds no\n * worker-local state, so it is safe to run outside the sub-manager.\n *\n * `minRetainedTs` is the retention watermark: the oldest commit-log ts still\n * retained after prune.\n *\n * Two ways a cache entry is deemed stale:\n *   1. **Retention guard** — `metadata.lastSnapshotTs < minRetainedTs` (or the\n *      watermark is unknown). The between-ts scan would start below the oldest\n *      retained commit log, so it could silently miss pruned commits → we cannot\n *      prove freshness and must recompute. This is the case that a one-shot\n *      (untracked by any subscription, so nothing holds the retention watermark\n *      down) can hit.\n *   2. **Overlap** — a commit in `(lastSnapshotTs, currentTs]` touched the read\n *      set.\n */\nexport async function evaluateCacheFreshness(\n  db: Pick<Database, \"getCommitLogsBetweenTs\" | \"hasCommitForPoints\">,\n  metadata: QueryCacheMetadata | null,\n  currentTs: bigint,\n  minRetainedTs: bigint | null,\n): Promise<CacheFreshness> {\n  if (!metadata) return { fresh: false, readSet: [], rawReadSet: [] };\n\n  const readSet = metadata.readSet;\n  const rawReadSet = mapReadSetToRaw(readSet);\n\n  if (minRetainedTs === null || metadata.lastSnapshotTs < minRetainedTs) {\n    return { fresh: false, readSet, rawReadSet };\n  }\n\n  // A query that read nothing can't be invalidated by any commit — permanently\n  // fresh (until TTL eviction). Skip the commit-log scan entirely.\n  if (rawReadSet.length === 0) return { fresh: true, readSet, rawReadSet };\n\n  // Window (lastSnapshotTs, currentTs]: commits strictly AFTER the cached\n  // snapshot (the data already reflects everything <= lastSnapshotTs) up to and\n  // INCLUDING currentTs. The DB scans take a half-open [begin, end), so +1n on\n  // both ends models that inclusive upper bound. Missing the upper bound would\n  // drop a mutation committed at exactly currentTs — and a one-shot query has no\n  // push-invalidation backstop, so it would serve stale.\n  const beginTs = metadata.lastSnapshotTs + 1n;\n  const endTs = currentTs + 1n;\n\n  // Partition the read set by how precisely a commit-log check can be pushed to\n  // the DB:\n  //   • range tables — a commit only matters if the row's prev/post state\n  //     satisfies the predicate, which only the in-app evaluator can decide, so\n  //     the row `data` for these tables must be fetched.\n  //   • point-only tables (carry no range read) — overlap is a pure\n  //     (table_id, id) key match, answerable by an existence probe with no blob\n  //     fetch or JSON parse.\n  // A point read whose table ALSO carries a range read is subsumed by that\n  // table's row fetch (checkLogsAffectReadSet re-checks it against those rows),\n  // so it is intentionally excluded from the point probe.\n  const rangeTables = new Map<string, Uint8Array>();\n  for (const r of rawReadSet) {\n    if (r.kind === \"range\") rangeTables.set(tableKey(r.tableId), r.tableId);\n  }\n\n  const pointProbes: { tableId: Uint8Array; id: Uint8Array }[] = [];\n  for (const r of rawReadSet) {\n    if (r.kind === \"point\" && !rangeTables.has(tableKey(r.tableId))) {\n      pointProbes.push({ tableId: r.tableId, id: r.id });\n    }\n  }\n\n  // Point-only tables: one existence probe on exact (table_id, id) pairs — no\n  // data blobs fetched, no predicates evaluated.\n  if (pointProbes.length > 0) {\n    if (await db.hasCommitForPoints(beginTs, endTs, pointProbes)) {\n      return { fresh: false, readSet, rawReadSet };\n    }\n  }\n\n  // Range tables: fetch the window's logs for just those tables and evaluate\n  // predicates (and any point reads subsumed onto them) in-app.\n  if (rangeTables.size > 0) {\n    const logs = await db.getCommitLogsBetweenTs(beginTs, endTs, [...rangeTables.values()]);\n    if (checkLogsAffectReadSet(logs, rawReadSet)) {\n      return { fresh: false, readSet, rawReadSet };\n    }\n  }\n\n  return { fresh: true, readSet, rawReadSet };\n}\n\n/** Stable hex key for a table-id byte string, for use as a Map/Set key (byte\n * arrays compare by identity, not value). */\nfunction tableKey(bytes: Uint8Array): string {\n  let s = \"\";\n  for (let i = 0; i < bytes.length; i++) s += bytes[i].toString(16).padStart(2, \"0\");\n  return s;\n}\n\nfunction checkPointReadOverlap(\n  log: CommitLogEntry,\n  rawRead: RawPointRead,\n): boolean {\n  return bytesEqual(log.id, rawRead.id);\n}\n\nfunction checkRangeReadOverlap(\n  log: CommitLogEntry,\n  rawRead: RawRangeRead\n): boolean {\n  const logData = parseLogData(log);\n\n  // No envelope at all → can't reason, must conflict-out.\n  if (!logData) { \n    return true;\n  }\n\n  // Commit logs serialize the full WriteEntry (see PgDatabase.insertCommitLogs),\n  // so extract the row state from it. Same prev-OR-post check as the\n  // in-memory invalidator path.\n  const op = (logData.op as WriteOp | undefined) ?? \"update\";\n  const data = logData.data as Record<string, unknown> | undefined;\n  const prevData = logData.prevData as Record<string, unknown> | undefined;\n\n  return checkRowWriteAffectsRange(op, prevData, data, rawRead.predicate);\n}\n\nexport function checkWriteSetAffectsReadSet(\n  writeSet: RawWriteEntry[],\n  rawReadSet: RawReadEntry[]\n): boolean {\n  for (const write of writeSet) {\n    for (const rawRead of rawReadSet) {\n      if (!bytesEqual(write.tableId, rawRead.tableId)) continue;\n\n      if (checkWriteAffectsRawReadEntry(write, rawRead)) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n\nfunction checkWriteAffectsRawReadEntry(\n  write: RawWriteEntry,\n  rawRead: RawReadEntry\n): boolean {\n  if (rawRead.kind === \"point\") {\n    return bytesEqual(write.id, rawRead.id);\n  }\n  return checkRowWriteAffectsRange(\n    write.op,\n    write.prevData,\n    write.data,\n    rawRead.predicate,\n  );\n}\n\n/**\n * Evaluate whether a write affects a range subscription, given the row's\n * prior and post state. The write is considered affecting if EITHER side\n * matched the predicate — that catches:\n *   - rows entering the result set (prev \"no\", post \"yes\")\n *   - rows leaving the result set (prev \"yes\", post \"no\")\n *   - rows changing while still in the set (prev \"yes\", post \"yes\")\n * Skipped only if both sides are a definite \"no\".\n *\n * When prevData is missing (e.g. inserts, or commit logs predating this\n * change), we fall back to conservative \"unknown\" on that side.\n */\nfunction checkRowWriteAffectsRange(\n  op: WriteOp,\n  prevData: Record<string, unknown> | undefined,\n  data: Record<string, unknown> | undefined,\n  predicate: RawRangeRead[\"predicate\"],\n): boolean {\n  const prevVerdict: OverlapVerdict = prevData\n    ? evaluatePredicateAgainstRow(prevData, predicate)\n    : (op === \"insert\" ? \"no\" : \"unknown\");\n\n  let postVerdict: OverlapVerdict;\n  if (op === \"delete\") {\n    postVerdict = \"no\";\n  } else if (data) {\n    // Merge over prevData so unchanged columns carry over — otherwise a\n    // partial update (e.g. {title: \"x\"}) would be \"unknown\" on every\n    // predicate column it doesn't touch.\n    const post = prevData ? { ...prevData, ...data } : data;\n    postVerdict = evaluatePredicateAgainstRow(post, predicate);\n  } else {\n    postVerdict = \"unknown\";\n  }\n\n  return prevVerdict !== \"no\" || postVerdict !== \"no\";\n}"],"mappings":"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"}

package/dist/postgres-BKGLPrKt.d.ts

@@ -0,0 +1,113 @@
+import { $r as WriteEntry, Gn as DbType, Hn as CoreInitLockCtx, Jn as PreparedQueries, Kn as LazyCommitTsParam, Qn as CacheLayer, Un as Database, Wn as DbQueryResult, Xn as SqlBuilder, Xr as ReadEntry, Zn as TxDatabase, qn as PooledClient, yr as CommitLogEntry } from "./index-BQRlJY_1.js";
+import { Pool, PoolConfig } from "pg";
+import { Logger } from "pino";
+
+//#region src/db/postgres.d.ts
+declare class PgDatabase implements Database {
+  constructor(logger: Logger, config: PoolConfig, pool?: Pool | undefined);
+  private logger;
+  config: PoolConfig;
+  private pool;
+  readonly sqlBuilder: SqlBuilder;
+  readonly dbType: DbType;
+  columnTypes: Map<string, Map<string, string>>;
+  protected sqlCache: Map<string, string>;
+  /**
+   * Fetches actual column types from Postgres for `table` and returns a
+   * map of DB column name → PG type string (as produced by `format_type`,
+   * e.g. `bigint`, `integer`, `character varying(32)`, `text[]`, `jsonb`).
+   * No caching here — see {@link getColumnTypes} for the cached path.
+   */
+  loadColumnTypesFromPg(table: string): Promise<Map<string, string>>;
+  /**
+   * Synchronous column-type lookup. The apply path calls this on every
+   * batched write, so it can't await — populate the cache via
+   * {@link bootstrapColumnTypes} at server start. Throws if `table` is
+   * missing (programmer error / bootstrap skipped).
+   */
+  getColumnTypes(table: string): Map<string, string> | null;
+  /**
+   * Eagerly load column types into the in-memory cache. With a Redis
+   * client supplied, attempts the cache key first and falls through to
+   * Postgres on miss (writing the result back to Redis). This is the
+   * "one server queries PG, the rest read from Redis" pattern for cold
+   * starts in a multi-instance deploy. Without Redis, always queries PG.
+   *
+   * Pass `tables` to limit the load to a specific list; otherwise every
+   * user table in the connected database is loaded.
+   *
+   * The Redis cache key should encode whatever invalidates types in your
+   * environment (typically a schema version / deploy version). The
+   * subscriber in supalive-server.ts is expected to publish a reload
+   * signal after migrations and invoke {@link invalidateColumnTypes}.
+   */
+  bootstrapColumnTypes(opts: {
+    redis?: CacheLayer;
+    cacheKey: string;
+    tables?: string[];
+  }): Promise<void>;
+  /**
+   * Invalidate cached types (and dependent SQL) for `table`, or the entire
+   * cache if `table` is omitted. The Redis-pubsub reload signal in
+   * supalive-server.ts is expected to call this on schema changes.
+   */
+  private invalidateColumnTypes;
+  /** Enumerate the user-defined tables in the connected database — used
+   * by bootstrapColumnTypes() when no explicit list is provided. */
+  private listUserTables;
+  getCoreVersion(): Promise<bigint>;
+  coreMigrationStatements(toVersion: bigint): string[];
+  withCoreInitLock(fn: (ctx: CoreInitLockCtx) => Promise<void>): Promise<void>;
+  query<T = any>(sql: string, params?: unknown[]): Promise<DbQueryResult<T>>;
+  getClient(): Promise<PooledClient>;
+  getTransactionClient(): Promise<TxDatabase>;
+  /** Internal: replace this instance's caches with shared references from
+   * a parent. Used by PgDatabase.getTransactionClient. */
+  adoptCaches(columnTypes: Map<string, Map<string, string>>, sqlCache: Map<string, string>): void;
+  getLatestSnapshotTimestamp(): Promise<bigint>;
+  updateLatestSnapshotTimestamp(commitTs: bigint): Promise<void>;
+  getMinSnapshotTimestamp(): Promise<bigint>;
+  updateMinSnapshotTimestamp(ts: bigint): Promise<void>;
+  getNextTimestamp(): Promise<bigint>;
+  attachPrevDataToWriteSet(writeSet: WriteEntry[], readSet: ReadEntry[]): Promise<void>;
+  prepareCommitWrites(readSet: ReadEntry[], writeSet: WriteEntry[], commitTs: LazyCommitTsParam): Promise<PreparedQueries>;
+  private pgPrepareBatchWrites;
+  private pgPrepareInsertSingle;
+  private pgPrepareInsertBatch;
+  private pgPrepareUpdateSingle;
+  private pgPrepareUpdateBatch;
+  private pgPrepareDeleteSingle;
+  private pgPrepareDeleteBatch;
+  private buildOrGetInsertSql;
+  private buildOrGetUpdateSql;
+  private buildOrGetDeleteSql;
+  private pgPrepareCommitLogs;
+  /**
+   * Point-only OCC check. For each genuine point read, compare the row's
+   * current commit_ts against the value captured at read time. A `null`
+   * expectedCommitTs means "row didn't exist when we read"; any row found
+   * now is a conflict. Reads whose row is being written in this same txn
+   * are skipped — the CAS UPDATE/DELETE already validated those.
+   */
+  private pgPrepareValidatePointReadsByCommitTs;
+  commitWrites(beginTs: bigint, queries: PreparedQueries, commitTs: bigint): Promise<{
+    success: boolean;
+  }>;
+  private pgApplyWrites;
+  /**
+   * Point-only OCC check. For each genuine point read, compare the row's
+   * current commit_ts against the value captured at read time. A `null`
+   * expectedCommitTs means "row didn't exist when we read"; any row found
+   * now is a conflict. Reads whose row is being written in this same txn
+   * are skipped — the CAS UPDATE/DELETE already validated those.
+   */
+  private validatePointReadsByCommitTs;
+  pruneCommitLogsBefore(ts: bigint): Promise<bigint>;
+  getMinCommitLogTs(): Promise<bigint | null>;
+  getCommitLogsBetweenTs(beginTs: bigint, endTs: bigint, tableIds: Uint8Array[]): Promise<CommitLogEntry[]>;
+  getCommitLogsSinceTs(sinceTs: bigint, excludeTs: bigint, tableIds: Uint8Array[]): Promise<CommitLogEntry[]>;
+  close(): Promise<void>;
+}
+//#endregion
+export { PgDatabase as t };
+//# sourceMappingURL=postgres-BKGLPrKt.d.ts.map

package/dist/postgres-BKGLPrKt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-BKGLPrKt.d.ts","names":[],"sources":["../src/db/postgres.ts"],"mappings":";;;;;cAiBa,UAAA,YAAsB,QAAA;cAE/B,MAAA,EAAQ,MAAA,EACR,MAAA,EAAQ,UAAA,EACR,IAAA,GAAM,IAAA;EAAA,QAWA,MAAA;EACD,MAAA,EAAQ,UAAA;EAAA,QACP,IAAA;EAAA,SACC,UAAA,EAAY,UAAA;EAAA,SACZ,MAAA,EAAQ,MAAA;EAMV,WAAA,EAAa,GAAA,SAAY,GAAA;EAAA,UAGtB,QAAA,EAAU,GAAA;EAHY;;;;;;EAW1B,qBAAA,CAAsB,KAAA,WAAgB,OAAA,CAAQ,GAAA;EAoDhD;;;;;;EA5BJ,cAAA,CAAe,KAAA,WAAgB,GAAA;EAyJ4B;;;;;;;;;;;;;;;EAjIrD,oBAAA,CAAqB,IAAA;IACzB,KAAA,GAAQ,UAAA;IACR,QAAA;IACA,MAAA;EAAA,IACE,OAAA;EAyRD;;;;;EAAA,QA/OK,qBAAA;EA23BsF;;EAAA,QA72BhF,cAAA;EAUR,cAAA,IAAkB,OAAA;EAWxB,uBAAA,CAAwB,SAAA;EAUlB,gBAAA,CAAiB,EAAA,GAAK,GAAA,EAAK,eAAA,KAAoB,OAAA,SAAgB,OAAA;EAsC/D,KAAA,UAAe,GAAA,UAAa,MAAA,eAAyB,OAAA,CAAQ,aAAA,CAAc,CAAA;EAe3E,SAAA,IAAa,OAAA,CAAQ,YAAA;EAIrB,oBAAA,IAAwB,OAAA,CAAQ,UAAA;EAxOL;;EAoPjC,WAAA,CACE,WAAA,EAAa,GAAA,SAAY,GAAA,mBACzB,QAAA,EAAU,GAAA;EAMN,0BAAA,IAA8B,OAAA;EAK9B,6BAAA,CAA8B,QAAA,WAAmB,OAAA;EAOjD,uBAAA,IAA2B,OAAA;EAO3B,0BAAA,CAA2B,EAAA,WAAa,OAAA;EAOxC,gBAAA,IAAoB,OAAA;EAuBpB,wBAAA,CAAyB,QAAA,EAAU,UAAA,IAAc,OAAA,EAAS,SAAA,KAAc,OAAA;EAgExE,mBAAA,CACJ,OAAA,EAAS,SAAA,IACT,QAAA,EAAU,UAAA,IACV,QAAA,EAAU,iBAAA,GACT,OAAA,CAAQ,eAAA;EAAA,QAoBG,oBAAA;EAAA,QA2BN,qBAAA;EAAA,QAkBM,oBAAA;EAAA,QA+DN,qBAAA;EAAA,QAwBM,oBAAA;EAAA,QAsEN,qBAAA;EAAA,QAgBM,oBAAA;EAAA,QAiDN,mBAAA;EAAA,QAqBA,mBAAA;EAAA,QA4BA,mBAAA;EAAA,QAcM,mBAAA;EA3qBR;;;;;;;EAAA,QAytBE,qCAAA;EAkDF,YAAA,CACJ,OAAA,UACA,OAAA,EAAS,eAAA,EACT,QAAA,WACC,OAAA;IAAU,OAAA;EAAA;EAAA,QAqCC,aAAA;EApwBa;;;;;;;EAAA,QA+2Bb,4BAAA;EA0CR,qBAAA,CAAsB,EAAA,WAAa,OAAA;EAQnC,iBAAA,IAAqB,OAAA;EAQrB,sBAAA,CAAuB,OAAA,UAAiB,KAAA,UAAe,QAAA,EAAU,UAAA,KAAe,OAAA,CAAQ,cAAA;EAmBxF,oBAAA,CAAqB,OAAA,UAAiB,SAAA,UAAmB,QAAA,EAAU,UAAA,KAAe,OAAA,CAAQ,cAAA;EAmB1F,KAAA,IAAS,OAAA;AAAA"}

package/dist/postgres-CKBWXyY8.d.ts

@@ -0,0 +1,113 @@
+import { $r as WriteEntry, Gn as DbType, Hn as CoreInitLockCtx, Jn as PreparedQueries, Kn as LazyCommitTsParam, Qn as CacheLayer, Un as Database, Wn as DbQueryResult, Xn as SqlBuilder, Xr as ReadEntry, Zn as TxDatabase, qn as PooledClient, yr as CommitLogEntry } from "./index-D8O39FoZ.js";
+import { Pool, PoolConfig } from "pg";
+import { Logger } from "pino";
+
+//#region src/db/postgres.d.ts
+declare class PgDatabase implements Database {
+  constructor(logger: Logger, config: PoolConfig, pool?: Pool | undefined);
+  private logger;
+  config: PoolConfig;
+  private pool;
+  readonly sqlBuilder: SqlBuilder;
+  readonly dbType: DbType;
+  columnTypes: Map<string, Map<string, string>>;
+  protected sqlCache: Map<string, string>;
+  /**
+   * Fetches actual column types from Postgres for `table` and returns a
+   * map of DB column name → PG type string (as produced by `format_type`,
+   * e.g. `bigint`, `integer`, `character varying(32)`, `text[]`, `jsonb`).
+   * No caching here — see {@link getColumnTypes} for the cached path.
+   */
+  loadColumnTypesFromPg(table: string): Promise<Map<string, string>>;
+  /**
+   * Synchronous column-type lookup. The apply path calls this on every
+   * batched write, so it can't await — populate the cache via
+   * {@link bootstrapColumnTypes} at server start. Throws if `table` is
+   * missing (programmer error / bootstrap skipped).
+   */
+  getColumnTypes(table: string): Map<string, string> | null;
+  /**
+   * Eagerly load column types into the in-memory cache. With a Redis
+   * client supplied, attempts the cache key first and falls through to
+   * Postgres on miss (writing the result back to Redis). This is the
+   * "one server queries PG, the rest read from Redis" pattern for cold
+   * starts in a multi-instance deploy. Without Redis, always queries PG.
+   *
+   * Pass `tables` to limit the load to a specific list; otherwise every
+   * user table in the connected database is loaded.
+   *
+   * The Redis cache key should encode whatever invalidates types in your
+   * environment (typically a schema version / deploy version). The
+   * subscriber in supalive-server.ts is expected to publish a reload
+   * signal after migrations and invoke {@link invalidateColumnTypes}.
+   */
+  bootstrapColumnTypes(opts: {
+    redis?: CacheLayer;
+    cacheKey: string;
+    tables?: string[];
+  }): Promise<void>;
+  /**
+   * Invalidate cached types (and dependent SQL) for `table`, or the entire
+   * cache if `table` is omitted. The Redis-pubsub reload signal in
+   * supalive-server.ts is expected to call this on schema changes.
+   */
+  private invalidateColumnTypes;
+  /** Enumerate the user-defined tables in the connected database — used
+   * by bootstrapColumnTypes() when no explicit list is provided. */
+  private listUserTables;
+  getCoreVersion(): Promise<bigint>;
+  coreMigrationStatements(toVersion: bigint): string[];
+  withCoreInitLock(fn: (ctx: CoreInitLockCtx) => Promise<void>): Promise<void>;
+  query<T = any>(sql: string, params?: unknown[]): Promise<DbQueryResult<T>>;
+  getClient(): Promise<PooledClient>;
+  getTransactionClient(): Promise<TxDatabase>;
+  /** Internal: replace this instance's caches with shared references from
+   * a parent. Used by PgDatabase.getTransactionClient. */
+  adoptCaches(columnTypes: Map<string, Map<string, string>>, sqlCache: Map<string, string>): void;
+  getLatestSnapshotTimestamp(): Promise<bigint>;
+  updateLatestSnapshotTimestamp(commitTs: bigint): Promise<void>;
+  getMinSnapshotTimestamp(): Promise<bigint>;
+  updateMinSnapshotTimestamp(ts: bigint): Promise<void>;
+  getNextTimestamp(): Promise<bigint>;
+  attachPrevDataToWriteSet(writeSet: WriteEntry[], readSet: ReadEntry[]): Promise<void>;
+  prepareCommitWrites(readSet: ReadEntry[], writeSet: WriteEntry[], commitTs: LazyCommitTsParam): Promise<PreparedQueries>;
+  private pgPrepareBatchWrites;
+  private pgPrepareInsertSingle;
+  private pgPrepareInsertBatch;
+  private pgPrepareUpdateSingle;
+  private pgPrepareUpdateBatch;
+  private pgPrepareDeleteSingle;
+  private pgPrepareDeleteBatch;
+  private buildOrGetInsertSql;
+  private buildOrGetUpdateSql;
+  private buildOrGetDeleteSql;
+  private pgPrepareCommitLogs;
+  /**
+   * Point-only OCC check. For each genuine point read, compare the row's
+   * current commit_ts against the value captured at read time. A `null`
+   * expectedCommitTs means "row didn't exist when we read"; any row found
+   * now is a conflict. Reads whose row is being written in this same txn
+   * are skipped — the CAS UPDATE/DELETE already validated those.
+   */
+  private pgPrepareValidatePointReadsByCommitTs;
+  commitWrites(beginTs: bigint, queries: PreparedQueries, commitTs: bigint): Promise<{
+    success: boolean;
+  }>;
+  private pgApplyWrites;
+  /**
+   * Point-only OCC check. For each genuine point read, compare the row's
+   * current commit_ts against the value captured at read time. A `null`
+   * expectedCommitTs means "row didn't exist when we read"; any row found
+   * now is a conflict. Reads whose row is being written in this same txn
+   * are skipped — the CAS UPDATE/DELETE already validated those.
+   */
+  private validatePointReadsByCommitTs;
+  pruneCommitLogsBefore(ts: bigint): Promise<bigint>;
+  getMinCommitLogTs(): Promise<bigint | null>;
+  getCommitLogsBetweenTs(beginTs: bigint, endTs: bigint, tableIds: Uint8Array[]): Promise<CommitLogEntry[]>;
+  getCommitLogsSinceTs(sinceTs: bigint, excludeTs: bigint, tableIds: Uint8Array[]): Promise<CommitLogEntry[]>;
+  close(): Promise<void>;
+}
+//#endregion
+export { PgDatabase as t };
+//# sourceMappingURL=postgres-CKBWXyY8.d.ts.map

package/dist/postgres-CKBWXyY8.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-CKBWXyY8.d.ts","names":[],"sources":["../src/db/postgres.ts"],"mappings":";;;;;cAiBa,UAAA,YAAsB,QAAA;cAE/B,MAAA,EAAQ,MAAA,EACR,MAAA,EAAQ,UAAA,EACR,IAAA,GAAM,IAAA;EAAA,QAWA,MAAA;EACD,MAAA,EAAQ,UAAA;EAAA,QACP,IAAA;EAAA,SACC,UAAA,EAAY,UAAA;EAAA,SACZ,MAAA,EAAQ,MAAA;EAMV,WAAA,EAAa,GAAA,SAAY,GAAA;EAAA,UAGtB,QAAA,EAAU,GAAA;EAHY;;;;;;EAW1B,qBAAA,CAAsB,KAAA,WAAgB,OAAA,CAAQ,GAAA;EAoDhD;;;;;;EA5BJ,cAAA,CAAe,KAAA,WAAgB,GAAA;EAyJ4B;;;;;;;;;;;;;;;EAjIrD,oBAAA,CAAqB,IAAA;IACzB,KAAA,GAAQ,UAAA;IACR,QAAA;IACA,MAAA;EAAA,IACE,OAAA;EAyRD;;;;;EAAA,QA/OK,qBAAA;EA23BsF;;EAAA,QA72BhF,cAAA;EAUR,cAAA,IAAkB,OAAA;EAWxB,uBAAA,CAAwB,SAAA;EAUlB,gBAAA,CAAiB,EAAA,GAAK,GAAA,EAAK,eAAA,KAAoB,OAAA,SAAgB,OAAA;EAsC/D,KAAA,UAAe,GAAA,UAAa,MAAA,eAAyB,OAAA,CAAQ,aAAA,CAAc,CAAA;EAe3E,SAAA,IAAa,OAAA,CAAQ,YAAA;EAIrB,oBAAA,IAAwB,OAAA,CAAQ,UAAA;EAxOL;;EAoPjC,WAAA,CACE,WAAA,EAAa,GAAA,SAAY,GAAA,mBACzB,QAAA,EAAU,GAAA;EAMN,0BAAA,IAA8B,OAAA;EAK9B,6BAAA,CAA8B,QAAA,WAAmB,OAAA;EAOjD,uBAAA,IAA2B,OAAA;EAO3B,0BAAA,CAA2B,EAAA,WAAa,OAAA;EAOxC,gBAAA,IAAoB,OAAA;EAuBpB,wBAAA,CAAyB,QAAA,EAAU,UAAA,IAAc,OAAA,EAAS,SAAA,KAAc,OAAA;EAgExE,mBAAA,CACJ,OAAA,EAAS,SAAA,IACT,QAAA,EAAU,UAAA,IACV,QAAA,EAAU,iBAAA,GACT,OAAA,CAAQ,eAAA;EAAA,QAoBG,oBAAA;EAAA,QA2BN,qBAAA;EAAA,QAkBM,oBAAA;EAAA,QA+DN,qBAAA;EAAA,QAwBM,oBAAA;EAAA,QAsEN,qBAAA;EAAA,QAgBM,oBAAA;EAAA,QAiDN,mBAAA;EAAA,QAqBA,mBAAA;EAAA,QA4BA,mBAAA;EAAA,QAcM,mBAAA;EA3qBR;;;;;;;EAAA,QAytBE,qCAAA;EAkDF,YAAA,CACJ,OAAA,UACA,OAAA,EAAS,eAAA,EACT,QAAA,WACC,OAAA;IAAU,OAAA;EAAA;EAAA,QAqCC,aAAA;EApwBa;;;;;;;EAAA,QA+2Bb,4BAAA;EA0CR,qBAAA,CAAsB,EAAA,WAAa,OAAA;EAQnC,iBAAA,IAAqB,OAAA;EAQrB,sBAAA,CAAuB,OAAA,UAAiB,KAAA,UAAe,QAAA,EAAU,UAAA,KAAe,OAAA,CAAQ,cAAA;EAmBxF,oBAAA,CAAqB,OAAA,UAAiB,SAAA,UAAmB,QAAA,EAAU,UAAA,KAAe,OAAA,CAAQ,cAAA;EAmB1F,KAAA,IAAS,OAAA;AAAA"}