@rocicorp/zero 1.7.0 → 1.8.0-canary.1

package/out/zero-server/src/adapters/drizzle.d.ts

@@ -1,19 +1,42 @@
-import type { PgDatabase, PgQueryResultHKT, PgTransaction } from 'drizzle-orm/pg-core';
-import type { ExtractTablesWithRelations } from 'drizzle-orm/relations';
 import type { Schema } from '../../../zero-types/src/schema.ts';
 import type { DBConnection, DBTransaction, Row } from '../../../zql/src/mutate/custom.ts';
 import { ZQLDatabase } from '../zql-database.ts';
 export type { ZQLDatabase };
-export type DrizzleDatabase<TQueryResult extends PgQueryResultHKT = PgQueryResultHKT, TSchema extends Record<string, unknown> = Record<string, unknown>> = PgDatabase<TQueryResult, TSchema>;
+type DrizzleSession = {
+    prepareQuery: {
+        length: number;
+    };
+};
+type DrizzleTransactionLike = {
+    _: {
+        session: DrizzleSession;
+    };
+};
+type DrizzleQueryResult<TResult> = PromiseLike<TResult> & {
+    execute(): Promise<TResult>;
+};
+type DrizzleInferSelect<TTable> = TTable extends {
+    $inferSelect: infer TSelect;
+} ? TSelect : Record<string, unknown>;
+type DrizzleTransactionFromSchema<TSchema> = DrizzleTransactionLike & {
+    query: {
+        [TTable in keyof TSchema]: {
+            findFirst(args?: unknown): DrizzleQueryResult<DrizzleInferSelect<TSchema[TTable]> | undefined>;
+        };
+    };
+};
+export type DrizzleDatabase<TTransaction extends DrizzleTransactionLike = DrizzleTransactionLike> = {
+    transaction<T>(transaction: (tx: TTransaction) => Promise<T>, config?: never): Promise<T>;
+};
 /**
  * Helper type for the wrapped transaction used by drizzle-orm.
  *
  * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, DrizzleTransaction<typeof drizzleDb>>`.
  */
