@supalive/core 1.20.2 → 1.21.0

package/dist/src/exports/mysql.js

@@ -1,2 +1,2 @@
-import { t as MySqlDatabase } from "../../mysql-BX3cm94v.js";
+import { t as MySqlDatabase } from "../../mysql-CcIuIAt0.js";
 export { MySqlDatabase };

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

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

package/dist/src/exports/postgres.js

@@ -1,2 +1,2 @@
-import { t as PgDatabase } from "../../postgres-DwiUT_A6.js";
+import { t as PgDatabase } from "../../postgres-CLhoKn_R.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-DsBAE32T.js";
+import { $ as ActionProcedures, $n as schemaRegistry, An as ComputedCodec, At as QueryFn, Bn as MutationArgs, Cn as buildPredicateSql, Ct as MutationConfig, Dn as matchesPredicate, Dt as OutputOf, En as jsonPathExtract, Et as MutationProcedure, Fn as DefineSchemaConfig, Ft as createMutationBuilder, Gn as ReturnQuery, Hn as Prettify, In as IndexDefinition, It as createQueryBuilder, Jn as SchemaColumnsOptions, Kn as SchemaCodecs, Ln as InferSchema, Mn as ComputedField, Mt as TypeOf, Nn as ComputedFieldConfig, Nt as createActionBuilder, On as ActionArgs, Ot as QueryConfig, Pn as DeclarativeIndex, Pt as createJobBuilder, Qn as defineSchema, Rn as InsertData, Sn as QueryBuilder, St as JobProcedure, Tn as jsonPathExists, Tt as MutationFn, Un as QueryArgs, Vn as OverrideField, Wn as ReturnLiveQuery, Xn as StoredSchemaColumnsOptions, Yn as SchemaDefinition, Zn as defineComputedField, _n as JsonHasKeyMultiOptions, _t as HandlerLogger, at as PublicProcedures, bn as OrderDirection, bt as JobCtx, cn as EphemeralFlushError, ct as Router, dn as EphemeralSetOptions, dt as ActionConfig, er as shouldTrackSchema, et as AppRouter, ft as ActionCtx, gn as JsonContainsOptions, gt as ContextOf, hn as IdAndCommitTs, ht as AnyProcedure, it as ProcedureNames, jn as ComputedDataType, jt as QueryProcedure, kn as ColumnCodec, kt as QueryCtx, ln as EphemeralKeyNotFoundError, lt as getContextRegistry, mt as ActionProcedure, nt as JobProcedures, on as EPHEMERAL_DEFAULT_TTL_SECONDS, ot as QueryProcedures, pn as EphemeralWriter, pt as ActionFn, qn as SchemaColumnMapping, rt as MutationProcedures, sn as EphemeralDecodeError, st as RegisteredProcedure, tr as tableNameToId, tt as ContextRegistry, un as EphemeralReader, ut as router, vn as JsonOpOptions, vt as HandlerObservability, wn as jsonContains, wt as MutationCtx, xn as PaginationClause, xt as JobFn, yn as OrderByOptions, yt as JobConfig, zn as Model } from "../../index-DB7_pv9P.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-CiacMqje.js";
 import * as z$2 from "zod";
 
@@ -17,5 +17,5 @@ declare module "zod" {
   }
 } //# sourceMappingURL=procedure.d.ts.map
 //#endregion
-export { ActionArgs, type ActionConfig, type ActionCtx, type ActionFn, type ActionProcedure, type ActionProcedures, type AnyProcedure, type AppRouter, ColumnCodec, ComputedCodec, ComputedDataType, ComputedField, ComputedFieldConfig, type ContextOf, ContextRegistry, DeclarativeIndex, DefineSchemaConfig, type HandlerLogger, type HandlerObservability, IdAndCommitTs, IndexDefinition, InferSchema, InsertData, type JobConfig, type JobCtx, type JobFn, type JobProcedure, type JobProcedures, JsonContainsOptions, JsonHasKeyMultiOptions, JsonOpOptions, Model, MutationArgs, type MutationConfig, type MutationCtx, type MutationFn, type MutationProcedure, type MutationProcedures, OrderByOptions, OrderDirection, type OutputOf, OverrideField, PaginationClause, Prettify, type ProcedureNames, type PublicProcedures, QueryArgs, QueryBuilder, type QueryConfig, type QueryCtx, type QueryFn, type QueryProcedure, type QueryProcedures, type RegisteredProcedure, ReturnLiveQuery, ReturnQuery, type Router, SchemaCodecs, SchemaColumnMapping, SchemaColumnsOptions, SchemaDefinition, StoredSchemaColumnsOptions, type TypeOf, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, patchZod, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId };
+export { ActionArgs, type ActionConfig, type ActionCtx, type ActionFn, type ActionProcedure, type ActionProcedures, type AnyProcedure, type AppRouter, ColumnCodec, ComputedCodec, ComputedDataType, ComputedField, ComputedFieldConfig, type ContextOf, ContextRegistry, DeclarativeIndex, DefineSchemaConfig, EPHEMERAL_DEFAULT_TTL_SECONDS, EphemeralDecodeError, EphemeralFlushError, EphemeralKeyNotFoundError, type EphemeralReader, type EphemeralSetOptions, type EphemeralWriter, type HandlerLogger, type HandlerObservability, IdAndCommitTs, IndexDefinition, InferSchema, InsertData, type JobConfig, type JobCtx, type JobFn, type JobProcedure, type JobProcedures, JsonContainsOptions, JsonHasKeyMultiOptions, JsonOpOptions, Model, MutationArgs, type MutationConfig, type MutationCtx, type MutationFn, type MutationProcedure, type MutationProcedures, OrderByOptions, OrderDirection, type OutputOf, OverrideField, PaginationClause, Prettify, type ProcedureNames, type PublicProcedures, QueryArgs, QueryBuilder, type QueryConfig, type QueryCtx, type QueryFn, type QueryProcedure, type QueryProcedures, type RegisteredProcedure, ReturnLiveQuery, ReturnQuery, type Router, SchemaCodecs, SchemaColumnMapping, SchemaColumnsOptions, SchemaDefinition, StoredSchemaColumnsOptions, type TypeOf, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, patchZod, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId };
 //# sourceMappingURL=procedure.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"procedure.d.ts","names":[],"sources":["../../../src/router/zod_patch.ts","../../../src/exports/procedure.ts"],"mappings":";;;;;;;;;AAgBA;iBAAgB,QAAA,CAAS,SAAmB,SAAD,GAAC;;;;YCThC,OAAA;IACR,SAAA,CAAU,IAAA;EAAA;AAAA"}
+{"version":3,"file":"procedure.d.ts","names":[],"sources":["../../../src/router/zod_patch.ts","../../../src/exports/procedure.ts"],"mappings":";;;;;;;;;AAgBA;iBAAgB,QAAA,CAAS,SAAmB,SAAD,GAAC;;;;YCAhC,OAAA;IACR,SAAA,CAAU,IAAA;EAAA;AAAA"}

