@supalive/core 1.1.0 → 1.2.1

package/dist/src/exports/subscription-manager-worker-entry.js

@@ -1,5 +1,5 @@
-import { i as mapWriteSetToRaw } from "../../overlap-checker-Ct_HP_iB.js";
-import { C as UpdateSubscriptionReadSetParamsSchema, _ as RegisterSubscriptionParamsSchema, a as initCacheLayer, h as RegisterSubscriptionBatchParamsSchema, i as createDatabase, p as InvalidateWritesetParamsSchema, t as SubscriptionWorker, x as UnregisterSubscriptionsParamsSchema, y as UnregisterSubscriptionParamsSchema } from "../../subscription-worker-CqoWp6zB.js";
+import { a as mapWriteSetToRaw } from "../../overlap-checker-ClJC0nxW.js";
+import { a as createDatabase, b as UpdateSubscriptionReadSetParamsSchema, f as RegisterSubscriptionBatchParamsSchema, g as UnregisterSubscriptionParamsSchema, m as RegisterSubscriptionParamsSchema, o as initCacheLayer, t as SubscriptionWorker, u as InvalidateWritesetParamsSchema, v as UnregisterSubscriptionsParamsSchema } from "../../subscription-worker-B2XtjFWY.js";
 import { parentPort } from "node:worker_threads";
 //#region src/server/subscription-manager-worker-entry.ts
 if (!parentPort) throw new Error("subscription-manager-worker-entry must run inside a worker_threads Worker");
@@ -17,7 +17,6 @@ async function init(payload) {
 		commandMaxRetries: 5,
 		createSubClient: false
 	});
