@supalive/core 0.1.3 → 0.1.5

package/dist/types_client_rpc-CIsjQQGG.js

@@ -0,0 +1,105 @@
+import z from "zod";
+//#region src/db/types_client_rpc.ts
+const AuthMessageSchema = z.object({
+	type: z.literal("auth"),
+	data: z.record(z.string(), z.any()).optional()
+});
+const CallMessageSchema = z.object({
+	type: z.literal("call"),
+	id: z.string(),
+	procedure: z.string(),
+	input: z.unknown()
+});
+const SubscribeMessageSchema = z.object({
+	type: z.literal("subscribe"),
+	id: z.string(),
+	procedure: z.string(),
+	input: z.unknown()
+});
+const UnsubscribeMessageSchema = z.object({
+	type: z.literal("unsubscribe"),
+	subId: z.string()
+});
+const ClientMessageSchema = z.union([
+	AuthMessageSchema,
+	CallMessageSchema,
+	SubscribeMessageSchema,
+	UnsubscribeMessageSchema
+]);
+const ConnectedMessageSchema = z.object({
+	type: z.literal("connected"),
+	sessionId: z.string()
+});
+const AuthSuccessMessageSchema = z.object({
+	type: z.literal("auth:success"),
+	userId: z.string(),
+	extra: z.object().optional()
+});
+const AuthFailedMessageSchema = z.object({
+	type: z.literal("auth:failed"),
+	message: z.string(),
+	extra: z.record(z.string(), z.unknown()).optional()
+});
+const ResponseMessageSchema = z.object({
+	type: z.literal("response"),
+	id: z.string(),
+	success: z.boolean(),
+	data: z.unknown().optional(),
+	error: z.string().optional(),
+	code: z.string().optional(),
+	/**
+	* Populated by the server only for a successful `subscribe` response.
+	* Carries the canonical, server-computed subscription id so the client
+	* can route subsequent `sub:update` / `sub:gone` messages without
+	* recomputing the hash locally (which would require the wasm runtime
+	* and would not reflect server-side per-procedure `queryIdentity`
+	* overrides).
+	*/
+	subId: z.string().optional()
+});
+const SubscriptionUpdateMessageSchema = z.object({
+	type: z.literal("sub:update"),
+	subId: z.string(),
+	data: z.unknown(),
+	dataHash: z.string().optional()
+});
+/**
+* Notifies a client that a subscription is no longer tracked on the server
+* and will not receive further updates. Sent when, during a sub-manager
+* recovery cycle, the registration record could not be found (e.g. another
+* app-server instance fully unregistered the sub while we were disconnected).
+* The client may choose to re-subscribe or surface the state to the user.
+*/
+const SubscriptionGoneMessageSchema = z.object({
+	type: z.literal("sub:gone"),
+	subId: z.string(),
+	reason: z.string().optional()
+});
+/**
+* Server-driven liveness signal. Sent when the channel has been idle for
+* the configured app-ping interval (default 15s) and again after every
+* outbound message. Pure no-op for the client: receiving any message
+* (including this one) resets the client's inactivity watchdog. The client
+* does NOT reply.
+*/
+const ServerPingMessageSchema = z.object({ type: z.literal("ping") });
+const ServerMessageSchema = z.union([
+	ConnectedMessageSchema,
+	AuthSuccessMessageSchema,
+	AuthFailedMessageSchema,
+	ResponseMessageSchema,
+	SubscriptionUpdateMessageSchema,
+	SubscriptionGoneMessageSchema,
+	ServerPingMessageSchema
+]);
+var AuthenticationError = class extends Error {
+	extra;
+	constructor(message, extra = {}) {
+		super(message);
+		this.extra = extra;
+	}
+};
+//#endregion
+export { CallMessageSchema as a, ResponseMessageSchema as c, SubscribeMessageSchema as d, SubscriptionGoneMessageSchema as f, AuthenticationError as i, ServerMessageSchema as l, UnsubscribeMessageSchema as m, AuthMessageSchema as n, ClientMessageSchema as o, SubscriptionUpdateMessageSchema as p, AuthSuccessMessageSchema as r, ConnectedMessageSchema as s, AuthFailedMessageSchema as t, ServerPingMessageSchema as u };
+
+//# sourceMappingURL=types_client_rpc-CIsjQQGG.js.map

