@supalive/core 1.17.0 → 1.19.0

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

@@ -1,2 +1,2 @@
-import { t as PgDatabase } from "../../postgres-B0fqJe1X.js";
+import { t as PgDatabase } from "../../postgres-DBuP9ON_.js";
 export { PgDatabase };

package/dist/src/exports/postgres.js

@@ -1,2 +1,2 @@
-import { t as PgDatabase } from "../../postgres-CN03Espg.js";
+import { t as PgDatabase } from "../../postgres-DwiUT_A6.js";
 export { PgDatabase };

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

@@ -1,4 +1,4 @@
-import { $ as ActionProcedures, An as MutationArgs, At as QueryFn, Bn as StoredSchemaColumnsOptions, Cn as ComputedFieldConfig, Ct as MutationConfig, Dn as InferSchema, Dt as OutputOf, En as IndexDefinition, Et as MutationProcedure, Fn as ReturnQuery, Ft as createMutationBuilder, Gn as tableNameToId, Hn as defineSchema, In as SchemaCodecs, It as createQueryBuilder, Ln as SchemaColumnMapping, Mn as Prettify, Mt as TypeOf, Nn as QueryArgs, Nt as createActionBuilder, On as InsertData, Ot as QueryConfig, Pn as ReturnLiveQuery, Pt as createJobBuilder, Rn as SchemaColumnsOptions, Sn as ComputedField, St as JobProcedure, Tn as DefineSchemaConfig, Tt as MutationFn, Un as schemaRegistry, Vn as defineComputedField, Wn as shouldTrackSchema, _n as matchesPredicate, _t as HandlerLogger, an as IdAndCommitTs, at as PublicProcedures, bn as ComputedCodec, bt as JobCtx, cn as JsonOpOptions, ct as Router, dn as PaginationClause, dt as ActionConfig, et as AppRouter, fn as QueryBuilder, ft as ActionCtx, gn as jsonPathExtract, gt as ContextOf, hn as jsonPathExists, ht as AnyProcedure, it as ProcedureNames, jn as OverrideField, jt as QueryProcedure, kn as Model, kt as QueryCtx, ln as OrderByOptions, lt as getContextRegistry, mn as jsonContains, mt as ActionProcedure, nt as JobProcedures, on as JsonContainsOptions, ot as QueryProcedures, pn as buildPredicateSql, pt as ActionFn, rt as MutationProcedures, sn as JsonHasKeyMultiOptions, st as RegisteredProcedure, tt as ContextRegistry, un as OrderDirection, ut as router, vn as ActionArgs, vt as HandlerObservability, wn as DeclarativeIndex, wt as MutationCtx, xn as ComputedDataType, xt as JobFn, yn as ColumnCodec, yt as JobConfig, zn as SchemaDefinition } from "../../index-B5hAqW3O.js";
+import { $ as ActionProcedures, An as MutationArgs, At as QueryFn, Bn as StoredSchemaColumnsOptions, Cn as ComputedFieldConfig, Ct as MutationConfig, Dn as InferSchema, Dt as OutputOf, En as IndexDefinition, Et as MutationProcedure, Fn as ReturnQuery, Ft as createMutationBuilder, Gn as tableNameToId, Hn as defineSchema, In as SchemaCodecs, It as createQueryBuilder, Ln as SchemaColumnMapping, Mn as Prettify, Mt as TypeOf, Nn as QueryArgs, Nt as createActionBuilder, On as InsertData, Ot as QueryConfig, Pn as ReturnLiveQuery, Pt as createJobBuilder, Rn as SchemaColumnsOptions, Sn as ComputedField, St as JobProcedure, Tn as DefineSchemaConfig, Tt as MutationFn, Un as schemaRegistry, Vn as defineComputedField, Wn as shouldTrackSchema, _n as matchesPredicate, _t as HandlerLogger, an as IdAndCommitTs, at as PublicProcedures, bn as ComputedCodec, bt as JobCtx, cn as JsonOpOptions, ct as Router, dn as PaginationClause, dt as ActionConfig, et as AppRouter, fn as QueryBuilder, ft as ActionCtx, gn as jsonPathExtract, gt as ContextOf, hn as jsonPathExists, ht as AnyProcedure, it as ProcedureNames, jn as OverrideField, jt as QueryProcedure, kn as Model, kt as QueryCtx, ln as OrderByOptions, lt as getContextRegistry, mn as jsonContains, mt as ActionProcedure, nt as JobProcedures, on as JsonContainsOptions, ot as QueryProcedures, pn as buildPredicateSql, pt as ActionFn, rt as MutationProcedures, sn as JsonHasKeyMultiOptions, st as RegisteredProcedure, tt as ContextRegistry, un as OrderDirection, ut as router, vn as ActionArgs, vt as HandlerObservability, wn as DeclarativeIndex, wt as MutationCtx, xn as ComputedDataType, xt as JobFn, yn as ColumnCodec, yt as JobConfig, zn as SchemaDefinition } from "../../index-CKo6HvJc.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-CiacMqje.js";
 import * as z$2 from "zod";
 

