@supalive/core 1.20.1 → 1.21.0

package/dist/ephemeral-BVeIVuYw.js

@@ -0,0 +1,276 @@
+import { r as supaliveStringify } from "./helper-zdJT5FUc.js";
+//#region src/db/ephemeral.ts
+/**
+* Default lifetime of an ephemeral entry: 7 days. Long enough that a value set
+* once (a device's last known position, a presence flag) survives normal
+* operation, short enough that abandoned keys eventually drain out of Redis on
+* their own. Override per call via {@link EphemeralSetOptions.ttlSeconds}.
+*/
+const EPHEMERAL_DEFAULT_TTL_SECONDS = 10080 * 60;
+/**
+* Shared stand-in for "this computation read no ephemeral state" — the
+* overwhelmingly common case. Frozen and reused so neither a `TxContext` nor a
+* `LiveResult` allocates an array for a query that never touches the store.
+*/
+const EMPTY_EPHEMERAL_KEYS = Object.freeze([]);
+/** Redis key holding the value for an ephemeral entry. */
+function valueKeyOf(key) {
+	return `sl:eph:${key}`;
+}
+/**
+* Single global monotonic counter bumped by every ephemeral write. Its value is
+* the `version` handed to the invalidation path, where it plays exactly the role
+* a mutation's `commitTs` plays: the discriminator in the cross-instance
+* recompute lock (`lock:recompute:<subId>:<version>`), so every instance racing
+* to recompute the same write agrees on which write it is racing for.
+*
+* It deliberately is NOT per-key: a recompute always re-reads the current value
+* from Redis, so the version only has to be unique per write *event*, never a
+* meaningful per-key revision.
+*/
+const SEQ_KEY = "sl:eph:seq";
+/**
+* Apply a batch of ephemeral writes and return the new global sequence.
+*
+* KEYS[1..n] — value keys; KEYS[n+1] — the sequence key.
+* ARGV[2i-1] — serialized value for KEYS[i]; ARGV[2i] — its TTL in seconds,
+* where `0` means "delete instead of set".
+*
+* A single script keeps the whole batch atomic and costs one round trip no
+* matter how many keys a mutation buffered, and the trailing INCR allocates the
+* version *after* every value is visible — so a recompute triggered by this
+* version can never read a pre-write value.
+*/
+const APPLY_EPHEMERAL_WRITES = `
+local n = #KEYS - 1
+for i = 1, n do
+  local ttl = tonumber(ARGV[i * 2])
+  if ttl <= 0 then
+    redis.call('DEL', KEYS[i])
+  else
+    redis.call('SET', KEYS[i], ARGV[i * 2 - 1], 'EX', ttl)
+  end
+end
+return redis.call('INCR', KEYS[n + 1])`;
+/** Thrown by {@link EphemeralReader.get} when the key holds no value. */
+var EphemeralKeyNotFoundError = class extends Error {
+	key;
+	constructor(key) {
+		super(`Ephemeral key not found: ${key}`);
+		this.key = key;
+		this.name = "EphemeralKeyNotFoundError";
+	}
+};
+/**
+* Thrown when a stored value does not match the schema the reader asked for —
+* corrupt bytes, or (far more likely) a value written by an older deploy under
+* a shape that has since changed.
+*
+* This is a hard error rather than a silent `null` because the two are not the
+* same thing: `null` means "nothing is here", and quietly conflating a schema
+* mismatch with absence turns a deploy bug into a blank screen. A caller that
+* genuinely wants tolerance can express it in the schema itself — `.catch()`,
+* `.optional()`, or a union — which is strictly more expressive than anything
+* this layer could decide on its behalf.
+*/
+var EphemeralDecodeError = class extends Error {
+	key;
+	constructor(key, options) {
+		super(`Ephemeral value at "${key}" did not match the expected schema`, options);
+		this.key = key;
+		this.name = "EphemeralDecodeError";
+	}
+};
+/**
+* Redis-backed store for state that drives live queries but is never persisted
+* to the database — a device's latest GPS fix, a "typing…" flag, a transient
+* job progress percentage.
+*
+* Unlike a table row, an ephemeral key has no commit log and no snapshot ts, so
+* it cannot participate in the OCC read set or the commit-log freshness replay.
+* Instead a query records the plain key strings it read
+* (`LiveResult.ephemeralKeys`), the sub-manager indexes subscriptions by those
+* keys, and a write looks subscribers up by exact key match — cheaper than the
+* write-set scan, because there is no predicate to evaluate.
+*/
+var EphemeralStore = class {
+	cache;
+	defaultTtlSeconds;
+	/**
+	* Fired after a batch of writes lands in Redis, with the affected keys and the
+	* newly allocated global version. The server wires this to the sub-manager's
+	* ephemeral invalidation, mirroring how `SupaliveDb.setOnAfterCommit` drives
+	* write-set invalidation. Left unset outside a server (tests, tooling), where
+	* writes are then purely local.
+	*/
+	onAfterWrite;
+	constructor(cache, opts) {
+		this.cache = cache;
+		this.defaultTtlSeconds = opts?.defaultTtlSeconds ?? 604800;
+	}
+	/** The TTL a `set` without an explicit `ttlSeconds` uses. */
+	get defaultTtl() {
+		return this.defaultTtlSeconds;
+	}
+	async find(key, schema) {
+		return decode(key, await this.cache.ephemeralGet(valueKeyOf(key)), schema);
+	}
+	async get(key, schema) {
+		const value = await this.find(key, schema);
+		if (value === null) throw new EphemeralKeyNotFoundError(key);
+		return value;
+	}
+	async getOr(key, schema, fallback) {
+		const value = await this.find(key, schema);
+		return value === null ? fallback : value;
+	}
+	async findMany(keys, schema) {
+		if (keys.length === 0) return [];
+		return (await this.cache.ephemeralGetMany(keys.map(valueKeyOf))).map((r, i) => decode(keys[i], r, schema));
+	}
+	async has(key) {
+		return await this.cache.ephemeralGet(valueKeyOf(key)) !== null;
+	}
+	async set(key, value, opts) {
+		await this.apply([this.prepareSet(key, value, opts)]);
+	}
+	async delete(key) {
+		await this.apply([this.prepareDelete(key)]);
+	}
+	/**
+	* Serialize a `set` into a buffered write WITHOUT touching Redis. Used by
+	* `DbWriter`, which defers ephemeral writes until its transaction commits.
+	*/
+	prepareSet(key, value, opts) {
+		const ttlSeconds = opts?.ttlSeconds ?? this.defaultTtlSeconds;
+		if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) throw new Error(`Ephemeral ttlSeconds must be a positive number (got ${ttlSeconds})`);
+		return {
+			key,
+			value: supaliveStringify(value),
+			ttlSeconds: Math.ceil(ttlSeconds)
+		};
+	}
+	/** The `delete` counterpart of {@link prepareSet}. */
+	prepareDelete(key) {
+		return {
+			key,
+			value: "",
+			ttlSeconds: 0
+		};
+	}
+	/**
+	* Apply buffered writes atomically, then notify the invalidation hook. The
+	* hook runs only after Redis holds the new values, so any recompute it
+	* triggers is guaranteed to read them.
+	*/
+	async apply(writes) {
+		if (writes.length === 0) return;
+		const version = await this.cache.evalScript(APPLY_EPHEMERAL_WRITES, [...writes.map((w) => valueKeyOf(w.key)), SEQ_KEY], writes.flatMap((w) => [w.value, String(w.ttlSeconds)]));
+		this.onAfterWrite?.(writes.map((w) => w.key), String(version));
+	}
+};
+function decode(key, raw, schema) {
+	if (raw === null || raw === void 0) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (cause) {
+		throw new EphemeralDecodeError(key, { cause });
+	}
+	const result = schema.safeParse(parsed);
+	if (!result.success) throw new EphemeralDecodeError(key, { cause: result.error });
+	return result.data;
+}
+/**
+* An {@link EphemeralStore} backed by a plain Map instead of Redis — for unit
+* tests and tooling that construct a `SupaliveDb` without a cache layer.
+*
+* It is process-local, so it is NOT a substitute for the real store in any
+* multi-instance deployment: two servers would each see their own values, and
+* cross-instance invalidation would push stale data. TTLs are honoured on read
+* (there is no background expiry), which is enough for the semantics tests care
+* about.
+*/
+function createMemoryEphemeralStore(opts) {
+	const values = /* @__PURE__ */ new Map();
+	let seq = 0;
+	const read = (key) => {
+		const entry = values.get(key);
+		if (!entry) return null;
+		if (entry.expiresAt <= Date.now()) {
+			values.delete(key);
+			return null;
+		}
+		return entry.value;
+	};
+	return new EphemeralStore({
+		ephemeralGet: async (key) => read(key),
+		ephemeralGetMany: async (keys) => keys.map(read),
+		evalScript: async (_src, keys, args) => {
+			for (let i = 0; i < keys.length - 1; i++) {
+				const ttl = Number(args[i * 2 + 1]);
+				if (ttl <= 0) values.delete(keys[i]);
+				else values.set(keys[i], {
+					value: String(args[i * 2]),
+					expiresAt: Date.now() + ttl * 1e3
+				});
+			}
+			return ++seq;
+		}
+	}, opts);
+}
+/**
+* Wrap `store` so every read also records a live-query dependency on the key it
+* touched. The dependency is on the KEY, not the value: reading a key that is
+* currently absent still subscribes you to it being set later.
+*/
+function createTrackedEphemeralReader(ctx, store) {
+	return {
+		find: (key, schema) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.find(key, schema);
+		},
+		get: (key, schema) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.get(key, schema);
+		},
+		getOr: (key, schema, fallback) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.getOr(key, schema, fallback);
+		},
+		findMany: (keys, schema) => {
+			for (const key of keys) ctx.internalTrackEphemeralRead(key);
+			return store.findMany(keys, schema);
+		},
+		has: (key) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.has(key);
+		}
+	};
+}
+/**
+* Wrap `store` for use inside a mutation: reads track as above, but writes are
+* BUFFERED on the context and applied only once the transaction commits.
+*
+* Buffering is what makes ephemeral writes safe in a transactional handler. A
+* mutation body can run several times — the OCC retry policy re-invokes it with
+* a fresh `DbWriter` on every conflict — so writing to Redis eagerly would
+* publish state from attempts that never committed, and push it to subscribers.
+* Only the committing attempt's buffer is flushed; a losing attempt's buffer is
+* discarded with its context.
+*/
+function createBufferedEphemeralWriter(ctx, store) {
+	return {
+		...createTrackedEphemeralReader(ctx, store),
+		set: async (key, value, opts) => {
+			ctx.internalBufferEphemeralWrite(store.prepareSet(key, value, opts));
+		},
+		delete: async (key) => {
+			ctx.internalBufferEphemeralWrite(store.prepareDelete(key));
+		}
+	};
+}
+//#endregion
+export { EphemeralStore as a, createTrackedEphemeralReader as c, EphemeralKeyNotFoundError as i, EPHEMERAL_DEFAULT_TTL_SECONDS as n, createBufferedEphemeralWriter as o, EphemeralDecodeError as r, createMemoryEphemeralStore as s, EMPTY_EPHEMERAL_KEYS as t };
+
+//# sourceMappingURL=ephemeral-BVeIVuYw.js.map