package/dist/types_client_rpc-CIsjQQGG.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types_client_rpc-CIsjQQGG.js","names":[],"sources":["../src/db/types_client_rpc.ts"],"sourcesContent":["import z from \"zod\";\n\nexport interface ErrorMessage {\n  type: \"error\";\n  id?: string;\n  error: string;\n  code?: string;\n}\n\n// ─── WebSocket Message Schemas ────────────────────────────────────────────────\n// Zod schemas for runtime validation of WebSocket messages\n\nexport const AuthMessageSchema = z.object({\n  type: z.literal(\"auth\"),\n  data: z.record(z.string(), z.any()).optional(),\n});\n\nexport const CallMessageSchema = z.object({\n  type: z.literal(\"call\"),\n  id: z.string(),\n  procedure: z.string(),\n  input: z.unknown(),\n});\n\nexport const SubscribeMessageSchema = z.object({\n  type: z.literal(\"subscribe\"),\n  id: z.string(),\n  procedure: z.string(),\n  input: z.unknown(),\n});\n\nexport const UnsubscribeMessageSchema = z.object({\n  type: z.literal(\"unsubscribe\"),\n  subId: z.string(),\n});\n\nexport const ClientMessageSchema = z.union([\n  AuthMessageSchema,\n  CallMessageSchema,\n  SubscribeMessageSchema,\n  UnsubscribeMessageSchema,\n]);\n\n// Infer TypeScript types from schemas\nexport type AuthMessage = z.infer<typeof AuthMessageSchema>;\nexport type CallMessage = z.infer<typeof CallMessageSchema>;\nexport type SubscribeMessage = z.infer<typeof SubscribeMessageSchema>;\nexport type UnsubscribeMessage = z.infer<typeof UnsubscribeMessageSchema>;\nexport type ClientMessage = z.infer<typeof ClientMessageSchema>;\n\n// ─── Server Message Schemas ───────────────────────────────────────────────────\n\nexport const ConnectedMessageSchema = z.object({\n  type: z.literal(\"connected\"),\n  sessionId: z.string(),\n});\n\nexport const AuthSuccessMessageSchema = z.object({\n  type: z.literal(\"auth:success\"),\n  userId: z.string(),\n  extra: z.object().optional()\n});\n\nexport const AuthFailedMessageSchema = z.object({\n  type: z.literal(\"auth:failed\"),\n  message: z.string(),\n  extra: z.record(z.string(), z.unknown()).optional()\n});\n\nexport const ResponseMessageSchema = z.object({\n  type: z.literal(\"response\"),\n  id: z.string(),\n  success: z.boolean(),\n  data: z.unknown().optional(),\n  error: z.string().optional(),\n  code: z.string().optional(),\n  /**\n   * Populated by the server only for a successful `subscribe` response.\n   * Carries the canonical, server-computed subscription id so the client\n   * can route subsequent `sub:update` / `sub:gone` messages without\n   * recomputing the hash locally (which would require the wasm runtime\n   * and would not reflect server-side per-procedure `queryIdentity`\n   * overrides).\n   */\n  subId: z.string().optional(),\n});\n\nexport const SubscriptionUpdateMessageSchema = z.object({\n  type: z.literal(\"sub:update\"),\n  subId: z.string(),\n  data: z.unknown(),\n  dataHash: z.string().optional(),\n});\n\n/**\n * Notifies a client that a subscription is no longer tracked on the server\n * and will not receive further updates. Sent when, during a sub-manager\n * recovery cycle, the registration record could not be found (e.g. another\n * app-server instance fully unregistered the sub while we were disconnected).\n * The client may choose to re-subscribe or surface the state to the user.\n */\nexport const SubscriptionGoneMessageSchema = z.object({\n  type: z.literal(\"sub:gone\"),\n  subId: z.string(),\n  reason: z.string().optional(),\n});\n\n/**\n * Server-driven liveness signal. Sent when the channel has been idle for\n * the configured app-ping interval (default 15s) and again after every\n * outbound message. Pure no-op for the client: receiving any message\n * (including this one) resets the client's inactivity watchdog. The client\n * does NOT reply.\n */\nexport const ServerPingMessageSchema = z.object({\n  type: z.literal(\"ping\"),\n});\n\nexport const ServerMessageSchema = z.union([\n  ConnectedMessageSchema,\n  AuthSuccessMessageSchema,\n  AuthFailedMessageSchema,\n  ResponseMessageSchema,\n  SubscriptionUpdateMessageSchema,\n  SubscriptionGoneMessageSchema,\n  ServerPingMessageSchema,\n]);\n\nexport type ConnectedMessage = z.infer<typeof ConnectedMessageSchema>;\nexport type AuthSuccessMessage = z.infer<typeof AuthSuccessMessageSchema>;\nexport type AuthFailedMessage = z.infer<typeof AuthFailedMessageSchema>;\nexport type ResponseMessage = z.infer<typeof ResponseMessageSchema>;\nexport type SubscriptionUpdateMessage = z.infer<typeof SubscriptionUpdateMessageSchema>;\nexport type SubscriptionGoneMessage = z.infer<typeof SubscriptionGoneMessageSchema>;\nexport type ServerPingMessage = z.infer<typeof ServerPingMessageSchema>;\nexport type ServerMessage = z.infer<typeof ServerMessageSchema>;\n\nexport class AuthenticationError extends Error {\n  constructor(\n    message: string,\n    public extra: Record<string, unknown> = {},\n  ) {\n    super(message);\n  }\n}\n\n/**\n * Helper type to check if a procedure is internal.\n */\nexport type IsInternal<T> = T extends { internal: infer I } ? (I extends true ? true : false) : false;\n\nexport interface Context {\n  requestId: string;\n  /** Authenticated user info */\n  user: {\n    userId: string;\n  };\n}\n"],"mappings":";;AAYA,MAAa,oBAAoB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,MAAM;CACtB,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,SAAS;AAC/C,CAAC;AAED,MAAa,oBAAoB,EAAE,OAAO;CACxC,MAAM,EAAE,QAAQ,MAAM;CACtB,IAAI,EAAE,OAAO;CACb,WAAW,EAAE,OAAO;CACpB,OAAO,EAAE,QAAQ;AACnB,CAAC;AAED,MAAa,yBAAyB,EAAE,OAAO;CAC7C,MAAM,EAAE,QAAQ,WAAW;CAC3B,IAAI,EAAE,OAAO;CACb,WAAW,EAAE,OAAO;CACpB,OAAO,EAAE,QAAQ;AACnB,CAAC;AAED,MAAa,2BAA2B,EAAE,OAAO;CAC/C,MAAM,EAAE,QAAQ,aAAa;CAC7B,OAAO,EAAE,OAAO;AAClB,CAAC;AAED,MAAa,sBAAsB,EAAE,MAAM;CACzC;CACA;CACA;CACA;AACF,CAAC;AAWD,MAAa,yBAAyB,EAAE,OAAO;CAC7C,MAAM,EAAE,QAAQ,WAAW;CAC3B,WAAW,EAAE,OAAO;AACtB,CAAC;AAED,MAAa,2BAA2B,EAAE,OAAO;CAC/C,MAAM,EAAE,QAAQ,cAAc;CAC9B,QAAQ,EAAE,OAAO;CACjB,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS;AAC7B,CAAC;AAED,MAAa,0BAA0B,EAAE,OAAO;CAC9C,MAAM,EAAE,QAAQ,aAAa;CAC7B,SAAS,EAAE,OAAO;CAClB,OAAO,EAAE,OAAO,EAAE,OAAO,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,SAAS;AACpD,CAAC;AAED,MAAa,wBAAwB,EAAE,OAAO;CAC5C,MAAM,EAAE,QAAQ,UAAU;CAC1B,IAAI,EAAE,OAAO;CACb,SAAS,EAAE,QAAQ;CACnB,MAAM,EAAE,QAAQ,CAAC,CAAC,SAAS;CAC3B,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS;CAC3B,MAAM,EAAE,OAAO,CAAC,CAAC,SAAS;;;;;;;;;CAS1B,OAAO,EAAE,OAAO,CAAC,CAAC,SAAS;AAC7B,CAAC;AAED,MAAa,kCAAkC,EAAE,OAAO;CACtD,MAAM,EAAE,QAAQ,YAAY;CAC5B,OAAO,EAAE,OAAO;CAChB,MAAM,EAAE,QAAQ;CAChB,UAAU,EAAE,OAAO,CAAC,CAAC,SAAS;AAChC,CAAC;;;;;;;;AASD,MAAa,gCAAgC,EAAE,OAAO;CACpD,MAAM,EAAE,QAAQ,UAAU;CAC1B,OAAO,EAAE,OAAO;CAChB,QAAQ,EAAE,OAAO,CAAC,CAAC,SAAS;AAC9B,CAAC;;;;;;;;AASD,MAAa,0BAA0B,EAAE,OAAO,EAC9C,MAAM,EAAE,QAAQ,MAAM,EACxB,CAAC;AAED,MAAa,sBAAsB,EAAE,MAAM;CACzC;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAWD,IAAa,sBAAb,cAAyC,MAAM;CAGpC;CAFT,YACE,SACA,QAAwC,CAAC,GACzC;EACA,MAAM,OAAO;EAFN,KAAA,QAAA;CAGT;AACF"}

package/dist/types_db-Ctf-ksoy.js