-export type DrizzleTransaction<TDbOrSchema extends DrizzleDatabase | Record<string, unknown>, TSchema extends Record<string, unknown> = TDbOrSchema extends PgDatabase<PgQueryResultHKT, infer TInferredSchema> ? TInferredSchema : TDbOrSchema> = PgTransaction<PgQueryResultHKT, TSchema, ExtractTablesWithRelations<TSchema>>;
-export declare class DrizzleConnection<TDrizzle extends DrizzleDatabase, TTransaction extends DrizzleTransaction<TDrizzle> = DrizzleTransaction<TDrizzle>> implements DBConnection<TTransaction> {
+export type DrizzleTransaction<TDbOrSchema = Record<string, unknown>> = TDbOrSchema extends DrizzleDatabase<infer TTransaction> ? TTransaction : DrizzleTransactionFromSchema<TDbOrSchema>;
+export declare class DrizzleConnection<TDrizzle, TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>> implements DBConnection<TTransaction> {
     #private;
-    constructor(drizzle: TDrizzle);
+    constructor(drizzle: TDrizzle & DrizzleDatabase<TTransaction>);
     transaction<T>(fn: (tx: DBTransaction<TTransaction>) => Promise<T>): Promise<T>;
 }
 export declare function toIterableRows(result: unknown): Iterable<Row>;
@@ -55,5 +78,5 @@ export declare function toIterableRows(result: unknown): Iterable<Row>;
  * });
  * ```
  */
-export declare function zeroDrizzle<TSchema extends Schema, TDrizzle extends DrizzleDatabase>(schema: TSchema, client: TDrizzle): ZQLDatabase<TSchema, DrizzleTransaction<TDrizzle>>;
+export declare function zeroDrizzle<TSchema extends Schema, TDrizzle, TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>>(schema: TSchema, client: TDrizzle & DrizzleDatabase<TTransaction>): ZQLDatabase<TSchema, TTransaction>;
 //# sourceMappingURL=drizzle.d.ts.map

package/out/zero-server/src/adapters/drizzle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/drizzle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,aAAa,EACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAC,0BAA0B,EAAC,MAAM,uBAAuB,CAAC;AAGtE,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAE1B,MAAM,MAAM,eAAe,CACzB,YAAY,SAAS,gBAAgB,GAAG,gBAAgB,EACxD,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAC/D,UAAU,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;AAEtC;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAC5B,WAAW,SAAS,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7D,OAAO,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,WAAW,SAAS,UAAU,CACtE,gBAAgB,EAChB,MAAM,eAAe,CACtB,GACG,eAAe,GACf,WAAW,IACb,aAAa,CACf,gBAAgB,EAChB,OAAO,EACP,0BAA0B,CAAC,OAAO,CAAC,CACpC,CAAC;AAEF,qBAAa,iBAAiB,CAC5B,QAAQ,SAAS,eAAe,EAChC,YAAY,SAAS,kBAAkB,CAAC,QAAQ,CAAC,GAC/C,kBAAkB,CAAC,QAAQ,CAAC,CAC9B,YAAW,YAAY,CAAC,YAAY,CAAC;;gBAGzB,OAAO,EAAE,QAAQ;IAI7B,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAClD,OAAO,CAAC,CAAC,CAAC;CASd;AA8CD,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAuB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,WAAW,CACzB,OAAO,SAAS,MAAM,EACtB,QAAQ,SAAS,eAAe,EAEhC,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,QAAQ,GACf,WAAW,CAAC,OAAO,EAAE,kBAAkB,CAAC,QAAQ,CAAC,CAAC,CAKpD"}
+{"version":3,"file":"drizzle.d.ts","sourceRoot":"","sources":["../../../../../zero-server/src/adapters/drizzle.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,mCAAmC,CAAC;AAE9D,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,GAAG,EACJ,MAAM,mCAAmC,CAAC;AAG3C,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAE/C,YAAY,EAAC,WAAW,EAAC,CAAC;AAmB1B,KAAK,cAAc,GAAG;IACpB,YAAY,EAAE;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC;CAChC,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,CAAC,EAAE;QAAC,OAAO,EAAE,cAAc,CAAA;KAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,kBAAkB,CAAC,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,GAAG;IACxD,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;CAC7B,CAAC;AAEF,KAAK,kBAAkB,CAAC,MAAM,IAAI,MAAM,SAAS;IAAC,YAAY,EAAE,MAAM,OAAO,CAAA;CAAC,GAC1E,OAAO,GACP,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE5B,KAAK,4BAA4B,CAAC,OAAO,IAAI,sBAAsB,GAAG;IACpE,KAAK,EAAE;SACJ,MAAM,IAAI,MAAM,OAAO,GAAG;YACzB,SAAS,CACP,IAAI,CAAC,EAAE,OAAO,GACb,kBAAkB,CAAC,kBAAkB,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;SACxE;KACF,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,eAAe,CACzB,YAAY,SAAS,sBAAsB,GAAG,sBAAsB,IAClE;IACF,WAAW,CAAC,CAAC,EACX,WAAW,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,CAAC,CAAC,EAC7C,MAAM,CAAC,EAAE,KAAK,GACb,OAAO,CAAC,CAAC,CAAC,CAAC;CACf,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,CAAC,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAClE,WAAW,SAAS,eAAe,CAAC,MAAM,YAAY,CAAC,GACnD,YAAY,GACZ,4BAA4B,CAAC,WAAW,CAAC,CAAC;AAEhD,qBAAa,iBAAiB,CAC5B,QAAQ,EACR,YAAY,SAAS,sBAAsB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,CAC1E,YAAW,YAAY,CAAC,YAAY,CAAC;;gBAGzB,OAAO,EAAE,QAAQ,GAAG,eAAe,CAAC,YAAY,CAAC;IAI7D,WAAW,CAAC,CAAC,EACX,EAAE,EAAE,CAAC,EAAE,EAAE,aAAa,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,GAClD,OAAO,CAAC,CAAC,CAAC;CASd;AAwDD,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC,GAAG,CAAC,CAuB7D;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,WAAW,CACzB,OAAO,SAAS,MAAM,EACtB,QAAQ,EACR,YAAY,SAAS,sBAAsB,GAAG,kBAAkB,CAAC,QAAQ,CAAC,EAE1E,MAAM,EAAE,OAAO,EACf,MAAM,EAAE,QAAQ,GAAG,eAAe,CAAC,YAAY,CAAC,GAC/C,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,CAKpC"}

package/out/zero-server/src/adapters/drizzle.js

@@ -19,10 +19,12 @@ var DrizzleInternalTransaction = class {
 		return executePostgresQuery(this, ast, format, schema, serverSchema);
 	}
 	async query(sql, params) {
-		return toIterableRows(await this.wrappedTransaction._.session.prepareQuery({
+		const { session } = this.wrappedTransaction._;
+		const query = {
 			sql,
 			params
-		}, void 0, void 0, false).execute());
+		};
+		return toIterableRows(await (session.prepareQuery.length < 7 ? session.prepareQuery(query, "objects", void 0, void 0) : session.prepareQuery(query, void 0, void 0, false)).execute());
 	}
 };
 function isIterable(value) {

package/out/zero-server/src/adapters/drizzle.js.map

@@ -1 +1 @@
-{"version":3,"file":"drizzle.js","names":["#drizzle"],"sources":["../../../../../zero-server/src/adapters/drizzle.ts"],"sourcesContent":["import type {\n  PgDatabase,\n  PgQueryResultHKT,\n  PgTransaction,\n} from 'drizzle-orm/pg-core';\nimport type {ExtractTablesWithRelations} from 'drizzle-orm/relations';\nimport type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\nexport type DrizzleDatabase<\n  TQueryResult extends PgQueryResultHKT = PgQueryResultHKT,\n  TSchema extends Record<string, unknown> = Record<string, unknown>,\n> = PgDatabase<TQueryResult, TSchema>;\n\n/**\n * Helper type for the wrapped transaction used by drizzle-orm.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, DrizzleTransaction<typeof drizzleDb>>`.\n */\nexport type DrizzleTransaction<\n  TDbOrSchema extends DrizzleDatabase | Record<string, unknown>,\n  TSchema extends Record<string, unknown> = TDbOrSchema extends PgDatabase<\n    PgQueryResultHKT,\n    infer TInferredSchema\n  >\n    ? TInferredSchema\n    : TDbOrSchema,\n> = PgTransaction<\n  PgQueryResultHKT,\n  TSchema,\n  ExtractTablesWithRelations<TSchema>\n>;\n\nexport class DrizzleConnection<\n  TDrizzle extends DrizzleDatabase,\n  TTransaction extends DrizzleTransaction<TDrizzle> =\n    DrizzleTransaction<TDrizzle>,\n> implements DBConnection<TTransaction> {\n  readonly #drizzle: TDrizzle;\n\n  constructor(drizzle: TDrizzle) {\n    this.#drizzle = drizzle;\n  }\n\n  transaction<T>(\n    fn: (tx: DBTransaction<TTransaction>) => Promise<T>,\n  ): Promise<T> {\n    return this.#drizzle.transaction(drizzleTx =>\n      fn(\n        new DrizzleInternalTransaction(\n          drizzleTx,\n        ) as DBTransaction<TTransaction>,\n      ),\n    );\n  }\n}\n\nclass DrizzleInternalTransaction<\n  TTransaction extends DrizzleTransaction<DrizzleDatabase>,\n> implements DBTransaction<TTransaction> {\n  readonly wrappedTransaction: TTransaction;\n\n  constructor(drizzleTx: TTransaction) {\n    this.wrappedTransaction = drizzleTx;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  async query(sql: string, params: unknown[]): Promise<Iterable<Row>> {\n    const prepared = this.wrappedTransaction._.session.prepareQuery(\n      {sql, params},\n      undefined,\n      undefined,\n      false,\n    );\n    const result = await prepared.execute();\n    return toIterableRows(result);\n  }\n}\n\nfunction isIterable(value: unknown): value is Iterable<unknown> {\n  return (\n    // oxlint-disable-next-line eqeqeq\n    value != null &&\n    typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function'\n  );\n}\n\nexport function toIterableRows(result: unknown): Iterable<Row> {\n  if (result === null || result === undefined) {\n    return [] as Row[];\n  }\n  if (Array.isArray(result)) {\n    return result as Row[];\n  }\n  if (isIterable(result)) {\n    return result as Iterable<Row>;\n  }\n  if (typeof result === 'object') {\n    const rows = (result as {rows?: unknown}).rows;\n    if (rows === null || rows === undefined) {\n      return [] as Row[];\n    }\n    if (Array.isArray(rows)) {\n      return rows as Row[];\n    }\n    if (isIterable(rows)) {\n      return rows as Iterable<Row>;\n    }\n  }\n  throw new TypeError('Drizzle query result is not iterable');\n}\n\n/**\n * Wrap a `drizzle-orm` database for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying drizzle transaction.\n * Use {@link DrizzleTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Drizzle database.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {drizzle} from 'drizzle-orm/node-postgres';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroDrizzle} from '@rocicorp/zero/server/adapters/drizzle';\n * import {z} from 'zod/mini';\n *\n * const pool = new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!});\n * const drizzleDb = drizzle(pool, {schema: drizzleSchema});\n * const zql = zeroDrizzle(schema, drizzleDb);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction\n *           .insert(drizzleSchema.user)\n *           .values({id: args.id, name: args.name, status: 'active'});\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroDrizzle<\n  TSchema extends Schema,\n  TDrizzle extends DrizzleDatabase,\n>(\n  schema: TSchema,\n  client: TDrizzle,\n): ZQLDatabase<TSchema, DrizzleTransaction<TDrizzle>> {\n  return new ZQLDatabase(\n    new DrizzleConnection<TDrizzle, DrizzleTransaction<TDrizzle>>(client),\n    schema,\n  );\n}\n"],"mappings":";;;AA6CA,IAAa,oBAAb,MAIwC;CACtC;CAEA,YAAY,SAAmB;EAC7B,KAAKA,WAAW;CAClB;CAEA,YACE,IACY;EACZ,OAAO,KAAKA,SAAS,aAAY,cAC/B,GACE,IAAI,2BACF,SACF,CACF,CACF;CACF;AACF;AAEA,IAAM,6BAAN,MAEyC;CACvC;CAEA,YAAY,WAAyB;EACnC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,MAAM,KAAa,QAA2C;EAQlE,OAAO,eAAe,MAPL,KAAK,mBAAmB,EAAE,QAAQ,aACjD;GAAC;GAAK;EAAM,GACZ,KAAA,GACA,KAAA,GACA,KAEmB,EAAS,QAAQ,CACV;CAC9B;AACF;AAEA,SAAS,WAAW,OAA4C;CAC9D,OAEE,SAAS,QACT,OAAQ,MAA4B,OAAO,cAAc;AAE7D;AAEA,SAAgB,eAAe,QAAgC;CAC7D,IAAI,WAAW,QAAQ,WAAW,KAAA,GAChC,OAAO,CAAC;CAEV,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAET,IAAI,WAAW,MAAM,GACnB,OAAO;CAET,IAAI,OAAO,WAAW,UAAU;EAC9B,MAAM,OAAQ,OAA4B;EAC1C,IAAI,SAAS,QAAQ,SAAS,KAAA,GAC5B,OAAO,CAAC;EAEV,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO;EAET,IAAI,WAAW,IAAI,GACjB,OAAO;CAEX;CACA,MAAM,IAAI,UAAU,sCAAsC;AAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,YAId,QACA,QACoD;CACpD,OAAO,IAAI,YACT,IAAI,kBAA0D,MAAM,GACpE,MACF;AACF"}
+{"version":3,"file":"drizzle.js","names":["#drizzle"],"sources":["../../../../../zero-server/src/adapters/drizzle.ts"],"sourcesContent":["import type {AST} from '../../../zero-protocol/src/ast.ts';\nimport type {Format} from '../../../zero-types/src/format.ts';\nimport type {Schema} from '../../../zero-types/src/schema.ts';\nimport type {ServerSchema} from '../../../zero-types/src/server-schema.ts';\nimport type {\n  DBConnection,\n  DBTransaction,\n  Row,\n} from '../../../zql/src/mutate/custom.ts';\nimport type {HumanReadable} from '../../../zql/src/query/query.ts';\nimport {executePostgresQuery} from '../pg-query-executor.ts';\nimport {ZQLDatabase} from '../zql-database.ts';\n\nexport type {ZQLDatabase};\n\ntype DrizzleQuery = {sql: string; params: unknown[]};\ntype DrizzlePreparedQuery = {execute(): Promise<unknown>};\n\ntype DrizzlePrepareQueryV0 = (\n  query: DrizzleQuery,\n  fields: undefined,\n  name: undefined,\n  isResponseInArrayMode: false,\n) => DrizzlePreparedQuery;\n\ntype DrizzlePrepareQueryV1 = (\n  query: DrizzleQuery,\n  mode: 'objects',\n  name: undefined,\n  mapper: undefined,\n) => DrizzlePreparedQuery;\n\ntype DrizzleSession = {\n  prepareQuery: {length: number};\n};\n\ntype DrizzleTransactionLike = {\n  _: {session: DrizzleSession};\n};\n\ntype DrizzleQueryResult<TResult> = PromiseLike<TResult> & {\n  execute(): Promise<TResult>;\n};\n\ntype DrizzleInferSelect<TTable> = TTable extends {$inferSelect: infer TSelect}\n  ? TSelect\n  : Record<string, unknown>;\n\ntype DrizzleTransactionFromSchema<TSchema> = DrizzleTransactionLike & {\n  query: {\n    [TTable in keyof TSchema]: {\n      findFirst(\n        args?: unknown,\n      ): DrizzleQueryResult<DrizzleInferSelect<TSchema[TTable]> | undefined>;\n    };\n  };\n};\n\nexport type DrizzleDatabase<\n  TTransaction extends DrizzleTransactionLike = DrizzleTransactionLike,\n> = {\n  transaction<T>(\n    transaction: (tx: TTransaction) => Promise<T>,\n    config?: never,\n  ): Promise<T>;\n};\n\n/**\n * Helper type for the wrapped transaction used by drizzle-orm.\n *\n * @remarks Use with `ServerTransaction` as `ServerTransaction<Schema, DrizzleTransaction<typeof drizzleDb>>`.\n */\nexport type DrizzleTransaction<TDbOrSchema = Record<string, unknown>> =\n  TDbOrSchema extends DrizzleDatabase<infer TTransaction>\n    ? TTransaction\n    : DrizzleTransactionFromSchema<TDbOrSchema>;\n\nexport class DrizzleConnection<\n  TDrizzle,\n  TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>,\n> implements DBConnection<TTransaction> {\n  readonly #drizzle: DrizzleDatabase<TTransaction>;\n\n  constructor(drizzle: TDrizzle & DrizzleDatabase<TTransaction>) {\n    this.#drizzle = drizzle;\n  }\n\n  transaction<T>(\n    fn: (tx: DBTransaction<TTransaction>) => Promise<T>,\n  ): Promise<T> {\n    return this.#drizzle.transaction(drizzleTx =>\n      fn(\n        new DrizzleInternalTransaction(\n          drizzleTx,\n        ) as DBTransaction<TTransaction>,\n      ),\n    );\n  }\n}\n\nclass DrizzleInternalTransaction<\n  TTransaction extends DrizzleTransactionLike,\n> implements DBTransaction<TTransaction> {\n  readonly wrappedTransaction: TTransaction;\n\n  constructor(drizzleTx: TTransaction) {\n    this.wrappedTransaction = drizzleTx;\n  }\n\n  runQuery<TReturn>(\n    ast: AST,\n    format: Format,\n    schema: Schema,\n    serverSchema: ServerSchema,\n  ): Promise<HumanReadable<TReturn>> {\n    return executePostgresQuery<TReturn>(\n      this,\n      ast,\n      format,\n      schema,\n      serverSchema,\n    );\n  }\n\n  async query(sql: string, params: unknown[]): Promise<Iterable<Row>> {\n    const {session} = this.wrappedTransaction._;\n    const query = {sql, params};\n    const prepared =\n      session.prepareQuery.length < 7\n        ? (session.prepareQuery as DrizzlePrepareQueryV1)(\n            query,\n            'objects',\n            undefined,\n            undefined,\n          )\n        : (session.prepareQuery as DrizzlePrepareQueryV0)(\n            query,\n            undefined,\n            undefined,\n            false,\n          );\n    const result = await prepared.execute();\n    return toIterableRows(result);\n  }\n}\n\nfunction isIterable(value: unknown): value is Iterable<unknown> {\n  return (\n    // oxlint-disable-next-line eqeqeq\n    value != null &&\n    typeof (value as Iterable<unknown>)[Symbol.iterator] === 'function'\n  );\n}\n\nexport function toIterableRows(result: unknown): Iterable<Row> {\n  if (result === null || result === undefined) {\n    return [] as Row[];\n  }\n  if (Array.isArray(result)) {\n    return result as Row[];\n  }\n  if (isIterable(result)) {\n    return result as Iterable<Row>;\n  }\n  if (typeof result === 'object') {\n    const rows = (result as {rows?: unknown}).rows;\n    if (rows === null || rows === undefined) {\n      return [] as Row[];\n    }\n    if (Array.isArray(rows)) {\n      return rows as Row[];\n    }\n    if (isIterable(rows)) {\n      return rows as Iterable<Row>;\n    }\n  }\n  throw new TypeError('Drizzle query result is not iterable');\n}\n\n/**\n * Wrap a `drizzle-orm` database for Zero ZQL.\n *\n * Provides ZQL querying plus access to the underlying drizzle transaction.\n * Use {@link DrizzleTransaction} to type your server mutator transaction.\n *\n * @param schema - Zero schema.\n * @param client - Drizzle database.\n *\n * @example\n * ```ts\n * import {Pool} from 'pg';\n * import {drizzle} from 'drizzle-orm/node-postgres';\n * import {defineMutator, defineMutators} from '@rocicorp/zero';\n * import {zeroDrizzle} from '@rocicorp/zero/server/adapters/drizzle';\n * import {z} from 'zod/mini';\n *\n * const pool = new Pool({connectionString: process.env.ZERO_UPSTREAM_DB!});\n * const drizzleDb = drizzle(pool, {schema: drizzleSchema});\n * const zql = zeroDrizzle(schema, drizzleDb);\n *\n * export const serverMutators = defineMutators({\n *   user: {\n *     create: defineMutator(\n *       z.object({id: z.string(), name: z.string()}),\n *       async ({tx, args}) => {\n *         if (tx.location !== 'server') {\n *           throw new Error('Server-only mutator');\n *         }\n *         await tx.dbTransaction.wrappedTransaction\n *           .insert(drizzleSchema.user)\n *           .values({id: args.id, name: args.name, status: 'active'});\n *       },\n *     ),\n *   },\n * });\n * ```\n */\nexport function zeroDrizzle<\n  TSchema extends Schema,\n  TDrizzle,\n  TTransaction extends DrizzleTransactionLike = DrizzleTransaction<TDrizzle>,\n>(\n  schema: TSchema,\n  client: TDrizzle & DrizzleDatabase<TTransaction>,\n): ZQLDatabase<TSchema, TTransaction> {\n  return new ZQLDatabase(\n    new DrizzleConnection<TDrizzle, TTransaction>(client),\n    schema,\n  );\n}\n"],"mappings":";;;AA6EA,IAAa,oBAAb,MAGwC;CACtC;CAEA,YAAY,SAAmD;EAC7D,KAAKA,WAAW;CAClB;CAEA,YACE,IACY;EACZ,OAAO,KAAKA,SAAS,aAAY,cAC/B,GACE,IAAI,2BACF,SACF,CACF,CACF;CACF;AACF;AAEA,IAAM,6BAAN,MAEyC;CACvC;CAEA,YAAY,WAAyB;EACnC,KAAK,qBAAqB;CAC5B;CAEA,SACE,KACA,QACA,QACA,cACiC;EACjC,OAAO,qBACL,MACA,KACA,QACA,QACA,YACF;CACF;CAEA,MAAM,MAAM,KAAa,QAA2C;EAClE,MAAM,EAAC,YAAW,KAAK,mBAAmB;EAC1C,MAAM,QAAQ;GAAC;GAAK;EAAM;EAgB1B,OAAO,eAAe,OAdpB,QAAQ,aAAa,SAAS,IACzB,QAAQ,aACP,OACA,WACA,KAAA,GACA,KAAA,CACF,IACC,QAAQ,aACP,OACA,KAAA,GACA,KAAA,GACA,KACF,GACwB,QAAQ,CACV;CAC9B;AACF;AAEA,SAAS,WAAW,OAA4C;CAC9D,OAEE,SAAS,QACT,OAAQ,MAA4B,OAAO,cAAc;AAE7D;AAEA,SAAgB,eAAe,QAAgC;CAC7D,IAAI,WAAW,QAAQ,WAAW,KAAA,GAChC,OAAO,CAAC;CAEV,IAAI,MAAM,QAAQ,MAAM,GACtB,OAAO;CAET,IAAI,WAAW,MAAM,GACnB,OAAO;CAET,IAAI,OAAO,WAAW,UAAU;EAC9B,MAAM,OAAQ,OAA4B;EAC1C,IAAI,SAAS,QAAQ,SAAS,KAAA,GAC5B,OAAO,CAAC;EAEV,IAAI,MAAM,QAAQ,IAAI,GACpB,OAAO;EAET,IAAI,WAAW,IAAI,GACjB,OAAO;CAEX;CACA,MAAM,IAAI,UAAU,sCAAsC;AAC5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,SAAgB,YAKd,QACA,QACoC;CACpC,OAAO,IAAI,YACT,IAAI,kBAA0C,MAAM,GACpD,MACF;AACF"}

package/out/zql/src/ivm/memory-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-source.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/memory-source.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memory-source.d.ts","sourceRoot":"","sources":["../../../../../zql/src/ivm/memory-source.ts"],"names":[],"mappings":"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"}

package/out/zql/src/ivm/memory-source.js

@@ -152,6 +152,17 @@ var MemorySource = class MemorySource {
 			else scanStart[key] = dir === "asc" ? minValue : maxValue;
 		} else scanStart = startAt;
 		const rowsIterable = generateRows(data, scanStart, req.reverse);
+		if (!(this.#overlay && conn.lastPushedEpoch >= this.#overlay.epoch) && !req.start && !conn.filters) {
+			const { constraint } = req;
+			for (const row of rowsIterable) {
+				if (constraint && !constraintMatchesRow(constraint, row)) break;
+				yield {
+					row,
+					relationships: {}
+				};
+			}
+			return;
+		}
 		const withConstraint = generateWithConstraint(skipYields(generateWithStart(generateWithOverlay(startAt, pkConstraint ? once(rowsIterable) : rowsIterable, req.constraint, this.#overlay, conn.lastPushedEpoch, indexComparator, conn.filters?.predicate), req.start, connectionComparator)), req.constraint);
 		yield* conn.filters ? generateWithFilter(withConstraint, conn.filters.predicate) : withConstraint;
 	}

package/out/zql/src/ivm/memory-source.js.map

@@ -1 +1 @@
-{"version":3,"file":"memory-source.js","names":["#tableName","#columns","#primaryKey","#primaryIndexSort","#indexes","#connections","#getPrimaryIndex","#fetch","#disconnect","#getSchema","#fetchMulti","#getOrCreateIndex","#overlay","#writeChange","#pushEpoch"],"sources":["../../../../../zql/src/ivm/memory-source.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {BTreeSet} from '../../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport {once, toSorted} from '../../../shared/src/iterables.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  Condition,\n  Ordering,\n  OrderPart,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-types/src/schema-value.ts';\nimport type {DebugDelegate} from '../builder/debug-delegate.ts';\nimport {\n  createPredicate,\n  transformFilters,\n  type NoSubqueryCondition,\n} from '../builder/filter.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {makeAddChange, makeEditChange, makeRemoveChange} from './change.ts';\nimport {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  primaryKeyConstraintFromFilters,\n  type Constraint,\n} from './constraint.ts';\nimport {\n  compareValues,\n  makeComparator,\n  valuesEqual,\n  type Comparator,\n  type Node,\n} from './data.ts';\nimport {filterPush} from './filter-push.ts';\nimport {\n  skipYields,\n  type FetchRequest,\n  type Input,\n  type MultiConstraint,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {SourceChangeIndex} from './source-change-index.ts';\nimport type {\n  Source,\n  SourceChange,\n  SourceChangeAdd,\n  SourceChangeEdit,\n  SourceChangeRemove,\n  SourceInput,\n} from './source.ts';\nimport {makeSourceChangeAdd, makeSourceChangeRemove} from './source.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Overlay = {\n  epoch: number;\n  change: SourceChange;\n};\n\nexport type Overlays = {\n  add: Row | undefined;\n  remove: Row | undefined;\n};\n\ntype Index = {\n  comparator: Comparator;\n  data: BTreeSet<Row>;\n  usedBy: Set<Connection>;\n};\n\nexport type Connection = {\n  input: Input;\n  output: Output | undefined;\n  sort?: Ordering | undefined;\n  splitEditKeys: Set<string> | undefined;\n  compareRows: Comparator;\n  filters:\n    | {\n        condition: NoSubqueryCondition;\n        predicate: (row: Row) => boolean;\n      }\n    | undefined;\n  readonly debug?: DebugDelegate | undefined;\n  lastPushedEpoch: number;\n};\n\n/**\n * A `MemorySource` is a source that provides data to the pipeline from an\n * in-memory data source.\n *\n * This data is kept in sorted order as downstream pipelines will always expect\n * the data they receive from `pull` to be in sorted order.\n */\nexport class MemorySource implements Source {\n  readonly #tableName: string;\n  readonly #columns: Record<string, SchemaValue>;\n  readonly #primaryKey: PrimaryKey;\n  readonly #primaryIndexSort: Ordering;\n  readonly #indexes: Map<string, Index> = new Map();\n  readonly #connections: Connection[] = [];\n\n  #overlay: Overlay | undefined;\n  #pushEpoch = 0;\n\n  constructor(\n    tableName: string,\n    columns: Record<string, SchemaValue>,\n    primaryKey: PrimaryKey,\n    primaryIndexData?: BTreeSet<Row>,\n  ) {\n    this.#tableName = tableName;\n    this.#columns = columns;\n    this.#primaryKey = primaryKey;\n    this.#primaryIndexSort = primaryKey.map(k => [k, 'asc']);\n    const comparator = makeBoundComparator(this.#primaryIndexSort);\n    this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {\n      comparator,\n      data: primaryIndexData ?? new BTreeSet<Row>(comparator),\n      usedBy: new Set(),\n    });\n  }\n\n  get tableSchema() {\n    return {\n      name: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n    };\n  }\n\n  fork() {\n    const primaryIndex = this.#getPrimaryIndex();\n    return new MemorySource(\n      this.#tableName,\n      this.#columns,\n      this.#primaryKey,\n      primaryIndex.data.clone(),\n    );\n  }\n\n  get data(): BTreeSet<Row> {\n    return this.#getPrimaryIndex().data;\n  }\n\n  #getSchema(connection: Connection, unordered: boolean): SourceSchema {\n    return {\n      tableName: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n      sort: unordered ? undefined : connection.sort,\n      system: 'client',\n      relationships: {},\n      isHidden: false,\n      compareRows: connection.compareRows,\n    };\n  }\n\n  connect(\n    sort: Ordering | undefined,\n    filters?: Condition,\n    splitEditKeys?: Set<string>,\n  ): SourceInput {\n    const transformedFilters = transformFilters(filters);\n    const unordered = sort === undefined;\n    const internalSort = sort ?? this.#primaryIndexSort;\n\n    const input: SourceInput = {\n      getSchema: () => schema,\n      fetch: req => this.#fetch(req, connection),\n      setOutput: output => {\n        connection.output = output;\n      },\n      destroy: () => {\n        this.#disconnect(input);\n      },\n      fullyAppliedFilters: !transformedFilters.conditionsRemoved,\n    };\n\n    const connection: Connection = {\n      input,\n      output: undefined,\n      sort: internalSort,\n      splitEditKeys,\n      compareRows: makeComparator(internalSort),\n      filters: transformedFilters.filters\n        ? {\n            condition: transformedFilters.filters,\n            predicate: createPredicate(transformedFilters.filters),\n          }\n        : undefined,\n      lastPushedEpoch: 0,\n    };\n    const schema = this.#getSchema(connection, unordered);\n    if (!unordered) {\n      assertOrderingIncludesPK(internalSort, this.#primaryKey);\n    }\n    this.#connections.push(connection);\n    return input;\n  }\n\n  #disconnect(input: Input): void {\n    const idx = this.#connections.findIndex(c => c.input === input);\n    assert(idx !== -1, 'Connection not found');\n    this.#connections.splice(idx, 1);\n\n    // TODO: We used to delete unused indexes here. But in common cases like\n    // navigating into issue detail pages it caused a ton of constantly\n    // building and destroying indexes.\n    //\n    // Perhaps some intelligent LRU or something is needed here but for now,\n    // the opposite extreme of keeping all indexes for the lifetime of the\n    // page seems better.\n  }\n\n  #getPrimaryIndex(): Index {\n    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));\n    assert(index, 'Primary index not found');\n    return index;\n  }\n\n  #getOrCreateIndex(sort: Ordering, usedBy: Connection): Index {\n    const key = JSON.stringify(sort);\n    const index = this.#indexes.get(key);\n    // Future optimization could use existing index if it's the same just sorted\n    // in reverse of needed.\n    if (index) {\n      index.usedBy.add(usedBy);\n      return index;\n    }\n\n    const comparator = makeBoundComparator(sort);\n\n    // When creating these synchronously becomes a problem, a few options:\n    // 1. Allow users to specify needed indexes up front\n    // 2. Create indexes in a different thread asynchronously (this would require\n    // modifying the BTree to be able to be passed over structured-clone, or using\n    // a different library.)\n    // 3. We could even theoretically do (2) on multiple threads and then merge the\n    // results!\n    const rows = toSorted(this.#getPrimaryIndex().data, comparator);\n    const data = BTreeSet.fromSorted(comparator, rows);\n\n    const newIndex = {comparator, data, usedBy: new Set([usedBy])};\n    this.#indexes.set(key, newIndex);\n    return newIndex;\n  }\n\n  // For unit testing that we correctly clean up indexes.\n  getIndexKeys(): string[] {\n    return [...this.#indexes.keys()];\n  }\n\n  *#fetch(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // multiConstraints is handled by driving sub-fetches off the first\n    // entry's values and post-filtering matches against any remaining\n    // entries. TableSource implements multi-IN natively via SQL `AND` of\n    // `IN` clauses; the in-memory path is correct but not specially\n    // optimized — it pays the index-seek cost per primary value, then\n    // walks each result against the rest.\n    if (\n      req.multiConstraints &&\n      req.multiConstraints.some(mc => mc.length > 0)\n    ) {\n      yield* this.#fetchMulti(req, conn);\n      return;\n    }\n    const requestedSort = must(conn.sort);\n    const {compareRows} = conn;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const connectionComparator: Comparator = req.reverse\n      ? (r1, r2) => compareRows(r2, r1)\n      : compareRows;\n\n    const pkConstraint = primaryKeyConstraintFromFilters(\n      conn.filters?.condition,\n      this.#primaryKey,\n    );\n    // The primary key constraint will be more limiting than the constraint\n    // so swap out to that if it exists.\n    const fetchOrPkConstraint = pkConstraint ?? req.constraint;\n\n    // If there is a constraint, we need an index sorted by it first.\n    const indexSort: OrderPart[] = [];\n    if (fetchOrPkConstraint) {\n      for (const key of Object.keys(fetchOrPkConstraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n\n    // For the special case of constraining by PK, we don't need to worry about\n    // any requested sort since there can only be one result. Otherwise we also\n    // need the index sorted by the requested sort.\n    if (\n      this.#primaryKey.length > 1 ||\n      !fetchOrPkConstraint ||\n      !constraintMatchesPrimaryKey(fetchOrPkConstraint, this.#primaryKey)\n    ) {\n      indexSort.push(...requestedSort);\n    }\n\n    const index = this.#getOrCreateIndex(indexSort, conn);\n    const {data, comparator: compare} = index;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const indexComparator: Comparator = req.reverse\n      ? (r1, r2) => compare(r2, r1)\n      : compare;\n\n    const startAt = req.start?.row;\n\n    // If there is a constraint, we want to start our scan at the first row that\n    // matches the constraint. But because the next OrderPart can be `desc`,\n    // it's not true that {[constraintKey]: constraintValue} is the first\n    // matching row. Because in that case, the other fields will all be\n    // `undefined`, and in Zero `undefined` is always less than any other value.\n    // So if the second OrderPart is descending then `undefined` values will\n    // actually be the *last* row. We need a way to stay \"start at the first row\n    // with this constraint value\". RowBound with the corresponding compareBound\n    // comparator accomplishes this. The right thing is probably to teach the\n    // btree library to support this concept.\n    let scanStart: RowBound | undefined;\n\n    if (fetchOrPkConstraint) {\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(fetchOrPkConstraint, key)) {\n          scanStart[key] = fetchOrPkConstraint[key];\n        } else {\n          if (req.reverse) {\n            scanStart[key] = dir === 'asc' ? maxValue : minValue;\n          } else {\n            scanStart[key] = dir === 'asc' ? minValue : maxValue;\n          }\n        }\n      }\n    } else {\n      scanStart = startAt;\n    }\n\n    const rowsIterable = generateRows(data, scanStart, req.reverse);\n    const withOverlay = generateWithOverlay(\n      startAt,\n      pkConstraint ? once(rowsIterable) : rowsIterable,\n      // use `req.constraint` here and not `fetchOrPkConstraint` since `fetchOrPkConstraint` could be the\n      // primary key constraint. The primary key constraint comes from filters and is acting as a filter\n      // rather than as the fetch constraint.\n      req.constraint,\n      this.#overlay,\n      conn.lastPushedEpoch,\n      // Use indexComparator, generateWithOverlayInner has a subtle dependency\n      // on this.  Since generateWithConstraint is done after\n      // generateWithOverlay, the generator consumed by generateWithOverlayInner\n      // does not end when the constraint stops matching and so the final\n      // check to yield an add overlay if not yet yielded is not reached.\n      // However, using the indexComparator the add overlay will be less than\n      // the first row that does not match the constraint, and so any\n      // not yet yielded add overlay will be yielded when the first row\n      // not matching the constraint is reached.\n      indexComparator,\n      conn.filters?.predicate,\n    );\n\n    const withConstraint = generateWithConstraint(\n      skipYields(\n        generateWithStart(withOverlay, req.start, connectionComparator),\n      ),\n      // we use `req.constraint` and not `fetchOrPkConstraint` here because we need to\n      // AND the constraint with what could have been the primary key constraint\n      req.constraint,\n    );\n\n    yield* conn.filters\n      ? generateWithFilter(withConstraint, conn.filters.predicate)\n      : withConstraint;\n  }\n\n  *#fetchMulti(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // Caller (`#fetch`) guards entry on `req.multiConstraints.some(mc =>\n    // mc.length > 0)`, so `multis` is guaranteed non-empty after the\n    // empty-entry filter. Per the MultiConstraint contract (operator.ts),\n    // entries are non-empty, share key shape, are unique, and are\n    // key-compatible with `req.constraint`.\n    const multis = must(req.multiConstraints).filter(mc => mc.length > 0);\n    const primary = multis[0];\n    const rest = multis.slice(1);\n    const baseConstraint = req.constraint;\n\n    // Drive sub-fetches off `primary`. Within each sub-fetch the source\n    // can use its index for `primary`; we then post-filter rows by\n    // checking they also match every entry in `rest`. Per the\n    // MultiConstraint contract (see operator.ts), entries are unique and\n    // key-compatible with `baseConstraint`, so we don't dedupe or check\n    // compatibility here.\n    const subStreams: Stream<Node | 'yield'>[] = primary.map(c => {\n      const merged: Constraint = baseConstraint ? {...baseConstraint, ...c} : c;\n      return this.#fetch(\n        {...req, constraint: merged, multiConstraints: undefined},\n        conn,\n      );\n    });\n    const merged = mergeSortedStreams(\n      subStreams,\n      req.reverse\n        ? (a, b) => conn.compareRows(b.row, a.row)\n        : (a, b) => conn.compareRows(a.row, b.row),\n    );\n\n    if (rest.length === 0) {\n      yield* merged;\n      return;\n    }\n\n    for (const node of merged) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      let matchesAll = true;\n      for (const mc of rest) {\n        let any = false;\n        for (const c of mc) {\n          if (constraintMatchesRow(c, node.row)) {\n            any = true;\n            break;\n          }\n        }\n        if (!any) {\n          matchesAll = false;\n          break;\n        }\n      }\n      if (matchesAll) yield node;\n    }\n  }\n\n  *push(change: SourceChange): Stream<'yield'> {\n    for (const result of this.genPush(change)) {\n      if (result === 'yield') {\n        yield result;\n      }\n    }\n  }\n\n  *genPush(change: SourceChange) {\n    const primaryIndex = this.#getPrimaryIndex();\n    const {data} = primaryIndex;\n    const exists = (row: Row) => data.has(row);\n    const setOverlay = (o: Overlay | undefined) => (this.#overlay = o);\n    const writeChange = (c: SourceChange) => this.#writeChange(c);\n    yield* genPushAndWriteWithSplitEdit(\n      this.#connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      () => ++this.#pushEpoch,\n    );\n  }\n\n  #writeChange(change: SourceChange) {\n    for (const {data} of this.#indexes.values()) {\n      switch (change[SourceChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          const added = data.add(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            added,\n            'MemorySource: add must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.REMOVE: {\n          const removed = data.delete(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: remove must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.EDIT: {\n          // TODO: We could see if the PK (form the index tree's perspective)\n          // changed and if not we could use set.\n          // We cannot just do `set` with the new value since the `oldRow` might\n          // not map to the same entry as the new `row` in the index btree.\n          const removed = data.delete(change[SourceChangeIndex.OLD_ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: edit remove must succeed since row existence was already checked',\n          );\n          data.add(change[SourceChangeIndex.ROW]);\n          break;\n        }\n        default:\n          unreachable(change);\n      }\n    }\n  }\n}\n\nfunction* generateWithConstraint(\n  it: Stream<Node>,\n  constraint: Constraint | undefined,\n) {\n  for (const node of it) {\n    if (constraint && !constraintMatchesRow(constraint, node.row)) {\n      break;\n    }\n    yield node;\n  }\n}\n\nfunction* generateWithFilter(it: Stream<Node>, filter: (row: Row) => boolean) {\n  for (const node of it) {\n    if (filter(node.row)) {\n      yield node;\n    }\n  }\n}\n\nexport function* genPushAndWriteWithSplitEdit(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: (row: Row) => boolean,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  getNextEpoch: () => number,\n) {\n  let shouldSplitEdit = false;\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT) {\n    for (const {splitEditKeys} of connections) {\n      if (splitEditKeys) {\n        for (const key of splitEditKeys) {\n          if (\n            !valuesEqual(\n              change[SourceChangeIndex.ROW][key],\n              change[SourceChangeIndex.OLD_ROW][key],\n            )\n          ) {\n            shouldSplitEdit = true;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT && shouldSplitEdit) {\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeRemove(change[SourceChangeIndex.OLD_ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeAdd(change[SourceChangeIndex.ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  } else {\n    yield* genPushAndWrite(\n      connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  }\n}\n\nfunction* genPushAndWrite(\n  connections: readonly Connection[],\n  change: SourceChangeAdd | SourceChangeRemove | SourceChangeEdit,\n  exists: (row: Row) => boolean,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  pushEpoch: number,\n) {\n  for (const x of genPush(connections, change, exists, setOverlay, pushEpoch)) {\n    yield x;\n  }\n  writeChange(change);\n}\n\nfunction* genPush(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: (row: Row) => boolean,\n  setOverlay: (o: Overlay | undefined) => void,\n  pushEpoch: number,\n) {\n  switch (change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      assert(\n        !exists(change[SourceChangeIndex.ROW]),\n        () => `Row already exists ${stringify(change)}`,\n      );\n      break;\n    case ChangeType.REMOVE:\n      assert(\n        exists(change[SourceChangeIndex.ROW]),\n        () => `Row not found ${stringify(change)}`,\n      );\n      break;\n    case ChangeType.EDIT:\n      assert(\n        exists(change[SourceChangeIndex.OLD_ROW]),\n        () => `Row not found ${stringify(change)}`,\n      );\n      break;\n    default:\n      unreachable(change);\n  }\n\n  for (const conn of connections) {\n    const {output, filters, input} = conn;\n    if (output) {\n      conn.lastPushedEpoch = pushEpoch;\n      setOverlay({epoch: pushEpoch, change});\n      const outputChange: Change =\n        change[SourceChangeIndex.TYPE] === ChangeType.EDIT\n          ? makeEditChange(\n              {row: change[SourceChangeIndex.ROW], relationships: {}},\n              {row: change[SourceChangeIndex.OLD_ROW], relationships: {}},\n            )\n          : change[SourceChangeIndex.TYPE] === ChangeType.ADD\n            ? makeAddChange({\n                row: change[SourceChangeIndex.ROW],\n                relationships: {},\n              })\n            : makeRemoveChange({\n                row: change[SourceChangeIndex.ROW],\n                relationships: {},\n              });\n      yield* filterPush(outputChange, output, input, filters?.predicate);\n      yield undefined;\n    }\n  }\n\n  setOverlay(undefined);\n}\n\nexport function* generateWithStart(\n  nodes: Iterable<Node | 'yield'>,\n  start: Start | undefined,\n  compare: (r1: Row, r2: Row) => number,\n): Stream<Node | 'yield'> {\n  if (!start) {\n    yield* nodes;\n    return;\n  }\n  let started = false;\n  for (const node of nodes) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!started) {\n      if (start.basis === 'at') {\n        if (compare(node.row, start.row) >= 0) {\n          started = true;\n        }\n      } else if (start.basis === 'after') {\n        if (compare(node.row, start.row) > 0) {\n          started = true;\n        }\n      }\n    }\n    if (started) {\n      yield node;\n    }\n  }\n}\n\n/**\n * Takes an iterator and overlay.\n * Splices the overlay into the iterator at the correct position.\n *\n * @param startAt - if there is a lower bound to the stream. If the lower bound of the stream\n * is above the overlay, the overlay will be skipped.\n * @param rows - the stream into which the overlay should be spliced\n * @param constraint - constraint that was applied to the rowIterator and should\n * also be applied to the overlay.\n * @param overlay - the overlay values to splice in\n * @param compare - the comparator to use to find the position for the overlay\n */\nexport function* generateWithOverlay(\n  startAt: Row | undefined,\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  compare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  const overlays = computeOverlays(\n    startAt,\n    constraint,\n    overlayToApply,\n    compare,\n    filterPredicate,\n    multiConstraints,\n  );\n  yield* generateWithOverlayInner(rows, overlays, compare);\n}\n\nfunction computeOverlays(\n  startAt: Row | undefined,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  compare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\n): Overlays {\n  let overlays: Overlays = {\n    add: undefined,\n    remove: undefined,\n  };\n  switch (overlay?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlay.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: overlay.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n\n  if (startAt) {\n    overlays = overlaysForStartAt(overlays, startAt, compare);\n  }\n\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n\n  return overlays;\n}\n\nfunction applyMultiConstraintsToOverlays(\n  overlays: Overlays,\n  multiConstraints: readonly MultiConstraint[] | undefined,\n): Overlays {\n  if (!multiConstraints) return overlays;\n  for (const mc of multiConstraints) {\n    if (mc.length > 0) {\n      overlays = overlaysForMultiConstraint(overlays, mc);\n    }\n  }\n  return overlays;\n}\n\nexport {overlaysForMultiConstraint as overlaysForMultiConstraintForTest};\n\nfunction overlaysForMultiConstraint(\n  {add, remove}: Overlays,\n  multiConstraint: MultiConstraint,\n): Overlays {\n  const matchesAny = (row: Row | undefined) => {\n    if (row === undefined) return false;\n    for (const c of multiConstraint) {\n      if (constraintMatchesRow(c, row)) return true;\n    }\n    return false;\n  };\n  return {\n    add: matchesAny(add) ? add : undefined,\n    remove: matchesAny(remove) ? remove : undefined,\n  };\n}\n\nexport {overlaysForStartAt as overlaysForStartAtForTest};\n\nfunction overlaysForStartAt(\n  {add, remove}: Overlays,\n  startAt: Row,\n  compare: Comparator,\n): Overlays {\n  const undefinedIfBeforeStartAt = (row: Row | undefined) =>\n    row === undefined || compare(row, startAt) < 0 ? undefined : row;\n  return {\n    add: undefinedIfBeforeStartAt(add),\n    remove: undefinedIfBeforeStartAt(remove),\n  };\n}\n\nexport {overlaysForConstraint as overlaysForConstraintForTest};\n\nfunction overlaysForConstraint(\n  {add, remove}: Overlays,\n  constraint: Constraint,\n): Overlays {\n  const undefinedIfDoesntMatchConstraint = (row: Row | undefined) =>\n    row === undefined || !constraintMatchesRow(constraint, row)\n      ? undefined\n      : row;\n\n  return {\n    add: undefinedIfDoesntMatchConstraint(add),\n    remove: undefinedIfDoesntMatchConstraint(remove),\n  };\n}\n\nfunction overlaysForFilterPredicate(\n  {add, remove}: Overlays,\n  filterPredicate: (row: Row) => boolean | undefined,\n): Overlays {\n  const undefinedIfDoesntMatchFilter = (row: Row | undefined) =>\n    row === undefined || !filterPredicate(row) ? undefined : row;\n\n  return {\n    add: undefinedIfDoesntMatchFilter(add),\n    remove: undefinedIfDoesntMatchFilter(remove),\n  };\n}\n\nexport function* generateWithOverlayInner(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  compare: (r1: Row, r2: Row) => number,\n) {\n  let addOverlayYielded = false;\n  let removeOverlaySkipped = false;\n  for (const row of rowIterator) {\n    if (!addOverlayYielded && overlays.add) {\n      const cmp = compare(overlays.add, row);\n      if (cmp < 0) {\n        addOverlayYielded = true;\n        yield {row: overlays.add, relationships: {}};\n      }\n    }\n\n    if (!removeOverlaySkipped && overlays.remove) {\n      const cmp = compare(overlays.remove, row);\n      if (cmp === 0) {\n        removeOverlaySkipped = true;\n        continue;\n      }\n    }\n    yield {row, relationships: {}};\n  }\n\n  if (!addOverlayYielded && overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n}\n\n/**\n * Like {@link generateWithOverlay} but for unordered streams.\n * No `startAt` or comparator needed. Injects remove/old-edit rows eagerly\n * at the start, and suppresses add/new-edit rows inline by PK match.\n */\nexport function* generateWithOverlayUnordered(\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  primaryKey: PrimaryKey,\n  filterPredicate?: (row: Row) => boolean,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  let overlays: Overlays = {add: undefined, remove: undefined};\n  switch (overlayToApply?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlayToApply.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: overlayToApply.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n  yield* generateWithOverlayInnerUnordered(rows, overlays, primaryKey);\n}\n\nexport function* generateWithOverlayInnerUnordered(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  primaryKey: PrimaryKey,\n) {\n  // Eager inject: yield the add overlay at the start (row not yet in storage)\n  if (overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n  // Stream with inline suppress: skip the remove overlay (row still in storage)\n  let removeSkipped = false;\n  for (const row of rowIterator) {\n    if (\n      !removeSkipped &&\n      overlays.remove &&\n      rowMatchesPK(overlays.remove, row, primaryKey)\n    ) {\n      removeSkipped = true;\n      continue;\n    }\n    yield {row, relationships: {}};\n  }\n}\n\nfunction rowMatchesPK(a: Row, b: Row, primaryKey: PrimaryKey): boolean {\n  for (const key of primaryKey) {\n    if (!valuesEqual(a[key], b[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * A location to begin scanning an index from. Can either be a specific value\n * or the min or max possible value for the type. This is used to start a scan\n * at the beginning of the rows matching a constraint.\n */\ntype Bound = Value | MinValue | MaxValue;\ntype RowBound = Record<string, Bound>;\nconst minValue = Symbol('min-value');\ntype MinValue = typeof minValue;\nconst maxValue = Symbol('max-value');\ntype MaxValue = typeof maxValue;\n\nfunction makeBoundComparator(sort: Ordering): Comparator {\n  // Pre-extract the first two keys/directions to avoid per-call array access.\n  // All paths share one function literal (single SFI) so the BTree comparator call site\n  // stays monomorphic across indexes with different sort orderings, preventing V8 IC deopt.\n  // Even a 2-SFI split (e.g. separate len=1 path) creates a polymorphic IC that\n  // measurably regresses performance, so we keep a single return body.\n  const len = sort.length;\n  const k0 = sort[0][0];\n  const a0 = sort[0][1] === 'asc';\n  const k1 = len > 1 ? sort[1][0] : '';\n  const a1 = len > 1 ? sort[1][1] === 'asc' : true;\n\n  return (a: RowBound, b: RowBound) => {\n    const c0 = a0 ? compareBounds(a[k0], b[k0]) : compareBounds(b[k0], a[k0]);\n    if (len === 1 || c0 !== 0) return c0;\n    const c1 = a1 ? compareBounds(a[k1], b[k1]) : compareBounds(b[k1], a[k1]);\n    if (len === 2 || c1 !== 0) return c1;\n    // Hot! Do not use destructuring\n    for (let i = 2; i < len; i++) {\n      const cmp = compareBounds(a[sort[i][0]], b[sort[i][0]]);\n      if (cmp !== 0) return sort[i][1] === 'asc' ? cmp : -cmp;\n    }\n    return 0;\n  };\n}\n\nfunction compareBounds(a: Bound, b: Bound): number {\n  if (a === b) {\n    return 0;\n  }\n  // Use typeof to guard the Symbol sentinel checks first. This gives V8 a\n  // clear type discriminant so the common non-symbol path compiles as a\n  // specialised numeric/string fast-path without a Smi deopt when the\n  // minValue/maxValue sentinel symbols appear.\n  if (typeof a === 'symbol') {\n    return a === minValue ? -1 : 1;\n  }\n  if (typeof b === 'symbol') {\n    return b === minValue ? 1 : -1;\n  }\n  return compareValues(a, b);\n}\n\nfunction* generateRows(\n  data: BTreeSet<Row>,\n  scanStart: RowBound | undefined,\n  reverse: boolean | undefined,\n) {\n  yield* data[reverse ? 'valuesFromReversed' : 'valuesFrom'](\n    scanStart as Row | undefined,\n  );\n}\n\nexport function stringify(change: SourceChange) {\n  return JSON.stringify(change, (_, v) =>\n    typeof v === 'bigint' ? v.toString() : v,\n  );\n}\n\n/**\n * N-way merge of pre-sorted Node streams. Each input stream must yield\n * Nodes in `compare` order (and may interleave 'yield' values, which are\n * forwarded as-is). The merged stream yields Nodes in `compare` order.\n *\n * Implemented as a binary min-heap keyed by `compare(entry.row, ...)`, so\n * each emit costs O(log K) (K = number of streams) rather than the O(K)\n * a linear-scan-of-heads merge would. Matters when FlippedJoin chunks a\n * large `multiConstraints` IN-list into hundreds of sub-fetches.\n *\n * If the merged stream is closed early (e.g. downstream `Take` `break`s\n * after hitting its limit, prompting JS to call `.return()` on this\n * generator), the `finally` block propagates `.return()` to each\n * non-exhausted sub-iterator so the underlying sources (SQLite cursors,\n * etc.) can run their cleanup. Without this, mid-merge early-termination\n * leaves cursors open, causing later writes on the same connection to\n * fail with \"database connection is busy executing a query\".\n */\nexport function* mergeSortedStreams(\n  streams: readonly Stream<Node | 'yield'>[],\n  compare: (a: Node, b: Node) => number,\n): Stream<Node | 'yield'> {\n  const iterators: Iterator<Node | 'yield'>[] = streams.map(s =>\n    s[Symbol.iterator](),\n  );\n  // True while iterators[i] hasn't yet returned `done`. The finally\n  // block uses this to skip already-exhausted streams when propagating\n  // `.return()`.\n  const active: boolean[] = new Array(iterators.length).fill(true);\n\n  // Min-heap of entries; `idx` tells us which stream to refill from\n  // after the entry's row is emitted.\n  type Entry = {row: Node; idx: number};\n  const heap: Entry[] = [];\n\n  const siftUp = (start: number) => {\n    let i = start;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (compare(heap[i].row, heap[p].row) >= 0) return;\n      const t = heap[i];\n      heap[i] = heap[p];\n      heap[p] = t;\n      i = p;\n    }\n  };\n\n  const siftDown = (start: number) => {\n    let i = start;\n    const n = heap.length;\n    while (true) {\n      const l = (i << 1) + 1;\n      const r = l + 1;\n      let smallest = i;\n      if (l < n && compare(heap[l].row, heap[smallest].row) < 0) smallest = l;\n      if (r < n && compare(heap[r].row, heap[smallest].row) < 0) smallest = r;\n      if (smallest === i) return;\n      const t = heap[i];\n      heap[i] = heap[smallest];\n      heap[smallest] = t;\n      i = smallest;\n    }\n  };\n\n  // Pull the next Node from iterator `idx`, forwarding any 'yield's.\n  // Returns the Node, or `undefined` once the stream is exhausted.\n  const pullNext = function* (\n    idx: number,\n  ): Generator<'yield', Node | undefined, undefined> {\n    while (true) {\n      const r = iterators[idx].next();\n      if (r.done) {\n        active[idx] = false;\n        return undefined;\n      }\n      if (r.value === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      return r.value;\n    }\n  };\n\n  try {\n    // Prime: push the first row of each non-empty stream onto the heap.\n    for (let i = 0; i < iterators.length; i++) {\n      const row = yield* pullNext(i);\n      if (row !== undefined) {\n        heap.push({row, idx: i});\n        siftUp(heap.length - 1);\n      }\n    }\n\n    while (heap.length > 0) {\n      // Root is the global min across all active streams.\n      const top = heap[0];\n      yield top.row;\n      const next = yield* pullNext(top.idx);\n      if (next !== undefined) {\n        // Refill root in place (top === heap[0]) and sift down. The\n        // already-yielded `top.row` value is captured by the yield, so\n        // mutating it here doesn't affect what was emitted.\n        top.row = next;\n        siftDown(0);\n      } else {\n        // Stream exhausted. Move tail to root and shrink. Pop returns\n        // the last entry; if the heap had only one entry it was the\n        // root we just yielded, so we just leave the heap empty.\n        const last = must(heap.pop());\n        if (heap.length > 0) {\n          heap[0] = last;\n          siftDown(0);\n        }\n      }\n    }\n  } finally {\n    // Close any iterators that aren't already exhausted so their\n    // `finally` blocks (which release cursors / cached statements) run.\n    for (let i = 0; i < iterators.length; i++) {\n      if (active[i]) {\n        iterators[i].return?.();\n      }\n    }\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"memory-source.js","names":["#tableName","#columns","#primaryKey","#primaryIndexSort","#indexes","#connections","#getPrimaryIndex","#fetch","#disconnect","#getSchema","#fetchMulti","#getOrCreateIndex","#overlay","#writeChange","#pushEpoch"],"sources":["../../../../../zql/src/ivm/memory-source.ts"],"sourcesContent":["import {assert, unreachable} from '../../../shared/src/asserts.ts';\nimport {BTreeSet} from '../../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../../shared/src/has-own.ts';\nimport {once, toSorted} from '../../../shared/src/iterables.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport type {\n  Condition,\n  Ordering,\n  OrderPart,\n} from '../../../zero-protocol/src/ast.ts';\nimport type {Row, Value} from '../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../zero-protocol/src/primary-key.ts';\nimport type {SchemaValue} from '../../../zero-types/src/schema-value.ts';\nimport type {DebugDelegate} from '../builder/debug-delegate.ts';\nimport {\n  createPredicate,\n  transformFilters,\n  type NoSubqueryCondition,\n} from '../builder/filter.ts';\nimport {assertOrderingIncludesPK} from '../query/complete-ordering.ts';\nimport {ChangeType} from './change-type.ts';\nimport type {Change} from './change.ts';\nimport {makeAddChange, makeEditChange, makeRemoveChange} from './change.ts';\nimport {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  primaryKeyConstraintFromFilters,\n  type Constraint,\n} from './constraint.ts';\nimport {\n  compareValues,\n  makeComparator,\n  valuesEqual,\n  type Comparator,\n  type Node,\n} from './data.ts';\nimport {filterPush} from './filter-push.ts';\nimport {\n  skipYields,\n  type FetchRequest,\n  type Input,\n  type MultiConstraint,\n  type Output,\n  type Start,\n} from './operator.ts';\nimport type {SourceSchema} from './schema.ts';\nimport {SourceChangeIndex} from './source-change-index.ts';\nimport type {\n  Source,\n  SourceChange,\n  SourceChangeAdd,\n  SourceChangeEdit,\n  SourceChangeRemove,\n  SourceInput,\n} from './source.ts';\nimport {makeSourceChangeAdd, makeSourceChangeRemove} from './source.ts';\nimport type {Stream} from './stream.ts';\n\nexport type Overlay = {\n  epoch: number;\n  change: SourceChange;\n};\n\nexport type Overlays = {\n  add: Row | undefined;\n  remove: Row | undefined;\n};\n\ntype Index = {\n  comparator: Comparator;\n  data: BTreeSet<Row>;\n  usedBy: Set<Connection>;\n};\n\nexport type Connection = {\n  input: Input;\n  output: Output | undefined;\n  sort?: Ordering | undefined;\n  splitEditKeys: Set<string> | undefined;\n  compareRows: Comparator;\n  filters:\n    | {\n        condition: NoSubqueryCondition;\n        predicate: (row: Row) => boolean;\n      }\n    | undefined;\n  readonly debug?: DebugDelegate | undefined;\n  lastPushedEpoch: number;\n};\n\n/**\n * A `MemorySource` is a source that provides data to the pipeline from an\n * in-memory data source.\n *\n * This data is kept in sorted order as downstream pipelines will always expect\n * the data they receive from `pull` to be in sorted order.\n */\nexport class MemorySource implements Source {\n  readonly #tableName: string;\n  readonly #columns: Record<string, SchemaValue>;\n  readonly #primaryKey: PrimaryKey;\n  readonly #primaryIndexSort: Ordering;\n  readonly #indexes: Map<string, Index> = new Map();\n  readonly #connections: Connection[] = [];\n\n  #overlay: Overlay | undefined;\n  #pushEpoch = 0;\n\n  constructor(\n    tableName: string,\n    columns: Record<string, SchemaValue>,\n    primaryKey: PrimaryKey,\n    primaryIndexData?: BTreeSet<Row>,\n  ) {\n    this.#tableName = tableName;\n    this.#columns = columns;\n    this.#primaryKey = primaryKey;\n    this.#primaryIndexSort = primaryKey.map(k => [k, 'asc']);\n    const comparator = makeBoundComparator(this.#primaryIndexSort);\n    this.#indexes.set(JSON.stringify(this.#primaryIndexSort), {\n      comparator,\n      data: primaryIndexData ?? new BTreeSet<Row>(comparator),\n      usedBy: new Set(),\n    });\n  }\n\n  get tableSchema() {\n    return {\n      name: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n    };\n  }\n\n  fork() {\n    const primaryIndex = this.#getPrimaryIndex();\n    return new MemorySource(\n      this.#tableName,\n      this.#columns,\n      this.#primaryKey,\n      primaryIndex.data.clone(),\n    );\n  }\n\n  get data(): BTreeSet<Row> {\n    return this.#getPrimaryIndex().data;\n  }\n\n  #getSchema(connection: Connection, unordered: boolean): SourceSchema {\n    return {\n      tableName: this.#tableName,\n      columns: this.#columns,\n      primaryKey: this.#primaryKey,\n      sort: unordered ? undefined : connection.sort,\n      system: 'client',\n      relationships: {},\n      isHidden: false,\n      compareRows: connection.compareRows,\n    };\n  }\n\n  connect(\n    sort: Ordering | undefined,\n    filters?: Condition,\n    splitEditKeys?: Set<string>,\n  ): SourceInput {\n    const transformedFilters = transformFilters(filters);\n    const unordered = sort === undefined;\n    const internalSort = sort ?? this.#primaryIndexSort;\n\n    const input: SourceInput = {\n      getSchema: () => schema,\n      fetch: req => this.#fetch(req, connection),\n      setOutput: output => {\n        connection.output = output;\n      },\n      destroy: () => {\n        this.#disconnect(input);\n      },\n      fullyAppliedFilters: !transformedFilters.conditionsRemoved,\n    };\n\n    const connection: Connection = {\n      input,\n      output: undefined,\n      sort: internalSort,\n      splitEditKeys,\n      compareRows: makeComparator(internalSort),\n      filters: transformedFilters.filters\n        ? {\n            condition: transformedFilters.filters,\n            predicate: createPredicate(transformedFilters.filters),\n          }\n        : undefined,\n      lastPushedEpoch: 0,\n    };\n    const schema = this.#getSchema(connection, unordered);\n    if (!unordered) {\n      assertOrderingIncludesPK(internalSort, this.#primaryKey);\n    }\n    this.#connections.push(connection);\n    return input;\n  }\n\n  #disconnect(input: Input): void {\n    const idx = this.#connections.findIndex(c => c.input === input);\n    assert(idx !== -1, 'Connection not found');\n    this.#connections.splice(idx, 1);\n\n    // TODO: We used to delete unused indexes here. But in common cases like\n    // navigating into issue detail pages it caused a ton of constantly\n    // building and destroying indexes.\n    //\n    // Perhaps some intelligent LRU or something is needed here but for now,\n    // the opposite extreme of keeping all indexes for the lifetime of the\n    // page seems better.\n  }\n\n  #getPrimaryIndex(): Index {\n    const index = this.#indexes.get(JSON.stringify(this.#primaryIndexSort));\n    assert(index, 'Primary index not found');\n    return index;\n  }\n\n  #getOrCreateIndex(sort: Ordering, usedBy: Connection): Index {\n    const key = JSON.stringify(sort);\n    const index = this.#indexes.get(key);\n    // Future optimization could use existing index if it's the same just sorted\n    // in reverse of needed.\n    if (index) {\n      index.usedBy.add(usedBy);\n      return index;\n    }\n\n    const comparator = makeBoundComparator(sort);\n\n    // When creating these synchronously becomes a problem, a few options:\n    // 1. Allow users to specify needed indexes up front\n    // 2. Create indexes in a different thread asynchronously (this would require\n    // modifying the BTree to be able to be passed over structured-clone, or using\n    // a different library.)\n    // 3. We could even theoretically do (2) on multiple threads and then merge the\n    // results!\n    const rows = toSorted(this.#getPrimaryIndex().data, comparator);\n    const data = BTreeSet.fromSorted(comparator, rows);\n\n    const newIndex = {comparator, data, usedBy: new Set([usedBy])};\n    this.#indexes.set(key, newIndex);\n    return newIndex;\n  }\n\n  // For unit testing that we correctly clean up indexes.\n  getIndexKeys(): string[] {\n    return [...this.#indexes.keys()];\n  }\n\n  *#fetch(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // multiConstraints is handled by driving sub-fetches off the first\n    // entry's values and post-filtering matches against any remaining\n    // entries. TableSource implements multi-IN natively via SQL `AND` of\n    // `IN` clauses; the in-memory path is correct but not specially\n    // optimized — it pays the index-seek cost per primary value, then\n    // walks each result against the rest.\n    if (\n      req.multiConstraints &&\n      req.multiConstraints.some(mc => mc.length > 0)\n    ) {\n      yield* this.#fetchMulti(req, conn);\n      return;\n    }\n    const requestedSort = must(conn.sort);\n    const {compareRows} = conn;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const connectionComparator: Comparator = req.reverse\n      ? (r1, r2) => compareRows(r2, r1)\n      : compareRows;\n\n    const pkConstraint = primaryKeyConstraintFromFilters(\n      conn.filters?.condition,\n      this.#primaryKey,\n    );\n    // The primary key constraint will be more limiting than the constraint\n    // so swap out to that if it exists.\n    const fetchOrPkConstraint = pkConstraint ?? req.constraint;\n\n    // If there is a constraint, we need an index sorted by it first.\n    const indexSort: OrderPart[] = [];\n    if (fetchOrPkConstraint) {\n      for (const key of Object.keys(fetchOrPkConstraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n\n    // For the special case of constraining by PK, we don't need to worry about\n    // any requested sort since there can only be one result. Otherwise we also\n    // need the index sorted by the requested sort.\n    if (\n      this.#primaryKey.length > 1 ||\n      !fetchOrPkConstraint ||\n      !constraintMatchesPrimaryKey(fetchOrPkConstraint, this.#primaryKey)\n    ) {\n      indexSort.push(...requestedSort);\n    }\n\n    const index = this.#getOrCreateIndex(indexSort, conn);\n    const {data, comparator: compare} = index;\n    // Avoid allocating a new closure when not reversing (the common case).\n    const indexComparator: Comparator = req.reverse\n      ? (r1, r2) => compare(r2, r1)\n      : compare;\n\n    const startAt = req.start?.row;\n\n    // If there is a constraint, we want to start our scan at the first row that\n    // matches the constraint. But because the next OrderPart can be `desc`,\n    // it's not true that {[constraintKey]: constraintValue} is the first\n    // matching row. Because in that case, the other fields will all be\n    // `undefined`, and in Zero `undefined` is always less than any other value.\n    // So if the second OrderPart is descending then `undefined` values will\n    // actually be the *last* row. We need a way to stay \"start at the first row\n    // with this constraint value\". RowBound with the corresponding compareBound\n    // comparator accomplishes this. The right thing is probably to teach the\n    // btree library to support this concept.\n    let scanStart: RowBound | undefined;\n\n    if (fetchOrPkConstraint) {\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(fetchOrPkConstraint, key)) {\n          scanStart[key] = fetchOrPkConstraint[key];\n        } else {\n          if (req.reverse) {\n            scanStart[key] = dir === 'asc' ? maxValue : minValue;\n          } else {\n            scanStart[key] = dir === 'asc' ? minValue : maxValue;\n          }\n        }\n      }\n    } else {\n      scanStart = startAt;\n    }\n\n    const rowsIterable = generateRows(data, scanStart, req.reverse);\n\n    // Fast path: no overlay to apply, no `start`, and no connection filters.\n    // This is the common shape for join child-lookups, plain scans, and source\n    // fetches that sit beneath a downstream `Filter` operator. In that case the\n    // whole generator stack (generateWithOverlay → generateWithStart →\n    // skipYields → generateWithConstraint) reduces to: walk rows from\n    // `scanStart`, wrap each as a Node, and stop once the constraint no longer\n    // matches (rows are sorted by the constraint key first, so matches are\n    // contiguous). Collapsing the five chained generators into one loop removes\n    // a large amount of per-row generator-resume overhead on the hottest path.\n    const overlayActive =\n      this.#overlay && conn.lastPushedEpoch >= this.#overlay.epoch;\n    if (!overlayActive && !req.start && !conn.filters) {\n      const {constraint} = req;\n      for (const row of rowsIterable) {\n        if (constraint && !constraintMatchesRow(constraint, row)) {\n          break;\n        }\n        yield {row, relationships: {}};\n      }\n      return;\n    }\n\n    const withOverlay = generateWithOverlay(\n      startAt,\n      pkConstraint ? once(rowsIterable) : rowsIterable,\n      // use `req.constraint` here and not `fetchOrPkConstraint` since `fetchOrPkConstraint` could be the\n      // primary key constraint. The primary key constraint comes from filters and is acting as a filter\n      // rather than as the fetch constraint.\n      req.constraint,\n      this.#overlay,\n      conn.lastPushedEpoch,\n      // Use indexComparator, generateWithOverlayInner has a subtle dependency\n      // on this.  Since generateWithConstraint is done after\n      // generateWithOverlay, the generator consumed by generateWithOverlayInner\n      // does not end when the constraint stops matching and so the final\n      // check to yield an add overlay if not yet yielded is not reached.\n      // However, using the indexComparator the add overlay will be less than\n      // the first row that does not match the constraint, and so any\n      // not yet yielded add overlay will be yielded when the first row\n      // not matching the constraint is reached.\n      indexComparator,\n      conn.filters?.predicate,\n    );\n\n    const withConstraint = generateWithConstraint(\n      skipYields(\n        generateWithStart(withOverlay, req.start, connectionComparator),\n      ),\n      // we use `req.constraint` and not `fetchOrPkConstraint` here because we need to\n      // AND the constraint with what could have been the primary key constraint\n      req.constraint,\n    );\n\n    yield* conn.filters\n      ? generateWithFilter(withConstraint, conn.filters.predicate)\n      : withConstraint;\n  }\n\n  *#fetchMulti(req: FetchRequest, conn: Connection): Stream<Node | 'yield'> {\n    // Caller (`#fetch`) guards entry on `req.multiConstraints.some(mc =>\n    // mc.length > 0)`, so `multis` is guaranteed non-empty after the\n    // empty-entry filter. Per the MultiConstraint contract (operator.ts),\n    // entries are non-empty, share key shape, are unique, and are\n    // key-compatible with `req.constraint`.\n    const multis = must(req.multiConstraints).filter(mc => mc.length > 0);\n    const primary = multis[0];\n    const rest = multis.slice(1);\n    const baseConstraint = req.constraint;\n\n    // Drive sub-fetches off `primary`. Within each sub-fetch the source\n    // can use its index for `primary`; we then post-filter rows by\n    // checking they also match every entry in `rest`. Per the\n    // MultiConstraint contract (see operator.ts), entries are unique and\n    // key-compatible with `baseConstraint`, so we don't dedupe or check\n    // compatibility here.\n    const subStreams: Stream<Node | 'yield'>[] = primary.map(c => {\n      const merged: Constraint = baseConstraint ? {...baseConstraint, ...c} : c;\n      return this.#fetch(\n        {...req, constraint: merged, multiConstraints: undefined},\n        conn,\n      );\n    });\n    const merged = mergeSortedStreams(\n      subStreams,\n      req.reverse\n        ? (a, b) => conn.compareRows(b.row, a.row)\n        : (a, b) => conn.compareRows(a.row, b.row),\n    );\n\n    if (rest.length === 0) {\n      yield* merged;\n      return;\n    }\n\n    for (const node of merged) {\n      if (node === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      let matchesAll = true;\n      for (const mc of rest) {\n        let any = false;\n        for (const c of mc) {\n          if (constraintMatchesRow(c, node.row)) {\n            any = true;\n            break;\n          }\n        }\n        if (!any) {\n          matchesAll = false;\n          break;\n        }\n      }\n      if (matchesAll) yield node;\n    }\n  }\n\n  *push(change: SourceChange): Stream<'yield'> {\n    for (const result of this.genPush(change)) {\n      if (result === 'yield') {\n        yield result;\n      }\n    }\n  }\n\n  *genPush(change: SourceChange) {\n    const primaryIndex = this.#getPrimaryIndex();\n    const {data} = primaryIndex;\n    const exists = (row: Row) => data.has(row);\n    const setOverlay = (o: Overlay | undefined) => (this.#overlay = o);\n    const writeChange = (c: SourceChange) => this.#writeChange(c);\n    yield* genPushAndWriteWithSplitEdit(\n      this.#connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      () => ++this.#pushEpoch,\n    );\n  }\n\n  #writeChange(change: SourceChange) {\n    for (const {data} of this.#indexes.values()) {\n      switch (change[SourceChangeIndex.TYPE]) {\n        case ChangeType.ADD: {\n          const added = data.add(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            added,\n            'MemorySource: add must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.REMOVE: {\n          const removed = data.delete(change[SourceChangeIndex.ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: remove must succeed since row existence was already checked',\n          );\n          break;\n        }\n        case ChangeType.EDIT: {\n          // TODO: We could see if the PK (form the index tree's perspective)\n          // changed and if not we could use set.\n          // We cannot just do `set` with the new value since the `oldRow` might\n          // not map to the same entry as the new `row` in the index btree.\n          const removed = data.delete(change[SourceChangeIndex.OLD_ROW]);\n          // must succeed since we checked has() above.\n          assert(\n            removed,\n            'MemorySource: edit remove must succeed since row existence was already checked',\n          );\n          data.add(change[SourceChangeIndex.ROW]);\n          break;\n        }\n        default:\n          unreachable(change);\n      }\n    }\n  }\n}\n\nfunction* generateWithConstraint(\n  it: Stream<Node>,\n  constraint: Constraint | undefined,\n) {\n  for (const node of it) {\n    if (constraint && !constraintMatchesRow(constraint, node.row)) {\n      break;\n    }\n    yield node;\n  }\n}\n\nfunction* generateWithFilter(it: Stream<Node>, filter: (row: Row) => boolean) {\n  for (const node of it) {\n    if (filter(node.row)) {\n      yield node;\n    }\n  }\n}\n\nexport function* genPushAndWriteWithSplitEdit(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: (row: Row) => boolean,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  getNextEpoch: () => number,\n) {\n  let shouldSplitEdit = false;\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT) {\n    for (const {splitEditKeys} of connections) {\n      if (splitEditKeys) {\n        for (const key of splitEditKeys) {\n          if (\n            !valuesEqual(\n              change[SourceChangeIndex.ROW][key],\n              change[SourceChangeIndex.OLD_ROW][key],\n            )\n          ) {\n            shouldSplitEdit = true;\n            break;\n          }\n        }\n      }\n    }\n  }\n\n  if (change[SourceChangeIndex.TYPE] === ChangeType.EDIT && shouldSplitEdit) {\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeRemove(change[SourceChangeIndex.OLD_ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n    yield* genPushAndWrite(\n      connections,\n      makeSourceChangeAdd(change[SourceChangeIndex.ROW]),\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  } else {\n    yield* genPushAndWrite(\n      connections,\n      change,\n      exists,\n      setOverlay,\n      writeChange,\n      getNextEpoch(),\n    );\n  }\n}\n\nfunction* genPushAndWrite(\n  connections: readonly Connection[],\n  change: SourceChangeAdd | SourceChangeRemove | SourceChangeEdit,\n  exists: (row: Row) => boolean,\n  setOverlay: (o: Overlay | undefined) => Overlay | undefined,\n  writeChange: (c: SourceChange) => void,\n  pushEpoch: number,\n) {\n  for (const x of genPush(connections, change, exists, setOverlay, pushEpoch)) {\n    yield x;\n  }\n  writeChange(change);\n}\n\nfunction* genPush(\n  connections: readonly Connection[],\n  change: SourceChange,\n  exists: (row: Row) => boolean,\n  setOverlay: (o: Overlay | undefined) => void,\n  pushEpoch: number,\n) {\n  switch (change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      assert(\n        !exists(change[SourceChangeIndex.ROW]),\n        () => `Row already exists ${stringify(change)}`,\n      );\n      break;\n    case ChangeType.REMOVE:\n      assert(\n        exists(change[SourceChangeIndex.ROW]),\n        () => `Row not found ${stringify(change)}`,\n      );\n      break;\n    case ChangeType.EDIT:\n      assert(\n        exists(change[SourceChangeIndex.OLD_ROW]),\n        () => `Row not found ${stringify(change)}`,\n      );\n      break;\n    default:\n      unreachable(change);\n  }\n\n  for (const conn of connections) {\n    const {output, filters, input} = conn;\n    if (output) {\n      conn.lastPushedEpoch = pushEpoch;\n      setOverlay({epoch: pushEpoch, change});\n      const outputChange: Change =\n        change[SourceChangeIndex.TYPE] === ChangeType.EDIT\n          ? makeEditChange(\n              {row: change[SourceChangeIndex.ROW], relationships: {}},\n              {row: change[SourceChangeIndex.OLD_ROW], relationships: {}},\n            )\n          : change[SourceChangeIndex.TYPE] === ChangeType.ADD\n            ? makeAddChange({\n                row: change[SourceChangeIndex.ROW],\n                relationships: {},\n              })\n            : makeRemoveChange({\n                row: change[SourceChangeIndex.ROW],\n                relationships: {},\n              });\n      yield* filterPush(outputChange, output, input, filters?.predicate);\n      yield undefined;\n    }\n  }\n\n  setOverlay(undefined);\n}\n\nexport function* generateWithStart(\n  nodes: Iterable<Node | 'yield'>,\n  start: Start | undefined,\n  compare: (r1: Row, r2: Row) => number,\n): Stream<Node | 'yield'> {\n  if (!start) {\n    yield* nodes;\n    return;\n  }\n  let started = false;\n  for (const node of nodes) {\n    if (node === 'yield') {\n      yield node;\n      continue;\n    }\n    if (!started) {\n      if (start.basis === 'at') {\n        if (compare(node.row, start.row) >= 0) {\n          started = true;\n        }\n      } else if (start.basis === 'after') {\n        if (compare(node.row, start.row) > 0) {\n          started = true;\n        }\n      }\n    }\n    if (started) {\n      yield node;\n    }\n  }\n}\n\n/**\n * Takes an iterator and overlay.\n * Splices the overlay into the iterator at the correct position.\n *\n * @param startAt - if there is a lower bound to the stream. If the lower bound of the stream\n * is above the overlay, the overlay will be skipped.\n * @param rows - the stream into which the overlay should be spliced\n * @param constraint - constraint that was applied to the rowIterator and should\n * also be applied to the overlay.\n * @param overlay - the overlay values to splice in\n * @param compare - the comparator to use to find the position for the overlay\n */\nexport function* generateWithOverlay(\n  startAt: Row | undefined,\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  compare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  const overlays = computeOverlays(\n    startAt,\n    constraint,\n    overlayToApply,\n    compare,\n    filterPredicate,\n    multiConstraints,\n  );\n  yield* generateWithOverlayInner(rows, overlays, compare);\n}\n\nfunction computeOverlays(\n  startAt: Row | undefined,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  compare: Comparator,\n  filterPredicate?: (row: Row) => boolean | undefined,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\n): Overlays {\n  let overlays: Overlays = {\n    add: undefined,\n    remove: undefined,\n  };\n  switch (overlay?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlay.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlay.change[SourceChangeIndex.ROW],\n        remove: overlay.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n\n  if (startAt) {\n    overlays = overlaysForStartAt(overlays, startAt, compare);\n  }\n\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n\n  return overlays;\n}\n\nfunction applyMultiConstraintsToOverlays(\n  overlays: Overlays,\n  multiConstraints: readonly MultiConstraint[] | undefined,\n): Overlays {\n  if (!multiConstraints) return overlays;\n  for (const mc of multiConstraints) {\n    if (mc.length > 0) {\n      overlays = overlaysForMultiConstraint(overlays, mc);\n    }\n  }\n  return overlays;\n}\n\nexport {overlaysForMultiConstraint as overlaysForMultiConstraintForTest};\n\nfunction overlaysForMultiConstraint(\n  {add, remove}: Overlays,\n  multiConstraint: MultiConstraint,\n): Overlays {\n  const matchesAny = (row: Row | undefined) => {\n    if (row === undefined) return false;\n    for (const c of multiConstraint) {\n      if (constraintMatchesRow(c, row)) return true;\n    }\n    return false;\n  };\n  return {\n    add: matchesAny(add) ? add : undefined,\n    remove: matchesAny(remove) ? remove : undefined,\n  };\n}\n\nexport {overlaysForStartAt as overlaysForStartAtForTest};\n\nfunction overlaysForStartAt(\n  {add, remove}: Overlays,\n  startAt: Row,\n  compare: Comparator,\n): Overlays {\n  const undefinedIfBeforeStartAt = (row: Row | undefined) =>\n    row === undefined || compare(row, startAt) < 0 ? undefined : row;\n  return {\n    add: undefinedIfBeforeStartAt(add),\n    remove: undefinedIfBeforeStartAt(remove),\n  };\n}\n\nexport {overlaysForConstraint as overlaysForConstraintForTest};\n\nfunction overlaysForConstraint(\n  {add, remove}: Overlays,\n  constraint: Constraint,\n): Overlays {\n  const undefinedIfDoesntMatchConstraint = (row: Row | undefined) =>\n    row === undefined || !constraintMatchesRow(constraint, row)\n      ? undefined\n      : row;\n\n  return {\n    add: undefinedIfDoesntMatchConstraint(add),\n    remove: undefinedIfDoesntMatchConstraint(remove),\n  };\n}\n\nfunction overlaysForFilterPredicate(\n  {add, remove}: Overlays,\n  filterPredicate: (row: Row) => boolean | undefined,\n): Overlays {\n  const undefinedIfDoesntMatchFilter = (row: Row | undefined) =>\n    row === undefined || !filterPredicate(row) ? undefined : row;\n\n  return {\n    add: undefinedIfDoesntMatchFilter(add),\n    remove: undefinedIfDoesntMatchFilter(remove),\n  };\n}\n\nexport function* generateWithOverlayInner(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  compare: (r1: Row, r2: Row) => number,\n) {\n  let addOverlayYielded = false;\n  let removeOverlaySkipped = false;\n  for (const row of rowIterator) {\n    if (!addOverlayYielded && overlays.add) {\n      const cmp = compare(overlays.add, row);\n      if (cmp < 0) {\n        addOverlayYielded = true;\n        yield {row: overlays.add, relationships: {}};\n      }\n    }\n\n    if (!removeOverlaySkipped && overlays.remove) {\n      const cmp = compare(overlays.remove, row);\n      if (cmp === 0) {\n        removeOverlaySkipped = true;\n        continue;\n      }\n    }\n    yield {row, relationships: {}};\n  }\n\n  if (!addOverlayYielded && overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n}\n\n/**\n * Like {@link generateWithOverlay} but for unordered streams.\n * No `startAt` or comparator needed. Injects remove/old-edit rows eagerly\n * at the start, and suppresses add/new-edit rows inline by PK match.\n */\nexport function* generateWithOverlayUnordered(\n  rows: Iterable<Row>,\n  constraint: Constraint | undefined,\n  overlay: Overlay | undefined,\n  lastPushedEpoch: number,\n  primaryKey: PrimaryKey,\n  filterPredicate?: (row: Row) => boolean,\n  multiConstraints?: readonly MultiConstraint[] | undefined,\n) {\n  let overlayToApply: Overlay | undefined = undefined;\n  if (overlay && lastPushedEpoch >= overlay.epoch) {\n    overlayToApply = overlay;\n  }\n  let overlays: Overlays = {add: undefined, remove: undefined};\n  switch (overlayToApply?.change[SourceChangeIndex.TYPE]) {\n    case ChangeType.ADD:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: undefined,\n      };\n      break;\n    case ChangeType.REMOVE:\n      overlays = {\n        add: undefined,\n        remove: overlayToApply.change[SourceChangeIndex.ROW],\n      };\n      break;\n    case ChangeType.EDIT:\n      overlays = {\n        add: overlayToApply.change[SourceChangeIndex.ROW],\n        remove: overlayToApply.change[SourceChangeIndex.OLD_ROW],\n      };\n      break;\n  }\n  if (constraint) {\n    overlays = overlaysForConstraint(overlays, constraint);\n  }\n  overlays = applyMultiConstraintsToOverlays(overlays, multiConstraints);\n  if (filterPredicate) {\n    overlays = overlaysForFilterPredicate(overlays, filterPredicate);\n  }\n  yield* generateWithOverlayInnerUnordered(rows, overlays, primaryKey);\n}\n\nexport function* generateWithOverlayInnerUnordered(\n  rowIterator: Iterable<Row>,\n  overlays: Overlays,\n  primaryKey: PrimaryKey,\n) {\n  // Eager inject: yield the add overlay at the start (row not yet in storage)\n  if (overlays.add) {\n    yield {row: overlays.add, relationships: {}};\n  }\n  // Stream with inline suppress: skip the remove overlay (row still in storage)\n  let removeSkipped = false;\n  for (const row of rowIterator) {\n    if (\n      !removeSkipped &&\n      overlays.remove &&\n      rowMatchesPK(overlays.remove, row, primaryKey)\n    ) {\n      removeSkipped = true;\n      continue;\n    }\n    yield {row, relationships: {}};\n  }\n}\n\nfunction rowMatchesPK(a: Row, b: Row, primaryKey: PrimaryKey): boolean {\n  for (const key of primaryKey) {\n    if (!valuesEqual(a[key], b[key])) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * A location to begin scanning an index from. Can either be a specific value\n * or the min or max possible value for the type. This is used to start a scan\n * at the beginning of the rows matching a constraint.\n */\ntype Bound = Value | MinValue | MaxValue;\ntype RowBound = Record<string, Bound>;\nconst minValue = Symbol('min-value');\ntype MinValue = typeof minValue;\nconst maxValue = Symbol('max-value');\ntype MaxValue = typeof maxValue;\n\nfunction makeBoundComparator(sort: Ordering): Comparator {\n  // Pre-extract the first two keys/directions to avoid per-call array access.\n  // All paths share one function literal (single SFI) so the BTree comparator call site\n  // stays monomorphic across indexes with different sort orderings, preventing V8 IC deopt.\n  // Even a 2-SFI split (e.g. separate len=1 path) creates a polymorphic IC that\n  // measurably regresses performance, so we keep a single return body.\n  const len = sort.length;\n  const k0 = sort[0][0];\n  const a0 = sort[0][1] === 'asc';\n  const k1 = len > 1 ? sort[1][0] : '';\n  const a1 = len > 1 ? sort[1][1] === 'asc' : true;\n\n  return (a: RowBound, b: RowBound) => {\n    const c0 = a0 ? compareBounds(a[k0], b[k0]) : compareBounds(b[k0], a[k0]);\n    if (len === 1 || c0 !== 0) return c0;\n    const c1 = a1 ? compareBounds(a[k1], b[k1]) : compareBounds(b[k1], a[k1]);\n    if (len === 2 || c1 !== 0) return c1;\n    // Hot! Do not use destructuring\n    for (let i = 2; i < len; i++) {\n      const cmp = compareBounds(a[sort[i][0]], b[sort[i][0]]);\n      if (cmp !== 0) return sort[i][1] === 'asc' ? cmp : -cmp;\n    }\n    return 0;\n  };\n}\n\nfunction compareBounds(a: Bound, b: Bound): number {\n  if (a === b) {\n    return 0;\n  }\n  // Use typeof to guard the Symbol sentinel checks first. This gives V8 a\n  // clear type discriminant so the common non-symbol path compiles as a\n  // specialised numeric/string fast-path without a Smi deopt when the\n  // minValue/maxValue sentinel symbols appear.\n  if (typeof a === 'symbol') {\n    return a === minValue ? -1 : 1;\n  }\n  if (typeof b === 'symbol') {\n    return b === minValue ? 1 : -1;\n  }\n  return compareValues(a, b);\n}\n\nfunction* generateRows(\n  data: BTreeSet<Row>,\n  scanStart: RowBound | undefined,\n  reverse: boolean | undefined,\n) {\n  yield* data[reverse ? 'valuesFromReversed' : 'valuesFrom'](\n    scanStart as Row | undefined,\n  );\n}\n\nexport function stringify(change: SourceChange) {\n  return JSON.stringify(change, (_, v) =>\n    typeof v === 'bigint' ? v.toString() : v,\n  );\n}\n\n/**\n * N-way merge of pre-sorted Node streams. Each input stream must yield\n * Nodes in `compare` order (and may interleave 'yield' values, which are\n * forwarded as-is). The merged stream yields Nodes in `compare` order.\n *\n * Implemented as a binary min-heap keyed by `compare(entry.row, ...)`, so\n * each emit costs O(log K) (K = number of streams) rather than the O(K)\n * a linear-scan-of-heads merge would. Matters when FlippedJoin chunks a\n * large `multiConstraints` IN-list into hundreds of sub-fetches.\n *\n * If the merged stream is closed early (e.g. downstream `Take` `break`s\n * after hitting its limit, prompting JS to call `.return()` on this\n * generator), the `finally` block propagates `.return()` to each\n * non-exhausted sub-iterator so the underlying sources (SQLite cursors,\n * etc.) can run their cleanup. Without this, mid-merge early-termination\n * leaves cursors open, causing later writes on the same connection to\n * fail with \"database connection is busy executing a query\".\n */\nexport function* mergeSortedStreams(\n  streams: readonly Stream<Node | 'yield'>[],\n  compare: (a: Node, b: Node) => number,\n): Stream<Node | 'yield'> {\n  const iterators: Iterator<Node | 'yield'>[] = streams.map(s =>\n    s[Symbol.iterator](),\n  );\n  // True while iterators[i] hasn't yet returned `done`. The finally\n  // block uses this to skip already-exhausted streams when propagating\n  // `.return()`.\n  const active: boolean[] = new Array(iterators.length).fill(true);\n\n  // Min-heap of entries; `idx` tells us which stream to refill from\n  // after the entry's row is emitted.\n  type Entry = {row: Node; idx: number};\n  const heap: Entry[] = [];\n\n  const siftUp = (start: number) => {\n    let i = start;\n    while (i > 0) {\n      const p = (i - 1) >> 1;\n      if (compare(heap[i].row, heap[p].row) >= 0) return;\n      const t = heap[i];\n      heap[i] = heap[p];\n      heap[p] = t;\n      i = p;\n    }\n  };\n\n  const siftDown = (start: number) => {\n    let i = start;\n    const n = heap.length;\n    while (true) {\n      const l = (i << 1) + 1;\n      const r = l + 1;\n      let smallest = i;\n      if (l < n && compare(heap[l].row, heap[smallest].row) < 0) smallest = l;\n      if (r < n && compare(heap[r].row, heap[smallest].row) < 0) smallest = r;\n      if (smallest === i) return;\n      const t = heap[i];\n      heap[i] = heap[smallest];\n      heap[smallest] = t;\n      i = smallest;\n    }\n  };\n\n  // Pull the next Node from iterator `idx`, forwarding any 'yield's.\n  // Returns the Node, or `undefined` once the stream is exhausted.\n  const pullNext = function* (\n    idx: number,\n  ): Generator<'yield', Node | undefined, undefined> {\n    while (true) {\n      const r = iterators[idx].next();\n      if (r.done) {\n        active[idx] = false;\n        return undefined;\n      }\n      if (r.value === 'yield') {\n        yield 'yield';\n        continue;\n      }\n      return r.value;\n    }\n  };\n\n  try {\n    // Prime: push the first row of each non-empty stream onto the heap.\n    for (let i = 0; i < iterators.length; i++) {\n      const row = yield* pullNext(i);\n      if (row !== undefined) {\n        heap.push({row, idx: i});\n        siftUp(heap.length - 1);\n      }\n    }\n\n    while (heap.length > 0) {\n      // Root is the global min across all active streams.\n      const top = heap[0];\n      yield top.row;\n      const next = yield* pullNext(top.idx);\n      if (next !== undefined) {\n        // Refill root in place (top === heap[0]) and sift down. The\n        // already-yielded `top.row` value is captured by the yield, so\n        // mutating it here doesn't affect what was emitted.\n        top.row = next;\n        siftDown(0);\n      } else {\n        // Stream exhausted. Move tail to root and shrink. Pop returns\n        // the last entry; if the heap had only one entry it was the\n        // root we just yielded, so we just leave the heap empty.\n        const last = must(heap.pop());\n        if (heap.length > 0) {\n          heap[0] = last;\n          siftDown(0);\n        }\n      }\n    }\n  } finally {\n    // Close any iterators that aren't already exhausted so their\n    // `finally` blocks (which release cursors / cached statements) run.\n    for (let i = 0; i < iterators.length; i++) {\n      if (active[i]) {\n        iterators[i].return?.();\n      }\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAiGA,IAAa,eAAb,MAAa,aAA+B;CAC1C;CACA;CACA;CACA;CACA,2BAAwC,IAAI,IAAI;CAChD,eAAsC,CAAC;CAEvC;CACA,aAAa;CAEb,YACE,WACA,SACA,YACA,kBACA;EACA,KAAKA,aAAa;EAClB,KAAKC,WAAW;EAChB,KAAKC,cAAc;EACnB,KAAKC,oBAAoB,WAAW,KAAI,MAAK,CAAC,GAAG,KAAK,CAAC;EACvD,MAAM,aAAa,oBAAoB,KAAKA,iBAAiB;EAC7D,KAAKC,SAAS,IAAI,KAAK,UAAU,KAAKD,iBAAiB,GAAG;GACxD;GACA,MAAM,oBAAoB,IAAI,SAAc,UAAU;GACtD,wBAAQ,IAAI,IAAI;EAClB,CAAC;CACH;CAEA,IAAI,cAAc;EAChB,OAAO;GACL,MAAM,KAAKH;GACX,SAAS,KAAKC;GACd,YAAY,KAAKC;EACnB;CACF;CAEA,OAAO;EACL,MAAM,eAAe,KAAKI,iBAAiB;EAC3C,OAAO,IAAI,aACT,KAAKN,YACL,KAAKC,UACL,KAAKC,aACL,aAAa,KAAK,MAAM,CAC1B;CACF;CAEA,IAAI,OAAsB;EACxB,OAAO,KAAKI,iBAAiB,EAAE;CACjC;CAEA,WAAW,YAAwB,WAAkC;EACnE,OAAO;GACL,WAAW,KAAKN;GAChB,SAAS,KAAKC;GACd,YAAY,KAAKC;GACjB,MAAM,YAAY,KAAA,IAAY,WAAW;GACzC,QAAQ;GACR,eAAe,CAAC;GAChB,UAAU;GACV,aAAa,WAAW;EAC1B;CACF;CAEA,QACE,MACA,SACA,eACa;EACb,MAAM,qBAAqB,iBAAiB,OAAO;EACnD,MAAM,YAAY,SAAS,KAAA;EAC3B,MAAM,eAAe,QAAQ,KAAKC;EAElC,MAAM,QAAqB;GACzB,iBAAiB;GACjB,QAAO,QAAO,KAAKI,OAAO,KAAK,UAAU;GACzC,YAAW,WAAU;IACnB,WAAW,SAAS;GACtB;GACA,eAAe;IACb,KAAKC,YAAY,KAAK;GACxB;GACA,qBAAqB,CAAC,mBAAmB;EAC3C;EAEA,MAAM,aAAyB;GAC7B;GACA,QAAQ,KAAA;GACR,MAAM;GACN;GACA,aAAa,eAAe,YAAY;GACxC,SAAS,mBAAmB,UACxB;IACE,WAAW,mBAAmB;IAC9B,WAAW,gBAAgB,mBAAmB,OAAO;GACvD,IACA,KAAA;GACJ,iBAAiB;EACnB;EACA,MAAM,SAAS,KAAKC,WAAW,YAAY,SAAS;EACpD,IAAI,CAAC,WACH,yBAAyB,cAAc,KAAKP,WAAW;EAEzD,KAAKG,aAAa,KAAK,UAAU;EACjC,OAAO;CACT;CAEA,YAAY,OAAoB;EAC9B,MAAM,MAAM,KAAKA,aAAa,WAAU,MAAK,EAAE,UAAU,KAAK;EAC9D,OAAO,QAAQ,IAAI,sBAAsB;EACzC,KAAKA,aAAa,OAAO,KAAK,CAAC;CASjC;CAEA,mBAA0B;EACxB,MAAM,QAAQ,KAAKD,SAAS,IAAI,KAAK,UAAU,KAAKD,iBAAiB,CAAC;EACtE,OAAO,OAAO,yBAAyB;EACvC,OAAO;CACT;CAEA,kBAAkB,MAAgB,QAA2B;EAC3D,MAAM,MAAM,KAAK,UAAU,IAAI;EAC/B,MAAM,QAAQ,KAAKC,SAAS,IAAI,GAAG;EAGnC,IAAI,OAAO;GACT,MAAM,OAAO,IAAI,MAAM;GACvB,OAAO;EACT;EAEA,MAAM,aAAa,oBAAoB,IAAI;EAS3C,MAAM,OAAO,SAAS,KAAKE,iBAAiB,EAAE,MAAM,UAAU;EAG9D,MAAM,WAAW;GAAC;GAAY,MAFjB,SAAS,WAAW,YAAY,IAEf;GAAM,QAAQ,IAAI,IAAI,CAAC,MAAM,CAAC;EAAC;EAC7D,KAAKF,SAAS,IAAI,KAAK,QAAQ;EAC/B,OAAO;CACT;CAGA,eAAyB;EACvB,OAAO,CAAC,GAAG,KAAKA,SAAS,KAAK,CAAC;CACjC;CAEA,CAACG,OAAO,KAAmB,MAA0C;EAOnE,IACE,IAAI,oBACJ,IAAI,iBAAiB,MAAK,OAAM,GAAG,SAAS,CAAC,GAC7C;GACA,OAAO,KAAKG,YAAY,KAAK,IAAI;GACjC;EACF;EACA,MAAM,gBAAgB,KAAK,KAAK,IAAI;EACpC,MAAM,EAAC,gBAAe;EAEtB,MAAM,uBAAmC,IAAI,WACxC,IAAI,OAAO,YAAY,IAAI,EAAE,IAC9B;EAEJ,MAAM,eAAe,gCACnB,KAAK,SAAS,WACd,KAAKR,WACP;EAGA,MAAM,sBAAsB,gBAAgB,IAAI;EAGhD,MAAM,YAAyB,CAAC;EAChC,IAAI,qBACF,KAAK,MAAM,OAAO,OAAO,KAAK,mBAAmB,GAC/C,UAAU,KAAK,CAAC,KAAK,KAAK,CAAC;EAO/B,IACE,KAAKA,YAAY,SAAS,KAC1B,CAAC,uBACD,CAAC,4BAA4B,qBAAqB,KAAKA,WAAW,GAElE,UAAU,KAAK,GAAG,aAAa;EAIjC,MAAM,EAAC,MAAM,YAAY,YADX,KAAKS,kBAAkB,WAAW,IACZ;EAEpC,MAAM,kBAA8B,IAAI,WACnC,IAAI,OAAO,QAAQ,IAAI,EAAE,IAC1B;EAEJ,MAAM,UAAU,IAAI,OAAO;EAY3B,IAAI;EAEJ,IAAI,qBAAqB;GACvB,YAAY,CAAC;GACb,KAAK,MAAM,CAAC,KAAK,QAAQ,WACvB,IAAI,OAAO,qBAAqB,GAAG,GACjC,UAAU,OAAO,oBAAoB;QAErC,IAAI,IAAI,SACN,UAAU,OAAO,QAAQ,QAAQ,WAAW;QAE5C,UAAU,OAAO,QAAQ,QAAQ,WAAW;EAIpD,OACE,YAAY;EAGd,MAAM,eAAe,aAAa,MAAM,WAAW,IAAI,OAAO;EAa9D,IAAI,EADF,KAAKC,YAAY,KAAK,mBAAmB,KAAKA,SAAS,UACnC,CAAC,IAAI,SAAS,CAAC,KAAK,SAAS;GACjD,MAAM,EAAC,eAAc;GACrB,KAAK,MAAM,OAAO,cAAc;IAC9B,IAAI,cAAc,CAAC,qBAAqB,YAAY,GAAG,GACrD;IAEF,MAAM;KAAC;KAAK,eAAe,CAAC;IAAC;GAC/B;GACA;EACF;EAwBA,MAAM,iBAAiB,uBACrB,WACE,kBAxBgB,oBAClB,SACA,eAAe,KAAK,YAAY,IAAI,cAIpC,IAAI,YACJ,KAAKA,UACL,KAAK,iBAUL,iBACA,KAAK,SAAS,SAKM,GAAa,IAAI,OAAO,oBAAoB,CAChE,GAGA,IAAI,UACN;EAEA,OAAO,KAAK,UACR,mBAAmB,gBAAgB,KAAK,QAAQ,SAAS,IACzD;CACN;CAEA,CAACF,YAAY,KAAmB,MAA0C;EAMxE,MAAM,SAAS,KAAK,IAAI,gBAAgB,EAAE,QAAO,OAAM,GAAG,SAAS,CAAC;EACpE,MAAM,UAAU,OAAO;EACvB,MAAM,OAAO,OAAO,MAAM,CAAC;EAC3B,MAAM,iBAAiB,IAAI;EAe3B,MAAM,SAAS,mBAP8B,QAAQ,KAAI,MAAK;GAC5D,MAAM,SAAqB,iBAAiB;IAAC,GAAG;IAAgB,GAAG;GAAC,IAAI;GACxE,OAAO,KAAKH,OACV;IAAC,GAAG;IAAK,YAAY;IAAQ,kBAAkB,KAAA;GAAS,GACxD,IACF;EACF,CAEE,GACA,IAAI,WACC,GAAG,MAAM,KAAK,YAAY,EAAE,KAAK,EAAE,GAAG,KACtC,GAAG,MAAM,KAAK,YAAY,EAAE,KAAK,EAAE,GAAG,CAC7C;EAEA,IAAI,KAAK,WAAW,GAAG;GACrB,OAAO;GACP;EACF;EAEA,KAAK,MAAM,QAAQ,QAAQ;GACzB,IAAI,SAAS,SAAS;IACpB,MAAM;IACN;GACF;GACA,IAAI,aAAa;GACjB,KAAK,MAAM,MAAM,MAAM;IACrB,IAAI,MAAM;IACV,KAAK,MAAM,KAAK,IACd,IAAI,qBAAqB,GAAG,KAAK,GAAG,GAAG;KACrC,MAAM;KACN;IACF;IAEF,IAAI,CAAC,KAAK;KACR,aAAa;KACb;IACF;GACF;GACA,IAAI,YAAY,MAAM;EACxB;CACF;CAEA,CAAC,KAAK,QAAuC;EAC3C,KAAK,MAAM,UAAU,KAAK,QAAQ,MAAM,GACtC,IAAI,WAAW,SACb,MAAM;CAGZ;CAEA,CAAC,QAAQ,QAAsB;EAE7B,MAAM,EAAC,SADc,KAAKD,iBACX;EACf,MAAM,UAAU,QAAa,KAAK,IAAI,GAAG;EACzC,MAAM,cAAc,MAA4B,KAAKM,WAAW;EAChE,MAAM,eAAe,MAAoB,KAAKC,aAAa,CAAC;EAC5D,OAAO,6BACL,KAAKR,cACL,QACA,QACA,YACA,mBACM,EAAE,KAAKS,UACf;CACF;CAEA,aAAa,QAAsB;EACjC,KAAK,MAAM,EAAC,UAAS,KAAKV,SAAS,OAAO,GACxC,QAAQ,OAAO,IAAf;GACE,KAAK;IAGH,OAFc,KAAK,IAAI,OAAO,EAG5B,GACA,wEACF;IACA;GAEF,KAAK;IAGH,OAFgB,KAAK,OAAO,OAAO,EAGjC,GACA,2EACF;IACA;GAEF,KAAK;IAOH,OAFgB,KAAK,OAAO,OAAO,EAGjC,GACA,gFACF;IACA,KAAK,IAAI,OAAO,EAAsB;IACtC;GAEF,SACE,YAAY,MAAM;EACtB;CAEJ;AACF;AAEA,UAAU,uBACR,IACA,YACA;CACA,KAAK,MAAM,QAAQ,IAAI;EACrB,IAAI,cAAc,CAAC,qBAAqB,YAAY,KAAK,GAAG,GAC1D;EAEF,MAAM;CACR;AACF;AAEA,UAAU,mBAAmB,IAAkB,QAA+B;CAC5E,KAAK,MAAM,QAAQ,IACjB,IAAI,OAAO,KAAK,GAAG,GACjB,MAAM;AAGZ;AAEA,UAAiB,6BACf,aACA,QACA,QACA,YACA,aACA,cACA;CACA,IAAI,kBAAkB;CACtB,IAAI,OAAO,OAA4B;OAChC,MAAM,EAAC,mBAAkB,aAC5B,IAAI;QACG,MAAM,OAAO,eAChB,IACE,CAAC,YACC,OAAO,GAAuB,MAC9B,OAAO,GAA2B,IACpC,GACA;IACA,kBAAkB;IAClB;GACF;;CACF;CAKN,IAAI,OAAO,OAA4B,KAAmB,iBAAiB;EACzE,OAAO,gBACL,aACA,uBAAuB,OAAO,EAA0B,GACxD,QACA,YACA,aACA,aAAa,CACf;EACA,OAAO,gBACL,aACA,oBAAoB,OAAO,EAAsB,GACjD,QACA,YACA,aACA,aAAa,CACf;CACF,OACE,OAAO,gBACL,aACA,QACA,QACA,YACA,aACA,aAAa,CACf;AAEJ;AAEA,UAAU,gBACR,aACA,QACA,QACA,YACA,aACA,WACA;CACA,KAAK,MAAM,KAAK,QAAQ,aAAa,QAAQ,QAAQ,YAAY,SAAS,GACxE,MAAM;CAER,YAAY,MAAM;AACpB;AAEA,UAAU,QACR,aACA,QACA,QACA,YACA,WACA;CACA,QAAQ,OAAO,IAAf;EACE,KAAK;GACH,OACE,CAAC,OAAO,OAAO,EAAsB,SAC/B,sBAAsB,UAAU,MAAM,GAC9C;GACA;EACF,KAAK;GACH,OACE,OAAO,OAAO,EAAsB,SAC9B,iBAAiB,UAAU,MAAM,GACzC;GACA;EACF,KAAK;GACH,OACE,OAAO,OAAO,EAA0B,SAClC,iBAAiB,UAAU,MAAM,GACzC;GACA;EACF,SACE,YAAY,MAAM;CACtB;CAEA,KAAK,MAAM,QAAQ,aAAa;EAC9B,MAAM,EAAC,QAAQ,SAAS,UAAS;EACjC,IAAI,QAAQ;GACV,KAAK,kBAAkB;GACvB,WAAW;IAAC,OAAO;IAAW;GAAM,CAAC;GAgBrC,OAAO,WAdL,OAAO,OAA4B,IAC/B,eACE;IAAC,KAAK,OAAO;IAAwB,eAAe,CAAC;GAAC,GACtD;IAAC,KAAK,OAAO;IAA4B,eAAe,CAAC;GAAC,CAC5D,IACA,OAAO,OAA4B,IACjC,cAAc;IACZ,KAAK,OAAO;IACZ,eAAe,CAAC;GAClB,CAAC,IACD,iBAAiB;IACf,KAAK,OAAO;IACZ,eAAe,CAAC;GAClB,CAAC,GACuB,QAAQ,OAAO,SAAS,SAAS;GACjE,MAAM,KAAA;EACR;CACF;CAEA,WAAW,KAAA,CAAS;AACtB;AAEA,UAAiB,kBACf,OACA,OACA,SACwB;CACxB,IAAI,CAAC,OAAO;EACV,OAAO;EACP;CACF;CACA,IAAI,UAAU;CACd,KAAK,MAAM,QAAQ,OAAO;EACxB,IAAI,SAAS,SAAS;GACpB,MAAM;GACN;EACF;EACA,IAAI,CAAC;OACC,MAAM,UAAU;QACd,QAAQ,KAAK,KAAK,MAAM,GAAG,KAAK,GAClC,UAAU;GAAA,OAEP,IAAI,MAAM,UAAU;QACrB,QAAQ,KAAK,KAAK,MAAM,GAAG,IAAI,GACjC,UAAU;GAAA;EACZ;EAGJ,IAAI,SACF,MAAM;CAEV;AACF;;;;;;;;;;;;;AAcA,UAAiB,oBACf,SACA,MACA,YACA,SACA,iBACA,SACA,iBACA,kBACA;CACA,IAAI,iBAAsC,KAAA;CAC1C,IAAI,WAAW,mBAAmB,QAAQ,OACxC,iBAAiB;CAUnB,OAAO,yBAAyB,MARf,gBACf,SACA,YACA,gBACA,SACA,iBACA,gBAEoC,GAAU,OAAO;AACzD;AAEA,SAAS,gBACP,SACA,YACA,SACA,SACA,iBACA,kBACU;CACV,IAAI,WAAqB;EACvB,KAAK,KAAA;EACL,QAAQ,KAAA;CACV;CACA,QAAQ,SAAS,OAAO,IAAxB;EACE,KAAK;GACH,WAAW;IACT,KAAK,QAAQ,OAAO;IACpB,QAAQ,KAAA;GACV;GACA;EACF,KAAK;GACH,WAAW;IACT,KAAK,KAAA;IACL,QAAQ,QAAQ,OAAO;GACzB;GACA;EACF,KAAK;GACH,WAAW;IACT,KAAK,QAAQ,OAAO;IACpB,QAAQ,QAAQ,OAAO;GACzB;GACA;CACJ;CAEA,IAAI,SACF,WAAW,mBAAmB,UAAU,SAAS,OAAO;CAG1D,IAAI,YACF,WAAW,sBAAsB,UAAU,UAAU;CAGvD,WAAW,gCAAgC,UAAU,gBAAgB;CAErE,IAAI,iBACF,WAAW,2BAA2B,UAAU,eAAe;CAGjE,OAAO;AACT;AAEA,SAAS,gCACP,UACA,kBACU;CACV,IAAI,CAAC,kBAAkB,OAAO;CAC9B,KAAK,MAAM,MAAM,kBACf,IAAI,GAAG,SAAS,GACd,WAAW,2BAA2B,UAAU,EAAE;CAGtD,OAAO;AACT;AAIA,SAAS,2BACP,EAAC,KAAK,UACN,iBACU;CACV,MAAM,cAAc,QAAyB;EAC3C,IAAI,QAAQ,KAAA,GAAW,OAAO;EAC9B,KAAK,MAAM,KAAK,iBACd,IAAI,qBAAqB,GAAG,GAAG,GAAG,OAAO;EAE3C,OAAO;CACT;CACA,OAAO;EACL,KAAK,WAAW,GAAG,IAAI,MAAM,KAAA;EAC7B,QAAQ,WAAW,MAAM,IAAI,SAAS,KAAA;CACxC;AACF;AAIA,SAAS,mBACP,EAAC,KAAK,UACN,SACA,SACU;CACV,MAAM,4BAA4B,QAChC,QAAQ,KAAA,KAAa,QAAQ,KAAK,OAAO,IAAI,IAAI,KAAA,IAAY;CAC/D,OAAO;EACL,KAAK,yBAAyB,GAAG;EACjC,QAAQ,yBAAyB,MAAM;CACzC;AACF;AAIA,SAAS,sBACP,EAAC,KAAK,UACN,YACU;CACV,MAAM,oCAAoC,QACxC,QAAQ,KAAA,KAAa,CAAC,qBAAqB,YAAY,GAAG,IACtD,KAAA,IACA;CAEN,OAAO;EACL,KAAK,iCAAiC,GAAG;EACzC,QAAQ,iCAAiC,MAAM;CACjD;AACF;AAEA,SAAS,2BACP,EAAC,KAAK,UACN,iBACU;CACV,MAAM,gCAAgC,QACpC,QAAQ,KAAA,KAAa,CAAC,gBAAgB,GAAG,IAAI,KAAA,IAAY;CAE3D,OAAO;EACL,KAAK,6BAA6B,GAAG;EACrC,QAAQ,6BAA6B,MAAM;CAC7C;AACF;AAEA,UAAiB,yBACf,aACA,UACA,SACA;CACA,IAAI,oBAAoB;CACxB,IAAI,uBAAuB;CAC3B,KAAK,MAAM,OAAO,aAAa;EAC7B,IAAI,CAAC,qBAAqB,SAAS;OACrB,QAAQ,SAAS,KAAK,GAC9B,IAAM,GAAG;IACX,oBAAoB;IACpB,MAAM;KAAC,KAAK,SAAS;KAAK,eAAe,CAAC;IAAC;GAC7C;;EAGF,IAAI,CAAC,wBAAwB,SAAS;OACxB,QAAQ,SAAS,QAAQ,GACjC,MAAQ,GAAG;IACb,uBAAuB;IACvB;GACF;;EAEF,MAAM;GAAC;GAAK,eAAe,CAAC;EAAC;CAC/B;CAEA,IAAI,CAAC,qBAAqB,SAAS,KACjC,MAAM;EAAC,KAAK,SAAS;EAAK,eAAe,CAAC;CAAC;AAE/C;;;;;;AAOA,UAAiB,6BACf,MACA,YACA,SACA,iBACA,YACA,iBACA,kBACA;CACA,IAAI,iBAAsC,KAAA;CAC1C,IAAI,WAAW,mBAAmB,QAAQ,OACxC,iBAAiB;CAEnB,IAAI,WAAqB;EAAC,KAAK,KAAA;EAAW,QAAQ,KAAA;CAAS;CAC3D,QAAQ,gBAAgB,OAAO,IAA/B;EACE,KAAK;GACH,WAAW;IACT,KAAK,eAAe,OAAO;IAC3B,QAAQ,KAAA;GACV;GACA;EACF,KAAK;GACH,WAAW;IACT,KAAK,KAAA;IACL,QAAQ,eAAe,OAAO;GAChC;GACA;EACF,KAAK;GACH,WAAW;IACT,KAAK,eAAe,OAAO;IAC3B,QAAQ,eAAe,OAAO;GAChC;GACA;CACJ;CACA,IAAI,YACF,WAAW,sBAAsB,UAAU,UAAU;CAEvD,WAAW,gCAAgC,UAAU,gBAAgB;CACrE,IAAI,iBACF,WAAW,2BAA2B,UAAU,eAAe;CAEjE,OAAO,kCAAkC,MAAM,UAAU,UAAU;AACrE;AAEA,UAAiB,kCACf,aACA,UACA,YACA;CAEA,IAAI,SAAS,KACX,MAAM;EAAC,KAAK,SAAS;EAAK,eAAe,CAAC;CAAC;CAG7C,IAAI,gBAAgB;CACpB,KAAK,MAAM,OAAO,aAAa;EAC7B,IACE,CAAC,iBACD,SAAS,UACT,aAAa,SAAS,QAAQ,KAAK,UAAU,GAC7C;GACA,gBAAgB;GAChB;EACF;EACA,MAAM;GAAC;GAAK,eAAe,CAAC;EAAC;CAC/B;AACF;AAEA,SAAS,aAAa,GAAQ,GAAQ,YAAiC;CACrE,KAAK,MAAM,OAAO,YAChB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,GAC7B,OAAO;CAGX,OAAO;AACT;AASA,IAAM,WAAW,OAAO,WAAW;AAEnC,IAAM,WAAW,OAAO,WAAW;AAGnC,SAAS,oBAAoB,MAA4B;CAMvD,MAAM,MAAM,KAAK;CACjB,MAAM,KAAK,KAAK,GAAG;CACnB,MAAM,KAAK,KAAK,GAAG,OAAO;CAC1B,MAAM,KAAK,MAAM,IAAI,KAAK,GAAG,KAAK;CAClC,MAAM,KAAK,MAAM,IAAI,KAAK,GAAG,OAAO,QAAQ;CAE5C,QAAQ,GAAa,MAAgB;EACnC,MAAM,KAAK,KAAK,cAAc,EAAE,KAAK,EAAE,GAAG,IAAI,cAAc,EAAE,KAAK,EAAE,GAAG;EACxE,IAAI,QAAQ,KAAK,OAAO,GAAG,OAAO;EAClC,MAAM,KAAK,KAAK,cAAc,EAAE,KAAK,EAAE,GAAG,IAAI,cAAc,EAAE,KAAK,EAAE,GAAG;EACxE,IAAI,QAAQ,KAAK,OAAO,GAAG,OAAO;EAElC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,KAAK;GAC5B,MAAM,MAAM,cAAc,EAAE,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,GAAG;GACtD,IAAI,QAAQ,GAAG,OAAO,KAAK,GAAG,OAAO,QAAQ,MAAM,CAAC;EACtD;EACA,OAAO;CACT;AACF;AAEA,SAAS,cAAc,GAAU,GAAkB;CACjD,IAAI,MAAM,GACR,OAAO;CAMT,IAAI,OAAO,MAAM,UACf,OAAO,MAAM,WAAW,KAAK;CAE/B,IAAI,OAAO,MAAM,UACf,OAAO,MAAM,WAAW,IAAI;CAE9B,OAAO,cAAc,GAAG,CAAC;AAC3B;AAEA,UAAU,aACR,MACA,WACA,SACA;CACA,OAAO,KAAK,UAAU,uBAAuB,cAC3C,SACF;AACF;AAEA,SAAgB,UAAU,QAAsB;CAC9C,OAAO,KAAK,UAAU,SAAS,GAAG,MAChC,OAAO,MAAM,WAAW,EAAE,SAAS,IAAI,CACzC;AACF;;;;;;;;;;;;;;;;;;;AAoBA,UAAiB,mBACf,SACA,SACwB;CACxB,MAAM,YAAwC,QAAQ,KAAI,MACxD,EAAE,OAAO,UAAU,CACrB;CAIA,MAAM,SAAoB,IAAI,MAAM,UAAU,MAAM,EAAE,KAAK,IAAI;CAK/D,MAAM,OAAgB,CAAC;CAEvB,MAAM,UAAU,UAAkB;EAChC,IAAI,IAAI;EACR,OAAO,IAAI,GAAG;GACZ,MAAM,IAAK,IAAI,KAAM;GACrB,IAAI,QAAQ,KAAK,GAAG,KAAK,KAAK,GAAG,GAAG,KAAK,GAAG;GAC5C,MAAM,IAAI,KAAK;GACf,KAAK,KAAK,KAAK;GACf,KAAK,KAAK;GACV,IAAI;EACN;CACF;CAEA,MAAM,YAAY,UAAkB;EAClC,IAAI,IAAI;EACR,MAAM,IAAI,KAAK;EACf,OAAO,MAAM;GACX,MAAM,KAAK,KAAK,KAAK;GACrB,MAAM,IAAI,IAAI;GACd,IAAI,WAAW;GACf,IAAI,IAAI,KAAK,QAAQ,KAAK,GAAG,KAAK,KAAK,UAAU,GAAG,IAAI,GAAG,WAAW;GACtE,IAAI,IAAI,KAAK,QAAQ,KAAK,GAAG,KAAK,KAAK,UAAU,GAAG,IAAI,GAAG,WAAW;GACtE,IAAI,aAAa,GAAG;GACpB,MAAM,IAAI,KAAK;GACf,KAAK,KAAK,KAAK;GACf,KAAK,YAAY;GACjB,IAAI;EACN;CACF;CAIA,MAAM,WAAW,WACf,KACiD;EACjD,OAAO,MAAM;GACX,MAAM,IAAI,UAAU,KAAK,KAAK;GAC9B,IAAI,EAAE,MAAM;IACV,OAAO,OAAO;IACd;GACF;GACA,IAAI,EAAE,UAAU,SAAS;IACvB,MAAM;IACN;GACF;GACA,OAAO,EAAE;EACX;CACF;CAEA,IAAI;EAEF,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,MAAM,OAAO,SAAS,CAAC;GAC7B,IAAI,QAAQ,KAAA,GAAW;IACrB,KAAK,KAAK;KAAC;KAAK,KAAK;IAAC,CAAC;IACvB,OAAO,KAAK,SAAS,CAAC;GACxB;EACF;EAEA,OAAO,KAAK,SAAS,GAAG;GAEtB,MAAM,MAAM,KAAK;GACjB,MAAM,IAAI;GACV,MAAM,OAAO,OAAO,SAAS,IAAI,GAAG;GACpC,IAAI,SAAS,KAAA,GAAW;IAItB,IAAI,MAAM;IACV,SAAS,CAAC;GACZ,OAAO;IAIL,MAAM,OAAO,KAAK,KAAK,IAAI,CAAC;IAC5B,IAAI,KAAK,SAAS,GAAG;KACnB,KAAK,KAAK;KACV,SAAS,CAAC;IACZ;GACF;EACF;CACF,UAAU;EAGR,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KACpC,IAAI,OAAO,IACT,UAAU,GAAG,SAAS;CAG5B;AACF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocicorp/zero",
-  "version": "1.7.0",
+  "version": "1.8.0-canary.1",
   "description": "Zero is a web framework for serverless web development.",
   "homepage": "https://zero.rocicorp.dev",
   "bugs": {

package/out/zero-cache/src/services/change-streamer/backup-monitor.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"backup-monitor.js","names":["#lc","#replicaFile","#backupURL","#metricsEndpoint","#changeStreamer","#state","#reservations","#watermarks","#verifyBackupState","#purgesBlocked","#fatal","#cleanupDelayMs","#checkMetricsTimer","#initBackupLagMetric","#checkWatermarks","#scheduleCleanup","#fetchWatermarks","#lastWatermark","#latestBackupTime","#maxWatermarkUpTo","#confirmedDurable","#lastVerifiedUploadTime","#backupStaleSince","#shutDownOnWedgedBackup"],"sources":["../../../../../../zero-cache/src/services/change-streamer/backup-monitor.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport parsePrometheusTextFormat from 'parse-prometheus-text-format';\nimport {must} from '../../../../shared/src/must.ts';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {\n  getOrCreateCounter,\n  getOrCreateGauge,\n} from '../../observability/metrics.ts';\nimport {Subscription} from '../../types/subscription.ts';\nimport {RunningState, UnrecoverableError} from '../running-state.ts';\nimport type {Service} from '../service.ts';\nimport type {ChangeStreamerService} from './change-streamer.ts';\nimport type {SnapshotMessage} from './snapshot.ts';\n\nexport const CHECK_INTERVAL_MS = 60_000;\nconst MIN_CLEANUP_DELAY_MS = 30_000;\n\n/**\n * Allowance for clock skew between the machine reporting litestream metrics\n * and the timestamps reported by the backup destination (e.g. S3).\n */\nexport const BACKUP_VERIFICATION_SLACK_MS = 60_000;\n\n/**\n * How long the actual backup state may remain *continuously* behind the\n * backup progress claimed by litestream metrics before the backup is\n * considered genuinely wedged and the process is shut down.\n *\n * A wedged backup is dangerous: litestream believes it is making durable\n * progress when it is not, which can silently corrupt the backup (the WAL\n * format only makes *some* such gaps detectable). Once that is confirmed to\n * be the persistent state, continuing to run is worse than crashing, so the\n * process exits loudly (non-zero, with a logged error) and the wedged backup\n * destination becomes the priority to investigate.\n *\n * The change-log is conservatively *not* purged for the entire time the\n * backup is stale, so the only cost of a generous grace period is unbounded\n * change-log growth. We therefore err well on the side of slack: the backup\n * must stay stuck across many {@link CHECK_INTERVAL_MS} checks before we tear\n * the server down, so that a transient hiccup (a slow or briefly unreachable\n * destination, or litestream restarting) does not trigger a shutdown. The\n * staleness clock is reset the moment a purge is confirmed against a real\n * upload.\n */\nexport const WEDGED_SHUTDOWN_GRACE_MS = 15 * 60_000; // 15 minutes\n\n/**\n * Returns the time of the most recent object actually uploaded to the\n * backup replica destination (e.g. as determined by listing the snapshots\n * and WAL segments in S3). Rejects if the backup state cannot be determined.\n *\n * See `getLastBackupTime()` in `../litestream/commands.ts` for the\n * production implementation.\n */\nexport type BackupStateVerifier = () => Promise<Date>;\n\ntype Reservation = {\n  start: Date;\n  sub: Subscription<SnapshotMessage>;\n};\n\n/**\n * The BackupMonitor polls the litestream \"/metrics\" endpoint to track the\n * watermark (label) value of the `litestream_replica_progress` gauge and\n * schedules cleanup of change log entries that can be purged as a result.\n *\n * See: https://github.com/rocicorp/litestream/pull/3\n *\n * Note that change log entries cannot simply be purged as soon as they\n * have been applied and backed up by litestream. Consider the case in which\n * litestream backs up new wal segments every minute, but it takes 5 minutes\n * to restore a replica: if a zero-cache starts restoring a replica at\n * minute 0, and new watermarks are replicated at minutes 1, 2, 3, 4, and 5,\n * purging changelog records as soon as those watermarks are replicated would\n * result in the zero-cache not being able to catch up from minute 0 once it\n * has finished restoring the replica.\n *\n * The `/snapshot` reservation protocol is used to prevent premature change\n * log cleanup:\n * - Clients restoring a snapshot initiate a `/snapshot` request and hold that\n *   request open while it restores its snapshot, prepares it, and\n *   starts its subscription to the change stream. During this time, no\n *   cleanups are scheduled.\n * - When the subscription is started, the interval since the beginning of\n *   of the reservation is tracked to increase the background cleanup delay\n *   interval if needed. The reservation is ended (and request closed), and\n *   cleanup scheduling is resumed with the current delay interval.\n *\n * Note that the reservation request is the primary mechanism by which\n * premature change log cleanup is prevented. The cleanup delay interval is\n * a secondary safeguard.\n *\n * Additionally, because the watermarks reported by litestream metrics\n * reflect what litestream *believes* has been backed up (which has been\n * observed to diverge from reality when uploads silently fail), the cleanup\n * watermark is only advanced after verifying it against the actual backup\n * state in the replica destination via a {@link BackupStateVerifier}. If the\n * actual backup state stays behind the claimed progress for longer than\n * {@link WEDGED_SHUTDOWN_GRACE_MS}, the backup is treated as wedged and the\n * process is shut down rather than risk corrupting the backup.\n */\nexport class BackupMonitor implements Service {\n  readonly id = 'backup-monitor';\n  readonly #lc: LogContext;\n  readonly #replicaFile: string;\n  readonly #backupURL: string;\n  readonly #metricsEndpoint: string;\n  readonly #changeStreamer: ChangeStreamerService;\n  readonly #state = new RunningState(this.id);\n\n  readonly #reservations = new Map<string, Reservation>();\n  readonly #watermarks = new Map<string, Date>();\n\n  readonly #verifyBackupState: BackupStateVerifier;\n  readonly #purgesBlocked = getOrCreateCounter('replica', 'purge_blocked', {\n    description:\n      'Number of change-log purges blocked because the actual backup state ' +\n      '(as listed from the replica destination) could not be verified, or ' +\n      'is older than the backup progress claimed by litestream metrics. ' +\n      'A steadily increasing value indicates a wedged or failing backup. ' +\n      'The \"backup-wedged\" reason is emitted once just before the process ' +\n      'shuts itself down due to a persistently stale backup.',\n  });\n\n  // Rejected when the backup is determined to be genuinely wedged, which\n  // surfaces as a rejection of the `run()` promise and shuts the process down.\n  readonly #fatal = resolver<void>();\n\n  #lastWatermark: string = '';\n  #latestBackupTime: Date | null = null;\n  #lastVerifiedUploadTime: Date | null = null;\n  // Epoch ms at which the actual backup state was first observed to be\n  // continuously behind the watermark litestream claims to have backed up,\n  // or `null` while the backup is keeping up. Reset whenever a purge is\n  // confirmed against a real upload.\n  #backupStaleSince: number | null = null;\n  #cleanupDelayMs: number;\n  #checkMetricsTimer: NodeJS.Timeout | undefined;\n\n  constructor(\n    lc: LogContext,\n    replicaFile: string,\n    backupURL: string,\n    metricsEndpoint: string,\n    changeStreamer: ChangeStreamerService,\n    initialCleanupDelayMs: number,\n    verifyBackupState: BackupStateVerifier,\n  ) {\n    this.#lc = lc.withContext('component', this.id);\n    this.#replicaFile = replicaFile;\n    this.#backupURL = backupURL;\n    this.#metricsEndpoint = metricsEndpoint;\n    this.#changeStreamer = changeStreamer;\n    this.#verifyBackupState = verifyBackupState;\n    this.#cleanupDelayMs = Math.max(\n      initialCleanupDelayMs,\n      MIN_CLEANUP_DELAY_MS, // purely for peace of mind\n    );\n\n    this.#lc.info?.(\n      `backup monitor started ${initialCleanupDelayMs} ms after snapshot restore`,\n    );\n  }\n\n  run(): Promise<void> {\n    this.#lc.info?.(\n      `monitoring backups at ${this.#metricsEndpoint} with ` +\n        `${this.#cleanupDelayMs} ms cleanup delay`,\n    );\n    this.#checkMetricsTimer = setInterval(\n      this.checkWatermarksAndScheduleCleanup,\n      CHECK_INTERVAL_MS,\n    );\n    this.#initBackupLagMetric();\n    // Resolves on a normal stop; rejects if the backup is found to be wedged.\n    return Promise.race([this.#state.stopped(), this.#fatal.promise]);\n  }\n\n  startSnapshotReservation(taskID: string): Subscription<SnapshotMessage> {\n    this.#lc.info?.(`pausing change-log cleanup while ${taskID} snapshots`);\n    // In the case of retries, only track the last reservation.\n    this.#reservations.get(taskID)?.sub.cancel();\n\n    const sub = Subscription.create<SnapshotMessage>({\n      // If the reservation still exists when the connection closes\n      // (e.g. subscriber crashed), clean it up without updating the\n      // cleanup delay.\n      cleanup: () => this.endReservation(taskID, false),\n    });\n    this.#reservations.set(taskID, {start: new Date(), sub});\n    // Note: the Subscription must be returned immediately so that the\n    //       websocket can begin sending liveness pings.\n    void this.#changeStreamer\n      .getChangeLogState()\n      .then(changeLogState => {\n        sub.push([\n          'status',\n          {tag: 'status', backupURL: this.#backupURL, ...changeLogState},\n        ]);\n      })\n      .catch(e => {\n        this.#lc.warn?.(`failing snapshot reservation`, e);\n        sub.fail(e);\n      });\n    return sub;\n  }\n\n  endReservation(taskID: string, updateCleanupDelay = true) {\n    const res = this.#reservations.get(taskID);\n    if (res === undefined) {\n      return;\n    }\n    this.#reservations.delete(taskID);\n    const {start, sub} = res;\n    sub.cancel(); // closes the connection if still open\n\n    if (updateCleanupDelay) {\n      const duration = Date.now() - start.getTime();\n      this.#lc.info?.(`snapshot initialized by ${taskID} in ${duration} ms`);\n      if (duration > this.#cleanupDelayMs) {\n        this.#cleanupDelayMs = duration;\n        this.#lc.info?.(`increased cleanup delay to ${duration} ms`);\n      }\n    }\n  }\n\n  // Exported for testing\n  readonly checkWatermarksAndScheduleCleanup = async () => {\n    try {\n      await this.#checkWatermarks();\n    } catch (e) {\n      this.#lc.warn?.(`unable to fetch metrics at ${this.#metricsEndpoint}`, e);\n    }\n    try {\n      await this.#scheduleCleanup();\n    } catch (e) {\n      this.#lc.warn?.(`error scheduling cleanup`, e);\n    }\n  };\n\n  async *#fetchWatermarks(): AsyncGenerator<{\n    watermark: string;\n    time: Date;\n    name?: string | undefined;\n  }> {\n    const metricsEndpoint = this.#metricsEndpoint;\n    const signal = this.#state.signal;\n    let resp;\n    try {\n      resp = await fetch(metricsEndpoint, {signal});\n    } catch (e) {\n      if (signal.aborted) {\n        // not an error.\n        return;\n      }\n      // Treat exceptions from fetch (e.g. network errors) as non-fatal, and simply\n      // log them and skip the watermark check until the next interval.\n      this.#lc.warn?.(`unable to fetch metrics at ${this.#metricsEndpoint}`, e);\n      return;\n    }\n    if (!resp.ok) {\n      this.#lc.warn?.(\n        `unable to fetch metrics at ${this.#metricsEndpoint}: ${await resp.text()}`,\n      );\n      return;\n    }\n\n    const families = parsePrometheusTextFormat(await resp.text());\n    for (const family of families) {\n      if (\n        family.type === 'GAUGE' &&\n        family.name === 'litestream_replica_progress'\n      ) {\n        for (const metric of family.metrics) {\n          const watermark = metric.labels?.watermark;\n          const name = metric.labels?.name;\n          const time = new Date(parseFloat(metric.value) * 1000);\n\n          if (watermark) {\n            yield {watermark, time, name};\n          }\n        }\n      }\n    }\n  }\n\n  async #checkWatermarks() {\n    for await (const {watermark, name, time} of this.#fetchWatermarks()) {\n      if (watermark > this.#lastWatermark && !this.#watermarks.has(watermark)) {\n        this.#lc.info?.(\n          `replicated watermark=${watermark} to ${name}` +\n            ` at ${time.toISOString()}.`,\n        );\n        this.#watermarks.set(watermark, time);\n        this.#latestBackupTime = time;\n      }\n    }\n    return this.#latestBackupTime;\n  }\n\n  async #scheduleCleanup() {\n    if (this.#reservations.size > 0) {\n      this.#lc.info?.(\n        `watermark cleanup paused for snapshot(s): ${[...this.#reservations.keys()]}`,\n      );\n      return;\n    }\n    const latestCleanupTime = Date.now() - this.#cleanupDelayMs;\n    const maxWatermark = this.#maxWatermarkUpTo(latestCleanupTime);\n    if (maxWatermark.length === 0) {\n      return;\n    }\n    // Purge guard: the watermarks (and their backup times) come from\n    // litestream metrics, which are exported when litestream *believes*\n    // an upload succeeded, and have been observed to advance even when\n    // nothing was actually written to the backup destination. Purging the\n    // change-log based on a falsely advancing watermark permanently breaks\n    // the ability to restore + catch up. Before advancing the cleanup\n    // watermark, verify it against the actual backup state: a claimed\n    // backup time is only trusted if an object was actually uploaded to\n    // the replica destination at (or after) that time, modulo clock skew.\n    const claimedTime = must(this.#watermarks.get(maxWatermark));\n    if (!this.#confirmedDurable(claimedTime)) {\n      try {\n        this.#lastVerifiedUploadTime = await this.#verifyBackupState();\n      } catch (e) {\n        this.#purgesBlocked.add(1, {reason: 'verification-failed'});\n        // Skipping the purge is safe: the change-log just grows.\n        this.#lc.warn?.(\n          `unable to verify backup state. skipping change-log cleanup ` +\n            `up to watermark ${maxWatermark} ` +\n            `(claimed backup time ${claimedTime.toISOString()})`,\n          e,\n        );\n        return;\n      }\n    }\n    // Watermarks whose backup time isn't yet confirmed durable remain in the\n    // map and are re-evaluated at the next check.\n    const lastUpload = must(this.#lastVerifiedUploadTime);\n    const verifiedWatermark = this.#maxWatermarkUpTo(\n      Math.min(\n        latestCleanupTime,\n        lastUpload.getTime() + BACKUP_VERIFICATION_SLACK_MS,\n      ),\n    );\n    if (verifiedWatermark.length === 0) {\n      this.#purgesBlocked.add(1, {reason: 'backup-stale'});\n      const now = Date.now();\n      if (this.#backupStaleSince === null) {\n        this.#backupStaleSince = now;\n      }\n      const staleForMs = now - this.#backupStaleSince;\n      this.#lc.warn?.(\n        `blocked change-log cleanup up to watermark ${maxWatermark}: ` +\n          `litestream claims it was backed up at ` +\n          `${claimedTime.toISOString()}, but the last object actually ` +\n          `uploaded to ${this.#backupURL} was at ` +\n          `${lastUpload.toISOString()}. ` +\n          `The backup has been stale for ${staleForMs} ms.`,\n      );\n      if (staleForMs >= WEDGED_SHUTDOWN_GRACE_MS) {\n        this.#shutDownOnWedgedBackup(staleForMs, claimedTime, lastUpload);\n      }\n      return;\n    }\n    // The cleanup watermark advanced past a real upload, so the backup is\n    // keeping up: clear the staleness clock.\n    this.#backupStaleSince = null;\n    this.#changeStreamer.scheduleCleanup(verifiedWatermark);\n    for (const watermark of this.#watermarks.keys()) {\n      if (watermark <= verifiedWatermark) {\n        this.#watermarks.delete(watermark);\n      }\n    }\n    this.#lastWatermark = verifiedWatermark;\n  }\n\n  /**\n   * Called when the backup has been continuously stale for longer than\n   * {@link WEDGED_SHUTDOWN_GRACE_MS}. Continuing to run risks corrupting the\n   * backup, so the process is shut down by rejecting the {@link run()}\n   * promise. The exit is non-zero and logged at ERROR for alerting; on\n   * restart the monitor re-verifies, so a still-wedged backup keeps the\n   * process down until the destination is fixed.\n   */\n  #shutDownOnWedgedBackup(\n    staleForMs: number,\n    claimedTime: Date,\n    lastUpload: Date,\n  ) {\n    this.#purgesBlocked.add(1, {reason: 'backup-wedged'});\n    const err = new UnrecoverableError(\n      `backup at ${this.#backupURL} is wedged: litestream claims a backup ` +\n        `at ${claimedTime.toISOString()}, but the last object actually ` +\n        `uploaded was at ${lastUpload.toISOString()}, and the backup has ` +\n        `not advanced for ${staleForMs} ms (grace period ` +\n        `${WEDGED_SHUTDOWN_GRACE_MS} ms). Shutting down to avoid corrupting ` +\n        `the backup; investigate the backup destination.`,\n    );\n    this.#lc.error?.(err.message);\n    clearInterval(this.#checkMetricsTimer);\n    this.#fatal.reject(err);\n  }\n\n  /**\n   * Returns the newest watermark whose backup time is at or before `cutoff`\n   * (epoch ms), or `''` if there is none.\n   */\n  #maxWatermarkUpTo(cutoff: number): string {\n    let max = '';\n    for (const [watermark, backupTime] of this.#watermarks) {\n      if (backupTime.getTime() <= cutoff && watermark > max) {\n        max = watermark;\n      }\n    }\n    return max;\n  }\n\n  /**\n   * Returns `true` if the actual backup state, as last verified against the\n   * backup destination, confirms that data claimed to be backed up at\n   * `claimedTime` is durable (i.e. an object was actually uploaded at or\n   * after `claimedTime`, allowing {@link BACKUP_VERIFICATION_SLACK_MS} of\n   * clock skew).\n   */\n  #confirmedDurable(claimedTime: Date): boolean {\n    const lastUpload = this.#lastVerifiedUploadTime;\n    return (\n      lastUpload !== null &&\n      claimedTime.getTime() <=\n        lastUpload.getTime() + BACKUP_VERIFICATION_SLACK_MS\n    );\n  }\n\n  stop(): Promise<void> {\n    clearInterval(this.#checkMetricsTimer);\n    for (const {sub} of this.#reservations.values()) {\n      // Close any pending reservations. This commonly happens when a new\n      // replication-manager makes a `/snapshot` reservation on the existing\n      // replication-manager, and then shuts it down when it takes over the\n      // replication slot.\n      sub.cancel();\n    }\n    this.#state.stop(this.#lc);\n    return promiseVoid;\n  }\n\n  #initBackupLagMetric() {\n    getOrCreateGauge('replica', 'backup_lag', {\n      description:\n        'Latency from when a change is written to the replica ' +\n        'to when it is backed up to litestream. It is expected to create a saw ' +\n        'pattern from 0 to the configured ZERO_LITESTREAM_INCREMENTAL_BACKUP_INTERVAL_MINUTES.',\n      unit: 'millisecond',\n    }).addCallback(async o => {\n      // For legacy litestream, we use the watermark metric (and its associated\n      // backup time) exported by litestream metrics to determine the time of\n      // of the backed up watermark. This is technically imprecise--it would be\n      // more correct to use the committed writeTimeMs--but it is good enough\n      // in that it serves the purpose of detecting a non-functioning backup.\n      // With litestream v5, this can be made more precise by querying the\n      // _zero.replicationState row from the backup directly using an LTX-based\n      // database reader.\n      const latestBackup = await this.#checkWatermarks();\n      if (!latestBackup) {\n        this.#lc.warn?.(\n          `no backed up watermarks. unable to report replica.backup_lag`,\n        );\n        return;\n      }\n      const db = new Database(this.#lc, this.#replicaFile, {readonly: true});\n      try {\n        const {writeTimeMs} = db\n          .prepare(/*sql*/ `SELECT writeTimeMs FROM \"_zero.replicationState\"`)\n          .get<{writeTimeMs: number}>();\n        const backupLag = Math.max(0, writeTimeMs - latestBackup.getTime());\n        o.observe(backupLag);\n      } catch (e) {\n        this.#lc.warn?.(`error measuring replica.backup_lag metric`, e);\n      } finally {\n        db.close();\n      }\n    });\n  }\n}\n"],"mappings":"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"}