package/dist/ephemeral-BVeIVuYw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeral-BVeIVuYw.js","names":[],"sources":["../src/db/ephemeral.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\nimport type { CacheLayer } from \"./cache\";\nimport { supaliveStringify } from \"../helper\";\n\n/**\n * Default lifetime of an ephemeral entry: 7 days. Long enough that a value set\n * once (a device's last known position, a presence flag) survives normal\n * operation, short enough that abandoned keys eventually drain out of Redis on\n * their own. Override per call via {@link EphemeralSetOptions.ttlSeconds}.\n */\nexport const EPHEMERAL_DEFAULT_TTL_SECONDS = 7 * 24 * 60 * 60;\n\n/**\n * Shared stand-in for \"this computation read no ephemeral state\" — the\n * overwhelmingly common case. Frozen and reused so neither a `TxContext` nor a\n * `LiveResult` allocates an array for a query that never touches the store.\n */\nexport const EMPTY_EPHEMERAL_KEYS: string[] = Object.freeze([] as string[]) as string[];\n\n/** Redis key holding the value for an ephemeral entry. */\nfunction valueKeyOf(key: string): string {\n  return `sl:eph:${key}`;\n}\n\n/**\n * Single global monotonic counter bumped by every ephemeral write. Its value is\n * the `version` handed to the invalidation path, where it plays exactly the role\n * a mutation's `commitTs` plays: the discriminator in the cross-instance\n * recompute lock (`lock:recompute:<subId>:<version>`), so every instance racing\n * to recompute the same write agrees on which write it is racing for.\n *\n * It deliberately is NOT per-key: a recompute always re-reads the current value\n * from Redis, so the version only has to be unique per write *event*, never a\n * meaningful per-key revision.\n */\nconst SEQ_KEY = \"sl:eph:seq\";\n\n/**\n * Apply a batch of ephemeral writes and return the new global sequence.\n *\n * KEYS[1..n] — value keys; KEYS[n+1] — the sequence key.\n * ARGV[2i-1] — serialized value for KEYS[i]; ARGV[2i] — its TTL in seconds,\n * where `0` means \"delete instead of set\".\n *\n * A single script keeps the whole batch atomic and costs one round trip no\n * matter how many keys a mutation buffered, and the trailing INCR allocates the\n * version *after* every value is visible — so a recompute triggered by this\n * version can never read a pre-write value.\n */\nconst APPLY_EPHEMERAL_WRITES = `\nlocal n = #KEYS - 1\nfor i = 1, n do\n  local ttl = tonumber(ARGV[i * 2])\n  if ttl <= 0 then\n    redis.call('DEL', KEYS[i])\n  else\n    redis.call('SET', KEYS[i], ARGV[i * 2 - 1], 'EX', ttl)\n  end\nend\nreturn redis.call('INCR', KEYS[n + 1])`;\n\n/** Thrown by {@link EphemeralReader.get} when the key holds no value. */\nexport class EphemeralKeyNotFoundError extends Error {\n  constructor(readonly key: string) {\n    super(`Ephemeral key not found: ${key}`);\n    this.name = \"EphemeralKeyNotFoundError\";\n  }\n}\n\n/**\n * Thrown when a stored value does not match the schema the reader asked for —\n * corrupt bytes, or (far more likely) a value written by an older deploy under\n * a shape that has since changed.\n *\n * This is a hard error rather than a silent `null` because the two are not the\n * same thing: `null` means \"nothing is here\", and quietly conflating a schema\n * mismatch with absence turns a deploy bug into a blank screen. A caller that\n * genuinely wants tolerance can express it in the schema itself — `.catch()`,\n * `.optional()`, or a union — which is strictly more expressive than anything\n * this layer could decide on its behalf.\n */\nexport class EphemeralDecodeError extends Error {\n  constructor(readonly key: string, options?: { cause?: unknown }) {\n    super(`Ephemeral value at \"${key}\" did not match the expected schema`, options);\n    this.name = \"EphemeralDecodeError\";\n  }\n}\n\nexport interface EphemeralSetOptions {\n  /**\n   * Lifetime in seconds. Defaults to {@link EPHEMERAL_DEFAULT_TTL_SECONDS}\n   * (7 days), or to the server-configured default.\n   *\n   * Expiry is silent: when the TTL elapses the value simply disappears and the\n   * next recompute of a subscribed query observes `null`. It does NOT by itself\n   * push an update — call {@link EphemeralWriter.delete} when subscribers need\n   * to see the value go away at a specific moment.\n   */\n  ttlSeconds?: number;\n}\n\n/**\n * Read side of the ephemeral store.\n *\n * Reached from a query/mutation handler as `ctx.db.ephemeral`, where every read\n * also records a live-query dependency on the key, and from an action/job as\n * `ctx.db.ephemeral` on the {@link SupaliveDb} itself (untracked — an action has\n * no read set).\n *\n * Every read takes the Zod schema its value should satisfy. Ephemeral state is\n * schemaless in Redis — no table, no column types, and its writer may be a\n * different deploy of your own code — so a `as T` cast here would be a type\n * that is checked nowhere and true only by convention. Passing the schema makes\n * the boundary an actual parse.\n *\n * The naming mirrors the SQL query builder: {@link find} returns `null` for a\n * missing key exactly like `query(Schema).find(id)` does, {@link get} is the\n * \"I know it's there\" variant that throws, and {@link getOr} supplies a default.\n */\nexport interface EphemeralReader {\n  /** Value for `key`, or `null` when it is absent or expired. */\n  find<T>(key: string, schema: ZodType<T>): Promise<T | null>;\n  /** Value for `key`. Throws {@link EphemeralKeyNotFoundError} when absent. */\n  get<T>(key: string, schema: ZodType<T>): Promise<T>;\n  /** Value for `key`, or `fallback` when it is absent or expired. */\n  getOr<T>(key: string, schema: ZodType<T>, fallback: T): Promise<T>;\n  /** Values for `keys`, positionally aligned; `null` for each absent key. */\n  findMany<T>(keys: string[], schema: ZodType<T>): Promise<(T | null)[]>;\n  /** Whether `key` currently holds a value. Does not decode it, so it needs no\n   *  schema — and a value that fails to parse still counts as present. */\n  has(key: string): Promise<boolean>;\n}\n\n/** Read side plus writes. See {@link EphemeralReader} for the read semantics. */\nexport interface EphemeralWriter extends EphemeralReader {\n  /** Store `value` under `key`, replacing any existing entry. */\n  set<T>(key: string, value: T, opts?: EphemeralSetOptions): Promise<void>;\n  /** Remove `key`. Invalidates subscribers just like a `set` does. */\n  delete(key: string): Promise<void>;\n}\n\n/** A single pending write in a `DbWriter`'s buffer. `ttlSeconds: 0` = delete. */\nexport interface PendingEphemeralWrite {\n  key: string;\n  /** Pre-serialized payload; empty string for a delete. */\n  value: string;\n  ttlSeconds: number;\n}\n\n/**\n * Redis-backed store for state that drives live queries but is never persisted\n * to the database — a device's latest GPS fix, a \"typing…\" flag, a transient\n * job progress percentage.\n *\n * Unlike a table row, an ephemeral key has no commit log and no snapshot ts, so\n * it cannot participate in the OCC read set or the commit-log freshness replay.\n * Instead a query records the plain key strings it read\n * (`LiveResult.ephemeralKeys`), the sub-manager indexes subscriptions by those\n * keys, and a write looks subscribers up by exact key match — cheaper than the\n * write-set scan, because there is no predicate to evaluate.\n */\nexport class EphemeralStore implements EphemeralWriter {\n  private readonly cache: CacheLayer;\n  private readonly defaultTtlSeconds: number;\n\n  /**\n   * Fired after a batch of writes lands in Redis, with the affected keys and the\n   * newly allocated global version. The server wires this to the sub-manager's\n   * ephemeral invalidation, mirroring how `SupaliveDb.setOnAfterCommit` drives\n   * write-set invalidation. Left unset outside a server (tests, tooling), where\n   * writes are then purely local.\n   */\n  onAfterWrite?: (keys: string[], version: string) => void;\n\n  constructor(cache: CacheLayer, opts?: { defaultTtlSeconds?: number }) {\n    this.cache = cache;\n    this.defaultTtlSeconds = opts?.defaultTtlSeconds ?? EPHEMERAL_DEFAULT_TTL_SECONDS;\n  }\n\n  /** The TTL a `set` without an explicit `ttlSeconds` uses. */\n  get defaultTtl(): number {\n    return this.defaultTtlSeconds;\n  }\n\n  async find<T>(key: string, schema: ZodType<T>): Promise<T | null> {\n    const raw = await this.cache.ephemeralGet(valueKeyOf(key));\n    return decode(key, raw, schema);\n  }\n\n  async get<T>(key: string, schema: ZodType<T>): Promise<T> {\n    const value = await this.find(key, schema);\n    if (value === null) throw new EphemeralKeyNotFoundError(key);\n    return value;\n  }\n\n  async getOr<T>(key: string, schema: ZodType<T>, fallback: T): Promise<T> {\n    const value = await this.find(key, schema);\n    return value === null ? fallback : value;\n  }\n\n  async findMany<T>(keys: string[], schema: ZodType<T>): Promise<(T | null)[]> {\n    if (keys.length === 0) return [];\n    const raw = await this.cache.ephemeralGetMany(keys.map(valueKeyOf));\n    return raw.map((r, i) => decode(keys[i]!, r, schema));\n  }\n\n  async has(key: string): Promise<boolean> {\n    return (await this.cache.ephemeralGet(valueKeyOf(key))) !== null;\n  }\n\n  async set<T>(key: string, value: T, opts?: EphemeralSetOptions): Promise<void> {\n    await this.apply([this.prepareSet(key, value, opts)]);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.apply([this.prepareDelete(key)]);\n  }\n\n  /**\n   * Serialize a `set` into a buffered write WITHOUT touching Redis. Used by\n   * `DbWriter`, which defers ephemeral writes until its transaction commits.\n   */\n  prepareSet<T>(key: string, value: T, opts?: EphemeralSetOptions): PendingEphemeralWrite {\n    const ttlSeconds = opts?.ttlSeconds ?? this.defaultTtlSeconds;\n    if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {\n      throw new Error(`Ephemeral ttlSeconds must be a positive number (got ${ttlSeconds})`);\n    }\n    return { key, value: supaliveStringify(value), ttlSeconds: Math.ceil(ttlSeconds) };\n  }\n\n  /** The `delete` counterpart of {@link prepareSet}. */\n  prepareDelete(key: string): PendingEphemeralWrite {\n    return { key, value: \"\", ttlSeconds: 0 };\n  }\n\n  /**\n   * Apply buffered writes atomically, then notify the invalidation hook. The\n   * hook runs only after Redis holds the new values, so any recompute it\n   * triggers is guaranteed to read them.\n   */\n  async apply(writes: PendingEphemeralWrite[]): Promise<void> {\n    if (writes.length === 0) return;\n\n    const version = await this.cache.evalScript(\n      APPLY_EPHEMERAL_WRITES,\n      [...writes.map((w) => valueKeyOf(w.key)), SEQ_KEY],\n      writes.flatMap((w) => [w.value, String(w.ttlSeconds)]),\n    );\n\n    this.onAfterWrite?.(writes.map((w) => w.key), String(version));\n  }\n}\n\nfunction decode<T>(key: string, raw: string | null, schema: ZodType<T>): T | null {\n  if (raw === null || raw === undefined) return null;\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (cause) {\n    throw new EphemeralDecodeError(key, { cause });\n  }\n\n  const result = schema.safeParse(parsed);\n  if (!result.success) throw new EphemeralDecodeError(key, { cause: result.error });\n  return result.data;\n}\n\n/**\n * An {@link EphemeralStore} backed by a plain Map instead of Redis — for unit\n * tests and tooling that construct a `SupaliveDb` without a cache layer.\n *\n * It is process-local, so it is NOT a substitute for the real store in any\n * multi-instance deployment: two servers would each see their own values, and\n * cross-instance invalidation would push stale data. TTLs are honoured on read\n * (there is no background expiry), which is enough for the semantics tests care\n * about.\n */\nexport function createMemoryEphemeralStore(opts?: { defaultTtlSeconds?: number }): EphemeralStore {\n  const values = new Map<string, { value: string; expiresAt: number }>();\n  let seq = 0;\n\n  const read = (key: string): string | null => {\n    const entry = values.get(key);\n    if (!entry) return null;\n    if (entry.expiresAt <= Date.now()) {\n      values.delete(key);\n      return null;\n    }\n    return entry.value;\n  };\n\n  const backing = {\n    ephemeralGet: async (key: string) => read(key),\n    ephemeralGetMany: async (keys: string[]) => keys.map(read),\n    // Mirrors APPLY_EPHEMERAL_WRITES: the trailing key is the sequence, and each\n    // value key carries a (value, ttl) ARGV pair where ttl <= 0 means delete.\n    evalScript: async (_src: string, keys: string[], args: (string | number)[]) => {\n      for (let i = 0; i < keys.length - 1; i++) {\n        const ttl = Number(args[i * 2 + 1]);\n        if (ttl <= 0) values.delete(keys[i]!);\n        else values.set(keys[i]!, { value: String(args[i * 2]), expiresAt: Date.now() + ttl * 1000 });\n      }\n      return ++seq;\n    },\n  } as unknown as CacheLayer;\n\n  return new EphemeralStore(backing, opts);\n}\n\n// ─── Handler-facing wrappers ─────────────────────────────────────────────────\n//\n// Built as free functions over a context rather than methods on it: the tracking\n// and buffering they add is the ONLY difference from the bare store, and keeping\n// them out of `DbReader`/`DbWriter` leaves those classes about SQL. Each takes\n// the context it reports to as its first argument.\n\n/** The slice of a `DbReader` these wrappers drive. Structural, so `context.ts`\n *  doesn't have to be imported here (it imports this module). */\nexport interface EphemeralReadTracker {\n  internalTrackEphemeralRead(key: string): void;\n}\n\n/** The slice of a `DbWriter` the write wrapper drives. */\nexport interface EphemeralWriteBuffer extends EphemeralReadTracker {\n  internalBufferEphemeralWrite(write: PendingEphemeralWrite): void;\n}\n\n/**\n * Wrap `store` so every read also records a live-query dependency on the key it\n * touched. The dependency is on the KEY, not the value: reading a key that is\n * currently absent still subscribes you to it being set later.\n */\nexport function createTrackedEphemeralReader(\n  ctx: EphemeralReadTracker,\n  store: EphemeralStore,\n): EphemeralReader {\n  return {\n    find: (key, schema) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.find(key, schema);\n    },\n    get: (key, schema) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.get(key, schema);\n    },\n    getOr: (key, schema, fallback) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.getOr(key, schema, fallback);\n    },\n    findMany: (keys, schema) => {\n      for (const key of keys) ctx.internalTrackEphemeralRead(key);\n      return store.findMany(keys, schema);\n    },\n    has: (key) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.has(key);\n    },\n  };\n}\n\n/**\n * Wrap `store` for use inside a mutation: reads track as above, but writes are\n * BUFFERED on the context and applied only once the transaction commits.\n *\n * Buffering is what makes ephemeral writes safe in a transactional handler. A\n * mutation body can run several times — the OCC retry policy re-invokes it with\n * a fresh `DbWriter` on every conflict — so writing to Redis eagerly would\n * publish state from attempts that never committed, and push it to subscribers.\n * Only the committing attempt's buffer is flushed; a losing attempt's buffer is\n * discarded with its context.\n */\nexport function createBufferedEphemeralWriter(\n  ctx: EphemeralWriteBuffer,\n  store: EphemeralStore,\n): EphemeralWriter {\n  return {\n    ...createTrackedEphemeralReader(ctx, store),\n    set: async (key, value, opts) => {\n      ctx.internalBufferEphemeralWrite(store.prepareSet(key, value, opts));\n    },\n    delete: async (key) => {\n      ctx.internalBufferEphemeralWrite(store.prepareDelete(key));\n    },\n  };\n}\n"],"mappings":"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"}