@@ -0,0 +1,168 @@
+import { o as utf8Encode } from "./helper-zdJT5FUc.js";
+import z from "zod";
+//#region src/db/types_db.ts
+const BigIntSchema = z.string().transform((val) => BigInt(val));
+const CompareOperatorSchema = z.enum([
+	"=",
+	"!=",
+	">",
+	">=",
+	"<",
+	"<=",
+	"like",
+	"ilike",
+	"contains",
+	"icontains",
+	"between",
+	"jsonContains",
+	"jsonContainedBy",
+	"jsonHasKey",
+	"jsonArrayContains",
+	"isNull",
+	"isNotNull"
+]);
+const PredicateSchema = z.lazy(() => z.union([
+	LeafPredicateSchema,
+	AndPredicateSchema,
+	OrPredicateSchema
+]));
+const LeafPredicateSchema = z.object({
+	"kind": z.literal("leaf"),
+	column: z.string(),
+	operator: CompareOperatorSchema,
+	value: z.unknown(),
+	value2: z.unknown().optional(),
+	raw: z.boolean().optional(),
+	path: z.string().optional(),
+	mode: z.enum(["one", "all"]).optional()
+});
+const AndPredicateSchema = z.object({
+	kind: z.literal("and"),
+	children: z.array(PredicateSchema)
+});
+const OrPredicateSchema = z.object({
+	kind: z.literal("or"),
+	children: z.array(PredicateSchema)
+});
+const Uint8ArraySchema = z.any().transform((val) => {
+	if (val instanceof Uint8Array) return val;
+	return bytesFromJson(val);
+});
+function normalizeIdToBytes(id, fromHex = false) {
+	const data = (typeof id === "number" ? String(id) : id).replace(/-/g, "");
+	if (fromHex === true) {
+		const len = data.length >>> 1;
+		const out = new Uint8Array(len);
+		for (let i = 0; i < len; i++) out[i] = parseInt(data.substring(i * 2, i * 2 + 2), 16);
+		return out;
+	}
+	return utf8Encode(data);
+}
+function normalizeToBytes(value) {
+	try {
+		return bytesFromJson(value);
+	} catch (_) {
+		return /* @__PURE__ */ new Uint8Array(0);
+	}
+}
+function bytesFromJson(value) {
+	if (value instanceof Uint8Array) return value;
+	if (Array.isArray(value)) return Uint8Array.from(value);
+	if (value && typeof value === "object" && "type" in value && value.type === "Buffer" && "data" in value) return Uint8Array.from(value.data);
+	if (typeof value === "string") return utf8Encode(value);
+	if (typeof value === "number") return utf8Encode(String(value));
+	throw new Error("Invalid buffer value");
+}
+const PointReadSchema = z.object({
+	kind: z.literal("point"),
+	table: z.string(),
+	id: z.string(),
+	tableId: Uint8ArraySchema,
+	expectedCommitTs: BigIntSchema.nullable().optional()
+});
+const RawPointReadSchema = z.object({
+	kind: z.literal("point"),
+	tableId: Uint8ArraySchema,
+	id: Uint8ArraySchema,
+	table: z.string(),
+	expectedCommitTs: BigIntSchema.nullable().optional()
+});
+/**
+* Query specification for a range read (get with filters).
+* This is the query definition, not the result.
+*/
+const RangeReadSchema = z.object({
+	kind: z.literal("range"),
+	table: z.string(),
+	tableId: Uint8ArraySchema,
+	predicate: PredicateSchema,
+	columns: z.array(z.string()),
+	orderBy: z.string().nullable().optional(),
+	limit: z.number().nullable().optional(),
+	offset: z.number().nullable().optional()
+});
+const RawRangeReadSchema = z.object({
+	kind: z.literal("range"),
+	table: z.string(),
+	tableId: Uint8ArraySchema,
+	predicate: PredicateSchema,
+	columns: z.array(z.string()),
+	orderBy: z.string().nullable().optional(),
+	limit: z.number().nullable().optional(),
+	offset: z.number().nullable().optional()
+});
+const ReadEntrySchema = z.union([PointReadSchema, RangeReadSchema]);
+const RawReadEntrySchema = z.union([RawPointReadSchema, RawRangeReadSchema]);
+const WriteOpSchema = z.enum([
+	"insert",
+	"update",
+	"delete"
+]);
+const WriteEntrySchema = z.object({
+	table: z.string(),
+	tableId: Uint8ArraySchema,
+	id: z.string(),
+	op: WriteOpSchema,
+	data: z.record(z.string(), z.unknown()).optional(),
+	prevData: z.record(z.string(), z.unknown()).optional(),
+	expectedCommitTs: BigIntSchema.nullable().optional()
+});
+const QueryCacheMetadataSchema = z.object({
+	lastSnapshotTs: BigIntSchema,
+	readSet: z.array(ReadEntrySchema)
+});
+const QueryCacheEntrySchema = z.object({ data: z.unknown() });
+const CachedPgMetadataSchema = z.record(z.string(), z.record(z.string(), z.string()));
+const NO_RETRY = {
+	maxAttempts: 1,
+	backoff: "none"
+};
+const DEFAULT_RETRY = {
+	maxAttempts: 12,
+	backoff: "exponential",
+	delayMs: 15
+};
+var OccConflictError = class OccConflictError extends Error {
+	reason;
+	conflictDetail;
+	constructor(reason, conflictDetail) {
+		super(`OCC conflict: ${reason}`);
+		this.reason = reason;
+		this.conflictDetail = conflictDetail;
+		this.name = "OccConflictError";
+	}
+	static isOccConflictError(err) {
+		if (err instanceof OccConflictError || err && typeof err === "object" && err.name === "OccConflictError") return true;
+		return false;
+	}
+};
+var OccAbortError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OccAbortError";
+	}
+};
+//#endregion
+export { normalizeIdToBytes as C, bytesFromJson as S, RawRangeReadSchema as _, DEFAULT_RETRY as a, WriteEntrySchema as b, OccAbortError as c, PointReadSchema as d, PredicateSchema as f, RawPointReadSchema as g, RangeReadSchema as h, CompareOperatorSchema as i, OccConflictError as l, QueryCacheMetadataSchema as m, BigIntSchema as n, LeafPredicateSchema as o, QueryCacheEntrySchema as p, CachedPgMetadataSchema as r, NO_RETRY as s, AndPredicateSchema as t, OrPredicateSchema as u, RawReadEntrySchema as v, normalizeToBytes as w, WriteOpSchema as x, ReadEntrySchema as y };
+
+//# sourceMappingURL=types_db-Ctf-ksoy.js.map