-	let db;
 	if (payload.database.type === "postgres") db = createDatabase({
 		type: "postgres",
 		connectionString: payload.database.connectionString,
@@ -73,11 +72,15 @@ async function dispatch(req) {
 		case 9: return db.getLatestSnapshotTimestamp();
 		case 10: {
 			const ts = req.payload;
-			return db.pruneCommitLogsBefore(ts);
+			return worker.prune(ts);
 		}
+		case 12: return worker.refreshRetentionWatermark();
+		case 13:
+			worker.setRetentionWatermark(req.payload);
+			return null;
 		case 11:
 			try {
-				await void 0;
+				await db?.close();
 			} catch (_) {}
 			try {
 				await void 0;

package/dist/src/exports/subscription-manager-worker-entry.js.map

@@ -1 +1 @@
-{"version":3,"file":"subscription-manager-worker-entry.js","names":[],"sources":["../../../src/server/subscription-manager-worker-entry.ts"],"sourcesContent":["import { parentPort } from \"node:worker_threads\";\nimport Redis from \"ioredis\";\nimport type { Database } from \"../db/db\";\nimport { mapWriteSetToRaw } from \"./overlap-checker\";\nimport {\n  InvalidateWritesetParamsSchema,\n  RegisterSubscriptionBatchParamsSchema,\n  RegisterSubscriptionParamsSchema,\n  UnregisterSubscriptionParamsSchema,\n  UnregisterSubscriptionsParamsSchema,\n  UpdateSubscriptionReadSetParamsSchema,\n} from \"./subscription-manager-types\";\nimport { SubscriptionWorker } from \"./subscription-worker\";\nimport {\n  MsgType,\n  type WorkerInitPayload,\n  type WorkerRequest,\n  type WorkerResponse,\n} from \"./subscription-manager-worker-protocol\";\nimport { createDatabase, initCacheLayer } from \"../db/init_db\";\n\nif (!parentPort) {\n  throw new Error(\"subscription-manager-worker-entry must run inside a worker_threads Worker\");\n}\n\nconst port = parentPort;\n\nlet worker: SubscriptionWorker | null = null;\nlet db: Database | null = null;\nlet redis: Redis | null = null;\n\nasync function init(payload: WorkerInitPayload): Promise<void> {\n  const { cacheLayer } = initCacheLayer({\n    upstash: {\n      url: `https://${process.env.UPSTASH_REDIS_HOST}`,\n      token: process.env.UPSTASH_REDIS_TOKEN ?? \"\",\n      redisUrl: process.env.UPSTASH_REDIS_URL ?? \"\"\n    },\n    cacheTtlSeconds: payload.cacheTTLSeconds,\n    commandMaxRetries: 5,\n    createSubClient: false,\n  });\n\n  let db: Database;\n  if (payload.database.type === \"postgres\") {\n    db = createDatabase({\n      type: \"postgres\",\n      connectionString: payload.database.connectionString,\n      maxConnections: payload.maxConnectionsPerWorker,\n      minConnections: payload.database.minConnections ?? 1,\n      idleTimeoutMillis: payload.database.idleTimeoutMillis ?? 30_000,\n      connectionTimeoutMillis: payload.database.connectionTimeoutMillis ?? 7_000,\n    }, payload.workerId);\n  } else {\n    db = createDatabase({\n      type: \"mysql\",\n      connectionString: payload.database.connectionString,\n      maxConnections: payload.maxConnectionsPerWorker,\n      minConnections: payload.database.minConnections ?? 1,\n      idleTimeoutMillis: payload.database.idleTimeoutMillis ?? 30_000,\n      connectionTimeoutMillis: payload.database.connectionTimeoutMillis ?? 7_000,\n      queueLimit: payload.database.queueLimit ?? 0,\n    }, payload.workerId);\n  }\n\n  worker = new SubscriptionWorker(payload.workerId, cacheLayer, db);\n}\n\nasync function dispatch(req: WorkerRequest): Promise<unknown> {\n  if (req.type === MsgType.Init) {\n    await init(req.payload as WorkerInitPayload);\n    return null;\n  }\n\n  if (!worker) {\n    throw new Error(\"Worker received message before Init\");\n  }\n\n  switch (req.type) {\n    case MsgType.Register: {\n      const params = RegisterSubscriptionParamsSchema.parse(req.payload);\n      return worker.register(params);\n    }\n    case MsgType.RegisterBatch: {\n      const params = RegisterSubscriptionBatchParamsSchema.parse(req.payload);\n      return Promise.all(params.map((p) => worker!.register(p)));\n    }\n    case MsgType.UpdateReadSet: {\n      const params = UpdateSubscriptionReadSetParamsSchema.parse(req.payload);\n      return worker.updateReadSet(params);\n    }\n    case MsgType.Unregister: {\n      const params = UnregisterSubscriptionParamsSchema.parse(req.payload);\n      return worker.unregister(params);\n    }\n    case MsgType.Unregisters: {\n      const params = UnregisterSubscriptionsParamsSchema.parse(req.payload);\n      return worker.unregisters(params);\n    }\n    case MsgType.Invalidate: {\n      const { writeSet } = InvalidateWritesetParamsSchema.parse(req.payload);\n      const rawWriteSet = mapWriteSetToRaw(writeSet);\n      return worker.invalidate(rawWriteSet);\n    }\n    case MsgType.MinSubscriptionTs: {\n      const m = worker.minSubscriptionTs();\n      // bigint isn't structured-cloneable via JSON; postMessage handles\n      // bigints natively, so we return it as-is.\n      return m;\n    }\n    case MsgType.LatestSnapshotTs: {\n      return db!.getLatestSnapshotTimestamp();\n    }\n    case MsgType.Prune: {\n      const ts = req.payload as bigint;\n      return db!.pruneCommitLogsBefore(ts);\n    }\n    case MsgType.Shutdown: {\n      try { await db?.close(); } catch (_) { /* ignore */ }\n      try { await (redis as any)?.quit?.(); } catch (_) { /* ignore */ }\n      return null;\n    }\n    default: {\n      throw new Error(`Unknown MsgType: ${req.type satisfies never}`);\n    }\n  }\n}\n\nport.on(\"message\", async (req: WorkerRequest) => {\n  try {\n    const result = await dispatch(req);\n    const res: WorkerResponse = { reqId: req.reqId, ok: true, result };\n    port.postMessage(res);\n  } catch (err) {\n    const e = err as Error;\n    const res: WorkerResponse = {\n      reqId: req.reqId,\n      ok: false,\n      error: { message: e?.message ?? String(err), stack: e?.stack },\n    };\n    port.postMessage(res);\n  }\n});\n"],"mappings":"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"}
+{"version":3,"file":"subscription-manager-worker-entry.js","names":[],"sources":["../../../src/server/subscription-manager-worker-entry.ts"],"sourcesContent":["import { parentPort } from \"node:worker_threads\";\nimport Redis from \"ioredis\";\nimport type { Database } from \"../db/db\";\nimport { mapWriteSetToRaw } from \"./overlap-checker\";\nimport {\n  InvalidateWritesetParamsSchema,\n  RegisterSubscriptionBatchParamsSchema,\n  RegisterSubscriptionParamsSchema,\n  UnregisterSubscriptionParamsSchema,\n  UnregisterSubscriptionsParamsSchema,\n  UpdateSubscriptionReadSetParamsSchema,\n} from \"./subscription-manager-types\";\nimport { SubscriptionWorker } from \"./subscription-worker\";\nimport {\n  MsgType,\n  type WorkerInitPayload,\n  type WorkerRequest,\n  type WorkerResponse,\n} from \"./subscription-manager-worker-protocol\";\nimport { createDatabase, initCacheLayer } from \"../db/init_db\";\n\nif (!parentPort) {\n  throw new Error(\"subscription-manager-worker-entry must run inside a worker_threads Worker\");\n}\n\nconst port = parentPort;\n\nlet worker: SubscriptionWorker | null = null;\nlet db: Database | null = null;\nlet redis: Redis | null = null;\n\nasync function init(payload: WorkerInitPayload): Promise<void> {\n  const { cacheLayer } = initCacheLayer({\n    upstash: {\n      url: `https://${process.env.UPSTASH_REDIS_HOST}`,\n      token: process.env.UPSTASH_REDIS_TOKEN ?? \"\",\n      redisUrl: process.env.UPSTASH_REDIS_URL ?? \"\"\n    },\n    cacheTtlSeconds: payload.cacheTTLSeconds,\n    commandMaxRetries: 5,\n    createSubClient: false,\n  });\n\n  if (payload.database.type === \"postgres\") {\n    db = createDatabase({\n      type: \"postgres\",\n      connectionString: payload.database.connectionString,\n      maxConnections: payload.maxConnectionsPerWorker,\n      minConnections: payload.database.minConnections ?? 1,\n      idleTimeoutMillis: payload.database.idleTimeoutMillis ?? 30_000,\n      connectionTimeoutMillis: payload.database.connectionTimeoutMillis ?? 7_000,\n    }, payload.workerId);\n  } else {\n    db = createDatabase({\n      type: \"mysql\",\n      connectionString: payload.database.connectionString,\n      maxConnections: payload.maxConnectionsPerWorker,\n      minConnections: payload.database.minConnections ?? 1,\n      idleTimeoutMillis: payload.database.idleTimeoutMillis ?? 30_000,\n      connectionTimeoutMillis: payload.database.connectionTimeoutMillis ?? 7_000,\n      queueLimit: payload.database.queueLimit ?? 0,\n    }, payload.workerId);\n  }\n\n  worker = new SubscriptionWorker(payload.workerId, cacheLayer, db);\n}\n\nasync function dispatch(req: WorkerRequest): Promise<unknown> {\n  if (req.type === MsgType.Init) {\n    await init(req.payload as WorkerInitPayload);\n    return null;\n  }\n\n  if (!worker) {\n    throw new Error(\"Worker received message before Init\");\n  }\n\n  switch (req.type) {\n    case MsgType.Register: {\n      const params = RegisterSubscriptionParamsSchema.parse(req.payload);\n      return worker.register(params);\n    }\n    case MsgType.RegisterBatch: {\n      const params = RegisterSubscriptionBatchParamsSchema.parse(req.payload);\n      return Promise.all(params.map((p) => worker!.register(p)));\n    }\n    case MsgType.UpdateReadSet: {\n      const params = UpdateSubscriptionReadSetParamsSchema.parse(req.payload);\n      return worker.updateReadSet(params);\n    }\n    case MsgType.Unregister: {\n      const params = UnregisterSubscriptionParamsSchema.parse(req.payload);\n      return worker.unregister(params);\n    }\n    case MsgType.Unregisters: {\n      const params = UnregisterSubscriptionsParamsSchema.parse(req.payload);\n      return worker.unregisters(params);\n    }\n    case MsgType.Invalidate: {\n      const { writeSet } = InvalidateWritesetParamsSchema.parse(req.payload);\n      const rawWriteSet = mapWriteSetToRaw(writeSet);\n      return worker.invalidate(rawWriteSet);\n    }\n    case MsgType.MinSubscriptionTs: {\n      const m = worker.minSubscriptionTs();\n      // bigint isn't structured-cloneable via JSON; postMessage handles\n      // bigints natively, so we return it as-is.\n      return m;\n    }\n    case MsgType.LatestSnapshotTs: {\n      return db!.getLatestSnapshotTimestamp();\n    }\n    case MsgType.Prune: {\n      const ts = req.payload as bigint;\n      // Route through the worker so it deletes AND republishes the new watermark.\n      return worker.prune(ts);\n    }\n    case MsgType.RefreshRetentionWatermark: {\n      // Seed/repair the watermark from the DB and return it so the manager can\n      // fan it out to the other workers.\n      return worker.refreshRetentionWatermark();\n    }\n    case MsgType.SetRetentionWatermark: {\n      worker.setRetentionWatermark(req.payload as bigint);\n      return null;\n    }\n    case MsgType.Shutdown: {\n      try { await db?.close(); } catch (_) { /* ignore */ }\n      try { await (redis as any)?.quit?.(); } catch (_) { /* ignore */ }\n      return null;\n    }\n    default: {\n      throw new Error(`Unknown MsgType: ${req.type satisfies never}`);\n    }\n  }\n}\n\nport.on(\"message\", async (req: WorkerRequest) => {\n  try {\n    const result = await dispatch(req);\n    const res: WorkerResponse = { reqId: req.reqId, ok: true, result };\n    port.postMessage(res);\n  } catch (err) {\n    const e = err as Error;\n    const res: WorkerResponse = {\n      reqId: req.reqId,\n      ok: false,\n      error: { message: e?.message ?? String(err), stack: e?.stack },\n    };\n    port.postMessage(res);\n  }\n});\n"],"mappings":"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"}

package/dist/src/exports/types.d.ts

@@ -1,4 +1,4 @@
-import { $n as CompareOperator, A as ResponseMessageSchema, Ar as RetryConfig, B as SubscriptionUpdateMessageSchema, C as ClientMessageSchema, Cr as RawPointReadSchema, D as ErrorMessage, Dr as RawReadEntrySchema, E as Context, Er as RawReadEntry, F as SubscribeMessage, Fr as bytesFromJson, H as UnsubscribeMessageSchema, I as SubscribeMessageSchema, Ir as normalizeIdToBytes, Jn as BigIntSchema, Kn as AndPredicate, L as SubscriptionGoneMessage, Lr as normalizeToBytes, M as ServerMessageSchema, Mr as WriteEntrySchema, N as ServerPingMessage, Nr as WriteOp, O as IsInternal, Or as ReadEntry, P as ServerPingMessageSchema, Pr as WriteOpSchema, Qn as CommitTs, R as SubscriptionGoneMessageSchema, S as ClientMessage, Sr as RawPointRead, T as ConnectedMessageSchema, Tr as RawRangeReadSchema, V as UnsubscribeMessage, Xn as CachedPgMetadataSchema, Yn as CachedPgMetadata, Zn as CommitLogEntry, _ as AuthSuccessMessage, _r as QueryCacheMetadata, ar as MutationResult, b as CallMessage, br as RangeRead, cr as OccConflictError, dr as PointRead, er as CompareOperatorSchema, fr as PointReadSchema, g as AuthMessageSchema, gr as QueryCacheEntrySchema, h as AuthMessage, hr as QueryCacheEntry, ir as LiveResult, j as ServerMessage, jr as WriteEntry, k as ResponseMessage, kr as ReadEntrySchema, lr as OrPredicate, m as AuthFailedMessageSchema, mr as PredicateSchema, nr as LeafPredicate, or as NO_RETRY, p as AuthFailedMessage, pr as Predicate, qn as AndPredicateSchema, rr as LeafPredicateSchema, sr as OccAbortError, tr as DEFAULT_RETRY, ur as OrPredicateSchema, v as AuthSuccessMessageSchema, vr as QueryCacheMetadataSchema, w as ConnectedMessage, wr as RawRangeRead, x as CallMessageSchema, xr as RangeReadSchema, y as AuthenticationError, yr as QuerySpec, z as SubscriptionUpdateMessage } from "../../index-DouKwYL6.js";
+import { $n as AndPredicate, A as ResponseMessageSchema, Ar as RawPointReadSchema, B as SubscriptionUpdateMessageSchema, Br as WriteOp, C as ClientMessageSchema, Cr as QueryCacheEntrySchema, D as ErrorMessage, Dr as RangeRead, E as Context, Er as QuerySpec, F as SubscribeMessage, Fr as ReadEntry, H as UnsubscribeMessageSchema, Hr as bytesFromJson, I as SubscribeMessageSchema, Ir as ReadEntrySchema, L as SubscriptionGoneMessage, Lr as RetryConfig, M as ServerMessageSchema, Mr as RawRangeReadSchema, N as ServerPingMessage, Nr as RawReadEntry, O as IsInternal, Or as RangeReadSchema, P as ServerPingMessageSchema, Pr as RawReadEntrySchema, R as SubscriptionGoneMessageSchema, Rr as WriteEntry, S as ClientMessage, Sr as QueryCacheEntry, T as ConnectedMessageSchema, Tr as QueryCacheMetadataSchema, Ur as normalizeIdToBytes, V as UnsubscribeMessage, Vr as WriteOpSchema, Wr as normalizeToBytes, _ as AuthSuccessMessage, _r as OrPredicateSchema, ar as CommitTs, b as CallMessage, br as Predicate, cr as DEFAULT_RETRY, dr as LiveResult, er as AndPredicateSchema, fr as MutationResult, g as AuthMessageSchema, gr as OrPredicate, h as AuthMessage, hr as OccConflictError, ir as CommitLogEntry, j as ServerMessage, jr as RawRangeRead, k as ResponseMessage, kr as RawPointRead, lr as LeafPredicate, m as AuthFailedMessageSchema, mr as OccAbortError, nr as CachedPgMetadata, or as CompareOperator, p as AuthFailedMessage, pr as NO_RETRY, rr as CachedPgMetadataSchema, sr as CompareOperatorSchema, tr as BigIntSchema, ur as LeafPredicateSchema, v as AuthSuccessMessageSchema, vr as PointRead, w as ConnectedMessage, wr as QueryCacheMetadata, x as CallMessageSchema, xr as PredicateSchema, y as AuthenticationError, yr as PointReadSchema, z as SubscriptionUpdateMessage, zr as WriteEntrySchema } from "../../index-DJYvJYR4.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-CiacMqje.js";
-import { _ as UpstashConfig, a as RemoteSubscriptionMessage, c as RemoteSubscriptionUpdateSchema, d as SubscriptionEntry, f as DatabaseConfig, g as SupaliveServerConfig, h as SubscriptionManagerConfig, i as RemoteRecomputeRaceSchema, l as Session, m as PostgresConfig, n as PendingMutation, o as RemoteSubscriptionMessageSchema, p as MySQLConfig, r as RemoteRecomputeRace, s as RemoteSubscriptionUpdate, t as InstanceId, u as SubId } from "../../types_server-BW1ys_SK.js";
-export { AndPredicate, AndPredicateSchema, AuthFailedMessage, AuthFailedMessageSchema, AuthMessage, AuthMessageSchema, AuthSuccessMessage, AuthSuccessMessageSchema, AuthenticationError, BigIntSchema, CachedPgMetadata, CachedPgMetadataSchema, CallMessage, CallMessageSchema, ClientMessage, ClientMessageSchema, CommitLogEntry, CommitTs, CompareOperator, CompareOperatorSchema, ConnectedMessage, ConnectedMessageSchema, Context, DEFAULT_RETRY, DatabaseConfig, ErrorMessage, InstanceId, IsInternal, LeafPredicate, LeafPredicateSchema, LiveResult, MutationResult, MySQLConfig, NO_RETRY, OccAbortError, OccConflictError, OrPredicate, OrPredicateSchema, PendingMutation, PointRead, PointReadSchema, PostgresConfig, Predicate, PredicateSchema, QueryCacheEntry, QueryCacheEntrySchema, QueryCacheMetadata, QueryCacheMetadataSchema, QuerySpec, RangeRead, RangeReadSchema, RawPointRead, RawPointReadSchema, RawRangeRead, RawRangeReadSchema, RawReadEntry, RawReadEntrySchema, ReadEntry, ReadEntrySchema, RemoteRecomputeRace, RemoteRecomputeRaceSchema, RemoteSubscriptionMessage, RemoteSubscriptionMessageSchema, RemoteSubscriptionUpdate, RemoteSubscriptionUpdateSchema, ResponseMessage, ResponseMessageSchema, RetryConfig, ServerMessage, ServerMessageSchema, ServerPingMessage, ServerPingMessageSchema, Session, SubId, SubscribeMessage, SubscribeMessageSchema, SubscriptionEntry, SubscriptionGoneMessage, SubscriptionGoneMessageSchema, SubscriptionManagerConfig, SubscriptionUpdateMessage, SubscriptionUpdateMessageSchema, SupaliveServerConfig, UnsubscribeMessage, UnsubscribeMessageSchema, UpstashConfig, WriteEntry, WriteEntrySchema, WriteOp, WriteOpSchema, bytesFromJson, groupByToMap, normalizeIdToBytes, normalizeToBytes, stableStringify, supaliveStringify };
+import { _ as RpcRateLimitConfig, a as RemoteSubscriptionMessage, b as UpstashConfig, c as RemoteSubscriptionUpdateSchema, d as SubscriptionEntry, f as DatabaseConfig, g as RpcCorsConfig, h as RpcConfig, i as RemoteRecomputeRaceSchema, l as Session, m as PostgresConfig, n as PendingMutation, o as RemoteSubscriptionMessageSchema, p as MySQLConfig, r as RemoteRecomputeRace, s as RemoteSubscriptionUpdate, t as InstanceId, u as SubId, v as SubscriptionManagerConfig, y as SupaliveServerConfig } from "../../types_server-wW3ZgE7l.js";
+export { AndPredicate, AndPredicateSchema, AuthFailedMessage, AuthFailedMessageSchema, AuthMessage, AuthMessageSchema, AuthSuccessMessage, AuthSuccessMessageSchema, AuthenticationError, BigIntSchema, CachedPgMetadata, CachedPgMetadataSchema, CallMessage, CallMessageSchema, ClientMessage, ClientMessageSchema, CommitLogEntry, CommitTs, CompareOperator, CompareOperatorSchema, ConnectedMessage, ConnectedMessageSchema, Context, DEFAULT_RETRY, DatabaseConfig, ErrorMessage, InstanceId, IsInternal, LeafPredicate, LeafPredicateSchema, LiveResult, MutationResult, MySQLConfig, NO_RETRY, OccAbortError, OccConflictError, OrPredicate, OrPredicateSchema, PendingMutation, PointRead, PointReadSchema, PostgresConfig, Predicate, PredicateSchema, QueryCacheEntry, QueryCacheEntrySchema, QueryCacheMetadata, QueryCacheMetadataSchema, QuerySpec, RangeRead, RangeReadSchema, RawPointRead, RawPointReadSchema, RawRangeRead, RawRangeReadSchema, RawReadEntry, RawReadEntrySchema, ReadEntry, ReadEntrySchema, RemoteRecomputeRace, RemoteRecomputeRaceSchema, RemoteSubscriptionMessage, RemoteSubscriptionMessageSchema, RemoteSubscriptionUpdate, RemoteSubscriptionUpdateSchema, ResponseMessage, ResponseMessageSchema, RetryConfig, RpcConfig, RpcCorsConfig, RpcRateLimitConfig, ServerMessage, ServerMessageSchema, ServerPingMessage, ServerPingMessageSchema, Session, SubId, SubscribeMessage, SubscribeMessageSchema, SubscriptionEntry, SubscriptionGoneMessage, SubscriptionGoneMessageSchema, SubscriptionManagerConfig, SubscriptionUpdateMessage, SubscriptionUpdateMessageSchema, SupaliveServerConfig, UnsubscribeMessage, UnsubscribeMessageSchema, UpstashConfig, WriteEntry, WriteEntrySchema, WriteOp, WriteOpSchema, bytesFromJson, groupByToMap, normalizeIdToBytes, normalizeToBytes, stableStringify, supaliveStringify };

package/dist/src/exports/types.js

@@ -1,5 +1,5 @@
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-wGbzz6zo.js";
-import { C as normalizeIdToBytes, S as bytesFromJson, _ as RawRangeReadSchema, a as DEFAULT_RETRY, b as WriteEntrySchema, c as OccAbortError, d as PointReadSchema, f as PredicateSchema, g as RawPointReadSchema, h as RangeReadSchema, i as CompareOperatorSchema, l as OccConflictError, m as QueryCacheMetadataSchema, n as BigIntSchema, o as LeafPredicateSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, s as NO_RETRY, t as AndPredicateSchema, u as OrPredicateSchema, v as RawReadEntrySchema, w as normalizeToBytes, x as WriteOpSchema, y as ReadEntrySchema } from "../../types_db-DXj_l9n-.js";
+import { C as normalizeIdToBytes, S as bytesFromJson, _ as RawRangeReadSchema, a as DEFAULT_RETRY, b as WriteEntrySchema, c as OccAbortError, d as PointReadSchema, f as PredicateSchema, g as RawPointReadSchema, h as RangeReadSchema, i as CompareOperatorSchema, l as OccConflictError, m as QueryCacheMetadataSchema, n as BigIntSchema, o as LeafPredicateSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, s as NO_RETRY, t as AndPredicateSchema, u as OrPredicateSchema, v as RawReadEntrySchema, w as normalizeToBytes, x as WriteOpSchema, y as ReadEntrySchema } from "../../types_db-CTRm_awX.js";
 import { a as CallMessageSchema, c as ResponseMessageSchema, d as SubscribeMessageSchema, f as SubscriptionGoneMessageSchema, i as AuthenticationError, l as ServerMessageSchema, m as UnsubscribeMessageSchema, n as AuthMessageSchema, o as ClientMessageSchema, p as SubscriptionUpdateMessageSchema, r as AuthSuccessMessageSchema, s as ConnectedMessageSchema, t as AuthFailedMessageSchema, u as ServerPingMessageSchema } from "../../types_client_rpc-CIsjQQGG.js";
 import { n as RemoteSubscriptionMessageSchema, r as RemoteSubscriptionUpdateSchema, t as RemoteRecomputeRaceSchema } from "../../types_server-Dk6o_B7N.js";
 export { AndPredicateSchema, AuthFailedMessageSchema, AuthMessageSchema, AuthSuccessMessageSchema, AuthenticationError, BigIntSchema, CachedPgMetadataSchema, CallMessageSchema, ClientMessageSchema, CompareOperatorSchema, ConnectedMessageSchema, DEFAULT_RETRY, LeafPredicateSchema, NO_RETRY, OccAbortError, OccConflictError, OrPredicateSchema, PointReadSchema, PredicateSchema, QueryCacheEntrySchema, QueryCacheMetadataSchema, RangeReadSchema, RawPointReadSchema, RawRangeReadSchema, RawReadEntrySchema, ReadEntrySchema, RemoteRecomputeRaceSchema, RemoteSubscriptionMessageSchema, RemoteSubscriptionUpdateSchema, ResponseMessageSchema, ServerMessageSchema, ServerPingMessageSchema, SubscribeMessageSchema, SubscriptionGoneMessageSchema, SubscriptionUpdateMessageSchema, UnsubscribeMessageSchema, WriteEntrySchema, WriteOpSchema, bytesFromJson, groupByToMap, normalizeIdToBytes, normalizeToBytes, stableStringify, supaliveStringify };

package/dist/{subscription-worker-CqoWp6zB.js → subscription-worker-B2XtjFWY.js}

@@ -1,15 +1,86 @@
 import { r as supaliveStringify } from "./helper-wGbzz6zo.js";
-import { b as WriteEntrySchema, m as QueryCacheMetadataSchema, n as BigIntSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, y as ReadEntrySchema } from "./types_db-DXj_l9n-.js";
-import { n as checkWriteSetAffectsReadSet, r as mapReadSetToRaw, t as checkLogsAffectReadSet } from "./overlap-checker-Ct_HP_iB.js";
-import { t as MySqlDatabase } from "./mysql-bvnjYWvZ.js";
-import { t as PgDatabase } from "./postgres-B8u1YN8X.js";
-import { t as SupaliveDb } from "./realtime_db-DOCgqbwi.js";
+import { b as WriteEntrySchema, m as QueryCacheMetadataSchema, n as BigIntSchema, p as QueryCacheEntrySchema, r as CachedPgMetadataSchema, y as ReadEntrySchema } from "./types_db-CTRm_awX.js";
+import { i as mapReadSetToRaw, n as checkWriteSetAffectsReadSet, r as evaluateCacheFreshness } from "./overlap-checker-ClJC0nxW.js";
+import { t as MySqlDatabase } from "./mysql-C0mysDQ_.js";
+import { t as PgDatabase } from "./postgres-SvdXfb0w.js";
+import { t as SupaliveDb } from "./realtime_db-BtwBABDY.js";
 import z from "zod";
 import { v4 } from "uuid";
 import { ExponentialBackoff, handleAll, retry } from "cockatiel";
 import pino from "pino";
 import "pino-pretty";
+import { createHash } from "node:crypto";
 import Redis$1 from "ioredis";
+//#region src/logger.ts
+const appInstanceId = `instance-${v4().slice(0, 8)}`;
+const isProduction = process.env.ENV === "prod";
+const logger$1 = pino({
+	level: process.env.LOG_LEVEL || "info",
+	timestamp: pino.stdTimeFunctions.isoTime,
+	redact: { paths: ["user.password"] },
+	transport: isProduction ? void 0 : {
+		target: "pino-pretty",
+		options: { colorize: true }
+	},
+	serializers: { "columnsTypes": (map) => {
+		if (map instanceof Map) return serializeMapValue(map);
+		return map;
+	} },
+	base: { "srv": appInstanceId }
+});
+function logLevelOf(name) {
+	const defaultLogLevel = process.env.DEFAULT_LOG_LEVEL || "info";
+	return process.env[name]?.toLowerCase() || defaultLogLevel;
+}
+function serializeMapValue(map) {
+	const obj = {};
+	for (const [k, v] of map.entries()) {
+		obj[k] = {};
+		if (v instanceof Map) for (const [innerK, innerV] of v.entries()) obj[k][innerK] = innerV;
+		else obj[k] = v;
+	}
+	return obj;
+}
+//#endregion
+//#region src/server/retention-watermark.ts
+/** Redis pub/sub channel the sub-manager publishes the retention watermark on
+* after each prune (and at startup). App-server instances subscribe and update
+* their in-memory {@link RetentionWatermark}. Payload is the watermark `ts` as a
+* string. */
+const RETENTION_WATERMARK_CHANNEL = "supalive:retention_watermark";
+/**
+* In-memory holder for the commit-log retention watermark: the oldest commit-log
+* ts still retained after prune (see {@link Database.getMinSnapshotTimestamp}).
+* Read on the hot path by the query-cache freshness check — a plain variable, no
+* per-check Redis/DB round trip. Loaded once at startup from the `metadata`
+* table and kept fresh out-of-band: the sub-manager broadcasts the new watermark
+* (in-process to its workers, over Redis pub/sub to app servers) each time it
+* prunes.
+*
+* `set` is monotonic — the watermark only ever moves forward (pruning never
+* un-deletes rows), so an out-of-order or stale update can never lower it, which
+* keeps the freshness guard on the safe side (an over-estimate only costs an
+* extra recompute; an under-estimate could serve stale data).
+*
+* Initial value is the -1n genesis (not 0), matching `getMinSnapshotTimestamp`
+* and the empty-DB snapshot ts — so before anything is pruned the guard never
+* rejects a genesis-era entry (whose snapshot is -1).
+*/
+var RetentionWatermark = class {
+	ts = -1n;
+	get() {
+		return this.ts;
+	}
+	set(ts) {
+		if (ts > this.ts) this.ts = ts;
+	}
+	/** Seed from the persisted watermark (metadata table). Returns the current value. */
+	async loadFrom(db) {
+		this.set(await db.getMinSnapshotTimestamp());
+		return this.ts;
+	}
+};
+//#endregion
 //#region src/server/subscription-manager-types.ts
 const RegisterSubscriptionParamsSchema = z.object({
 	/**
@@ -35,7 +106,8 @@ const RegisterSubscriptionParamsSchema = z.object({
 const RegisterSubscriptionResultSchema = z.object({
 	cacheKey: z.string(),
 	recompute: z.boolean(),
-	readSet: z.array(ReadEntrySchema)
+	readSet: z.array(ReadEntrySchema),
+	version: z.string().optional()
 });
 const RegisterSubscriptionBatchParamsSchema = z.array(RegisterSubscriptionParamsSchema);
 const RegisterSubscriptionBatchResultSchema = z.array(RegisterSubscriptionResultSchema);
@@ -82,37 +154,6 @@ const RegistrationRecordSchema = z.object({
 	cacheKey: z.string()
 });
 //#endregion
-//#region src/logger.ts
-const appInstanceId = `instance-${v4().slice(0, 8)}`;
-const isProduction = process.env.ENV === "prod";
-const logger$1 = pino({
-	level: process.env.LOG_LEVEL || "info",
-	timestamp: pino.stdTimeFunctions.isoTime,
-	redact: { paths: ["user.password"] },
-	transport: isProduction ? void 0 : {
-		target: "pino-pretty",
-		options: { colorize: true }
-	},
-	serializers: { "columnsTypes": (map) => {
-		if (map instanceof Map) return serializeMapValue(map);
-		return map;
-	} },
-	base: { "srv": appInstanceId }
-});
-function logLevelOf(name) {
-	const defaultLogLevel = process.env.DEFAULT_LOG_LEVEL || "info";
-	return process.env[name]?.toLowerCase() || defaultLogLevel;
-}
-function serializeMapValue(map) {
-	const obj = {};
-	for (const [k, v] of map.entries()) {
-		obj[k] = {};
-		if (v instanceof Map) for (const [innerK, innerV] of v.entries()) obj[k][innerK] = innerV;
-		else obj[k] = v;
-	}
-	return obj;
-}
-//#endregion
 //#region src/db/cache.ts
 const logger = logger$1.child({ "name": "CACHE_LAYER" }, { level: logLevelOf("SERVER_LOG_LEVEL") });
 const redisRetryPolicy = retry(handleAll, {
@@ -123,18 +164,123 @@ const redisRetryPolicy = retry(handleAll, {
 		exponent: 2
 	})
 });
+/** Atomic one-shot recompute write: set data + metadata iff incoming version
+*  (ARGV[3]) is not older than the stored one. KEYS: data, meta. */
+const WRITE_DATA_AND_META = `
+local cur = redis.call('GET', KEYS[2])
+if cur then
+  local ok, m = pcall(cjson.decode, cur)
+  if ok and type(m) == 'table' and m.version and tonumber(ARGV[3]) < tonumber(m.version) then
+    return 0
+  end
+end
+redis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[4]))
+redis.call('SET', KEYS[2], ARGV[2], 'EX', tonumber(ARGV[4]))
+return 1`;
+/** Data-only write (subscribe path): set data iff incoming version (ARGV[2]) is
+*  not older than the stored metadata's version. KEYS: data, meta. */
+const WRITE_DATA_ONLY = `
+local cur = redis.call('GET', KEYS[2])
+if cur then
+  local ok, m = pcall(cjson.decode, cur)
+  if ok and type(m) == 'table' and m.version and tonumber(ARGV[2]) < tonumber(m.version) then
+    return 0
+  end
+end
+redis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[3]))
+return 1`;
+/** Metadata-only replace (subscription recompute): set meta iff incoming version
+*  (ARGV[2]) is not older than the stored one. KEYS: meta. */
+const REPLACE_META = `
+local cur = redis.call('GET', KEYS[1])
+if cur then
+  local ok, m = pcall(cjson.decode, cur)
+  if ok and type(m) == 'table' and m.version and tonumber(ARGV[2]) < tonumber(m.version) then
+    return 0
+  end
+end
+redis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[3]))
+return 1`;
+/** Metadata-only horizon advance (still-fresh subscription): bump lastSnapshotTs
+*  ONLY, without recomputing. Applies ARGV[1] iff the new horizon (ARGV[2]) is
+*  strictly ahead of the stored one AND no newer computation (stored.version >
+*  ARGV[3], the version the caller based its advance on) has landed meanwhile —
+*  so an advance never reverts a fresh recompute. KEYS: meta. */
+const ADVANCE_META = `
+local cur = redis.call('GET', KEYS[1])
+if not cur then return 0 end
+local ok, m = pcall(cjson.decode, cur)
+if not ok or type(m) ~= 'table' then return 0 end
+if tonumber(ARGV[2]) <= tonumber(m.lastSnapshotTs) then return 0 end
+if m.version and tonumber(m.version) > tonumber(ARGV[3]) then return 0 end
+redis.call('SET', KEYS[1], ARGV[1], 'EX', tonumber(ARGV[4]))
+return 1`;
 var CacheLayer = class {
 	redis;
 	ttlSeconds;
+	/** Cached EVALSHA digests keyed by Lua source (see evalScript). */
+	scriptShaCache = /* @__PURE__ */ new Map();
 	constructor(upstash, ttlSeconds = 3600) {
 		this.redis = upstash;
 		this.ttlSeconds = ttlSeconds;
 	}
-	async setQueryCacheFor(cacheKey, data, ttlSeconds) {
-		const combined = supaliveStringify({ data });
-		await redisRetryPolicy.execute(async () => {
-			await this.redis.setex(this.getQueryCacheDataKey(cacheKey), ttlSeconds ?? this.ttlSeconds, combined);
+	/**
+	* Run a Lua script via EVALSHA using the script's SHA1 (computed locally — the
+	* same digest Redis keys scripts by, so no SCRIPT LOAD round-trip is needed on
+	* the hot path). On NOSCRIPT (the script isn't in Redis's cache yet, e.g. first
+	* use or after a Redis restart/failover) load it explicitly via SCRIPT LOAD and
+	* re-run via EVALSHA — so the script ends up cached server-side and subsequent
+	* EVALSHA calls hit. The runtime client is always ioredis (see initCacheLayer).
+	*/
+	async evalScript(src, keys, args) {
+		const redis = this.redis;
+		let sha = this.scriptShaCache.get(src);
+		if (!sha) {
+			sha = createHash("sha1").update(src).digest("hex");
+			this.scriptShaCache.set(src, sha);
+		}
+		return redisRetryPolicy.execute(async () => {
+			try {
+				return await redis.evalsha(sha, keys.length, ...keys, ...args);
+			} catch (err) {
+				if (err instanceof Error && err.message.includes("NOSCRIPT")) {
+					const loadedSha = await redis.call("SCRIPT", "LOAD", src);
+					this.scriptShaCache.set(src, loadedSha);
+					return await redis.evalsha(loadedSha, keys.length, ...keys, ...args);
+				}
+				throw err;
+			}
+		});
+	}
+	/** One-shot recompute: atomically write data + metadata (CAS on version). */
+	async setQueryCacheAndMetadataFor(cacheKey, data, metaData, ttlSeconds) {
+		const ttl = ttlSeconds ?? this.ttlSeconds;
+		const dataJson = supaliveStringify({
+			data,
+			version: metaData.version
+		});
+		const metaJson = supaliveStringify(metaData);
+		await this.evalScript(WRITE_DATA_AND_META, [this.getQueryCacheDataKey(cacheKey), this.getQeruyCacheMetaKey(cacheKey)], [
+			dataJson,
+			metaJson,
+			metaData.version,
+			String(ttl)
+		]);
+	}
+	/** Subscribe path: write the data blob only (CAS against the metadata's
+	*  version). The metadata is written separately by the sub-worker; the
+	*  `version` links the two so a divergent pair is detected on read. */
+	async setQueryCacheFor(cacheKey, data, version, ttlSeconds) {
+		const ttl = ttlSeconds ?? this.ttlSeconds;
+		const dataJson = supaliveStringify({
+			data,
+			version
 		});
+		await this.evalScript(WRITE_DATA_ONLY, [this.getQueryCacheDataKey(cacheKey), this.getQeruyCacheMetaKey(cacheKey)], [
+			dataJson,
+			version,
+			String(ttl)
+		]);
 	}
 	async getQueryCacheFor(cacheKey) {
 		const dataRaw = await redisRetryPolicy.execute(() => this.redis.get(this.getQueryCacheDataKey(cacheKey)));
@@ -146,6 +292,31 @@ var CacheLayer = class {
 			return null;
 		}
 	}
+	/** Subscription recompute: replace the whole metadata (CAS on version). */
+	async replaceQueryCacheMetadata(cacheKey, metaData, ttlSeconds) {
+		const ttl = ttlSeconds ?? this.ttlSeconds;
+		const metaJson = supaliveStringify(metaData);
+		await this.evalScript(REPLACE_META, [this.getQeruyCacheMetaKey(cacheKey)], [
+			metaJson,
+			metaData.version,
+			String(ttl)
+		]);
+	}
+	/** Still-fresh subscription: advance `lastSnapshotTs` only, preserving the
+	*  data's `version` + `readSet` (no recompute). Monotonic and non-clobbering
+	*  — see ADVANCE_META. `metaData` carries the new horizon plus the version +
+	*  readSet the caller read, which the script keeps unless a newer computation
+	*  has since landed. */
+	async advanceQueryCacheMetadata(cacheKey, metaData, ttlSeconds) {
+		const ttl = ttlSeconds ?? this.ttlSeconds;
+		const metaJson = supaliveStringify(metaData);
+		await this.evalScript(ADVANCE_META, [this.getQeruyCacheMetaKey(cacheKey)], [
+			metaJson,
+			String(metaData.lastSnapshotTs),
+			metaData.version,
+			String(ttl)
+		]);
+	}
 	async getQueryCacheMetaData(cacheKey) {
 		const dataRaw = await redisRetryPolicy.execute(() => this.redis.get(this.getQeruyCacheMetaKey(cacheKey)));
 		if (!dataRaw) return null;
@@ -156,10 +327,6 @@ var CacheLayer = class {
 			return null;
 		}
 	}
-	async setQueryCacheMetadata(cacheKey, metaData) {
-		const metadata = supaliveStringify(metaData);
-		await redisRetryPolicy.execute(() => this.redis.set(this.getQeruyCacheMetaKey(cacheKey), metadata));
-	}
 	async persistRegistrationRecord(subId, record) {
 		const data = supaliveStringify(record);
 		await redisRetryPolicy.execute(() => this.redis.set(this.getRegistrationKey(subId), data));
@@ -242,6 +409,41 @@ var CacheLayer = class {
 //#endregion
 //#region src/db/init_db.ts
 /**
+* Current core runtime-bootstrap version. Bump this whenever core needs a new
+* runtime database operation — a data seed, a backfill, or a schema change that
+* must be applied directly at runtime rather than through the migration
+* pipeline. Each increment adds a case to `Database.coreMigrationStatements`.
+*
+* The core *schema* (the `commit_logs`/`metadata` tables and the
+* `global_commit_ts` sequence/counter) is NOT versioned here — it comes from
+* the generated schema (`coreTablesSql` / `generateSchemaSql`), which must be
+* applied to the database BEFORE `initCore` runs.
+*/
+const CORE_VERSION = 1n;
+/**
+* Bring the core runtime state up to {@link CORE_VERSION}. Idempotent and safe
+* to call from every process at startup: a lock-free version read short-circuits
+* the common "already current" case, and the actual migration runs under a
+* cross-process lock with a re-check so only one process applies it.
+*
+* Assumes the core schema already exists (apply the generated schema first);
+* the `metadata` table is where the version and seed rows live.
+*/
+async function initCore(db) {
+	if (await db.getCoreVersion() >= 1n) return;
+	await db.withCoreInitLock(async (ctx) => {
+		const from = await ctx.getVersion();
+		if (from >= 1n) return;
+		for (let v = from + 1n; v <= CORE_VERSION; v++) {
+			const statements = db.coreMigrationStatements(v);
+			logger$1.info(`Migrating core schema ${v - 1n} -> ${v} (${statements.length} statements)`);
+			for (const sql of statements) await ctx.exec(sql);
+		}
+		await ctx.setVersion(CORE_VERSION);
+		logger$1.info(`Core schema now at version ${CORE_VERSION}`);
+	});
+}
+/**
 * Default and env override for the per-statement DB timeout. PG enforces
 * this via `statement_timeout` (server cancels), MySQL via the per-query
 * `timeout` option (driver issues KILL QUERY). Set 0 to disable.
@@ -250,6 +452,7 @@ const DB_QUERY_TIMEOUT_MS = Number(process.env.SUPALIVE_DB_QUERY_TIMEOUT_MS ?? 3
 async function initDatabase(options) {
 	const impl = createDatabase(options.DbConfig, options.workerId);
 	const supaliveDb = SupaliveDb.create({ db: impl });
+	await initCore(impl);
 	await bootstrapDbTypes(supaliveDb, options.CacheLayer, options.forceBootstrapReload ?? false);
 	return supaliveDb;
 }
@@ -325,6 +528,7 @@ var SubscriptionWorker = class {
 	subscriptions = /* @__PURE__ */ new Map();
 	cache;
 	db;
+	retentionWatermark = new RetentionWatermark();
 	logger;
 	constructor(id, cache, db) {
 		this.id = id;
@@ -343,13 +547,55 @@ var SubscriptionWorker = class {
 	}
 	/**
 	* Lowest `lastSnapshotTs` across this worker's subscriptions, or `null`
-	* when there are none. Used by the dispatcher to derive a safe prune floor.
+	* when there are none. Used by the dispatcher to derive a safe prune watermark.
 	*/
 	minSubscriptionTs() {
 		let min = null;
 		for (const sub of this.subscriptions.values()) if (min === null || sub.lastSnapshotTs < min) min = sub.lastSnapshotTs;
 		return min;
 	}
+	/**
+	* Seed/repair the persisted retained watermark from the actual oldest retained
+	* commit log (`min(ts)`), then load it into memory and broadcast it. Called
+	* once at sub-manager startup — the `min(ts)` scan is off the hot path, and
+	* it corrects `metadata.min_retained_ts` even for a DB that was pruned before
+	* this feature existed. Returns the resulting watermark so the manager can
+	* broadcast it to the other workers.
+	*/
+	async refreshRetentionWatermark() {
+		const real = await this.db.getMinCommitLogTs() ?? 0n;
+		await this.db.updateMinSnapshotTimestamp(real);
+		const persisted = await this.db.getMinSnapshotTimestamp();
+		this.retentionWatermark.set(persisted);
+		await this.publishRetentionWatermark(persisted);
+		return this.retentionWatermark.get();
+	}
+	/** Adopt a watermark broadcast by the manager (in-process from the pruning
+	* worker). Monotonic, so an out-of-order message can't lower it. */
+	setRetentionWatermark(ts) {
+		this.retentionWatermark.set(ts);
+	}
+	/**
+	* Prune commit logs older than `minRetainedTs`. Advertises the new watermark FIRST —
+	* persist it, bump our in-memory copy, and broadcast it over Redis — and only
+	* then deletes, so no reader ever trusts a cache entry whose freshness scan
+	* would include rows we're about to remove. Returns rows deleted.
+	*/
+	async prune(minRetainedTs) {
+		await this.db.updateMinSnapshotTimestamp(minRetainedTs);
+		this.retentionWatermark.set(minRetainedTs);
+		await this.publishRetentionWatermark(minRetainedTs);
+		return await this.db.pruneCommitLogsBefore(minRetainedTs);
+	}
+	/** Broadcast the watermark to app-server instances over Redis pub/sub. Workers in
+	* this process get it in-process via {@link setRetentionWatermark}. */
+	async publishRetentionWatermark(ts) {
+		try {
+			await this.cache.redis.publish(RETENTION_WATERMARK_CHANNEL, ts.toString());
+		} catch (err) {
+			this.logger.error(err, "failed to publish commit-log watermark");
+		}
+	}
 	async register(params) {
 		const { subId, cacheKey, queryName, args, queryIdentity, instanceName, lastSnapshotTs } = params;
 		this.logger.info(`registering subscription: ${subId} from ${instanceName}`);
@@ -368,25 +614,15 @@ var SubscriptionWorker = class {
 			existing.timeout = null;
 		}
 		const metadata = await this.cache.getQueryCacheMetaData(cacheKey);
-		let needsRecompute = true;
-		let readSet;
-		let rawReadSet;
-		if (metadata) {
-			readSet = metadata.readSet;
-			rawReadSet = mapReadSetToRaw(readSet);
-			const tableIds = Array.from(new Set(readSet.map((r) => r.tableId)));
-			needsRecompute = checkLogsAffectReadSet(await this.db.getCommitLogsBetweenTs(metadata.lastSnapshotTs, lastSnapshotTs, tableIds), rawReadSet);
-			if (!needsRecompute) {
-				if (lastSnapshotTs !== metadata.lastSnapshotTs) this.cache.setQueryCacheMetadata(cacheKey, {
-					lastSnapshotTs,
-					readSet
-				}).catch((err) => this.logger.error(err, `Failed to update cache metadata for ${cacheKey}`));
-				metadata.lastSnapshotTs = lastSnapshotTs;
-			}
-		} else {
-			readSet = [];
-			rawReadSet = [];
-		}
+		const freshness = await evaluateCacheFreshness(this.db, metadata, lastSnapshotTs, this.retentionWatermark.get());
+		let needsRecompute = !freshness.fresh;
+		const readSet = freshness.readSet;
+		const rawReadSet = freshness.rawReadSet;
+		if (!needsRecompute && metadata && lastSnapshotTs > metadata.lastSnapshotTs) this.cache.advanceQueryCacheMetadata(cacheKey, {
+			lastSnapshotTs,
+			version: metadata.version,
+			readSet
+		}).catch((err) => this.logger.error(err, `Failed to advance cache metadata for ${cacheKey}`));
 		let newSubscription = {
 			subId,
 			queryName,
@@ -423,7 +659,8 @@ var SubscriptionWorker = class {
 		return {
 			cacheKey,
 			recompute: needsRecompute,
-			readSet
+			readSet,
+			version: metadata?.version
 		};
 	}
 	async updateReadSet(params) {
@@ -439,8 +676,9 @@ var SubscriptionWorker = class {
 			rawReadSet,
 			lastSnapshotTs
 		});
-		await this.cache.setQueryCacheMetadata(cacheKey, {
+		await this.cache.replaceQueryCacheMetadata(cacheKey, {
 			lastSnapshotTs,
+			version: String(lastSnapshotTs),
 			readSet
 		});
 		return { tracked: true };
@@ -506,6 +744,6 @@ var SubscriptionWorker = class {
 	}
 };
 //#endregion
-export { UpdateSubscriptionReadSetParamsSchema as C, UnregisterSubscriptionsResultSchema as S, RegisterSubscriptionParamsSchema as _, initCacheLayer as a, UnregisterSubscriptionResultSchema as b, appInstanceId as c, logger$1 as d, serializeMapValue as f, RegisterSubscriptionBatchResultSchema as g, RegisterSubscriptionBatchParamsSchema as h, createDatabase as i, isProduction as l, InvalidateWritesetResultSchema as m, DB_QUERY_TIMEOUT_MS as n, initDatabase as o, InvalidateWritesetParamsSchema as p, bootstrapDbTypes as r, CacheLayer as s, SubscriptionWorker as t, logLevelOf as u, RegisterSubscriptionResultSchema as v, UpdateSubscriptionReadSetResultSchema as w, UnregisterSubscriptionsParamsSchema as x, UnregisterSubscriptionParamsSchema as y };
+export { RetentionWatermark as C, logger$1 as D, logLevelOf as E, serializeMapValue as O, RETENTION_WATERMARK_CHANNEL as S, isProduction as T, UnregisterSubscriptionResultSchema as _, createDatabase as a, UpdateSubscriptionReadSetParamsSchema as b, initDatabase as c, InvalidateWritesetResultSchema as d, RegisterSubscriptionBatchParamsSchema as f, UnregisterSubscriptionParamsSchema as g, RegisterSubscriptionResultSchema as h, bootstrapDbTypes as i, CacheLayer as l, RegisterSubscriptionParamsSchema as m, CORE_VERSION as n, initCacheLayer as o, RegisterSubscriptionBatchResultSchema as p, DB_QUERY_TIMEOUT_MS as r, initCore as s, SubscriptionWorker as t, InvalidateWritesetParamsSchema as u, UnregisterSubscriptionsParamsSchema as v, appInstanceId as w, UpdateSubscriptionReadSetResultSchema as x, UnregisterSubscriptionsResultSchema as y };
 
-//# sourceMappingURL=subscription-worker-CqoWp6zB.js.map
+//# sourceMappingURL=subscription-worker-B2XtjFWY.js.map