package/dist/src/exports/procedure.js

@@ -3,6 +3,7 @@ import { n as tableNameToId } from "../../table-id-DyrJBKAQ.js";
 import { n as stableStringify, r as supaliveStringify, t as groupByToMap } from "../../helper-zdJT5FUc.js";
 import { a as jsonPathExtract, i as jsonPathExists, n as buildPredicateSql, o as matchesPredicate, r as jsonContains, t as QueryBuilder } from "../../query-LJranz0c.js";
 import { i as shouldTrackSchema, n as defineSchema, r as schemaRegistry, t as defineComputedField } from "../../schema-DRtz5h5l.js";
+import { a as EphemeralKeyNotFoundError, i as EphemeralFlushError, n as EPHEMERAL_DEFAULT_TTL_SECONDS, r as EphemeralDecodeError } from "../../ephemeral-CkidSG9y.js";
 //#region src/router/zod_patch.ts
 /**
 * Patch all Zod schema types on the given `z` namespace with `.modelName(name)`.
@@ -66,6 +67,6 @@ function patchZod(zInstance) {
 	}
 }
 //#endregion
-export { ContextRegistry, QueryBuilder, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, patchZod, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId };
+export { ContextRegistry, EPHEMERAL_DEFAULT_TTL_SECONDS, EphemeralDecodeError, EphemeralFlushError, EphemeralKeyNotFoundError, QueryBuilder, buildPredicateSql, createActionBuilder, createJobBuilder, createMutationBuilder, createQueryBuilder, defineComputedField, defineSchema, getContextRegistry, groupByToMap, jsonContains, jsonPathExists, jsonPathExtract, matchesPredicate, patchZod, router, schemaRegistry, shouldTrackSchema, stableStringify, supaliveStringify, tableNameToId };
 
 //# sourceMappingURL=procedure.js.map

package/dist/src/exports/procedure.js.map

@@ -1 +1 @@
-{"version":3,"file":"procedure.js","names":[],"sources":["../../../src/router/zod_patch.ts"],"sourcesContent":["// ─── Zod .modelName() extension ─────────────────────────────────────────────\n// Patches every Zod schema type with a `.modelName(\"Name\")` method that sets\n// `__genType` metadata for codegen model renaming.\n//\n// Zod v4: `z.string` is a factory — `z.string.prototype` is NOT the real class\n// prototype. We collect the actual prototypes by creating one instance per type,\n// then patch each unique prototype once.\n\nimport type { ZodType } from \"zod\";\nimport * as z from \"zod\";\n\n/**\n * Patch all Zod schema types on the given `z` namespace with `.modelName(name)`.\n * Must be called with the same `z` instance the consumer uses so the prototypes\n * match. Runs once per unique `z` instance (tracked via a WeakSet).\n */\nexport function patchZod(zInstance: typeof z): void {\n    const key = \"supalive_model_name_ext\";\n    const patchedInstances: Set<object> = (globalThis as any)[key] ??= new Set();\n    if (patchedInstances.has(zInstance)) return;\n    patchedInstances.add(zInstance);\n\n    const patched = new Set<object>();\n    const samples: ZodType[] = [\n        zInstance.string(), zInstance.number(), zInstance.boolean(), zInstance.bigint(), zInstance.date(),\n        zInstance.object({}), zInstance.array(zInstance.string()), zInstance.enum([\"_\"]),\n        zInstance.literal(\"_\"), zInstance.null(), zInstance.undefined(), zInstance.any(), zInstance.unknown(),\n        zInstance.void(), zInstance.never(), zInstance.nan(), zInstance.record(zInstance.string(), zInstance.string()),\n        zInstance.union([zInstance.string(), zInstance.number()]), zInstance.intersection(zInstance.string(), zInstance.string()),\n        zInstance.tuple([zInstance.string()]), zInstance.promise(zInstance.string()), zInstance.custom(),\n        zInstance.coerce.string(), zInstance.coerce.number(), zInstance.coerce.boolean(),\n        zInstance.coerce.bigint(), zInstance.coerce.date(),\n        zInstance.string().optional(), zInstance.string().nullable(), zInstance.string().default(\"\"),\n        zInstance.string().pipe(zInstance.string()), zInstance.string().transform(() => \"\"),\n    ];\n    for (const inst of samples) {\n        const proto = Object.getPrototypeOf(inst);\n        if (patched.has(proto)) continue;\n        patched.add(proto);\n        const metaDesc = Object.getOwnPropertyDescriptor(proto, \"meta\");\n        if (!metaDesc || !metaDesc.get) continue;\n        if ((proto as any).modelName) continue;\n        Object.defineProperty(proto, \"modelName\", {\n            value: function modelName(name: string) {\n                return this.meta({ __genType: name });\n            },\n            writable: true,\n            configurable: true,\n        });\n    }\n}"],"mappings":";;;;;;;;;;;AAgBA,SAAgB,SAAS,WAA2B;CAChD,MAAM,MAAM;CACZ,MAAM,mBAAgC,WAAoB,yBAAS,IAAI,IAAI;CAC3E,IAAI,iBAAiB,IAAI,SAAS,GAAG;CACrC,iBAAiB,IAAI,SAAS;CAE9B,MAAM,0BAAU,IAAI,IAAY;CAChC,MAAM,UAAqB;EACvB,UAAU,OAAO;EAAG,UAAU,OAAO;EAAG,UAAU,QAAQ;EAAG,UAAU,OAAO;EAAG,UAAU,KAAK;EAChG,UAAU,OAAO,CAAC,CAAC;EAAG,UAAU,MAAM,UAAU,OAAO,CAAC;EAAG,UAAU,KAAK,CAAC,GAAG,CAAC;EAC/E,UAAU,QAAQ,GAAG;EAAG,UAAU,KAAK;EAAG,UAAU,UAAU;EAAG,UAAU,IAAI;EAAG,UAAU,QAAQ;EACpG,UAAU,KAAK;EAAG,UAAU,MAAM;EAAG,UAAU,IAAI;EAAG,UAAU,OAAO,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC;EAC7G,UAAU,MAAM,CAAC,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC,CAAC;EAAG,UAAU,aAAa,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC;EACxH,UAAU,MAAM,CAAC,UAAU,OAAO,CAAC,CAAC;EAAG,UAAU,QAAQ,UAAU,OAAO,CAAC;EAAG,UAAU,OAAO;EAC/F,UAAU,OAAO,OAAO;EAAG,UAAU,OAAO,OAAO;EAAG,UAAU,OAAO,QAAQ;EAC/E,UAAU,OAAO,OAAO;EAAG,UAAU,OAAO,KAAK;EACjD,UAAU,OAAO,CAAC,CAAC,SAAS;EAAG,UAAU,OAAO,CAAC,CAAC,SAAS;EAAG,UAAU,OAAO,CAAC,CAAC,QAAQ,EAAE;EAC3F,UAAU,OAAO,CAAC,CAAC,KAAK,UAAU,OAAO,CAAC;EAAG,UAAU,OAAO,CAAC,CAAC,gBAAgB,EAAE;CACtF;CACA,KAAK,MAAM,QAAQ,SAAS;EACxB,MAAM,QAAQ,OAAO,eAAe,IAAI;EACxC,IAAI,QAAQ,IAAI,KAAK,GAAG;EACxB,QAAQ,IAAI,KAAK;EACjB,MAAM,WAAW,OAAO,yBAAyB,OAAO,MAAM;EAC9D,IAAI,CAAC,YAAY,CAAC,SAAS,KAAK;EAChC,IAAK,MAAc,WAAW;EAC9B,OAAO,eAAe,OAAO,aAAa;GACtC,OAAO,SAAS,UAAU,MAAc;IACpC,OAAO,KAAK,KAAK,EAAE,WAAW,KAAK,CAAC;GACxC;GACA,UAAU;GACV,cAAc;EAClB,CAAC;CACL;AACJ"}
+{"version":3,"file":"procedure.js","names":[],"sources":["../../../src/router/zod_patch.ts"],"sourcesContent":["// ─── Zod .modelName() extension ─────────────────────────────────────────────\n// Patches every Zod schema type with a `.modelName(\"Name\")` method that sets\n// `__genType` metadata for codegen model renaming.\n//\n// Zod v4: `z.string` is a factory — `z.string.prototype` is NOT the real class\n// prototype. We collect the actual prototypes by creating one instance per type,\n// then patch each unique prototype once.\n\nimport type { ZodType } from \"zod\";\nimport * as z from \"zod\";\n\n/**\n * Patch all Zod schema types on the given `z` namespace with `.modelName(name)`.\n * Must be called with the same `z` instance the consumer uses so the prototypes\n * match. Runs once per unique `z` instance (tracked via a WeakSet).\n */\nexport function patchZod(zInstance: typeof z): void {\n    const key = \"supalive_model_name_ext\";\n    const patchedInstances: Set<object> = (globalThis as any)[key] ??= new Set();\n    if (patchedInstances.has(zInstance)) return;\n    patchedInstances.add(zInstance);\n\n    const patched = new Set<object>();\n    const samples: ZodType[] = [\n        zInstance.string(), zInstance.number(), zInstance.boolean(), zInstance.bigint(), zInstance.date(),\n        zInstance.object({}), zInstance.array(zInstance.string()), zInstance.enum([\"_\"]),\n        zInstance.literal(\"_\"), zInstance.null(), zInstance.undefined(), zInstance.any(), zInstance.unknown(),\n        zInstance.void(), zInstance.never(), zInstance.nan(), zInstance.record(zInstance.string(), zInstance.string()),\n        zInstance.union([zInstance.string(), zInstance.number()]), zInstance.intersection(zInstance.string(), zInstance.string()),\n        zInstance.tuple([zInstance.string()]), zInstance.promise(zInstance.string()), zInstance.custom(),\n        zInstance.coerce.string(), zInstance.coerce.number(), zInstance.coerce.boolean(),\n        zInstance.coerce.bigint(), zInstance.coerce.date(),\n        zInstance.string().optional(), zInstance.string().nullable(), zInstance.string().default(\"\"),\n        zInstance.string().pipe(zInstance.string()), zInstance.string().transform(() => \"\"),\n    ];\n    for (const inst of samples) {\n        const proto = Object.getPrototypeOf(inst);\n        if (patched.has(proto)) continue;\n        patched.add(proto);\n        const metaDesc = Object.getOwnPropertyDescriptor(proto, \"meta\");\n        if (!metaDesc || !metaDesc.get) continue;\n        if ((proto as any).modelName) continue;\n        Object.defineProperty(proto, \"modelName\", {\n            value: function modelName(name: string) {\n                return this.meta({ __genType: name });\n            },\n            writable: true,\n            configurable: true,\n        });\n    }\n}"],"mappings":";;;;;;;;;;;;AAgBA,SAAgB,SAAS,WAA2B;CAChD,MAAM,MAAM;CACZ,MAAM,mBAAgC,WAAoB,yBAAS,IAAI,IAAI;CAC3E,IAAI,iBAAiB,IAAI,SAAS,GAAG;CACrC,iBAAiB,IAAI,SAAS;CAE9B,MAAM,0BAAU,IAAI,IAAY;CAChC,MAAM,UAAqB;EACvB,UAAU,OAAO;EAAG,UAAU,OAAO;EAAG,UAAU,QAAQ;EAAG,UAAU,OAAO;EAAG,UAAU,KAAK;EAChG,UAAU,OAAO,CAAC,CAAC;EAAG,UAAU,MAAM,UAAU,OAAO,CAAC;EAAG,UAAU,KAAK,CAAC,GAAG,CAAC;EAC/E,UAAU,QAAQ,GAAG;EAAG,UAAU,KAAK;EAAG,UAAU,UAAU;EAAG,UAAU,IAAI;EAAG,UAAU,QAAQ;EACpG,UAAU,KAAK;EAAG,UAAU,MAAM;EAAG,UAAU,IAAI;EAAG,UAAU,OAAO,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC;EAC7G,UAAU,MAAM,CAAC,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC,CAAC;EAAG,UAAU,aAAa,UAAU,OAAO,GAAG,UAAU,OAAO,CAAC;EACxH,UAAU,MAAM,CAAC,UAAU,OAAO,CAAC,CAAC;EAAG,UAAU,QAAQ,UAAU,OAAO,CAAC;EAAG,UAAU,OAAO;EAC/F,UAAU,OAAO,OAAO;EAAG,UAAU,OAAO,OAAO;EAAG,UAAU,OAAO,QAAQ;EAC/E,UAAU,OAAO,OAAO;EAAG,UAAU,OAAO,KAAK;EACjD,UAAU,OAAO,CAAC,CAAC,SAAS;EAAG,UAAU,OAAO,CAAC,CAAC,SAAS;EAAG,UAAU,OAAO,CAAC,CAAC,QAAQ,EAAE;EAC3F,UAAU,OAAO,CAAC,CAAC,KAAK,UAAU,OAAO,CAAC;EAAG,UAAU,OAAO,CAAC,CAAC,gBAAgB,EAAE;CACtF;CACA,KAAK,MAAM,QAAQ,SAAS;EACxB,MAAM,QAAQ,OAAO,eAAe,IAAI;EACxC,IAAI,QAAQ,IAAI,KAAK,GAAG;EACxB,QAAQ,IAAI,KAAK;EACjB,MAAM,WAAW,OAAO,yBAAyB,OAAO,MAAM;EAC9D,IAAI,CAAC,YAAY,CAAC,SAAS,KAAK;EAChC,IAAK,MAAc,WAAW;EAC9B,OAAO,eAAe,OAAO,aAAa;GACtC,OAAO,SAAS,UAAU,MAAc;IACpC,OAAO,KAAK,KAAK,EAAE,WAAW,KAAK,CAAC;GACxC;GACA,UAAU;GACV,cAAc;EAClB,CAAC;CACL;AACJ"}

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

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

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