package/dist/types_db-Ctf-ksoy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types_db-Ctf-ksoy.js","names":[],"sources":["../src/db/types_db.ts"],"sourcesContent":["import z from \"zod\";\nimport { utf8Encode } from \"./bytes\";\n\n/** Monotonically increasing integer from global_commit_ts sequence in Postgres */\nexport type CommitTs = bigint;\n\nexport const BigIntSchema = z.string().transform((val) => BigInt(val));\n\nexport const CompareOperatorSchema = z.enum([\n  \"=\", \"!=\", \">\", \">=\", \"<\", \"<=\",\n  \"like\", \"ilike\", \"contains\", \"icontains\",\n  \"between\",\n  \"jsonContains\", \"jsonContainedBy\", \"jsonHasKey\", \"jsonArrayContains\",\n  \"isNull\", \"isNotNull\"\n]);\nexport type CompareOperator = z.infer<typeof CompareOperatorSchema>;\n\n// Define the type first so z.lazy() can reference it\nexport type Predicate =\n  | LeafPredicate\n  | { kind: \"and\"; children: Predicate[] }\n  | { kind: \"or\"; children: Predicate[] };\nexport const PredicateSchema: z.ZodType<Predicate> = z.lazy(() =>\n  z.union([\n    LeafPredicateSchema,\n    AndPredicateSchema,\n    OrPredicateSchema,\n  ])\n);\n\nexport const LeafPredicateSchema = z.object({\n  \"kind\": z.literal(\"leaf\"),\n  column: z.string(),\n  operator: CompareOperatorSchema,\n  value: z.unknown(),\n  value2: z.unknown().optional(),\n  // For JSON ops: `true` means `value` is already in dialect-prepared form\n  // (a path expression for jsonHasKey, a JSON string for the contains family)\n  // and the SqlBuilder should pass it through without further escaping.\n  raw: z.boolean().optional(),\n  // For jsonContains/jsonContainedBy/jsonArrayContains: optional sub-path\n  // into the target JSON value to scope the check (jsonpath syntax, e.g.\n  // `$.\"a\".\"b\"`). Already compiled to a single string.\n  path: z.string().optional(),\n  // For jsonHasKey multi-path mode: when set, `value` is `string[]` (each\n  // entry a jsonpath) and the predicate checks for existence of any (`one`)\n  // or all (`all`) of them.\n  mode: z.enum([\"one\", \"all\"]).optional(),\n});\nexport type LeafPredicate = z.infer<typeof LeafPredicateSchema>;\n\nexport const AndPredicateSchema = z.object({\n  kind: z.literal(\"and\"),\n  children: z.array(PredicateSchema),\n});\nexport type AndPredicate = z.infer<typeof AndPredicateSchema>;\n\nexport const OrPredicateSchema = z.object({\n  kind: z.literal(\"or\"),\n  children: z.array(PredicateSchema),\n});\nexport type OrPredicate = z.infer<typeof OrPredicateSchema>;\n\n/** Query specification - what was queried (used for cache key generation) */\nexport type QuerySpec = ReadEntry;\n\nconst Uint8ArraySchema = z.any().transform((val) => {\n  if (val instanceof Uint8Array) return val;\n  return bytesFromJson(val);\n});\n\nexport function normalizeIdToBytes(id: string | number, fromHex = false): Uint8Array {\n  const idStr = typeof id === \"number\" ? String(id) : id;\n  const data = idStr.replace(/-/g, \"\");\n  if (fromHex === true) {\n    const len = data.length >>> 1;\n    const out = new Uint8Array(len);\n    for (let i = 0; i < len; i++) {\n      out[i] = parseInt(data.substring(i * 2, i * 2 + 2), 16);\n    }\n    return out;\n  }\n  return utf8Encode(data);\n}\n\nexport function normalizeToBytes(value: Uint8Array | unknown): Uint8Array {\n  try {\n    return bytesFromJson(value);\n  } catch (_) {\n    return new Uint8Array(0);\n  }\n}\n\nexport function bytesFromJson(value: Uint8Array | unknown): Uint8Array {\n  if (value instanceof Uint8Array) {\n    return value;\n  }\n  if (Array.isArray(value)) {\n    return Uint8Array.from(value as number[]);\n  }\n  if (value && typeof value === \"object\" && \"type\" in value && (value as any).type === \"Buffer\" && \"data\" in value) {\n    return Uint8Array.from((value as any).data);\n  }\n  if (typeof value === \"string\") {\n    return utf8Encode(value);\n  }\n  if (typeof value === \"number\") {\n    return utf8Encode(String(value));\n  }\n\n  throw new Error(\"Invalid buffer value\");\n}\n\n/* \n * Query specification for a point read (find by ID).\n */\nexport const PointReadSchema = z.object({\n  kind: z.literal(\"point\"),\n  table: z.string(),\n  id: z.string(),\n  tableId: Uint8ArraySchema,\n  // commit_ts of the row at read time. `null` = row didn't exist (so a later\n  // insert is a conflict). `undefined` = the read was added synthetically and\n  // OCC should fall back to the commit-log scan / general validator.\n  expectedCommitTs: BigIntSchema.nullable().optional(),\n});\nexport type PointRead = z.infer<typeof PointReadSchema>;\n\nexport const RawPointReadSchema = z.object({\n  kind: z.literal(\"point\"),\n  tableId: Uint8ArraySchema,\n  id: Uint8ArraySchema,\n  table: z.string(),\n  expectedCommitTs: BigIntSchema.nullable().optional(),\n});\nexport type RawPointRead = z.infer<typeof RawPointReadSchema>;\n\n/**\n * Query specification for a range read (get with filters).\n * This is the query definition, not the result.\n */\nexport const RangeReadSchema = z.object({\n  kind: z.literal(\"range\"),\n  table: z.string(),\n  tableId: Uint8ArraySchema,\n  predicate: PredicateSchema,\n  columns: z.array(z.string()),\n  orderBy: z.string().nullable().optional(),\n  limit: z.number().nullable().optional(),\n  offset: z.number().nullable().optional(),\n});\nexport type RangeRead = z.infer<typeof RangeReadSchema>;\n\nexport const RawRangeReadSchema = z.object({\n  kind: z.literal(\"range\"),\n  table: z.string(),\n  tableId: Uint8ArraySchema,\n  predicate: PredicateSchema,\n  columns: z.array(z.string()),\n  orderBy: z.string().nullable().optional(),\n  limit: z.number().nullable().optional(),\n  offset: z.number().nullable().optional(),\n});\nexport type RawRangeRead = z.infer<typeof RawRangeReadSchema>;\n\nexport const ReadEntrySchema = z.union([PointReadSchema, RangeReadSchema]);\nexport type ReadEntry = z.infer<typeof ReadEntrySchema>;\n\nexport const RawReadEntrySchema = z.union([RawPointReadSchema, RawRangeReadSchema]);\nexport type RawReadEntry = z.infer<typeof RawReadEntrySchema>;\n\nexport const WriteOpSchema = z.enum([\"insert\", \"update\", \"delete\"]);\nexport type WriteOp = z.infer<typeof WriteOpSchema>;\n\nexport const WriteEntrySchema = z.object({\n  table: z.string(),\n  tableId: Uint8ArraySchema,\n  id: z.string(),\n  op: WriteOpSchema,\n  data: z.record(z.string(), z.unknown()).optional(),\n  // Row state at beginTs, before this write. Populated server-side by\n  // attachPrevDataToWriteSet for `update`/`delete`. Lets the invalidator\n  // detect rows leaving a filtered result set (e.g. status changed from\n  // matching to non-matching).\n  prevData: z.record(z.string(), z.unknown()).optional(),\n  // commit_ts the row had right before this write. Drives the CAS guard:\n  // `UPDATE ... WHERE id=? AND commit_ts=expectedCommitTs`. Populated by\n  // attachPrevDataToWriteSet or carried over from a prior find() in the\n  // same txn. Undefined on inserts.\n  expectedCommitTs: BigIntSchema.nullable().optional(),\n});\nexport type WriteEntry = z.infer<typeof WriteEntrySchema>;\n\nexport interface CommitLogEntry {\n  id: Uint8Array;\n  ts: bigint;\n  tableId: Uint8Array;\n  data: Uint8Array;\n\n  _parsedData?: Record<string, unknown> | null\n}\n\nexport interface MutationResult<T> {\n  result: T;\n  writeSet: WriteEntry[];\n  commitTs: CommitTs;\n}\n\nexport interface LiveResult<T> {\n  ts: bigint,\n  data: T;\n  readSet: ReadEntry[];\n}\n\nexport const QueryCacheMetadataSchema = z.object({\n  lastSnapshotTs: BigIntSchema,\n  readSet: z.array(ReadEntrySchema),\n});\nexport type QueryCacheMetadata = z.infer<typeof QueryCacheMetadataSchema>;\n\nexport const QueryCacheEntrySchema = z.object({\n  data: z.unknown(),\n});\nexport type QueryCacheEntry = z.infer<typeof QueryCacheEntrySchema>;\n\nexport const CachedPgMetadataSchema = z.record(z.string(), z.record(z.string(), z.string()));\nexport type CachedPgMetadata = z.infer<typeof CachedPgMetadataSchema>;\n\nexport interface RetryConfig {\n  maxAttempts: number;\n  backoff: \"none\" | \"linear\" | \"exponential\";\n  delayMs?: number;\n  onConflict?: (attempt: number, error: OccConflictError) => void;\n}\n\nexport const NO_RETRY: RetryConfig = { maxAttempts: 1, backoff: \"none\" };\n\nexport const DEFAULT_RETRY: RetryConfig = {\n  maxAttempts: 12,\n  backoff: \"exponential\",\n  delayMs: 15,\n};\n\nexport class OccConflictError extends Error {\n  constructor(\n    public readonly reason: string,\n    public readonly conflictDetail?: unknown\n  ) {\n    super(`OCC conflict: ${reason}`);\n    this.name = \"OccConflictError\";\n  }\n\n  static isOccConflictError(err: unknown): boolean {\n    if (err instanceof OccConflictError ||\n      (err && typeof err === \"object\" && (err as { name?: string }).name === \"OccConflictError\")) {\n      return true;\n    }\n    return false;\n  }\n}\n\nexport class OccAbortError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"OccAbortError\";\n  }\n}"],"mappings":"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"}