package/dist/ephemeral-CkidSG9y.js

@@ -0,0 +1,295 @@
+import { r as supaliveStringify } from "./helper-zdJT5FUc.js";
+//#region src/db/ephemeral.ts
+/**
+* Default lifetime of an ephemeral entry: 7 days. Long enough that a value set
+* once (a device's last known position, a presence flag) survives normal
+* operation, short enough that abandoned keys eventually drain out of Redis on
+* their own. Override per call via {@link EphemeralSetOptions.ttlSeconds}.
+*/
+const EPHEMERAL_DEFAULT_TTL_SECONDS = 10080 * 60;
+/**
+* Shared stand-in for "this computation read no ephemeral state" — the
+* overwhelmingly common case. Frozen and reused so neither a `TxContext` nor a
+* `LiveResult` allocates an array for a query that never touches the store.
+*/
+const EMPTY_EPHEMERAL_KEYS = Object.freeze([]);
+/** Redis key holding the value for an ephemeral entry. */
+function valueKeyOf(key) {
+	return `sl:eph:${key}`;
+}
+/**
+* Single global monotonic counter bumped by every ephemeral write. Its value is
+* the `version` handed to the invalidation path, where it plays exactly the role
+* a mutation's `commitTs` plays: the discriminator in the cross-instance
+* recompute lock (`lock:recompute:<subId>:<version>`), so every instance racing
+* to recompute the same write agrees on which write it is racing for.
+*
+* It deliberately is NOT per-key: a recompute always re-reads the current value
+* from Redis, so the version only has to be unique per write *event*, never a
+* meaningful per-key revision.
+*/
+const SEQ_KEY = "sl:eph:seq";
+/**
+* Apply a batch of ephemeral writes and return the new global sequence.
+*
+* KEYS[1..n] — value keys; KEYS[n+1] — the sequence key.
+* ARGV[2i-1] — serialized value for KEYS[i]; ARGV[2i] — its TTL in seconds,
+* where `0` means "delete instead of set".
+*
+* A single script keeps the whole batch atomic and costs one round trip no
+* matter how many keys a mutation buffered, and the trailing INCR allocates the
+* version *after* every value is visible — so a recompute triggered by this
+* version can never read a pre-write value.
+*/
+const APPLY_EPHEMERAL_WRITES = `
+local n = #KEYS - 1
+for i = 1, n do
+  local ttl = tonumber(ARGV[i * 2])
+  if ttl <= 0 then
+    redis.call('DEL', KEYS[i])
+  else
+    redis.call('SET', KEYS[i], ARGV[i * 2 - 1], 'EX', ttl)
+  end
+end
+return redis.call('INCR', KEYS[n + 1])`;
+/** Thrown by {@link EphemeralReader.get} when the key holds no value. */
+var EphemeralKeyNotFoundError = class extends Error {
+	key;
+	constructor(key) {
+		super(`Ephemeral key not found: ${key}`);
+		this.key = key;
+		this.name = "EphemeralKeyNotFoundError";
+	}
+};
+/**
+* Thrown when a stored value does not match the schema the reader asked for —
+* corrupt bytes, or (far more likely) a value written by an older deploy under
+* a shape that has since changed.
+*
+* This is a hard error rather than a silent `null` because the two are not the
+* same thing: `null` means "nothing is here", and quietly conflating a schema
+* mismatch with absence turns a deploy bug into a blank screen. A caller that
+* genuinely wants tolerance can express it in the schema itself — `.catch()`,
+* `.optional()`, or a union — which is strictly more expressive than anything
+* this layer could decide on its behalf.
+*/
+var EphemeralDecodeError = class extends Error {
+	key;
+	constructor(key, options) {
+		super(`Ephemeral value at "${key}" did not match the expected schema`, options);
+		this.key = key;
+		this.name = "EphemeralDecodeError";
+	}
+};
+/**
+* Thrown when a mutation's buffered ephemeral writes could not be applied after
+* its transaction committed.
+*
+* The distinction this type exists to make: **the mutation succeeded**. Its rows
+* are written and durable, and their subscription invalidation has already gone
+* out. Only the ephemeral half — which lives in Redis, outside the transaction —
+* failed to land. A caller must NOT respond by retrying the mutation; that would
+* apply the row writes a second time. Retry the ephemeral write alone, or let
+* the next write to those keys carry the state forward.
+*/
+var EphemeralFlushError = class extends Error {
+	keys;
+	constructor(keys, options) {
+		super(`Mutation committed, but its ephemeral writes failed to apply (keys: ${keys.join(", ")}). The database changes are durable — do not retry the mutation.`, options);
+		this.keys = keys;
+		this.name = "EphemeralFlushError";
+	}
+};
+/**
+* Redis-backed store for state that drives live queries but is never persisted
+* to the database — a device's latest GPS fix, a "typing…" flag, a transient
+* job progress percentage.
+*
+* Unlike a table row, an ephemeral key has no commit log and no snapshot ts, so
+* it cannot participate in the OCC read set or the commit-log freshness replay.
+* Instead a query records the plain key strings it read
+* (`LiveResult.ephemeralKeys`), the sub-manager indexes subscriptions by those
+* keys, and a write looks subscribers up by exact key match — cheaper than the
+* write-set scan, because there is no predicate to evaluate.
+*/
+var EphemeralStore = class {
+	cache;
+	defaultTtlSeconds;
+	/**
+	* Fired after a batch of writes lands in Redis, with the affected keys and the
+	* newly allocated global version. The server wires this to the sub-manager's
+	* ephemeral invalidation, mirroring how `SupaliveDb.setOnAfterCommit` drives
+	* write-set invalidation. Left unset outside a server (tests, tooling), where
+	* writes are then purely local.
+	*/
+	onAfterWrite;
+	constructor(cache, opts) {
+		this.cache = cache;
+		this.defaultTtlSeconds = opts?.defaultTtlSeconds ?? 604800;
+	}
+	/** The TTL a `set` without an explicit `ttlSeconds` uses. */
+	get defaultTtl() {
+		return this.defaultTtlSeconds;
+	}
+	async find(key, schema) {
+		return decode(key, await this.cache.ephemeralGet(valueKeyOf(key)), schema);
+	}
+	async get(key, schema) {
+		const value = await this.find(key, schema);
+		if (value === null) throw new EphemeralKeyNotFoundError(key);
+		return value;
+	}
+	async getOr(key, schema, fallback) {
+		const value = await this.find(key, schema);
+		return value === null ? fallback : value;
+	}
+	async findMany(keys, schema) {
+		if (keys.length === 0) return [];
+		return (await this.cache.ephemeralGetMany(keys.map(valueKeyOf))).map((r, i) => decode(keys[i], r, schema));
+	}
+	async has(key) {
+		return await this.cache.ephemeralGet(valueKeyOf(key)) !== null;
+	}
+	async set(key, value, opts) {
+		await this.apply([this.prepareSet(key, value, opts)]);
+	}
+	async delete(key) {
+		await this.apply([this.prepareDelete(key)]);
+	}
+	/**
+	* Serialize a `set` into a buffered write WITHOUT touching Redis. Used by
+	* `DbWriter`, which defers ephemeral writes until its transaction commits.
+	*/
+	prepareSet(key, value, opts) {
+		const ttlSeconds = opts?.ttlSeconds ?? this.defaultTtlSeconds;
+		if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) throw new Error(`Ephemeral ttlSeconds must be a positive number (got ${ttlSeconds})`);
+		return {
+			key,
+			value: supaliveStringify(value),
+			ttlSeconds: Math.ceil(ttlSeconds)
+		};
+	}
+	/** The `delete` counterpart of {@link prepareSet}. */
+	prepareDelete(key) {
+		return {
+			key,
+			value: "",
+			ttlSeconds: 0
+		};
+	}
+	/**
+	* Apply buffered writes atomically, then notify the invalidation hook. The
+	* hook runs only after Redis holds the new values, so any recompute it
+	* triggers is guaranteed to read them.
+	*/
+	async apply(writes) {
+		if (writes.length === 0) return;
+		const version = await this.cache.evalScript(APPLY_EPHEMERAL_WRITES, [...writes.map((w) => valueKeyOf(w.key)), SEQ_KEY], writes.flatMap((w) => [w.value, String(w.ttlSeconds)]));
+		this.onAfterWrite?.(writes.map((w) => w.key), String(version));
+	}
+};
+function decode(key, raw, schema) {
+	if (raw === null || raw === void 0) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (cause) {
+		throw new EphemeralDecodeError(key, { cause });
+	}
+	const result = schema.safeParse(parsed);
+	if (!result.success) throw new EphemeralDecodeError(key, { cause: result.error });
+	return result.data;
+}
+/**
+* An {@link EphemeralStore} backed by a plain Map instead of Redis — for unit
+* tests and tooling that construct a `SupaliveDb` without a cache layer.
+*
+* It is process-local, so it is NOT a substitute for the real store in any
+* multi-instance deployment: two servers would each see their own values, and
+* cross-instance invalidation would push stale data. TTLs are honoured on read
+* (there is no background expiry), which is enough for the semantics tests care
+* about.
+*/
+function createMemoryEphemeralStore(opts) {
+	const values = /* @__PURE__ */ new Map();
+	let seq = 0;
+	const read = (key) => {
+		const entry = values.get(key);
+		if (!entry) return null;
+		if (entry.expiresAt <= Date.now()) {
+			values.delete(key);
+			return null;
+		}
+		return entry.value;
+	};
+	return new EphemeralStore({
+		ephemeralGet: async (key) => read(key),
+		ephemeralGetMany: async (keys) => keys.map(read),
+		evalScript: async (_src, keys, args) => {
+			for (let i = 0; i < keys.length - 1; i++) {
+				const ttl = Number(args[i * 2 + 1]);
+				if (ttl <= 0) values.delete(keys[i]);
+				else values.set(keys[i], {
+					value: String(args[i * 2]),
+					expiresAt: Date.now() + ttl * 1e3
+				});
+			}
+			return ++seq;
+		}
+	}, opts);
+}
+/**
+* Wrap `store` so every read also records a live-query dependency on the key it
+* touched. The dependency is on the KEY, not the value: reading a key that is
+* currently absent still subscribes you to it being set later.
+*/
+function createTrackedEphemeralReader(ctx, store) {
+	return {
+		find: (key, schema) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.find(key, schema);
+		},
+		get: (key, schema) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.get(key, schema);
+		},
+		getOr: (key, schema, fallback) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.getOr(key, schema, fallback);
+		},
+		findMany: (keys, schema) => {
+			for (const key of keys) ctx.internalTrackEphemeralRead(key);
+			return store.findMany(keys, schema);
+		},
+		has: (key) => {
+			ctx.internalTrackEphemeralRead(key);
+			return store.has(key);
+		}
+	};
+}
+/**
+* Wrap `store` for use inside a mutation: reads track as above, but writes are
+* BUFFERED on the context and applied only once the transaction commits.
+*
+* Buffering is what makes ephemeral writes safe in a transactional handler. A
+* mutation body can run several times — the OCC retry policy re-invokes it with
+* a fresh `DbWriter` on every conflict — so writing to Redis eagerly would
+* publish state from attempts that never committed, and push it to subscribers.
+* Only the committing attempt's buffer is flushed; a losing attempt's buffer is
+* discarded with its context.
+*/
+function createBufferedEphemeralWriter(ctx, store) {
+	return {
+		...createTrackedEphemeralReader(ctx, store),
+		set: async (key, value, opts) => {
+			ctx.internalBufferEphemeralWrite(store.prepareSet(key, value, opts));
+		},
+		delete: async (key) => {
+			ctx.internalBufferEphemeralWrite(store.prepareDelete(key));
+		}
+	};
+}
+//#endregion
+export { EphemeralKeyNotFoundError as a, createMemoryEphemeralStore as c, EphemeralFlushError as i, createTrackedEphemeralReader as l, EPHEMERAL_DEFAULT_TTL_SECONDS as n, EphemeralStore as o, EphemeralDecodeError as r, createBufferedEphemeralWriter as s, EMPTY_EPHEMERAL_KEYS as t };
+
+//# sourceMappingURL=ephemeral-CkidSG9y.js.map