package/dist/src/exports/schema-sql.d.ts

@@ -1,4 +1,4 @@
-import { Un as schemaRegistry, zn as SchemaDefinition } from "../../index-B5hAqW3O.js";
+import { Un as schemaRegistry, zn as SchemaDefinition } from "../../index-CKo6HvJc.js";
 
 //#region src/db/schema-sql.d.ts
 type SqlDialect = "postgres" | "mysql";

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

@@ -1,9 +1,8 @@
-import { Bt as IncomingJobRequest, D as Context, Gt as ScheduleHandle, Ht as JobScheduler, Kt as ScheduledJobDef, Lt as DevScheduler, Rt as DevSchedulerOptions, Ut as QStashScheduler, Vt as JobClient, Wt as QStashSchedulerOptions, _r as UpdateSubscriptionReadSetResult, ar as InvalidateWritesetParamsSchema, cr as RegisterSubscriptionParamsSchema, ct as Router, dr as UnregisterSubscriptionParamsSchema, fr as UnregisterSubscriptionResult, gr as UpdateSubscriptionReadSetParamsSchema, hr as UpdateSubscriptionReadSetParams, ir as InvalidateWritesetParams, lr as RegisterSubscriptionResult, nr as CacheLayer, or as InvalidateWritesetResult, qn as Database, qt as SupaliveDb, rr as AffectedSubscription, sr as RegisterSubscriptionParams, ur as UnregisterSubscriptionParams, zt as EnqueueOptions } from "../../index-B5hAqW3O.js";
-import { t as MySqlDatabase } from "../../mysql-C7Km_lgc.js";
-import { t as PgDatabase } from "../../postgres-B0fqJe1X.js";
-import { A as QueryTrigger, C as SubManagerLink, D as OperationKind, E as OperationEvent, F as startTimer, I as traceQueryExecution, M as configureRootLogger, N as elapsedMs, O as OperationOutcome, P as getRootLogger, S as SubManagerClient, T as ObservabilityOptions, b as SupaliveServerConfig, j as RequestLogMode, k as OperationTransport, p as DatabaseConfig, u as SubId, w as Observability, x as UpstashConfig, y as SubscriptionManagerConfig } from "../../types_server-kkQJDSjA.js";
+import { Bt as IncomingJobRequest, D as Context, Gt as ScheduleHandle, Ht as JobScheduler, Kt as ScheduledJobDef, Lt as DevScheduler, Rt as DevSchedulerOptions, Ut as QStashScheduler, Vt as JobClient, Wt as QStashSchedulerOptions, _r as UpdateSubscriptionReadSetParamsSchema, ar as InvalidateWritesetParams, cr as RegisterSubscriptionParams, ct as Router, dr as UnregisterSubscriptionParams, fr as UnregisterSubscriptionParamsSchema, gr as UpdateSubscriptionReadSetParams, ir as AffectedSubscription, lr as RegisterSubscriptionParamsSchema, nr as CacheLayer, or as InvalidateWritesetParamsSchema, pr as UnregisterSubscriptionResult, qn as Database, qt as SupaliveDb, rr as IORedisClient, sr as InvalidateWritesetResult, ur as RegisterSubscriptionResult, vr as UpdateSubscriptionReadSetResult, zt as EnqueueOptions } from "../../index-CKo6HvJc.js";
+import { t as MySqlDatabase } from "../../mysql-CyzJqrvO.js";
+import { t as PgDatabase } from "../../postgres-DBuP9ON_.js";
+import { A as QueryTrigger, C as SubManagerLink, D as OperationKind, E as OperationEvent, F as startTimer, I as traceQueryExecution, M as configureRootLogger, N as elapsedMs, O as OperationOutcome, P as getRootLogger, S as SubManagerClient, T as ObservabilityOptions, b as SupaliveServerConfig, j as RequestLogMode, k as OperationTransport, p as DatabaseConfig, u as SubId, w as Observability, x as UpstashConfig, y as SubscriptionManagerConfig } from "../../types_server-BCst4TfZ.js";
 import pino, { Level } from "pino";
-import Redis$1 from "ioredis";
 
 //#region src/server/supalive-server.d.ts
 /**
@@ -63,6 +62,11 @@ declare class SupaliveWebSocketServer<TContext extends Context> {
    * the scheduler registers are already reachable.
    */
   private syncJobSchedules;
+  /**
+   * The server's {@link Observability} — hand it to the internal caller's
+   * `init({ obs })` so its standalone calls log as per-procedure children of
+   * this server's request logger instead of a no-op.
+   */
   getObservability(): Observability;
   /** Absolute URL the scheduler POSTs to for a given job name. */
   endpointFor(name: string): string;