package/dist/types_server-Ch56y8L3.d.ts

@@ -0,0 +1,216 @@
+import { Tn as CacheLayer, er as MutationResult, tt as RegisteredProcedure, wt as SupaliveDb } from "./index-CTyXKcq_.js";
+import z from "zod";
+import { WebSocket } from "ws";
+import { Level } from "pino";
+import { Redis } from "ioredis";
+
+//#region src/config.d.ts
+interface UpstashConfig {
+  url: string;
+  token: string;
+  redisUrl: string;
+}
+/** Database configuration for PostgreSQL */
+interface PostgresConfig {
+  type: "postgres";
+  connectionString: string;
+  /** Optional max connections for the Postgres connection pool. Defaults to 10.*/
+  maxConnections?: number;
+  /** Optional min connections for the Postgres connection pool. Defaults to 1.*/
+  minConnections?: number;
+  /** Optional idle timeout for Postgres connections in milliseconds. Defaults to 30000 (30 seconds). */
+  idleTimeoutMillis?: number;
+  /** Optional connection timeout for acquiring Postgres connections in milliseconds. Defaults to 7000 (7 seconds). */
+  connectionTimeoutMillis?: number;
+}
+/** Database configuration for MySQL */
+interface MySQLConfig {
+  type: "mysql";
+  connectionString: string;
+  /** Optional max connections for the MySQL connection pool. Defaults to 20.*/
+  maxConnections?: number;
+  /** Optional min connections for the MySQL connection pool. Defaults to 1.*/
+  minConnections?: number;
+  /** Optional idle timeout for MySQL connections in milliseconds. Defaults to 30000 (30 seconds). */
+  idleTimeoutMillis?: number;
+  /** Optional connection timeout for acquiring MySQL connections in milliseconds. Defaults to 7000 (7 seconds). */
+  connectionTimeoutMillis?: number;
+  /** Optional flag to queue connection requests when pool is exhausted. Defaults to true (queue requests). */
+  queueLimit?: number;
+}
+type DatabaseConfig = PostgresConfig | MySQLConfig;
+/**
+ * Configuration for the Supalive WebSocket server.
+ */
+interface SupaliveServerConfig<TContext = Record<string, unknown>> {
+  /** Server port (default: 3000) */
+  port?: number;
+  /** Server host (default: "0.0.0.0") */
+  host?: string;
+  cacheLayer: CacheLayer;
+  redisSubClient: Redis;
+  /**
+   * Subscription Manager WebSocket URL for RPC communication.
+   * A single sub-manager process owns all subscription state for this
+   * deployment. Internally it spawns N logical workers (configured on the
+   * sub-manager side) and routes by hash(subId) to spread CPU across them.
+   */
+  subManagerUrl: string;
+  /** Database instance */
+  database: SupaliveDb;
+  /**
+   * Optional authentication callback.
+   * Called when client sends auth message.
+   * Return null to reject authentication.
+   */
+  verifyAuth?: (data: Record<string, unknown>, sessionId: string) => Promise<TContext | null>;
+  /**
+   * Server context name for procedure routing.
+   * Must match the router's contextName.
+   */
+  contextName?: string;
+  /**
+   * Session TTL in seconds (default: 3600 = 1 hour).
+   * Sessions are kept alive while connected and expire after disconnect.
+   */
+  sessionTtlSeconds?: number;
+  /**
+   * Enable detailed logging.
+   */
+  logLevel?: Level;
+  /**
+   * Extract user ID from context for cache key generation.
+   * If not provided, caching is disabled (each sub recomputes independently).
+   */
+  getUserId?: (ctx: TContext) => string;
+  /**
+   * Cache TTL in seconds (default: 3600).
+   * How long query results are cached in Redis.
+   */
+  cacheTtlSeconds?: number;
+}
+interface SubscriptionManagerConfig {
+  port: number;
+  upstash: {
+    url: string;
+    token: string;
+    redisUrl: string;
+  };
+  database: DatabaseConfig;
+  cacheTTLSeconds: number;
+  /**
+   * Number of logical workers inside the sub-manager process.
+   *
+   * Subscriptions are routed by FNV-1a(subId) % workers so that all operations
+   * for a given subId always land on the same worker (preserving the existing
+   * `instances: Set<string>` dedup). Each worker owns an independent
+   * subscriptions Map; on invalidate, all workers scan their own slice in
+   * parallel (logically — JS still runs one at a time inside one event loop,
+   * but per-worker scans are smaller so total work is split N ways).
+   *
+   * Defaults to `SUPALIVE_SUB_MANAGER_WORKERS` env var if set, else 1.
+   */
+  workers?: number;
+  /**
+   * Connection pool size *per worker*. If omitted, falls back to
+   * `floor(database.maxConnections / workers)` (min 1) so the total pool
+   * size stays close to the legacy single-worker configuration.
+   */
+  maxConnectionsPerWorker?: number;
+}
+//#endregion
+//#region src/server/types_server.d.ts
+type InstanceId = string;
+type SubId = string;
+/** Local tracking of an active subscription (per-session) */
+interface SubscriptionEntry {
+  subId: SubId;
+  cacheKey: string;
+  subscribedTimes: number;
+}
+/**
+ * A mutation that has been validated and parked on the per-session FIFO
+ * queue, waiting for the in-flight mutation on this socket to finish. Each
+ * `handleCall` for a mutation owns one of these and awaits its own
+ * resolve/reject so it can send the response.
+ */
+interface PendingMutation<TContext = Record<string, unknown>> {
+  procedure: RegisteredProcedure<TContext>;
+  validatedInput: unknown;
+  resolve: (result: MutationResult<unknown>) => void;
+  reject: (err: unknown) => void;
+}
+/** WebSocket session (runtime, with WebSocket) */
+interface Session<TContext = Record<string, unknown>> {
+  id: string;
+  ws: WebSocket;
+  /** Auth context from verifyAuth callback */
+  serverCtx: TContext;
+  subIds: Set<string>;
+  /**
+   * Per-socket FIFO mutation queue. at most one mutation
+   * drains at a time so a single client cannot saturate the OCC retry
+   * loop or fan out concurrent commits that race the same rows.
+   */
+  mutationQueue: PendingMutation<TContext>[];
+  mutationInFlight: boolean;
+  /** Per-socket count of currently executing actions. */
+  actionInFlight: number;
+  /**
+   * Wall-clock of the last inbound frame (text message, ws-ping, or ws-pong).
+   * Used by the per-session heartbeat to terminate sockets that have gone
+   * silent past `CLIENT_TIMEOUT_MS`.
+   */
+  lastReceivedAt: number;
+  /**
+   * Wall-clock of the last outbound frame. Gates the idle-only app-level
+   * ping so a busy session (frequent sub:updates etc.) doesn't emit a
+   * redundant `{type:"ping"}` on every heartbeat tick.
+   */
+  lastSentAt: number;
+  /**
+   * Per-session combined heartbeat. Single `setInterval` that handles
+   * both dead-TCP detection (ws-ping or terminate) and client-watchdog
+   * refresh (idle-only app-level ping) on each tick.
+   */
+  heartbeatTimer: ReturnType<typeof setInterval> | null;
+}
+declare const RemoteSubscriptionUpdateSchema: z.ZodObject<{
+  type: z.ZodLiteral<"update">;
+  subId: z.ZodString;
+  data: z.ZodUnknown;
+  dataHash: z.ZodString;
+  originInstance: z.ZodString;
+}, z.core.$strip>;
+type RemoteSubscriptionUpdate = z.infer<typeof RemoteSubscriptionUpdateSchema>;
+declare const RemoteRecomputeRaceSchema: z.ZodObject<{
+  type: z.ZodLiteral<"recompute-race">;
+  subId: z.ZodString;
+  cacheKey: z.ZodString;
+  queryName: z.ZodString;
+  args: z.ZodUnknown;
+  notifyInstances: z.ZodArray<z.ZodString>;
+  commitTs: z.ZodString;
+  originInstance: z.ZodString;
+}, z.core.$strip>;
+type RemoteRecomputeRace = z.infer<typeof RemoteRecomputeRaceSchema>;
+declare const RemoteSubscriptionMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"update">;
+  subId: z.ZodString;
+  data: z.ZodUnknown;
+  dataHash: z.ZodString;
+  originInstance: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  type: z.ZodLiteral<"recompute-race">;
+  subId: z.ZodString;
+  cacheKey: z.ZodString;
+  queryName: z.ZodString;
+  args: z.ZodUnknown;
+  notifyInstances: z.ZodArray<z.ZodString>;
+  commitTs: z.ZodString;
+  originInstance: z.ZodString;
+}, z.core.$strip>], "type">;
+type RemoteSubscriptionMessage = z.infer<typeof RemoteSubscriptionMessageSchema>;
+//#endregion
+export { UpstashConfig as _, RemoteSubscriptionMessage as a, RemoteSubscriptionUpdateSchema as c, SubscriptionEntry as d, DatabaseConfig as f, SupaliveServerConfig as g, SubscriptionManagerConfig as h, RemoteRecomputeRaceSchema as i, Session as l, PostgresConfig as m, PendingMutation as n, RemoteSubscriptionMessageSchema as o, MySQLConfig as p, RemoteRecomputeRace as r, RemoteSubscriptionUpdate as s, InstanceId as t, SubId as u };
+//# sourceMappingURL=types_server-Ch56y8L3.d.ts.map