@@ -1,7 +1,7 @@
-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-DsBAE32T.js";
-import { t as MySqlDatabase } from "../../mysql-C79_qNQO.js";
-import { t as PgDatabase } from "../../postgres-SM8muZqN.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-gSgzZHuD.js";
+import { Ar as UpdateSubscriptionReadSetParamsSchema, Bt as IncomingJobRequest, Cr as RegisterSubscriptionResult, D as Context, Er as UnregisterSubscriptionResult, Gt as ScheduleHandle, Ht as JobScheduler, Kt as ScheduledJobDef, Lt as DevScheduler, Rt as DevSchedulerOptions, Sr as RegisterSubscriptionParamsSchema, Tr as UnregisterSubscriptionParamsSchema, Ut as QStashScheduler, Vt as JobClient, Wt as QStashSchedulerOptions, _r as InvalidateEphemeralResult, an as EMPTY_EPHEMERAL_KEYS, br as InvalidateWritesetResult, cn as EphemeralFlushError, ct as Router, dn as EphemeralSetOptions, fn as EphemeralStore, fr as CacheLayer, gr as InvalidateEphemeralParamsSchema, hr as InvalidateEphemeralParams, jr as UpdateSubscriptionReadSetResult, kr as UpdateSubscriptionReadSetParams, ln as EphemeralKeyNotFoundError, mn as createMemoryEphemeralStore, mr as AffectedSubscription, on as EPHEMERAL_DEFAULT_TTL_SECONDS, pn as EphemeralWriter, pr as IORedisClient, qt as SupaliveDb, rr as Database, sn as EphemeralDecodeError, un as EphemeralReader, vr as InvalidateWritesetParams, wr as UnregisterSubscriptionParams, xr as RegisterSubscriptionParams, yr as InvalidateWritesetParamsSchema, zt as EnqueueOptions } from "../../index-DB7_pv9P.js";
+import { t as MySqlDatabase } from "../../mysql-Bvc_iWUy.js";
+import { t as PgDatabase } from "../../postgres-C5CbPBcp.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-xHmZ6baD.js";
 import pino, { Level } from "pino";
 
 //#region src/server/supalive-server.d.ts