@@ -79,6 +83,13 @@ declare class SupaliveWebSocketServer<TContext extends Context> {
    * procedures can schedule/cancel one-shots without reaching for the server.
    */
   getJobClient(): JobClient;
+  /**
+   * The current in-memory retention watermark (oldest retained commit-log ts) —
+   * the value the one-shot query cache freshness scan uses as its retention
+   * guard. Hand it to the internal caller's `init({ getMinRetainedTs })` so its
+   * cache-first reads use the SAME guard as the WS/HTTP query paths.
+   */
+  getMinRetainedTs(): bigint;
   stop(): Promise<void>;
   getStats(): {
     instanceId: string;
@@ -159,7 +170,6 @@ declare class SupaliveWebSocketServer<TContext extends Context> {
   private reexecuteAffectedQuery;
   private executeLiveQuery;
   private sendMessage;
-  private sendMessageRaw;
   private sendError;
   private subscribeToInstanceChannel;
   /**
@@ -316,7 +326,7 @@ type InitCacheLayerOptions = {
 };
 declare function initCacheLayer(config: InitCacheLayerOptions): {
   cacheLayer: CacheLayer;
-  redisSubClient?: Redis$1;
+  redisSubClient?: IORedisClient;
 };
 //#endregion
 //#region src/server/sub_hash.d.ts

package/dist/src/exports/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","names":[],"sources":["../../../src/server/supalive-server.ts","../../../src/logger.ts","../../../src/server/sub-manager.ts","../../../src/db/init_db.ts","../../../src/server/sub_hash.ts"],"mappings":"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"}
+{"version":3,"file":"server.d.ts","names":[],"sources":["../../../src/server/supalive-server.ts","../../../src/logger.ts","../../../src/server/sub-manager.ts","../../../src/db/init_db.ts","../../../src/server/sub_hash.ts"],"mappings":"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"}

package/dist/src/exports/server.js

@@ -1,418 +1,19 @@
 import { l as primaryOnlyConn, n as getContextRegistry } from "../../router-DP2ThAwh.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-zdJT5FUc.js";
-import { s as traceCacheCall } from "../../query-LJranz0c.js";
-import { r as evaluateCacheFreshness } from "../../overlap-checker-1TwhkAwy.js";
-import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-CWZmlWmM.js";
+import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-B8jh6MKl.js";
 import { n as RemoteSubscriptionMessageSchema } from "../../types_server-BhC19R2a.js";
-import { n as sleep } from "../../realtime_db-B0Tin87E.js";
-import { C as appInstanceId, D as serializeMapValue, E as logger, S as RetentionWatermark, T as logLevelOf, _ as UnregisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UpdateSubscriptionReadSetResultSchema, c as initCore, d as InvalidateWritesetParamsSchema, f as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as RegisterSubscriptionParamsSchema, n as SubscriptionWorker, o as createDatabase, p as RegisterSubscriptionBatchResultSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionsResultSchema, w as isProduction, x as RETENTION_WATERMARK_CHANNEL, y as UpdateSubscriptionReadSetParamsSchema } from "../../sub-worker-dispatch-qiSs5Xkm.js";
-import { n as resolveReadRouting, t as makeConnRouting } from "../../read-routing-BUcQAwnd.js";
-import { ROOT_CONTEXT, SpanKind, SpanStatusCode, context, isSpanContextValid, metrics, propagation, trace } from "@opentelemetry/api";
+import { a as serializeMapValue, i as logger, n as isProduction, r as logLevelOf, s as sleep, t as appInstanceId } from "../../logger-DrXccWFZ.js";
+import { a as elapsedMs, c as traceQueryExecution, d as generateSubscriptionId, f as getHashOf, i as configureRootLogger, l as ANONYMOUS_IDENTITY, o as getRootLogger, p as resolveQueryIdentity, r as Observability, s as startTimer, t as runCachedQuery, u as generateCacheKey } from "../../one-shot-query-BBiv9LGP.js";
+import { S as RetentionWatermark, _ as UnregisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UpdateSubscriptionReadSetResultSchema, c as initCore, d as InvalidateWritesetParamsSchema, f as InvalidateWritesetResultSchema, g as UnregisterSubscriptionParamsSchema, h as RegisterSubscriptionResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as RegisterSubscriptionParamsSchema, n as SubscriptionWorker, o as createDatabase, p as RegisterSubscriptionBatchResultSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionsResultSchema, x as RETENTION_WATERMARK_CHANNEL, y as UpdateSubscriptionReadSetParamsSchema } from "../../sub-worker-dispatch-BLujn13f.js";
+import { context, trace } from "@opentelemetry/api";
 import { v4 } from "uuid";
 import { createServer } from "http";
 import { WebSocket, WebSocketServer } from "ws";
 import { ExponentialBackoff, handleAll, retry } from "cockatiel";
-import { sha1 } from "hash-wasm";
 import { Client, Server } from "rpc-websockets";
 import { Client as Client$1, Receiver } from "@upstash/qstash";
 import { Worker } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
-//#region src/server/sub_hash.ts
-/** Compute stable hash using json-stable-stringify and SHA1. */
-async function getHashOf(input) {
-	return sha1((typeof input === "string" ? input : stableStringify(input)) ?? "");
-}
-/**
-* Default identity literal used when neither a procedure-level
-* `queryIdentity` override nor a per-session user is available.
-*/
-const ANONYMOUS_IDENTITY = "anonymous";
-/**
-* Resolve the segmentation key that participates in the subId/cacheKey hash for
-* a query. Shared by every query transport (WS subscribe, WS one-shot call, and
-* HTTP RPC) so identity — and therefore cache segmentation — is computed
-* identically regardless of how the query is invoked. Priority:
-*
-*   1. Procedure-level `queryIdentity` override:
-*        - `false`    → `ANONYMOUS_IDENTITY` (cache shared across users)
-*        - `string`   → that literal
-*        - `function` → serverCtx + input → string | null | undefined
-*   2. `getUserId(serverCtx)` → falls back to `ANONYMOUS_IDENTITY` when it
-*      returns null/undefined or isn't configured.
-*/
-function resolveQueryIdentity(procedure, serverCtx, input, getUserId) {
-	const override = procedure.queryIdentity;
-	if (override !== void 0) {
-		if (override === false) return ANONYMOUS_IDENTITY;
-		if (typeof override === "string") return override;
-		if (typeof override === "function") {
-			const value = override(serverCtx, input);
-			if (value === null || value === void 0) return ANONYMOUS_IDENTITY;
-			return value;
-		}
-	}
-	if (!getUserId) return ANONYMOUS_IDENTITY;
-	return getUserId(serverCtx) ?? "anonymous";
-}
-/**
-* Compute a subscription id from hash of procedure + input + queryIdentity.
-*
-* `queryIdentity` is the segmentation key for cache/subscriptions. By default
-* it is the authenticated user's id (so two users get distinct subscriptions
-* for the same query), but a procedure may override it to share cache/subs
-* across users (e.g. for a public, user-independent query).
-*/
-async function generateSubscriptionId(procedure, input, queryIdentity) {
-	return `sub_${await getHashOf(`${procedure}_${typeof input === "string" ? input : stableStringify(input)}_${queryIdentity}`)}`;
-}
-/**
-* Compute cache key from query name + args + queryIdentity. The identity
-* participates so that user-specific results don't poison each other's
-* cache when a procedure does authorize per-user.
-*/
-async function generateCacheKey(queryName, input, queryIdentity) {
-	return `ck_${await getHashOf(`${queryName}_${typeof input === "string" ? input : stableStringify(input)}_${queryIdentity}`)}`;
-}
-//#endregion
-//#region src/observability.ts
-let rootLogger = logger;
-/** Replace the process-wide root logger. Call once at startup, before creating
-* the server, to route Supalive's request/lifecycle logs through your own pino
-* instance. */
-function configureRootLogger(logger) {
-	rootLogger = logger;
-}
-/** The current root logger (defaults to the env-configured singleton). */
-function getRootLogger() {
-	return rootLogger;
-}
-const CLIENT_ERROR_CODES = /* @__PURE__ */ new Set([
-	"NOT_FOUND",
-	"BAD_REQUEST",
-	"INVALID_MESSAGE",
-	"PARSE_ERROR",
-	"UNAUTHENTICATED",
-	"RATE_LIMITED",
-	"METHOD_NOT_ALLOWED",
-	"TOO_MANY_CONCURRENT_MUTATIONS",
-	"TOO_MANY_CONCURRENT_ACTIONS",
-	"SUBSCRIBE_ERROR"
-]);
-/**
-* The bound observability surface for one server instance: an injectable logger,
-* OTel metric instruments, and the `record()` seam every operation funnels
-* through. Built once in the server constructor and shared with the HTTP RPC
-* handler.
-*/
-var Observability = class {
-	logger;
-	requestLog;
-	onEvent;
-	requestCounter;
-	durationHistogram;
-	activeConnections;
-	activeSubscriptions;
-	tracer;
-	constructor(opts = {}) {
-		const base = opts.logger ?? getRootLogger();
-		this.logger = opts.level ? base.child({}, { level: opts.level }) : base;
-		this.requestLog = opts.requestLog ?? "all";
-		this.onEvent = opts.onEvent;
-		const meterName = opts.meterName ?? "@supalive/core";
-		const meter = metrics.getMeter(meterName, opts.meterVersion);
-		this.tracer = trace.getTracer(meterName, opts.meterVersion);
-		this.requestCounter = meter.createCounter("supalive_requests_total", { description: "Total Supalive operations (WS calls, subscribes, HTTP RPC, jobs)." });
-		this.durationHistogram = meter.createHistogram("supalive_request_duration_ms", {
-			description: "Operation duration in milliseconds.",
-			unit: "ms"
-		});
-		this.activeConnections = meter.createUpDownCounter("supalive_active_connections", { description: "Currently open WebSocket connections." });
-		this.activeSubscriptions = meter.createUpDownCounter("supalive_active_subscriptions", { description: "Currently registered live-query subscriptions on this instance." });
-	}
-	/** Record one completed operation: metrics + optional onEvent + one log line,
-	*  and finalize the op's span (status/attributes/exception) when present. */
-	record(e) {
-		const traceId = this.finalizeSpan(e);
-		if (traceId) (e.extra ??= {}).traceId = traceId;
-		const attrs = {
-			transport: e.transport,
-			procedure: e.procedure ?? "",
-			kind: e.kind ?? "",
-			outcome: e.outcome,
-			code: e.code ?? ""
-		};
-		this.requestCounter.add(1, attrs);
-		this.durationHistogram.record(e.durationMs, attrs);
-		if (this.onEvent) try {
-			this.onEvent(e);
-		} catch {}
-		if (this.requestLog === "off") return;
-		if (e.outcome === "ok") {
-			if (this.requestLog !== "all") return;
-			this.logger.info(logFields(e), summary(e));
-			return;
-		}
-		const fields = logFields(e);
-		if (!e.error && e.code != null && CLIENT_ERROR_CODES.has(e.code)) this.logger.warn(fields, summary(e));
-		else this.logger.error({
-			...fields,
-			err: e.error
-		}, summary(e));
-	}
-	/**
-	* Start a SERVER span for an operation, as a child of `parent` (or the active
-	* context). No-op — returns a non-recording span — until a TracerProvider is
-	* registered by the app, so this costs nothing when tracing is disabled.
-	* Returns the span plus a context that has it active, for `context.with(...)`
-	* wrapping so nested handler work / `ctx.span` children attach correctly.
-	*/
-	startSpan(name, opts = {}) {
-		const parent = opts.parent ?? context.active();
-		const span = this.tracer.startSpan(name, {
-			kind: SpanKind.SERVER,
-			attributes: {
-				...opts.transport ? { "supalive.transport": opts.transport } : {},
-				...opts.procedure ? { "supalive.procedure": opts.procedure } : {},
-				...opts.kind ? { "supalive.kind": opts.kind } : {}
-			}
-		}, parent);
-		return {
-			span,
-			context: trace.setSpan(parent, span)
-		};
-	}
-	/**
-	* Continue a trace from an inbound carrier (HTTP headers, or a WS message's
-	* `trace` field). Returns a context to pass as `startSpan({ parent })`. When
-	* no propagator is registered / no trace context is present, returns the root
-	* context (a fresh trace).
-	*/
-	extractContext(carrier) {
-		return propagation.extract(ROOT_CONTEXT, carrier);
-	}
-	/** Set the span's final status/attributes from the event, then end it.
-	*  Returns the (valid) trace id for log correlation, or undefined. */
-	finalizeSpan(e) {
-		const span = e.span;
-		if (!span) return void 0;
-		try {
-			span.setAttribute("supalive.outcome", e.outcome);
-			if (e.code) span.setAttribute("supalive.code", e.code);
-			if (e.procedure) span.setAttribute("supalive.procedure", e.procedure);
-			if (e.kind) span.setAttribute("supalive.kind", e.kind);
-			if (e.outcome === "error") {
-				if (e.error instanceof Error) span.recordException(e.error);
-				span.setStatus({
-					code: SpanStatusCode.ERROR,
-					message: e.code
-				});
-			} else span.setStatus({ code: SpanStatusCode.OK });
-		} finally {
-			span.end();
-		}
-		const sc = span.spanContext();
-		return isSpanContextValid(sc) ? sc.traceId : void 0;
-	}
-	/** A request-scoped child logger for `ctx.log`, bound with the given fields
-	*  (reqId, procedure, and trace id when tracing is on). */
-	childLogger(fields) {
-		return this.logger.child(fields);
-	}
-	/**
-	* A LAZY request-scoped `ctx.log`. Most handlers never log, and pino's
-	* `.child()` (bindings merge + serialization) isn't free — so this defers the
-	* child creation until the first `debug/info/warn/error` call and reuses it
-	* after. When a handler logs nothing, no child logger is ever allocated; the
-	* only per-request cost is this small delegator object. Returns the narrow
-	* {@link HandlerLogger} surface the handler context exposes.
-	*/
-	lazyChildLogger(fields) {
-		const base = this.logger;
-		let child;
-		const get = () => child ??= base.child(fields);
-		return {
-			debug: (...args) => get().debug(...args),
-			info: (...args) => get().info(...args),
-			warn: (...args) => get().warn(...args),
-			error: (...args) => get().error(...args)
-		};
-	}
-	/** The span's trace id, or undefined when tracing is off / the span is
-	*  non-recording. For binding onto `ctx.log`. */
-	traceIdOf(span) {
-		if (!span) return void 0;
-		const sc = span.spanContext();
-		return isSpanContextValid(sc) ? sc.traceId : void 0;
-	}
-	connectionOpened() {
-		this.activeConnections.add(1);
-	}
-	connectionClosed() {
-		this.activeConnections.add(-1);
-	}
-	subscriptionAdded(n = 1) {
-		this.activeSubscriptions.add(n);
-	}
-	subscriptionRemoved(n = 1) {
-		this.activeSubscriptions.add(-n);
-	}
-};
-/** Start marker for an operation; pass to {@link elapsedMs} to get its duration. */
-function startTimer() {
-	return performance.now();
-}
-function elapsedMs(startedAt) {
-	return Math.round((performance.now() - startedAt) * 1e3) / 1e3;
-}
-const coreTracer = trace.getTracer("@supalive/core");
-/**
-* Run a query handler inside a `query <procedureName>` span, nested under
-* `parentContext` (the operation span) or the active context. The span is handed
-* to `run` so it becomes the query handler's `ctx.span` and the parent of any DB
-* spans. Cache HITs never call this (no execution), so a span appearing means a
-* real recompute — including the otherwise-invisible background reactive path,
-* where `parentContext` is omitted and the span is a root.
-*
-* No-op-cheap when tracing is off: the started span is non-recording, so we skip
-* the `context.with` and just run.
-*/
-function traceQueryExecution(procedureName, trigger, parentContext, run) {
-	const parent = parentContext ?? context.active();
-	const span = coreTracer.startSpan(`query ${procedureName}`, { attributes: {
-		"supalive.kind": "query",
-		"supalive.procedure": procedureName,
-		"supalive.trigger": trigger
-	} }, parent);
-	const exec = async () => {
-		try {
-			const r = await run(span);
-			span.setStatus({ code: SpanStatusCode.OK });
-			return r;
-		} catch (err) {
-			if (err instanceof Error) span.recordException(err);
-			span.setStatus({ code: SpanStatusCode.ERROR });
-			throw err;
-		} finally {
-			span.end();
-		}
-	};
-	return span.isRecording() ? context.with(trace.setSpan(parent, span), exec) : exec();
-}
-function logFields(e) {
-	const f = {
-		op: e.op,
-		transport: e.transport,
-		outcome: e.outcome,
-		durMs: e.durationMs
-	};
-	if (e.procedure) f.procedure = e.procedure;
-	if (e.kind) f.kind = e.kind;
-	if (e.code) f.code = e.code;
-	if (e.reqId) f.reqId = e.reqId;
-	if (e.sessionId) f.sessionId = e.sessionId;
-	if (e.userId != null) f.userId = e.userId;
-	if (e.extra) Object.assign(f, e.extra);
-	return f;
-}
-function summary(e) {
-	const label = e.procedure ? `${e.kind ?? e.op} ${e.procedure}` : e.op;
-	return `${e.transport} ${label} ${e.outcome}`;
-}
-//#endregion
-//#region src/server/one-shot-query.ts
-/**
-* Execute a one-shot query (WS `call` or HTTP RPC) with the same caching model
-* as a live subscription — but without registering a tracked subscription.
-*
-* Flow (mirrors `handleSubscribe` / worker `register`):
-*   1. Resolve `queryIdentity` → `cacheKey` (identical segmentation to subs).
-*   2. Pick the read connection ONCE (replica when it's caught up to the client's
-*      `clientMinTs`, else primary) and use it for BOTH the freshness scan and
-*      the row reads, so a cache HIT offloads the primary too — not just a miss.
-*   3. Freshness check via {@link evaluateCacheFreshness} on that connection:
-*      cached metadata + the retention watermark + a between-ts commit-log scan.
-*   4. Fresh  → return the cached data.
-*      Stale/miss → recompute via `queryInternalOn` (on the chosen connection)
-*      and write BOTH the data and the metadata (readSet + snapshotTs) back, so
-*      a later one-shot or a fresh subscription can reuse it.
-*
-* The retention guard is what makes an untracked one-shot safe: nothing holds
-* the prune watermark down for it, so an entry whose snapshot has fallen below
-* the oldest retained commit log is treated as a miss (its freshness scan would
-* be incomplete).
-*
-* `lastSnapshotTs` is the primary freshness upper bound — the latest snapshot ts
-* as of this call. The caller loads it (via `db.getLatestSnapshotTimestamp()`)
-* and passes it in, exactly like the subscribe path loads it before `register`,
-* so the snapshot read lives at the caller seam rather than being hidden here.
-*
-* `clientMinTs` is the caller's read high-water (the largest commit/snapshot ts
-* it has already observed). It gates replica routing: a query only runs on the
-* replica when the replica has applied at least `clientMinTs` — otherwise reads
-* (and the freshness scan) stay on the primary, preserving read-your-writes and
-* monotonic reads. It is clamped to `lastSnapshotTs` here, so a client can at
-* most force the primary (never a value beyond it). Returns the data plus the
-* `ts` the result reflects, which the caller echoes so the client can advance
-* its high-water.
-*/
-async function runCachedQuery(deps, handlerObs, procedure, procedureName, input, serverCtx, lastSnapshotTs, clientMinTs) {
-	const queryIdentity = resolveQueryIdentity(procedure, serverCtx, input, deps.getUserId);
-	const cacheKey = await generateCacheKey(procedureName, stableStringify(input), queryIdentity);
-	const routing = await resolveReadRouting(deps.db, lastSnapshotTs, clientMinTs ?? 0n);
-	const readTs = routing.readTs;
-	const { metadata, freshness } = await traceCacheCall("freshness", async () => {
-		const metadata = await deps.cache.getQueryCacheMetaData(cacheKey);
-		return {
-			metadata,
-			freshness: await evaluateCacheFreshness(routing.readImpl, metadata, readTs, deps.getMinRetainedTs())
-		};
-	});
-	if (freshness.fresh) {
-		const cached = await traceCacheCall("get", async (setHit) => {
-			const c = await deps.cache.getQueryCacheFor(cacheKey);
-			setHit(!!(c && metadata && c.version === metadata.version));
-			return c;
-		});
-		if (cached && metadata && cached.version === metadata.version) {
-			if (readTs > metadata.lastSnapshotTs) deps.cache.advanceQueryCacheMetadata(cacheKey, {
-				lastSnapshotTs: readTs,
-				version: metadata.version,
-				readSet: metadata.readSet
-			}).catch((err) => logger.error(err, "one-shot horizon advance failed"));
-			const servedTs = readTs > metadata.lastSnapshotTs ? readTs : metadata.lastSnapshotTs;
-			return {
-				data: cached.data,
-				ts: servedTs
-			};
-		}
-	}
-	const result = await deps.db.queryInternalOn({
-		impl: routing.readImpl,
-		beginTs: readTs
-	}, async (ctx) => {
-		const fn = procedure.fn;
-		return traceQueryExecution(procedureName, "request", void 0, (querySpan) => {
-			const qctx = {
-				db: ctx,
-				serverCtx,
-				...makeConnRouting(ctx, routing),
-				log: handlerObs.log,
-				span: querySpan
-			};
-			return fn(qctx, input);
-		});
-	});
-	await deps.cache.setQueryCacheAndMetadataFor(cacheKey, result.data, {
-		lastSnapshotTs: result.ts,
-		version: String(result.ts),
-		readSet: result.readSet
-	}).catch((err) => logger.error(err, "one-shot query cache write failed"));
-	return {
-		data: result.data,
-		ts: result.ts
-	};
-}
-//#endregion
 //#region src/server/sub-manager-client.ts
 const logger$3 = logger.child({ name: "SUBS_MGR_CLIENT" }, { level: logLevelOf("SUB_MANAGER_CLIENT_LOG_LEVEL") });
 const subscriptionManagerDataPack = {
@@ -842,6 +443,9 @@ var HttpRpcHandler = class {
 	rateLimiter;
 	/** Job webhook prefix (`{jobPath}/`) — a job POST is `{jobPath}/<jobName>`. */
 	jobPrefix;
+	/** App build number added as a top-level `build` field to every response
+	* envelope (see {@link HttpRpcDeps.buildNumber}). Undefined = omit. */
+	buildNumber;
 	constructor(deps) {
 		this.deps = deps;
 		this.rpc = deps.rpc;
@@ -852,6 +456,7 @@ var HttpRpcHandler = class {
 			this.rateLimiter = new FixedWindowRateLimiter(rl.windowMs ?? 6e4, rl.max ?? 120);
 		}
 		this.jobPrefix = `${deps.jobPath}/`;
+		this.buildNumber = deps.buildNumber;
 	}
 	/** True when this handler owns the given request path as an RPC call. The
 	* procedure name is carried in the body now, so a single exact path is the
@@ -1182,6 +787,7 @@ var HttpRpcHandler = class {
 		res.setHeader("access-control-max-age", "86400");
 	}
 	send(res, status, body) {
+		body.build = this.buildNumber;
 		res.writeHead(status, { "content-type": "application/json" });
 		res.end(supaliveStringify(body));
 	}
@@ -1356,7 +962,7 @@ var SupaliveWebSocketServer = class {
 		this.oneShotDeps = {
 			db: this.db,
 			cache: this.cache,
-			getUserId: config.getUserId,
+			getUserId: config.getUserId ?? (() => null),
 			getMinRetainedTs: () => this.retentionWatermark.get()
 		};
 		this.rpcHandler = new HttpRpcHandler({
@@ -1366,6 +972,7 @@ var SupaliveWebSocketServer = class {
 			verifyAuth: config.verifyAuth,
 			rpc: config.rpc ?? {},
 			rpcEnabled: config.rpc !== void 0,
+			buildNumber: config.buildNumber,
 			storage: this.storage,
 			scheduler: this.jobClient,
 			obs: this.obs,
@@ -1465,6 +1072,11 @@ var SupaliveWebSocketServer = class {
 			this.log.error(err, "Failed to sync job schedules");
 		}
 	}
+	/**
+	* The server's {@link Observability} — hand it to the internal caller's
+	* `init({ obs })` so its standalone calls log as per-procedure children of
+	* this server's request logger instead of a no-op.
+	*/
 	getObservability() {
 		return this.obs;
 	}
@@ -1493,6 +1105,15 @@ var SupaliveWebSocketServer = class {
 	getJobClient() {
 		return this.jobClient;
 	}
+	/**
+	* The current in-memory retention watermark (oldest retained commit-log ts) —
+	* the value the one-shot query cache freshness scan uses as its retention
+	* guard. Hand it to the internal caller's `init({ getMinRetainedTs })` so its
+	* cache-first reads use the SAME guard as the WS/HTTP query paths.
+	*/
+	getMinRetainedTs() {
+		return this.retentionWatermark.get();
+	}
 	async stop() {
 		this.wss.close();
 		for (const [ws] of this.sessions) ws.close(1001, "Server shutting down");
@@ -1518,10 +1139,18 @@ var SupaliveWebSocketServer = class {
 	*/
 	async handleHttpRequest(req, res) {
 		const path = (req.url ?? "/").split("?")[0];
-		if (req.method === "GET" && path === "/_health") return sendJson(res, 200, {
-			status: "ok",
-			instanceId: this.instanceId
-		});
+		if (req.method === "GET" && path === "/_health") {
+			const guard = this.config.guardHealthByHeader;
+			if (guard) {
+				const raw = req.headers[guard.name.toLowerCase()];
+				const headerValue = Array.isArray(raw) ? raw[0] : raw;
+				if (headerValue !== void 0 && (guard.value === void 0 || headerValue === guard.value)) return sendJson(res, 404, { error: "not found" });
+			}
+			return sendJson(res, 200, {
+				status: "ok",
+				instanceId: this.instanceId
+			});
+		}
 		if (this.rpcHandler.handlesPath(path)) return this.rpcHandler.handle(req, res, path);
 		if (this.rpcHandler.handlesJobPath(path)) return this.rpcHandler.handleJob(req, res, path);
 		if (this.config.onHttpRequest) {
@@ -1953,13 +1582,14 @@ var SupaliveWebSocketServer = class {
 				this.obs.subscriptionAdded();
 			}
 			if (liveResult) {
-				const [updateResult] = await Promise.all([this.subManagerClient.updateSubscriptionReadSet({
+				const updateResult = await this.subManagerClient.updateSubscriptionReadSet({
 					cacheKey,
 					subId,
 					lastSnapshotTs: liveResult.ts,
 					readSet: liveResult.readSet,
 					instanceName: this.instanceId
-				}), this.cache.setQueryCacheFor(cacheKey, data, liveResult.ts)]);
+				});
+				this.cache.setQueryCacheFor(cacheKey, data, liveResult.ts).catch((err) => this.log.warn(err, "writing query cache failed"));
 				if (!updateResult.tracked) this.log.warn(`updateSubscriptionReadSet returned tracked:false immediately after register for ${subId} — possible sub-manager restart mid-subscribe`);
 			}
 			dataHash = await getHashOf(data);
@@ -2256,12 +1886,10 @@ var SupaliveWebSocketServer = class {
 	}
 	sendMessage(session, message) {
 		if (session.ws.readyState !== WebSocket.OPEN) return;
+		message.build = this.config.buildNumber;
 		session.ws.send(supaliveStringify(message));
 		session.lastSentAt = Date.now();
 	}
-	sendMessageRaw(session, message) {
-		if (session.ws.readyState === WebSocket.OPEN) session.ws.send(message);
-	}
 	sendError(session, id, error, code) {
 		this.sendMessage(session, {
 			type: "response",