package/dist/types_server-Ch56y8L3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types_server-Ch56y8L3.d.ts","names":[],"sources":["../src/config.ts","../src/server/types_server.ts"],"mappings":";;;;;;;UAKiB,aAAA;EACb,GAAA;EACA,KAAA;EACA,QAAA;AAAA;;UAIa,cAAA;EACb,IAAA;EACA,gBAAA;EANA;EAQA,cAAA;EARQ;EAWR,cAAA;EAP2B;EAU3B,iBAAA;EAV2B;EAa3B,uBAAA;AAAA;;UAIa,WAAA;EACb,IAAA;EACA,gBAAA;EANuB;EAQvB,cAAA;EAJa;EAOb,cAAA;;EAGA,iBAAA;EATA;EAYA,uBAAA;EATA;EAYA,UAAA;AAAA;AAAA,KAGQ,cAAA,GAAiB,cAAA,GAAiB,WAAW;;;AAH3C;UAQG,oBAAA,YAAgC,MAAA;EALvB;EAOtB,IAAA;EAPyB;EAUzB,IAAA;EAKA,UAAA,EAAY,UAAA;EAIZ,cAAA,EAAgB,KAAA;EAdiB;;;;;;EAsBjC,aAAA;EAaK;EAVL,QAAA,EAAU,UAAA;EAiCQ;;;;;EA1BlB,UAAA,IACI,IAAA,EAAM,MAAA,mBACN,SAAA,aACC,OAAA,CAAQ,QAAA;EA9Bb;;;;EAoCA,WAAA;EAnBA;;;;EAyBA,iBAAA;EAdI;;;EAmBJ,QAAA,GAAW,KAAA;EAXX;;;;EAiBA,SAAA,IAAa,GAAA,EAAK,QAAA;EAAA;;;;EAMlB,eAAA;AAAA;AAAA,UAGa,yBAAA;EACb,IAAA;EACA,OAAA;IAAW,GAAA;IAAa,KAAA;IAAe,QAAA;EAAA;EACvC,QAAA,EAAU,cAAc;EACxB,eAAA;EADU;;;;;AAoBa;;;;ACxI3B;;;EDkII,OAAA;EClIkB;AAEtB;;;;EDsII,uBAAA;AAAA;;;KCxIQ,UAAA;AAAA,KAEA,KAAA;;UAGK,iBAAA;EACf,KAAA,EAAO,KAAK;EACZ,QAAA;EACA,eAAA;AAAA;;;;ADPU;AAIZ;;UCYiB,eAAA,YAA2B,MAAA;EAC1C,SAAA,EAAW,mBAAA,CAAoB,QAAA;EAC/B,cAAA;EACA,OAAA,GAAU,MAAA,EAAQ,cAAA;EAClB,MAAA,GAAS,GAAA;AAAA;;UAIM,OAAA,YAAmB,MAAA;EAClC,EAAA;EACA,EAAA,EAAI,SAAA;EDLW;ECOf,SAAA,EAAW,QAAA;EACX,MAAA,EAAQ,GAAA;EDRkB;;;;;ECc1B,aAAA,EAAe,eAAA,CAAgB,QAAA;EAC/B,gBAAA;EDCE;ECCF,cAAA;EDDY;AAGd;;;;ECIE,cAAA;EDCe;;;;;ECKf,UAAA;EDoBY;;;;;ECdZ,cAAA,EAAgB,UAAA,QAAkB,WAAA;AAAA;AAAA,cAgBvB,8BAAA,EAA8B,CAAA,CAAA,SAAA;;;;;;;KAO/B,wBAAA,GAA2B,CAAA,CAAE,KAAK,QAAQ,8BAAA;AAAA,cAEzC,yBAAA,EAAyB,CAAA,CAAA,SAAA;;;;;;;;;;KAU1B,mBAAA,GAAsB,CAAA,CAAE,KAAK,QAAQ,yBAAA;AAAA,cAEpC,+BAAA,EAA+B,CAAA,CAAA,qBAAA,EAAA,CAAA,CAAA,SAAA;;;;;;;;;;;;;;;;KAIhC,yBAAA,GAA4B,CAAA,CAAE,KAAK,QAAQ,+BAAA"}