@@ -151,6 +151,16 @@ declare class SupaliveWebSocketServer<TContext extends Context> {
    */
   private dropSubscriptionLocally;
   private handleMutationCommit;
+  /**
+   * Invalidate subscriptions that read any of `keys`. The ephemeral twin of
+   * {@link handleMutationCommit} (db/ephemeral.ts): same central sub-manager,
+   * same dispatch, same recompute — only the matching differs (exact key lookup
+   * instead of write-set/read-set overlap).
+   *
+   * `version` is the store's monotonic write sequence, standing in for a
+   * mutation's `commitTs` as the cross-instance recompute-lock discriminator.
+   */
+  private handleEphemeralWrite;
   /**
    * Route an affected sub to whichever instance can actually run the
    * recompute:
@@ -163,11 +173,42 @@ declare class SupaliveWebSocketServer<TContext extends Context> {
    *
    * If `notifyInstances` is empty (the sub has no live holders), we drop
    * the message — the next subscribe will recompute fresh state.
+   *
+   * `commitTs` identifies the write being reacted to — a mutation's `commitTs`,
+   * or an ephemeral write's sequence number(revision). Its only job is that every
+   * instance racing over the SAME write derives the same lock key, so any
+   * monotonic token works.
    */
   private dispatchAffected;
   private hasLocalSessionFor;
   private publishRecomputeRace;
+  /**
+   * Recomputes currently running, keyed by subId. Holds the in-flight promise
+   * plus the newest request that arrived while it was running — see
+   * {@link reexecuteAffectedQuery}.
+   */
+  private recomputesInFlight;
+  /**
+   * Recompute a subscription and push the result, coalescing concurrent
+   * requests for the same subId.
+   *
+   * A subscription is already shared by every session watching the same
+   * (procedure, args, identity), so one write produces one recompute no matter
+   * how many clients are attached. What that does NOT cover is RATE: two writes
+   * arriving 60ms apart used to start two overlapping recomputes of the same
+   * sub, which could finish out of order and leave clients on the older of the
+   * two results — `handleSubscriptionUpdate` applies whatever lands last.
+   *
+   * High-frequency ephemeral state (a position stream) makes that the normal
+   * case rather than a rare one, so requests are serialized per subId here:
+   * while one runs, later requests collapse into a single follow-up that fires
+   * once it finishes. Each recompute reads current state, so the follow-up
+   * reflects every write that arrived during the previous run — collapsing
+   * loses nothing but redundant work, and the last result published is always
+   * the newest.
+   */
   private reexecuteAffectedQuery;
+  private runRecompute;
   private executeLiveQuery;
   private sendMessage;
   private sendError;
@@ -256,6 +297,13 @@ declare class SubscriptionManager {
   private unregisterSubscription;
   private unregisterSubscriptions;
   private invalidateWriteset;
+  /**
+   * Ephemeral-key invalidation. Fans out to every worker exactly like
+   * {@link invalidateWriteset}: subscriptions are routed by hash(subId), which
+   * says nothing about which keys they read, so the holders of a given key can
+   * sit in any slice.
+   */
+  private invalidateEphemeral;
 }
 //#endregion
 //#region src/db/init_db.d.ts
@@ -299,6 +347,9 @@ type InitDbOptions = {
   CacheLayer: CacheLayer;
   forceBootstrapReload?: boolean;
   workerId?: number;
+  /** Default TTL for `ctx.db.ephemeral` writes (see db/ephemeral.ts).
+   *  Defaults to 7 days. A server overrides this from its own config. */
+  ephemeralTtlSeconds?: number;
 };
 declare function initDatabase(options: InitDbOptions): Promise<SupaliveDb>;
 declare function createDatabase(config: DatabaseConfig, workerId?: number): PgDatabase | MySqlDatabase;
@@ -353,5 +404,5 @@ declare function generateSubscriptionId(procedure: string, input: unknown | stri
  */
 declare function generateCacheKey(queryName: string, input: unknown | string, queryIdentity: string): Promise<string>;
 //#endregion
-export { ANONYMOUS_IDENTITY, type AffectedSubscription, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, type DevSchedulerOptions, type EnqueueOptions, type IncomingJobRequest, InitCacheLayerOptions, InitDbOptions, type InvalidateWritesetParams, InvalidateWritesetParamsSchema, type InvalidateWritesetResult, JobClient, type JobScheduler, Observability, ObservabilityOptions, OperationEvent, OperationKind, OperationOutcome, OperationTransport, QStashScheduler, type QStashSchedulerOptions, QueryTrigger, type RegisterSubscriptionParams, RegisterSubscriptionParamsSchema, type RegisterSubscriptionResult, RequestLogMode, type ScheduleHandle, type ScheduledJobDef, type SubId, SubManagerClient, type SubManagerLink, SubscriptionManager, SupaliveWebSocketServer, type UnregisterSubscriptionParams, UnregisterSubscriptionParamsSchema, type UnregisterSubscriptionResult, type UpdateSubscriptionReadSetParams, UpdateSubscriptionReadSetParamsSchema, type UpdateSubscriptionReadSetResult, appInstanceId, bootstrapDbTypes, configureRootLogger, createDatabase, elapsedMs, generateCacheKey, generateSubscriptionId, getHashOf, getRootLogger, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue, startTimer, traceQueryExecution };
+export { ANONYMOUS_IDENTITY, type AffectedSubscription, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, type DevSchedulerOptions, EMPTY_EPHEMERAL_KEYS, EPHEMERAL_DEFAULT_TTL_SECONDS, type EnqueueOptions, EphemeralDecodeError, EphemeralFlushError, EphemeralKeyNotFoundError, type EphemeralReader, type EphemeralSetOptions, EphemeralStore, type EphemeralWriter, type IncomingJobRequest, InitCacheLayerOptions, InitDbOptions, type InvalidateEphemeralParams, InvalidateEphemeralParamsSchema, type InvalidateEphemeralResult, type InvalidateWritesetParams, InvalidateWritesetParamsSchema, type InvalidateWritesetResult, JobClient, type JobScheduler, Observability, ObservabilityOptions, OperationEvent, OperationKind, OperationOutcome, OperationTransport, QStashScheduler, type QStashSchedulerOptions, QueryTrigger, type RegisterSubscriptionParams, RegisterSubscriptionParamsSchema, type RegisterSubscriptionResult, RequestLogMode, type ScheduleHandle, type ScheduledJobDef, type SubId, SubManagerClient, type SubManagerLink, SubscriptionManager, SupaliveWebSocketServer, type UnregisterSubscriptionParams, UnregisterSubscriptionParamsSchema, type UnregisterSubscriptionResult, type UpdateSubscriptionReadSetParams, UpdateSubscriptionReadSetParamsSchema, type UpdateSubscriptionReadSetResult, appInstanceId, bootstrapDbTypes, configureRootLogger, createDatabase, createMemoryEphemeralStore, elapsedMs, generateCacheKey, generateSubscriptionId, getHashOf, getRootLogger, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue, startTimer, traceQueryExecution };
 //# sourceMappingURL=server.d.ts.map

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":";;;;;;;;AAiIA;;cAAa,uBAAA,kBAAyC,OAAA;EAAA,QAC5C,MAAA;EAAA,QACA,UAAA;EAAA,QAEA,UAAA;EAAA,QACA,GAAA;EAAA,QAEA,KAAA;EAAA,QACA,QAAA;EAwQmB;EAAA,iBAtQV,iBAAA;EAAA,QACT,EAAA;EAAA,QACA,eAAA;EAAA,QACA,MAAA;EAAA,QAMA,kBAAA;EAAA,QAIA,WAAA;EAAA,QAEA,SAAA;EAAA,QACA,OAAA;EAAA,QACA,SAAA;EAs+C0D;;EAAA,QAn+C1D,UAAA;EA7BA;EAAA,QA+BA,OAAA;EAAA,QAEA,QAAA;EAAA,QACA,mBAAA;EAAA,QACA,gBAAA;EAAA,QAEA,KAAA;EA5BS;EAAA,QAmCT,GAAA;EAjCA;EAAA,QAmCA,GAAA;cAEI,MAAA,EAAQ,oBAAA,CAAqB,QAAA;EA1BjC;;;;;;;;;;;;EAAA,QA4KA,qBAAA;EAAA,QAqBA,kBAAA;EAOR,cAAA,CAAe,MAAA,EAAQ,MAAA,MAAY,QAAA;EAK7B,KAAA,IAAS,OAAA;EAjCP;;;;;;EAAA,QAyDM,gBAAA;EAxBC;;;;;EA4CR,gBAAA,IAAoB,aAAA;EAcrB;EATN,WAAA,CAAY,IAAA;EASoB;;;;;EAA1B,WAAA,CAAY,IAAA,UAAc,IAAA,WAAe,IAAA,GAAO,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAM/D;EAAV,SAAA,CAAU,QAAA,WAAmB,OAAA;EASnC;;;;EAAA,YAAA,IAAgB,SAAA;EAwBhB;;;;;;EAdA,gBAAA;EAIM,IAAA,IAAQ,OAAA;EAUd,QAAA;;;;;;EASA,aAAA;EA2bc;;;;;EAAA,QAlbA,iBAAA;EAAA,QA8CN,sBAAA;EAAA,QAQM,gBAAA;EAAA,QA4DA,aAAA;EAAA,QAmBA,cAAA;EAAA,QAqBA,UAAA;EAkwBN;;;;;;;EAAA,QA/tBA,eAAA;EA29BF;;;;;EAAA,QAj8BQ,kBAAA;EAAA,QAwCA,UAAA;EAAA,QAmLA,eAAA;EAAA,QAyLA,iBAAA;EAAA,QA2BA,gBAAA;EAqmByB;AAAA;;;;AC9rDzC;;;;AAA+D;AAC/D;;;;ED6rDyC,QA/iBzB,qBAAA;EAAA,QAgEA,kBAAA;EC1rCd;;;AAnBiB;AAqBnB;;EAFE,QDssCQ,uBAAA;EAAA,QAoBM,oBAAA;ECxtC+B;AAK/C;;;;;;;;EAL+C,QDqvC/B,oBAAA;EChvCgF;;;;;;;;;;;;AAAK;;;;ACiKrG;;EDjKgG,QDqxChF,gBAAA;EAAA,QAkBN,kBAAA;EAAA,QAOM,oBAAA;EE7hCA;;;;;EAAA,QFkkCN,kBAAA;EE/qCA;;;;;;;;;;;;;;;;;;;EAAA,QFosCM,sBAAA;EAAA,QAiCA,YAAA;EAAA,QA4EA,gBAAA;EAAA,QAsCN,WAAA;EAAA,QAYA,SAAA;EAAA,QAIM,0BAAA;EEvnCA;;;;;AA0CmB;EA1CnB,QFyqCA,kBAAA;;;AGzkDhB;;;;EH2lDQ,mBAAA,CAAoB,MAAA,cAAoB,OAAA;EGhlD1B;;;;;;;;EHkmDd,iBAAA,CAAkB,OAAA,UAAiB,OAAA,WAAkB,OAAA;EAAA,QAI7C,2BAAA;EAAA,QAmCA,yBAAA;EAAA,QA0BA,yBAAA;AAAA;;;cC9rDH,aAAA;AAAA,cACA,YAAA;AAAA,cACA,MAAA,EAAM,IAAA,CAAA,MAAA;AAAA,iBAqBH,UAAA,CAAW,IAAA,WAAe,KAAK;AAAA,iBAK/B,iBAAA,wCAAyD,GAAA,EAAK,GAAA,CAAI,CAAA,EAAG,CAAA,IAAK,MAAA,CAAO,CAAA,EAAG,CAAA;;;;;;;;;;cCiKvF,mBAAA;EAAA,QACH,GAAA;EAAA,QACA,IAAA;EAAA,QACA,MAAA;EAAA,QACA,OAAA;EAAA,QACA,aAAA;EAAA,wBACgB,iBAAA;cAEZ,MAAA,EAAQ,yBAAA;EFpEZ;;;;;;EAAA,QEoHA,iBAAA;EAiCF,KAAA,IAAS,OAAA;EAuBT,IAAA,IAAQ,OAAA;EFxJN;;;;;;;EEyKR,SAAA,IAAa,cAAA;EAAA,QAcC,eAAA;EFnKN;;;EAAA,QE+LM,2BAAA;EAUd,WAAA;EAIA,cAAA,CAAe,KAAA;EAAA,QAIP,SAAA;EAAA,QAIA,eAAA;EAAA,QAYA,SAAA;EAAA,QAIM,oBAAA;EAAA,QAKA,yBAAA;EAAA,QAwBA,yBAAA;EAAA,QAKA,sBAAA;EAAA,QAKA,uBAAA;EAAA,QAsBA,kBAAA;EF/DP;;;;;;EAAA,QE8EO,mBAAA;AAAA;;;;AF9VhB;;;;;;;;;;cG5Ga,YAAA;;;;;;;;;;iBAWS,QAAA,CAAS,EAAA,EAAI,QAAA,GAAW,OAAO;;;;;;cA6BxC,mBAAA;AAAA,KAID,aAAA;EACR,QAAA,EAAU,cAAA;EH0EJ;;;;;;EGnEN,eAAA,GAAkB,cAAA;EAClB,UAAA,EAAY,UAAA;EACZ,oBAAA;EACA,QAAA;EHuFM;;EGpFN,mBAAA;AAAA;AAAA,iBAGkB,YAAA,CAAa,OAAA,EAAS,aAAA,GAAgB,OAAA,CAAQ,UAAA;AAAA,iBAuBpD,cAAA,CAAe,MAAA,EAAQ,cAAA,EAAgB,QAAA,YAAoB,UAAA,GAAa,aAAA;;;;;;;;;;;;;;iBA4DlE,gBAAA,CAAiB,EAAA,EAAI,UAAA,EAAY,KAAA,EAAO,UAAA,EAAY,WAAA,aAAsB,OAAA;AAAA,KAsBpF,qBAAA;EACR,OAAA,EAAS,aAAa;EAEtB,eAAA;EAEA,iBAAA;EAEA,iBAAA;EAEA,oBAAA;EAEA,eAAA;AAAA;AAAA,iBAGY,cAAA,CAAe,MAAA,EAAQ,qBAAA;EAA0B,UAAA,EAAY,UAAA;EAAY,cAAA,GAAiB,aAAA;AAAA;;;;iBClMpF,SAAA,CAAU,KAAA,YAAiB,OAAO;;;;;cAS3C,kBAAA;;;;;;;;;iBAgDS,sBAAA,CACpB,SAAA,UACA,KAAA,oBACA,aAAA,WACC,OAAO;;;;;;iBAWY,gBAAA,CACpB,SAAA,UACA,KAAA,oBACA,aAAA,WACC,OAAO"}

package/dist/src/exports/server.js

@@ -1,10 +1,11 @@
 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 { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-B8jh6MKl.js";
+import { a as EphemeralKeyNotFoundError, c as createMemoryEphemeralStore, i as EphemeralFlushError, n as EPHEMERAL_DEFAULT_TTL_SECONDS, o as EphemeralStore, r as EphemeralDecodeError, t as EMPTY_EPHEMERAL_KEYS } from "../../ephemeral-CkidSG9y.js";
+import { i as AuthenticationError, o as ClientMessageSchema } from "../../types_client_rpc-CqUVHTwT.js";
 import { n as RemoteSubscriptionMessageSchema } from "../../types_server-BhC19R2a.js";
-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-Ci_z8w10.js";
+import { a as logLevelOf, i as isProduction, n as sleep, o as logger, r as appInstanceId, s as serializeMapValue } from "../../realtime_db-CTGOrFuV.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-DAAHGTcI.js";
+import { C as RETENTION_WATERMARK_CHANNEL, S as UpdateSubscriptionReadSetResultSchema, _ as RegisterSubscriptionResultSchema, a as bootstrapDbTypes, b as UnregisterSubscriptionsResultSchema, c as initCore, d as InvalidateEphemeralParamsSchema, f as InvalidateEphemeralResultSchema, g as RegisterSubscriptionParamsSchema, h as RegisterSubscriptionBatchResultSchema, i as DB_QUERY_TIMEOUT_MS, l as initDatabase, m as InvalidateWritesetResultSchema, n as SubscriptionWorker, o as createDatabase, p as InvalidateWritesetParamsSchema, r as CORE_VERSION, s as initCacheLayer, t as dispatchWorkerMessage, u as CacheLayer, v as UnregisterSubscriptionParamsSchema, w as RetentionWatermark, x as UpdateSubscriptionReadSetParamsSchema, y as UnregisterSubscriptionResultSchema } from "../../sub-worker-dispatch-Dwrp3c40.js";
 import { context, trace } from "@opentelemetry/api";
 import { v4 } from "uuid";
 import { createServer } from "http";
@@ -58,6 +59,16 @@ var SubManagerClient = class {
 	bufferedWriteSets = [];
 	bufferLimit;
 	bufferDroppedDuringOutage = false;
+	/**
+	* Ephemeral keys written while state === 'busy', mapped to the latest version
+	* seen for each. A MAP, not a queue like `bufferedWriteSets`: an ephemeral
+	* recompute re-reads the current value from Redis, so N writes to one key
+	* during an outage collapse into a single post-recovery invalidation with no
+	* loss of information. That makes the buffer self-bounding at the number of
+	* DISTINCT keys — which is what lets a 60ms position stream survive a long
+	* reconnect without a size limit or a drop path.
+	*/
+	bufferedEphemeralKeys = /* @__PURE__ */ new Map();
 	recoveryDriver;
 	affectedHandler;
 	constructor(urlOrOptions) {
@@ -120,6 +131,24 @@ var SubManagerClient = class {
 		return this.call("invalidateWriteset", params, InvalidateWritesetResultSchema);
 	}
 	/**
+	* Ephemeral-key counterpart of {@link invalidateWriteset}. Buffers the same
+	* way during an outage, but into {@link bufferedEphemeralKeys} — see there for
+	* why a map rather than a queue.
+	*
+	* Unlike the write-set buffer there is no drop path: ephemeral state has no
+	* commit log for `register` to replay, so a dropped key would leave its
+	* subscribers stale until something else happened to invalidate them.
+	* Collapsing per key keeps the buffer small enough that dropping is never
+	* needed.
+	*/
+	async invalidateEphemeral(params) {
+		if (this.state === "busy") {
+			for (const key of params.keys) this.bufferedEphemeralKeys.set(key, params.version);
+			return { affected: [] };
+		}
+		return this.call("invalidateEphemeral", params, InvalidateEphemeralResultSchema);
+	}
+	/**
 	* Single point through which RPCs go. Throws on transport / server error.
 	* `registerSubscription`, `updateSubscriptionReadSet`, and
 	* `unregisterSubscription` are NOT gated on the ready state: during a
@@ -142,6 +171,9 @@ var SubManagerClient = class {
 		this.bufferedWriteSets.push(...writeSet);
 	}
 	async flushBuffer() {
+		await Promise.all([this.flushWriteSetBuffer(), this.flushEphemeralBuffer()]);
+	}
+	async flushWriteSetBuffer() {
 		if (this.bufferedWriteSets.length === 0) return;
 		const writeSet = this.bufferedWriteSets;
 		this.bufferedWriteSets = [];
@@ -153,6 +185,28 @@ var SubManagerClient = class {
 			logger$3.error(err, "Failed to flush invalidate buffer after recovery");
 		}
 	}
+	/**
+	* Replay the outage's ephemeral writes as ONE invalidation. The version sent
+	* is the highest buffered — every collapsed write is subsumed by the single
+	* recompute this triggers, which reads whatever Redis holds now, so using the
+	* newest version keeps the recompute lock keyed to the most recent write
+	* rather than an already-superseded one.
+	*/
+	async flushEphemeralBuffer() {
+		if (this.bufferedEphemeralKeys.size === 0) return;
+		const keys = [...this.bufferedEphemeralKeys.keys()];
+		const version = [...this.bufferedEphemeralKeys.values()].reduce((a, b) => BigInt(b) > BigInt(a) ? b : a);
+		this.bufferedEphemeralKeys.clear();
+		try {
+			const result = await this.call("invalidateEphemeral", {
+				keys,
+				version
+			}, InvalidateEphemeralResultSchema);
+			if (this.affectedHandler && result.affected.length > 0) await this.affectedHandler(result.affected);
+		} catch (err) {
+			logger$3.error(err, "Failed to flush ephemeral invalidate buffer after recovery");
+		}
+	}
 	markBusy() {
 		if (this.state === "busy") return;
 		this.state = "busy";
@@ -202,6 +256,10 @@ var SubManagerClient = class {
 	bufferSize() {
 		return this.bufferedWriteSets.length;
 	}
+	/** @internal */
+	ephemeralBufferSize() {
+		return this.bufferedEphemeralKeys.size;
+	}
 };
 //#endregion
 //#region src/jobs/scheduler.ts
@@ -958,6 +1016,9 @@ var SupaliveWebSocketServer = class {
 		this.db.setOnAfterCommit((writeSet, commitTs) => {
 			this.handleMutationCommit(writeSet, commitTs).catch((err) => this.log.error(err, "post-commit invalidation failed"));
 		});
+		this.db.setOnAfterEphemeralWrite((keys, version) => {
+			this.handleEphemeralWrite(keys, version).catch((err) => this.log.error(err, "ephemeral invalidation failed"));
+		});
 		this.scheduler = config.scheduler;
 		this.jobPath = normalizeJobPath(config.jobPath ?? "/_jobs");
 		this.jobClient = new JobClient(this.scheduler, (name) => this.endpointFor(name));
@@ -1589,6 +1650,7 @@ var SupaliveWebSocketServer = class {
 					subId,
 					lastSnapshotTs: liveResult.ts,
 					readSet: liveResult.readSet,
+					ephemeralKeys: liveResult.ephemeralKeys,
 					instanceName: this.instanceId
 				});
 				this.cache.setQueryCacheFor(cacheKey, data, liveResult.ts).catch((err) => this.log.warn(err, "writing query cache failed"));
@@ -1775,12 +1837,38 @@ var SupaliveWebSocketServer = class {
 		try {
 			const result = await this.subManagerClient.invalidateWriteset({ writeSet });
 			this.log.debug({ affected: result }, "Sub-managers invalidation result");
-			if (result?.affected?.length > 0) await Promise.allSettled(result.affected.map((affected) => this.dispatchAffected(affected, commitTs)));
+			if (result?.affected?.length > 0) await Promise.allSettled(result.affected.map((affected) => this.dispatchAffected(affected, commitTs.toString())));
 		} catch (err) {
 			this.log.error(err, "Failed to notify sub-managers");
 		}
 	}
 	/**
+	* Invalidate subscriptions that read any of `keys`. The ephemeral twin of
+	* {@link handleMutationCommit} (db/ephemeral.ts): same central sub-manager,
+	* same dispatch, same recompute — only the matching differs (exact key lookup
+	* instead of write-set/read-set overlap).
+	*
+	* `version` is the store's monotonic write sequence, standing in for a
+	* mutation's `commitTs` as the cross-instance recompute-lock discriminator.
+	*/
+	async handleEphemeralWrite(keys, version) {
+		if (keys.length === 0) return;
+		this.log.debug({
+			keys,
+			version
+		}, "Ephemeral write committed");
+		try {
+			const result = await this.subManagerClient.invalidateEphemeral({
+				keys,
+				version
+			});
+			this.log.debug({ affected: result }, "Ephemeral invalidation result");
+			if (result?.affected?.length > 0) await Promise.allSettled(result.affected.map((affected) => this.dispatchAffected(affected, version)));
+		} catch (err) {
+			this.log.error(err, "Failed to notify sub-managers of ephemeral write");
+		}
+	}
+	/**
 	* Route an affected sub to whichever instance can actually run the
 	* recompute:
 	*   • If this instance has a local session for the sub, recompute here
@@ -1792,6 +1880,11 @@ var SupaliveWebSocketServer = class {
 	*
 	* If `notifyInstances` is empty (the sub has no live holders), we drop
 	* the message — the next subscribe will recompute fresh state.
+	*
+	* `commitTs` identifies the write being reacted to — a mutation's `commitTs`,
+	* or an ephemeral write's sequence number(revision). Its only job is that every
+	* instance racing over the SAME write derives the same lock key, so any
+	* monotonic token works.
 	*/
 	async dispatchAffected(affected, commitTs) {
 		if (this.hasLocalSessionFor(affected.subId)) {
@@ -1816,7 +1909,7 @@ var SupaliveWebSocketServer = class {
 			queryName: affected.queryName,
 			args: affected.args,
 			notifyInstances: affected.notifyInstances,
-			commitTs: commitTs.toString(),
+			commitTs,
 			originInstance: this.instanceId
 		});
 		const publishPromises = affected.notifyInstances.map(async (instance) => {
@@ -1830,7 +1923,60 @@ var SupaliveWebSocketServer = class {
 		});
 		await Promise.all(publishPromises);
 	}
+	/**
+	* Recomputes currently running, keyed by subId. Holds the in-flight promise
+	* plus the newest request that arrived while it was running — see
+	* {@link reexecuteAffectedQuery}.
+	*/
+	recomputesInFlight = /* @__PURE__ */ new Map();
+	/**
+	* Recompute a subscription and push the result, coalescing concurrent
+	* requests for the same subId.
+	*
+	* A subscription is already shared by every session watching the same
+	* (procedure, args, identity), so one write produces one recompute no matter
+	* how many clients are attached. What that does NOT cover is RATE: two writes
+	* arriving 60ms apart used to start two overlapping recomputes of the same
+	* sub, which could finish out of order and leave clients on the older of the
+	* two results — `handleSubscriptionUpdate` applies whatever lands last.
+	*
+	* High-frequency ephemeral state (a position stream) makes that the normal
+	* case rather than a rare one, so requests are serialized per subId here:
+	* while one runs, later requests collapse into a single follow-up that fires
+	* once it finishes. Each recompute reads current state, so the follow-up
+	* reflects every write that arrived during the previous run — collapsing
+	* loses nothing but redundant work, and the last result published is always
+	* the newest.
+	*/
 	async reexecuteAffectedQuery(affected, trigger = "recompute") {
+		const inFlight = this.recomputesInFlight.get(affected.subId);
+		if (inFlight) {
+			inFlight.pending = {
+				affected,
+				trigger
+			};
+			return inFlight.running;
+		}
+		const entry = { running: Promise.resolve() };
+		this.recomputesInFlight.set(affected.subId, entry);
+		entry.running = (async () => {
+			try {
+				let next = {
+					affected,
+					trigger
+				};
+				while (next) {
+					await this.runRecompute(next.affected, next.trigger);
+					next = entry.pending;
+					entry.pending = void 0;
+				}
+			} finally {
+				this.recomputesInFlight.delete(affected.subId);
+			}
+		})();
+		return entry.running;
+	}
+	async runRecompute(affected, trigger = "recompute") {
 		let foundSession = null;
 		for (const [, session] of this.sessions) if (session.subIds.has(affected.subId)) {
 			foundSession = session;
@@ -1848,6 +1994,7 @@ var SupaliveWebSocketServer = class {
 				subId: affected.subId,
 				lastSnapshotTs: liveResult.ts,
 				readSet: liveResult.readSet,
+				ephemeralKeys: liveResult.ephemeralKeys,
 				instanceName: this.instanceId
 			}), this.cache.setQueryCacheFor(affected.cacheKey, liveResult.data, liveResult.ts)]);
 			if (!updateResult.tracked) {
@@ -2288,6 +2435,7 @@ var SubscriptionManager = class SubscriptionManager {
 			unregisterSubscription: (p) => this.unregisterSubscription(p),
 			unregisterSubscriptions: (p) => this.unregisterSubscriptions(p),
 			invalidateWriteset: (p) => this.invalidateWriteset(p),
+			invalidateEphemeral: (p) => this.invalidateEphemeral(p),
 			setRecoveryDriver: () => {},
 			setAffectedHandler: () => {}
 		};
@@ -2330,6 +2478,7 @@ var SubscriptionManager = class SubscriptionManager {
 		wss.register("registerSubscriptionBatch", this.registerSubscriptionBatch.bind(this));
 		wss.register("updateSubscriptionReadSet", this.updateSubscriptionReadSet.bind(this));
 		wss.register("invalidateWriteset", this.invalidateWriteset.bind(this));
+		wss.register("invalidateEphemeral", this.invalidateEphemeral.bind(this));
 		wss.register("unregisterSubscription", this.unregisterSubscription.bind(this));
 		wss.register("unregisterSubscriptions", this.unregisterSubscriptions.bind(this));
 	}
@@ -2387,6 +2536,15 @@ var SubscriptionManager = class SubscriptionManager {
 	async invalidateWriteset(params) {
 		return { affected: (await Promise.all(this.workers.map((w) => w.send(7, params)))).flat() };
 	}
+	/**
+	* Ephemeral-key invalidation. Fans out to every worker exactly like
+	* {@link invalidateWriteset}: subscriptions are routed by hash(subId), which
+	* says nothing about which keys they read, so the holders of a given key can
+	* sit in any slice.
+	*/
+	async invalidateEphemeral(params) {
+		return { affected: (await Promise.all(this.workers.map((w) => w.send(14, params)))).flat() };
+	}
 };
 function resolveWorkerCount(configured) {
 	if (typeof configured === "number" && configured > 0) return Math.floor(configured);
@@ -2403,6 +2561,6 @@ function resolveMaxConnectionsPerWorker(config, workers) {
 	return Math.max(1, Math.floor(total / workers));
 }
 //#endregion
-export { ANONYMOUS_IDENTITY, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, InvalidateWritesetParamsSchema, JobClient, Observability, QStashScheduler, RegisterSubscriptionParamsSchema, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, UnregisterSubscriptionParamsSchema, UpdateSubscriptionReadSetParamsSchema, appInstanceId, bootstrapDbTypes, configureRootLogger, createDatabase, elapsedMs, generateCacheKey, generateSubscriptionId, getHashOf, getRootLogger, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue, startTimer, traceQueryExecution };
+export { ANONYMOUS_IDENTITY, CORE_VERSION, CacheLayer, DB_QUERY_TIMEOUT_MS, DevScheduler, EMPTY_EPHEMERAL_KEYS, EPHEMERAL_DEFAULT_TTL_SECONDS, EphemeralDecodeError, EphemeralFlushError, EphemeralKeyNotFoundError, EphemeralStore, InvalidateEphemeralParamsSchema, InvalidateWritesetParamsSchema, JobClient, Observability, QStashScheduler, RegisterSubscriptionParamsSchema, SubManagerClient, SubscriptionManager, SupaliveWebSocketServer, UnregisterSubscriptionParamsSchema, UpdateSubscriptionReadSetParamsSchema, appInstanceId, bootstrapDbTypes, configureRootLogger, createDatabase, createMemoryEphemeralStore, elapsedMs, generateCacheKey, generateSubscriptionId, getHashOf, getRootLogger, initCacheLayer, initCore, initDatabase, isProduction, logLevelOf, logger, serializeMapValue, startTimer, traceQueryExecution };
 
 //# sourceMappingURL=server.js.map