package/dist/ephemeral-CkidSG9y.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ephemeral-CkidSG9y.js","names":[],"sources":["../src/db/ephemeral.ts"],"sourcesContent":["import type { ZodType } from \"zod\";\nimport type { CacheLayer } from \"./cache\";\nimport { supaliveStringify } from \"../helper\";\n\n/**\n * Default lifetime of an ephemeral entry: 7 days. Long enough that a value set\n * once (a device's last known position, a presence flag) survives normal\n * operation, short enough that abandoned keys eventually drain out of Redis on\n * their own. Override per call via {@link EphemeralSetOptions.ttlSeconds}.\n */\nexport const EPHEMERAL_DEFAULT_TTL_SECONDS = 7 * 24 * 60 * 60;\n\n/**\n * Shared stand-in for \"this computation read no ephemeral state\" — the\n * overwhelmingly common case. Frozen and reused so neither a `TxContext` nor a\n * `LiveResult` allocates an array for a query that never touches the store.\n */\nexport const EMPTY_EPHEMERAL_KEYS: string[] = Object.freeze([] as string[]) as string[];\n\n/** Redis key holding the value for an ephemeral entry. */\nfunction valueKeyOf(key: string): string {\n  return `sl:eph:${key}`;\n}\n\n/**\n * Single global monotonic counter bumped by every ephemeral write. Its value is\n * the `version` handed to the invalidation path, where it plays exactly the role\n * a mutation's `commitTs` plays: the discriminator in the cross-instance\n * recompute lock (`lock:recompute:<subId>:<version>`), so every instance racing\n * to recompute the same write agrees on which write it is racing for.\n *\n * It deliberately is NOT per-key: a recompute always re-reads the current value\n * from Redis, so the version only has to be unique per write *event*, never a\n * meaningful per-key revision.\n */\nconst SEQ_KEY = \"sl:eph:seq\";\n\n/**\n * Apply a batch of ephemeral writes and return the new global sequence.\n *\n * KEYS[1..n] — value keys; KEYS[n+1] — the sequence key.\n * ARGV[2i-1] — serialized value for KEYS[i]; ARGV[2i] — its TTL in seconds,\n * where `0` means \"delete instead of set\".\n *\n * A single script keeps the whole batch atomic and costs one round trip no\n * matter how many keys a mutation buffered, and the trailing INCR allocates the\n * version *after* every value is visible — so a recompute triggered by this\n * version can never read a pre-write value.\n */\nconst APPLY_EPHEMERAL_WRITES = `\nlocal n = #KEYS - 1\nfor i = 1, n do\n  local ttl = tonumber(ARGV[i * 2])\n  if ttl <= 0 then\n    redis.call('DEL', KEYS[i])\n  else\n    redis.call('SET', KEYS[i], ARGV[i * 2 - 1], 'EX', ttl)\n  end\nend\nreturn redis.call('INCR', KEYS[n + 1])`;\n\n/** Thrown by {@link EphemeralReader.get} when the key holds no value. */\nexport class EphemeralKeyNotFoundError extends Error {\n  constructor(readonly key: string) {\n    super(`Ephemeral key not found: ${key}`);\n    this.name = \"EphemeralKeyNotFoundError\";\n  }\n}\n\n/**\n * Thrown when a stored value does not match the schema the reader asked for —\n * corrupt bytes, or (far more likely) a value written by an older deploy under\n * a shape that has since changed.\n *\n * This is a hard error rather than a silent `null` because the two are not the\n * same thing: `null` means \"nothing is here\", and quietly conflating a schema\n * mismatch with absence turns a deploy bug into a blank screen. A caller that\n * genuinely wants tolerance can express it in the schema itself — `.catch()`,\n * `.optional()`, or a union — which is strictly more expressive than anything\n * this layer could decide on its behalf.\n */\nexport class EphemeralDecodeError extends Error {\n  constructor(readonly key: string, options?: { cause?: unknown }) {\n    super(`Ephemeral value at \"${key}\" did not match the expected schema`, options);\n    this.name = \"EphemeralDecodeError\";\n  }\n}\n\n/**\n * Thrown when a mutation's buffered ephemeral writes could not be applied after\n * its transaction committed.\n *\n * The distinction this type exists to make: **the mutation succeeded**. Its rows\n * are written and durable, and their subscription invalidation has already gone\n * out. Only the ephemeral half — which lives in Redis, outside the transaction —\n * failed to land. A caller must NOT respond by retrying the mutation; that would\n * apply the row writes a second time. Retry the ephemeral write alone, or let\n * the next write to those keys carry the state forward.\n */\nexport class EphemeralFlushError extends Error {\n  constructor(readonly keys: string[], options?: { cause?: unknown }) {\n    super(\n      `Mutation committed, but its ephemeral writes failed to apply (keys: ${keys.join(\", \")}). ` +\n      `The database changes are durable — do not retry the mutation.`,\n      options,\n    );\n    this.name = \"EphemeralFlushError\";\n  }\n}\n\nexport interface EphemeralSetOptions {\n  /**\n   * Lifetime in seconds. Defaults to {@link EPHEMERAL_DEFAULT_TTL_SECONDS}\n   * (7 days), or to the server-configured default.\n   *\n   * Expiry is silent: when the TTL elapses the value simply disappears and the\n   * next recompute of a subscribed query observes `null`. It does NOT by itself\n   * push an update — call {@link EphemeralWriter.delete} when subscribers need\n   * to see the value go away at a specific moment.\n   */\n  ttlSeconds?: number;\n}\n\n/**\n * Read side of the ephemeral store.\n *\n * Reached from a query/mutation handler as `ctx.db.ephemeral`, where every read\n * also records a live-query dependency on the key, and from an action/job as\n * `ctx.db.ephemeral` on the {@link SupaliveDb} itself (untracked — an action has\n * no read set).\n *\n * Every read takes the Zod schema its value should satisfy. Ephemeral state is\n * schemaless in Redis — no table, no column types, and its writer may be a\n * different deploy of your own code — so a `as T` cast here would be a type\n * that is checked nowhere and true only by convention. Passing the schema makes\n * the boundary an actual parse.\n *\n * The naming mirrors the SQL query builder: {@link find} returns `null` for a\n * missing key exactly like `query(Schema).find(id)` does, {@link get} is the\n * \"I know it's there\" variant that throws, and {@link getOr} supplies a default.\n */\nexport interface EphemeralReader {\n  /** Value for `key`, or `null` when it is absent or expired. */\n  find<T>(key: string, schema: ZodType<T>): Promise<T | null>;\n  /** Value for `key`. Throws {@link EphemeralKeyNotFoundError} when absent. */\n  get<T>(key: string, schema: ZodType<T>): Promise<T>;\n  /** Value for `key`, or `fallback` when it is absent or expired. */\n  getOr<T>(key: string, schema: ZodType<T>, fallback: T): Promise<T>;\n  /** Values for `keys`, positionally aligned; `null` for each absent key. */\n  findMany<T>(keys: string[], schema: ZodType<T>): Promise<(T | null)[]>;\n  /** Whether `key` currently holds a value. Does not decode it, so it needs no\n   *  schema — and a value that fails to parse still counts as present. */\n  has(key: string): Promise<boolean>;\n}\n\n/** Read side plus writes. See {@link EphemeralReader} for the read semantics. */\nexport interface EphemeralWriter extends EphemeralReader {\n  /** Store `value` under `key`, replacing any existing entry. */\n  set<T>(key: string, value: T, opts?: EphemeralSetOptions): Promise<void>;\n  /** Remove `key`. Invalidates subscribers just like a `set` does. */\n  delete(key: string): Promise<void>;\n}\n\n/** A single pending write in a `DbWriter`'s buffer. `ttlSeconds: 0` = delete. */\nexport interface PendingEphemeralWrite {\n  key: string;\n  /** Pre-serialized payload; empty string for a delete. */\n  value: string;\n  ttlSeconds: number;\n}\n\n/**\n * Redis-backed store for state that drives live queries but is never persisted\n * to the database — a device's latest GPS fix, a \"typing…\" flag, a transient\n * job progress percentage.\n *\n * Unlike a table row, an ephemeral key has no commit log and no snapshot ts, so\n * it cannot participate in the OCC read set or the commit-log freshness replay.\n * Instead a query records the plain key strings it read\n * (`LiveResult.ephemeralKeys`), the sub-manager indexes subscriptions by those\n * keys, and a write looks subscribers up by exact key match — cheaper than the\n * write-set scan, because there is no predicate to evaluate.\n */\nexport class EphemeralStore implements EphemeralWriter {\n  private readonly cache: CacheLayer;\n  private readonly defaultTtlSeconds: number;\n\n  /**\n   * Fired after a batch of writes lands in Redis, with the affected keys and the\n   * newly allocated global version. The server wires this to the sub-manager's\n   * ephemeral invalidation, mirroring how `SupaliveDb.setOnAfterCommit` drives\n   * write-set invalidation. Left unset outside a server (tests, tooling), where\n   * writes are then purely local.\n   */\n  onAfterWrite?: (keys: string[], version: string) => void;\n\n  constructor(cache: CacheLayer, opts?: { defaultTtlSeconds?: number }) {\n    this.cache = cache;\n    this.defaultTtlSeconds = opts?.defaultTtlSeconds ?? EPHEMERAL_DEFAULT_TTL_SECONDS;\n  }\n\n  /** The TTL a `set` without an explicit `ttlSeconds` uses. */\n  get defaultTtl(): number {\n    return this.defaultTtlSeconds;\n  }\n\n  async find<T>(key: string, schema: ZodType<T>): Promise<T | null> {\n    const raw = await this.cache.ephemeralGet(valueKeyOf(key));\n    return decode(key, raw, schema);\n  }\n\n  async get<T>(key: string, schema: ZodType<T>): Promise<T> {\n    const value = await this.find(key, schema);\n    if (value === null) throw new EphemeralKeyNotFoundError(key);\n    return value;\n  }\n\n  async getOr<T>(key: string, schema: ZodType<T>, fallback: T): Promise<T> {\n    const value = await this.find(key, schema);\n    return value === null ? fallback : value;\n  }\n\n  async findMany<T>(keys: string[], schema: ZodType<T>): Promise<(T | null)[]> {\n    if (keys.length === 0) return [];\n    const raw = await this.cache.ephemeralGetMany(keys.map(valueKeyOf));\n    return raw.map((r, i) => decode(keys[i]!, r, schema));\n  }\n\n  async has(key: string): Promise<boolean> {\n    return (await this.cache.ephemeralGet(valueKeyOf(key))) !== null;\n  }\n\n  async set<T>(key: string, value: T, opts?: EphemeralSetOptions): Promise<void> {\n    await this.apply([this.prepareSet(key, value, opts)]);\n  }\n\n  async delete(key: string): Promise<void> {\n    await this.apply([this.prepareDelete(key)]);\n  }\n\n  /**\n   * Serialize a `set` into a buffered write WITHOUT touching Redis. Used by\n   * `DbWriter`, which defers ephemeral writes until its transaction commits.\n   */\n  prepareSet<T>(key: string, value: T, opts?: EphemeralSetOptions): PendingEphemeralWrite {\n    const ttlSeconds = opts?.ttlSeconds ?? this.defaultTtlSeconds;\n    if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {\n      throw new Error(`Ephemeral ttlSeconds must be a positive number (got ${ttlSeconds})`);\n    }\n    return { key, value: supaliveStringify(value), ttlSeconds: Math.ceil(ttlSeconds) };\n  }\n\n  /** The `delete` counterpart of {@link prepareSet}. */\n  prepareDelete(key: string): PendingEphemeralWrite {\n    return { key, value: \"\", ttlSeconds: 0 };\n  }\n\n  /**\n   * Apply buffered writes atomically, then notify the invalidation hook. The\n   * hook runs only after Redis holds the new values, so any recompute it\n   * triggers is guaranteed to read them.\n   */\n  async apply(writes: PendingEphemeralWrite[]): Promise<void> {\n    if (writes.length === 0) return;\n\n    const version = await this.cache.evalScript(\n      APPLY_EPHEMERAL_WRITES,\n      [...writes.map((w) => valueKeyOf(w.key)), SEQ_KEY],\n      writes.flatMap((w) => [w.value, String(w.ttlSeconds)]),\n    );\n\n    this.onAfterWrite?.(writes.map((w) => w.key), String(version));\n  }\n}\n\nfunction decode<T>(key: string, raw: string | null, schema: ZodType<T>): T | null {\n  if (raw === null || raw === undefined) return null;\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (cause) {\n    throw new EphemeralDecodeError(key, { cause });\n  }\n\n  const result = schema.safeParse(parsed);\n  if (!result.success) throw new EphemeralDecodeError(key, { cause: result.error });\n  return result.data;\n}\n\n/**\n * An {@link EphemeralStore} backed by a plain Map instead of Redis — for unit\n * tests and tooling that construct a `SupaliveDb` without a cache layer.\n *\n * It is process-local, so it is NOT a substitute for the real store in any\n * multi-instance deployment: two servers would each see their own values, and\n * cross-instance invalidation would push stale data. TTLs are honoured on read\n * (there is no background expiry), which is enough for the semantics tests care\n * about.\n */\nexport function createMemoryEphemeralStore(opts?: { defaultTtlSeconds?: number }): EphemeralStore {\n  const values = new Map<string, { value: string; expiresAt: number }>();\n  let seq = 0;\n\n  const read = (key: string): string | null => {\n    const entry = values.get(key);\n    if (!entry) return null;\n    if (entry.expiresAt <= Date.now()) {\n      values.delete(key);\n      return null;\n    }\n    return entry.value;\n  };\n\n  const backing = {\n    ephemeralGet: async (key: string) => read(key),\n    ephemeralGetMany: async (keys: string[]) => keys.map(read),\n    // Mirrors APPLY_EPHEMERAL_WRITES: the trailing key is the sequence, and each\n    // value key carries a (value, ttl) ARGV pair where ttl <= 0 means delete.\n    evalScript: async (_src: string, keys: string[], args: (string | number)[]) => {\n      for (let i = 0; i < keys.length - 1; i++) {\n        const ttl = Number(args[i * 2 + 1]);\n        if (ttl <= 0) values.delete(keys[i]!);\n        else values.set(keys[i]!, { value: String(args[i * 2]), expiresAt: Date.now() + ttl * 1000 });\n      }\n      return ++seq;\n    },\n  } as CacheLayer;\n\n  return new EphemeralStore(backing, opts);\n}\n\n// ─── Handler-facing wrappers ─────────────────────────────────────────────────\n//\n// Built as free functions over a context rather than methods on it: the tracking\n// and buffering they add is the ONLY difference from the bare store, and keeping\n// them out of `DbReader`/`DbWriter` leaves those classes about SQL. Each takes\n// the context it reports to as its first argument.\n\n/** The slice of a `DbReader` these wrappers drive. Structural, so `context.ts`\n *  doesn't have to be imported here (it imports this module). */\nexport interface EphemeralReadTracker {\n  internalTrackEphemeralRead(key: string): void;\n}\n\n/** The slice of a `DbWriter` the write wrapper drives. */\nexport interface EphemeralWriteBuffer extends EphemeralReadTracker {\n  internalBufferEphemeralWrite(write: PendingEphemeralWrite): void;\n}\n\n/**\n * Wrap `store` so every read also records a live-query dependency on the key it\n * touched. The dependency is on the KEY, not the value: reading a key that is\n * currently absent still subscribes you to it being set later.\n */\nexport function createTrackedEphemeralReader(\n  ctx: EphemeralReadTracker,\n  store: EphemeralStore,\n): EphemeralReader {\n  return {\n    find: (key, schema) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.find(key, schema);\n    },\n    get: (key, schema) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.get(key, schema);\n    },\n    getOr: (key, schema, fallback) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.getOr(key, schema, fallback);\n    },\n    findMany: (keys, schema) => {\n      for (const key of keys) ctx.internalTrackEphemeralRead(key);\n      return store.findMany(keys, schema);\n    },\n    has: (key) => {\n      ctx.internalTrackEphemeralRead(key);\n      return store.has(key);\n    },\n  };\n}\n\n/**\n * Wrap `store` for use inside a mutation: reads track as above, but writes are\n * BUFFERED on the context and applied only once the transaction commits.\n *\n * Buffering is what makes ephemeral writes safe in a transactional handler. A\n * mutation body can run several times — the OCC retry policy re-invokes it with\n * a fresh `DbWriter` on every conflict — so writing to Redis eagerly would\n * publish state from attempts that never committed, and push it to subscribers.\n * Only the committing attempt's buffer is flushed; a losing attempt's buffer is\n * discarded with its context.\n */\nexport function createBufferedEphemeralWriter(\n  ctx: EphemeralWriteBuffer,\n  store: EphemeralStore,\n): EphemeralWriter {\n  return {\n    ...createTrackedEphemeralReader(ctx, store),\n    set: async (key, value, opts) => {\n      ctx.internalBufferEphemeralWrite(store.prepareSet(key, value, opts));\n    },\n    delete: async (key) => {\n      ctx.internalBufferEphemeralWrite(store.prepareDelete(key));\n    },\n  };\n}\n"],"mappings":"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"}