package/dist/types_server-Dk6o_B7N.js

@@ -0,0 +1,24 @@
+import z from "zod";
+//#region src/server/types_server.ts
+const RemoteSubscriptionUpdateSchema = z.object({
+	type: z.literal("update"),
+	subId: z.string(),
+	data: z.unknown(),
+	dataHash: z.string(),
+	originInstance: z.string()
+});
+const RemoteRecomputeRaceSchema = z.object({
+	type: z.literal("recompute-race"),
+	subId: z.string(),
+	cacheKey: z.string(),
+	queryName: z.string(),
+	args: z.unknown(),
+	notifyInstances: z.array(z.string()),
+	commitTs: z.string(),
+	originInstance: z.string()
+});
+const RemoteSubscriptionMessageSchema = z.discriminatedUnion("type", [RemoteSubscriptionUpdateSchema, RemoteRecomputeRaceSchema]);
+//#endregion
+export { RemoteSubscriptionMessageSchema as n, RemoteSubscriptionUpdateSchema as r, RemoteRecomputeRaceSchema as t };
+
+//# sourceMappingURL=types_server-Dk6o_B7N.js.map

package/dist/types_server-Dk6o_B7N.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types_server-Dk6o_B7N.js","names":[],"sources":["../src/server/types_server.ts"],"sourcesContent":["import type { WebSocket } from \"ws\";\nimport type { ReadEntry, MutationResult } from \"../db/types_db\";\nimport type { RegisteredProcedure } from \"../router/router\";\nimport z from \"zod\";\n\n// ─── Core Types ───────────────────────────────────────────────────────────────\n\nexport type InstanceId = string;\n\nexport type SubId = string;\n\n/** Local tracking of an active subscription (per-session) */\nexport interface SubscriptionEntry {\n  subId: SubId;\n  cacheKey: string;\n  subscribedTimes: number;\n}\n\n/**\n * A mutation that has been validated and parked on the per-session FIFO\n * queue, waiting for the in-flight mutation on this socket to finish. Each\n * `handleCall` for a mutation owns one of these and awaits its own\n * resolve/reject so it can send the response.\n */\nexport interface PendingMutation<TContext = Record<string, unknown>> {\n  procedure: RegisteredProcedure<TContext>;\n  validatedInput: unknown;\n  resolve: (result: MutationResult<unknown>) => void;\n  reject: (err: unknown) => void;\n}\n\n/** WebSocket session (runtime, with WebSocket) */\nexport interface Session<TContext = Record<string, unknown>> {\n  id: string;\n  ws: WebSocket;\n  /** Auth context from verifyAuth callback */\n  serverCtx: TContext;\n  subIds: Set<string>;\n  /**\n   * Per-socket FIFO mutation queue. at most one mutation\n   * drains at a time so a single client cannot saturate the OCC retry\n   * loop or fan out concurrent commits that race the same rows.\n   */\n  mutationQueue: PendingMutation<TContext>[];\n  mutationInFlight: boolean;\n  /** Per-socket count of currently executing actions. */\n  actionInFlight: number;\n  /**\n   * Wall-clock of the last inbound frame (text message, ws-ping, or ws-pong).\n   * Used by the per-session heartbeat to terminate sockets that have gone\n   * silent past `CLIENT_TIMEOUT_MS`.\n   */\n  lastReceivedAt: number;\n  /**\n   * Wall-clock of the last outbound frame. Gates the idle-only app-level\n   * ping so a busy session (frequent sub:updates etc.) doesn't emit a\n   * redundant `{type:\"ping\"}` on every heartbeat tick.\n   */\n  lastSentAt: number;\n  /**\n   * Per-session combined heartbeat. Single `setInterval` that handles\n   * both dead-TCP detection (ws-ping or terminate) and client-watchdog\n   * refresh (idle-only app-level ping) on each tick.\n   */\n  heartbeatTimer: ReturnType<typeof setInterval> | null;\n}\n\n// Messages published on `sub:instance:<instanceId>` for cross-instance fan-out.\n//\n// Two variants:\n//   • update         — the writer (or race winner) recomputed and is pushing\n//                      the result; receivers forward `data` to their local\n//                      sessions.\n//   • recompute-race — the writer does not hold the affected sub locally, so\n//                      it broadcasts a race hint to every instance that does\n//                      (`notifyInstances`). Receivers try to acquire a Redis\n//                      lock keyed by (subId, commitTs); the winner runs the\n//                      query against one of its own sessions' serverCtx and\n//                      publishes the resulting `update` back out. Losers\n//                      no-op and pick up the winner's `update` over Redis.\nexport const RemoteSubscriptionUpdateSchema = z.object({\n  type: z.literal(\"update\"),\n  subId: z.string(),\n  data: z.unknown(),\n  dataHash: z.string(),\n  originInstance: z.string(),\n});\nexport type RemoteSubscriptionUpdate = z.infer<typeof RemoteSubscriptionUpdateSchema>;\n\nexport const RemoteRecomputeRaceSchema = z.object({\n  type: z.literal(\"recompute-race\"),\n  subId: z.string(),\n  cacheKey: z.string(),\n  queryName: z.string(),\n  args: z.unknown(),\n  notifyInstances: z.array(z.string()),\n  commitTs: z.string(),\n  originInstance: z.string(),\n});\nexport type RemoteRecomputeRace = z.infer<typeof RemoteRecomputeRaceSchema>;\n\nexport const RemoteSubscriptionMessageSchema = z.discriminatedUnion(\"type\", [\n  RemoteSubscriptionUpdateSchema,\n  RemoteRecomputeRaceSchema,\n]);\nexport type RemoteSubscriptionMessage = z.infer<typeof RemoteSubscriptionMessageSchema>;\n"],"mappings":";;AAgFA,MAAa,iCAAiC,EAAE,OAAO;CACrD,MAAM,EAAE,QAAQ,QAAQ;CACxB,OAAO,EAAE,OAAO;CAChB,MAAM,EAAE,QAAQ;CAChB,UAAU,EAAE,OAAO;CACnB,gBAAgB,EAAE,OAAO;AAC3B,CAAC;AAGD,MAAa,4BAA4B,EAAE,OAAO;CAChD,MAAM,EAAE,QAAQ,gBAAgB;CAChC,OAAO,EAAE,OAAO;CAChB,UAAU,EAAE,OAAO;CACnB,WAAW,EAAE,OAAO;CACpB,MAAM,EAAE,QAAQ;CAChB,iBAAiB,EAAE,MAAM,EAAE,OAAO,CAAC;CACnC,UAAU,EAAE,OAAO;CACnB,gBAAgB,EAAE,OAAO;AAC3B,CAAC;AAGD,MAAa,kCAAkC,EAAE,mBAAmB,QAAQ,CAC1E,gCACA,yBACF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supalive/core",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "type": "module",
   "description": "Core for supalive — reactive database framework",
   "license": "MIT",
@@ -55,7 +55,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p .",
+    "build": "tsdown",
     "test": "vitest --run"
   },
   "dependencies": {
@@ -92,4 +92,4 @@
       "optional": true
     }
   }
-}
+}

package/dist/src/client/caller_client.d.ts

@@ -1,42 +0,0 @@
-import type { AnyProcedure, InputOf, OutputOf } from "../router/procedure";
-import { type Router } from "../router/router";
-import type { SupaliveDb } from "../db/realtime_db";
-import { LiveResult } from "../db/types_db";
-export interface CallerOptions<TContext = unknown> {
-    db: SupaliveDb;
-    context?: TContext;
-    isInternal?: boolean;
-    inContext: string;
-}
-/**
- * Create a server-side caller that bypasses HTTP/WebSocket.
- *
- * For in-memory calls, input validation is skipped (data is already a JS object).
- * Query procedures also get a liveQuery() method for server-side use.
- */
-export declare function createCaller<AppRouter extends Router<Record<string, AnyProcedure<TContext>>, TContext>, TContext = unknown, TProcedures extends Record<string, AnyProcedure<TContext>> = AppRouter["procedures"]>(options: CallerOptions<any>): CallerFromProcedures<TProcedures, TContext>;
-/**
- * Caller type from procedures (includes internal procedures).
- * Query procedures also have liveQuery() for server-side use.
- */
-export type CallerFromProcedures<TProcedures extends Record<string, AnyProcedure<TContext>>, TContext = unknown> = {
-    [K in keyof TProcedures]: TProcedures[K] extends {
-        procedureType: "query";
-    } ? {
-        query: (input: InputOf<TProcedures[K]>) => Promise<OutputOf<TProcedures[K]>>;
-        liveQuery: (input: InputOf<TProcedures[K]>) => Promise<LiveResult<OutputOf<TProcedures[K]>>>;
-    } : TProcedures[K] extends {
-        procedureType: "mutation";
-    } ? {
-        mutate: (input: InputOf<TProcedures[K]>) => Promise<OutputOf<TProcedures[K]>>;
-    } : TProcedures[K] extends {
-        procedureType: "action";
-    } ? {
-        action: (input: InputOf<TProcedures[K]>) => Promise<OutputOf<TProcedures[K]>>;
-    } : never;
-};
-/**
- * Caller type from router.
- */
-export type CallerFromRouter<TRouter extends Router<any, any>> = CallerFromProcedures<TRouter["procedures"]>;
-//# sourceMappingURL=caller_client.d.ts.map

package/dist/src/client/caller_client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"caller_client.d.ts","sourceRoot":"","sources":["../../../src/client/caller_client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,YAAY,EAAE,OAAO,EAAe,QAAQ,EAAY,MAAM,qBAAqB,CAAC;AAC7G,OAAO,EAAsB,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAE5C,MAAM,WAAW,aAAa,CAAC,QAAQ,GAAG,OAAO;IAC7C,EAAE,EAAE,UAAU,CAAC;IACf,OAAO,CAAC,EAAE,QAAQ,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CACxB,SAAS,SAAS,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,EAAE,QAAQ,CAAC,EAC1E,QAAQ,GAAG,OAAO,EAClB,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,GAAG,SAAS,CAAC,YAAY,CAAC,EACtF,OAAO,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,oBAAoB,CAAC,WAAW,EAAE,QAAQ,CAAC,CAyE1E;AAED;;;GAGG;AACH,MAAM,MAAM,oBAAoB,CAAC,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,OAAO,IAAI;KAC9G,CAAC,IAAI,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS;QAAE,aAAa,EAAE,OAAO,CAAA;KAAE,GACzE;QACE,KAAK,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7E,SAAS,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;KAChG,GACC,WAAW,CAAC,CAAC,CAAC,SAAS;QAAE,aAAa,EAAE,UAAU,CAAA;KAAE,GACpD;QAAE,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GACjF,WAAW,CAAC,CAAC,CAAC,SAAS;QAAE,aAAa,EAAE,QAAQ,CAAA;KAAE,GAClD;QAAE,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,GACjF,KAAK;CACV,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,OAAO,SAAS,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,IAAI,oBAAoB,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC"}