@rocicorp/zero 1.12.0-canary.0 → 1.12.0-canary.10

package/out/zqlite/src/db.js.map

@@ -1 +1 @@
-{"version":3,"file":"db.js","names":["#db","#threshold","#lc","#pageSize","#run","#bytes","#stmt","#attrs","#logIfSlow","#it","#start","#sqliteRowTimeSum","#log","#logged"],"sources":["../../../../zqlite/src/db.ts"],"sourcesContent":["import {trace, type Attributes} from '@opentelemetry/api';\nimport type {LogContext} from '@rocicorp/logger';\nimport SQLite3Database, {\n  SqliteError,\n  type RunResult,\n  type Statement as SQLite3Statement,\n} from '@rocicorp/zero-sqlite3';\nimport {manualSpan} from '../../otel/src/span.ts';\nimport {version} from '../../otel/src/version.ts';\n\nconst tracer = trace.getTracer('view-syncer', version);\n\n// https://www.sqlite.org/pragma.html#pragma_auto_vacuum\nconst AUTO_VACUUM_INCREMENTAL = 2;\n\nconst MB = 1024 * 1024;\n\nfunction mb(bytes: number): string {\n  return (bytes / MB).toFixed(2);\n}\n\nexport class Database implements Disposable {\n  readonly #db: SQLite3Database.Database;\n  readonly #threshold: number;\n  readonly #lc: LogContext;\n  readonly #pageSize: number;\n\n  constructor(\n    lc: LogContext,\n    path: string,\n    options?: SQLite3Database.Options,\n    slowQueryThreshold = 100,\n  ) {\n    try {\n      this.#lc = lc.withContext('class', 'Database').withContext('path', path);\n      this.#db = new SQLite3Database(path, options);\n      this.#threshold = slowQueryThreshold;\n\n      // Keep the WAL when this is the last connection to close the database,\n      // which would otherwise checkpoint and delete it. Deleting it discards\n      // the WAL that a litestream backup continues from, forcing a new\n      // snapshot. See persistWal() for switching out of WAL mode.\n      this.#db.persistWal();\n\n      // Match Postgres LIKE/ILIKE semantics. Postgres LIKE is case-sensitive,\n      // but SQLite's LIKE operator is case-insensitive by default; enable\n      // case-sensitive LIKE so the bare operator matches Postgres. Case-\n      // insensitive ILIKE is handled in query-builder.ts by lower()-ing both\n      // operands (using the Unicode-aware lower() that @rocicorp/zero-sqlite3\n      // provides via ICU).\n      this.pragma('case_sensitive_like = ON');\n\n      const [{page_size: pageSize}] = this.pragma<{page_size: number}>(\n        'page_size',\n      );\n      this.#pageSize = pageSize;\n    } catch (cause) {\n      throw new DatabaseInitError(String(cause), {cause});\n    }\n  }\n\n  prepare(sql: string): Statement {\n    return this.#run(\n      'prepare',\n      sql,\n      () =>\n        new Statement(\n          this.#lc.withContext('sql', sql),\n          {class: 'Statement', sql},\n          this.#db.prepare(sql),\n          this.#threshold,\n        ),\n    );\n  }\n\n  exec(sql: string): void {\n    this.#run('exec', sql, () => this.#db.exec(sql));\n  }\n\n  pragma<T = unknown>(sql: string): T[] {\n    return this.#run<T[]>('pragma', sql, () => this.#db.pragma(sql) as T[]);\n  }\n\n  #bytes(pages: number) {\n    return pages * this.#pageSize;\n  }\n\n  compact(freeableBytesThreshold: number) {\n    const [{freelist_count: freelistCount}] = this.pragma<{\n      freelist_count: number;\n    }>('freelist_count');\n\n    const freeable = this.#bytes(freelistCount);\n    if (freeable < freeableBytesThreshold) {\n      this.#lc.debug?.(\n        `Not compacting ${this.#db.name}: ${mb(freeable)} freeable MB`,\n      );\n      return;\n    }\n    const [{auto_vacuum: autoVacuumMode}] = this.pragma<{auto_vacuum: number}>(\n      'auto_vacuum',\n    );\n    if (autoVacuumMode !== AUTO_VACUUM_INCREMENTAL) {\n      this.#lc.warn?.(\n        `Cannot compact ${mb(freeable)} MB of ` +\n          `${this.#db.name} because AUTO_VACUUM mode is ${autoVacuumMode}.`,\n      );\n      return;\n    }\n    const start = Date.now();\n    const [{page_count: pageCountBefore}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.pragma('incremental_vacuum');\n\n    const [{page_count: pageCountAfter}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.#lc.info?.(\n      `Compacted ${this.#db.name} from ` +\n        `${mb(this.#bytes(pageCountBefore))} MB to ` +\n        `${mb(this.#bytes(pageCountAfter))} MB ` +\n        `(${Date.now() - start} ms)`,\n    );\n  }\n\n  unsafeMode(unsafe: boolean) {\n    this.#db.unsafeMode(unsafe);\n  }\n\n  /**\n   * Toggles whether the WAL is kept when this is the last connection to close\n   * the database (on by default). Turn it off before switching the database\n   * out of WAL mode (e.g. `journal_mode = DELETE` or `OFF`): with it on, the\n   * WAL file is left behind and reopened by the next transaction, so the\n   * database effectively stays in WAL mode.\n   */\n  persistWal(persist: boolean) {\n    this.#db.persistWal(persist);\n  }\n\n  #run<T>(method: string, sql: string, fn: () => T): T {\n    const start = performance.now();\n    try {\n      return fn();\n    } catch (e) {\n      if (e instanceof SqliteError) {\n        e.message += `: ${sql}`;\n      }\n      throw e;\n    } finally {\n      const elapsed = performance.now() - start;\n      if (elapsed >= this.#threshold) {\n        logSlow(this.#lc.withContext('method', method), elapsed, {method});\n      }\n    }\n  }\n\n  /**\n   * Closes the database. For writable connections, `PRAGMA optimize` is run\n   * first (as recommended by SQLite) unless `optimize` is `false`, which is\n   * appropriate for short-lived handles on a database whose statistics are\n   * maintained by a longer-lived writer.\n   */\n  close({optimize = true}: {optimize?: boolean | undefined} = {}): void {\n    const start = Date.now();\n    if (optimize && !this.#db.readonly) {\n      try {\n        this.#db.pragma('optimize');\n        const elapsed = Date.now() - start;\n        if (elapsed > 2) {\n          this.#lc.debug?.(`PRAGMA optimized (${elapsed} ms)`);\n        }\n      } catch (e) {\n        this.#lc.warn?.('error running PRAGMA optimize', e);\n      }\n    }\n    this.#db.close();\n  }\n\n  transaction<T>(fn: () => T): T {\n    return this.#db.transaction(fn)();\n  }\n\n  get name() {\n    return this.#db.name;\n  }\n\n  get inTransaction() {\n    return this.#db.inTransaction;\n  }\n\n  [Symbol.dispose](): void {\n    this.close();\n  }\n}\n\nexport class Statement {\n  readonly #stmt: SQLite3Statement;\n  readonly #lc: LogContext;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  readonly scanStatus: SQLite3Statement['scanStatusV2'];\n  readonly scanStatusReset: SQLite3Statement['scanStatusReset'];\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    stmt: SQLite3Statement,\n    threshold: number,\n  ) {\n    this.#lc = lc.withContext('class', 'Statement');\n    this.#attrs = attrs;\n    this.#stmt = stmt;\n    this.#threshold = threshold;\n    this.scanStatus = this.#stmt.scanStatusV2.bind(this.#stmt);\n    this.scanStatusReset = this.#stmt.scanStatusReset.bind(this.#stmt);\n  }\n\n  safeIntegers(useBigInt: boolean): this {\n    this.#stmt.safeIntegers(useBigInt);\n    return this;\n  }\n\n  run(...params: unknown[]): RunResult {\n    const start = performance.now();\n    const ret = this.#stmt.run(...params);\n    this.#logIfSlow('run', performance.now() - start);\n    return ret;\n  }\n\n  get<T>(...params: unknown[]): T {\n    const start = performance.now();\n    const ret = this.#stmt.get(...params);\n    this.#logIfSlow('get', performance.now() - start);\n    return ret as T;\n  }\n\n  all<T>(...params: unknown[]): T[] {\n    const start = performance.now();\n    const ret = this.#stmt.all(...params);\n    this.#logIfSlow('all', performance.now() - start);\n    return ret as T[];\n  }\n\n  #logIfSlow(method: string, elapsed: number): void {\n    if (elapsed >= this.#threshold) {\n      logSlow(this.#lc.withContext('method', method), elapsed, {\n        ...this.#attrs,\n        method,\n      });\n    }\n  }\n\n  iterate<T>(...params: unknown[]): IterableIterator<T> {\n    return new LoggingIterableIterator(\n      this.#lc,\n      this.#attrs,\n      this.#stmt.iterate(...params),\n      this.#threshold,\n    ) as IterableIterator<T>;\n  }\n}\n\n// Bound consumer-time warnings across all databases and SQL statements in this\n// process. Nested iterators can all outlive the threshold during the same stall.\nconst ITERATOR_TOTAL_LOG_WINDOW_MS = 60_000;\nconst ITERATOR_TOTAL_LOG_LIMIT = 10;\nlet iteratorTotalLogWindowStart = -Infinity;\nlet iteratorTotalLogsInWindow = 0;\nlet suppressedIteratorTotalLogs = 0;\n\nfunction admitIteratorTotalLog(now: number): number | undefined {\n  if (now - iteratorTotalLogWindowStart >= ITERATOR_TOTAL_LOG_WINDOW_MS) {\n    iteratorTotalLogWindowStart = now;\n    iteratorTotalLogsInWindow = 0;\n  }\n  if (iteratorTotalLogsInWindow >= ITERATOR_TOTAL_LOG_LIMIT) {\n    suppressedIteratorTotalLogs++;\n    return undefined;\n  }\n  iteratorTotalLogsInWindow++;\n  const suppressedCount = suppressedIteratorTotalLogs;\n  suppressedIteratorTotalLogs = 0;\n  return suppressedCount;\n}\n\nclass LoggingIterableIterator<T> implements IterableIterator<T> {\n  readonly #lc: LogContext;\n  readonly #it: IterableIterator<T>;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  #start: number;\n  #sqliteRowTimeSum: number;\n  #logged = false;\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    it: IterableIterator<T>,\n    slowQueryThreshold: number,\n  ) {\n    this.#lc = lc;\n    this.#attrs = attrs;\n    this.#it = it;\n    this.#start = performance.now();\n    this.#threshold = slowQueryThreshold;\n    this.#sqliteRowTimeSum = 0;\n  }\n\n  next(): IteratorResult<T> {\n    const start = performance.now();\n    const ret = this.#it.next();\n    const elapsed = performance.now() - start;\n    this.#sqliteRowTimeSum += elapsed;\n    if (ret.done) {\n      this.#log();\n    }\n    return ret;\n  }\n\n  #log() {\n    // TableSource closes iterators in finally, including after next() is done.\n    if (this.#logged) {\n      return;\n    }\n    this.#logged = true;\n\n    // Total time includes downstream consumer work and waits between rows.\n    // Check it independently of the time spent stepping SQLite.\n    const now = performance.now();\n    const totalMs = now - this.#start;\n    if (totalMs >= this.#threshold) {\n      const suppressedCount = admitIteratorTotalLog(now);\n      if (suppressedCount !== undefined) {\n        logSlow(\n          this.#lc,\n          totalMs,\n          {\n            ...this.#attrs,\n            type: 'total',\n            method: 'iterate',\n            sqliteMs: this.#sqliteRowTimeSum,\n            ...(suppressedCount > 0 ? {suppressedCount} : undefined),\n          },\n          'Slow SQLite iterator total time (including consumer work and waits between rows)',\n        );\n      }\n    }\n    if (this.#sqliteRowTimeSum >= this.#threshold) {\n      logSlow(\n        this.#lc.withContext('method', 'iterate').withContext('type', 'sqlite'),\n        this.#sqliteRowTimeSum,\n        {\n          ...this.#attrs,\n          type: 'sqlite',\n          method: 'iterate',\n          totalMs,\n        },\n      );\n    }\n  }\n\n  [Symbol.iterator](): IterableIterator<T> {\n    return this;\n  }\n\n  return(): IteratorResult<T> {\n    this.#log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.return?.() as any;\n  }\n\n  throw(e: unknown): IteratorResult<T> {\n    this.#log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.throw?.(e) as any;\n  }\n}\n\nfunction logSlow(\n  lc: LogContext,\n  elapsed: number,\n  attrs: Attributes,\n  message = 'Slow SQLite query',\n): void {\n  for (const [key, value] of Object.entries(attrs)) {\n    lc = lc.withContext(key, value);\n  }\n  lc.warn?.(message, elapsed);\n  manualSpan(tracer, 'db.slow-query', elapsed, attrs);\n}\n\n/**\n * An error indicating that the Database failed to open. This essentially\n * wraps the TypeError thrown by the better-sqlite3 package with something\n * more specific.\n */\nexport class DatabaseInitError extends Error {}\n"],"mappings":"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"}
+{"version":3,"file":"db.js","names":[],"sources":["../../../../zqlite/src/db.ts"],"sourcesContent":["import {trace, type Attributes} from '@opentelemetry/api';\nimport type {LogContext} from '@rocicorp/logger';\nimport SQLite3Database, {\n  SqliteError,\n  type ColumnDefinition,\n  type RunResult,\n  type Statement as SQLite3Statement,\n  type StatementIterator as SQLite3StatementIterator,\n} from '@rocicorp/zero-sqlite3';\nimport {manualSpan} from '../../otel/src/span.ts';\nimport {version} from '../../otel/src/version.ts';\n\nconst tracer = trace.getTracer('view-syncer', version);\n\n// https://www.sqlite.org/pragma.html#pragma_auto_vacuum\nconst AUTO_VACUUM_INCREMENTAL = 2;\n\nconst MB = 1024 * 1024;\n\nfunction mb(bytes: number): string {\n  return (bytes / MB).toFixed(2);\n}\n\nexport class Database implements Disposable {\n  readonly #db: SQLite3Database.Database;\n  readonly #threshold: number;\n  readonly #lc: LogContext;\n  readonly #pageSize: number;\n\n  constructor(\n    lc: LogContext,\n    path: string,\n    options?: SQLite3Database.Options,\n    slowQueryThreshold = 100,\n  ) {\n    try {\n      this.#lc = lc.withContext('class', 'Database').withContext('path', path);\n      this.#db = new SQLite3Database(path, options);\n      this.#threshold = slowQueryThreshold;\n\n      // Keep the WAL when this is the last connection to close the database,\n      // which would otherwise checkpoint and delete it. Deleting it discards\n      // the WAL that a litestream backup continues from, forcing a new\n      // snapshot. See persistWal() for switching out of WAL mode.\n      this.#db.persistWal();\n\n      // Match Postgres LIKE/ILIKE semantics. Postgres LIKE is case-sensitive,\n      // but SQLite's LIKE operator is case-insensitive by default; enable\n      // case-sensitive LIKE so the bare operator matches Postgres. Case-\n      // insensitive ILIKE is handled in query-builder.ts by lower()-ing both\n      // operands (using the Unicode-aware lower() that @rocicorp/zero-sqlite3\n      // provides via ICU).\n      this.pragma('case_sensitive_like = ON');\n\n      const [{page_size: pageSize}] = this.pragma<{page_size: number}>(\n        'page_size',\n      );\n      this.#pageSize = pageSize;\n    } catch (cause) {\n      throw new DatabaseInitError(String(cause), {cause});\n    }\n  }\n\n  prepare(sql: string): Statement {\n    return this.#run(\n      'prepare',\n      sql,\n      () =>\n        new Statement(\n          this.#lc.withContext('sql', sql),\n          {class: 'Statement', sql},\n          this.#db.prepare(sql),\n          this.#threshold,\n        ),\n    );\n  }\n\n  exec(sql: string): void {\n    this.#run('exec', sql, () => this.#db.exec(sql));\n  }\n\n  pragma<T = unknown>(sql: string): T[] {\n    return this.#run<T[]>('pragma', sql, () => this.#db.pragma(sql) as T[]);\n  }\n\n  #bytes(pages: number) {\n    return pages * this.#pageSize;\n  }\n\n  compact(freeableBytesThreshold: number) {\n    const [{freelist_count: freelistCount}] = this.pragma<{\n      freelist_count: number;\n    }>('freelist_count');\n\n    const freeable = this.#bytes(freelistCount);\n    if (freeable < freeableBytesThreshold) {\n      this.#lc.debug?.(\n        `Not compacting ${this.#db.name}: ${mb(freeable)} freeable MB`,\n      );\n      return;\n    }\n    const [{auto_vacuum: autoVacuumMode}] = this.pragma<{auto_vacuum: number}>(\n      'auto_vacuum',\n    );\n    if (autoVacuumMode !== AUTO_VACUUM_INCREMENTAL) {\n      this.#lc.warn?.(\n        `Cannot compact ${mb(freeable)} MB of ` +\n          `${this.#db.name} because AUTO_VACUUM mode is ${autoVacuumMode}.`,\n      );\n      return;\n    }\n    const start = Date.now();\n    const [{page_count: pageCountBefore}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.pragma('incremental_vacuum');\n\n    const [{page_count: pageCountAfter}] = this.pragma<{page_count: number}>(\n      'page_count',\n    );\n\n    this.#lc.info?.(\n      `Compacted ${this.#db.name} from ` +\n        `${mb(this.#bytes(pageCountBefore))} MB to ` +\n        `${mb(this.#bytes(pageCountAfter))} MB ` +\n        `(${Date.now() - start} ms)`,\n    );\n  }\n\n  unsafeMode(unsafe: boolean) {\n    this.#db.unsafeMode(unsafe);\n  }\n\n  /**\n   * Toggles whether the WAL is kept when this is the last connection to close\n   * the database (on by default). Turn it off before switching the database\n   * out of WAL mode (e.g. `journal_mode = DELETE` or `OFF`): with it on, the\n   * WAL file is left behind and reopened by the next transaction, so the\n   * database effectively stays in WAL mode.\n   */\n  persistWal(persist: boolean) {\n    this.#db.persistWal(persist);\n  }\n\n  #run<T>(method: string, sql: string, fn: () => T): T {\n    const start = performance.now();\n    try {\n      return fn();\n    } catch (e) {\n      if (e instanceof SqliteError) {\n        e.message += `: ${sql}`;\n      }\n      throw e;\n    } finally {\n      const elapsed = performance.now() - start;\n      if (elapsed >= this.#threshold) {\n        logSlow(this.#lc.withContext('method', method), elapsed, {method});\n      }\n    }\n  }\n\n  /**\n   * Closes the database. For writable connections, `PRAGMA optimize` is run\n   * first (as recommended by SQLite) unless `optimize` is `false`, which is\n   * appropriate for short-lived handles on a database whose statistics are\n   * maintained by a longer-lived writer.\n   */\n  close({optimize = true}: {optimize?: boolean | undefined} = {}): void {\n    const start = Date.now();\n    if (optimize && !this.#db.readonly) {\n      try {\n        this.#db.pragma('optimize');\n        const elapsed = Date.now() - start;\n        if (elapsed > 2) {\n          this.#lc.debug?.(`PRAGMA optimized (${elapsed} ms)`);\n        }\n      } catch (e) {\n        this.#lc.warn?.('error running PRAGMA optimize', e);\n      }\n    }\n    this.#db.close();\n  }\n\n  transaction<T>(fn: () => T): T {\n    return this.#db.transaction(fn)();\n  }\n\n  get name() {\n    return this.#db.name;\n  }\n\n  get inTransaction() {\n    return this.#db.inTransaction;\n  }\n\n  [Symbol.dispose](): void {\n    this.close();\n  }\n}\n\nexport class Statement {\n  readonly #stmt: SQLite3Statement;\n  readonly #lc: LogContext;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  // Mirrors the native statement's mode, so that setting the mode it is\n  // already in, as callers sharing a cached statement do, stays in JS.\n  #mode: 'object' | 'raw' | 'pluck' = 'object';\n  readonly scanStatus: SQLite3Statement['scanStatusV2'];\n  readonly scanStatusReset: SQLite3Statement['scanStatusReset'];\n  #columnCount: number | undefined;\n  #safeIntegers: boolean | undefined;\n  #iterator: SQLite3StatementIterator | undefined;\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    stmt: SQLite3Statement,\n    threshold: number,\n  ) {\n    this.#lc = lc.withContext('class', 'Statement');\n    this.#attrs = attrs;\n    this.#stmt = stmt;\n    this.#threshold = threshold;\n    this.scanStatus = this.#stmt.scanStatusV2.bind(this.#stmt);\n    this.scanStatusReset = this.#stmt.scanStatusReset.bind(this.#stmt);\n  }\n\n  safeIntegers(useBigInt: boolean): this {\n    // Tracked here, like the row mode, to skip a native call per fetch.\n    if (this.#safeIntegers !== useBigInt) {\n      this.#stmt.safeIntegers(useBigInt);\n      this.#safeIntegers = useBigInt;\n    }\n    return this;\n  }\n\n  /**\n   * Return rows as arrays of column values instead of objects. Turning it\n   * off has no effect in pluck mode, as in better-sqlite3.\n   */\n  raw(enabled: boolean): this {\n    if (enabled ? this.#mode !== 'raw' : this.#mode === 'raw') {\n      this.#stmt.raw(enabled);\n      this.#mode = enabled ? 'raw' : 'object';\n    }\n    return this;\n  }\n\n  /**\n   * Return the first column of each row instead of the row. Turning it off\n   * has no effect in raw mode, as in better-sqlite3.\n   */\n  pluck(enabled: boolean): this {\n    if (enabled ? this.#mode !== 'pluck' : this.#mode === 'pluck') {\n      this.#stmt.pluck(enabled);\n      this.#mode = enabled ? 'pluck' : 'object';\n    }\n    return this;\n  }\n\n  /** The result columns, in the order of the values in a raw row. */\n  columns(): ColumnDefinition[] {\n    return this.#stmt.columns();\n  }\n\n  run(...params: unknown[]): RunResult {\n    const start = performance.now();\n    const ret = this.#stmt.run(...params);\n    this.#logIfSlow('run', performance.now() - start);\n    return ret;\n  }\n\n  get<T>(...params: unknown[]): T {\n    const start = performance.now();\n    const ret = this.#stmt.get(...params);\n    this.#logIfSlow('get', performance.now() - start);\n    return ret as T;\n  }\n\n  all<T>(...params: unknown[]): T[] {\n    const start = performance.now();\n    const ret = this.#stmt.all(...params);\n    this.#logIfSlow('all', performance.now() - start);\n    return ret as T[];\n  }\n\n  #logIfSlow(method: string, elapsed: number): void {\n    if (elapsed >= this.#threshold) {\n      logSlow(this.#lc.withContext('method', method), elapsed, {\n        ...this.#attrs,\n        method,\n      });\n    }\n  }\n\n  iterate<T>(...params: unknown[]): IterableIterator<T> {\n    return new LoggingIterableIterator(\n      this.#lc,\n      this.#attrs,\n      this.#stmt.iterate(...params),\n      this.#threshold,\n    ) as IterableIterator<T>;\n  }\n\n  /**\n   * Reads the statement's rows in batches. Integers are read as with\n   * `safeIntegers(true)`. The cursor must be {@link BatchCursor.close closed}.\n   */\n  batches(params: readonly unknown[]): BatchCursor {\n    this.#columnCount ??= this.#stmt.columns().length;\n    const log = new IterationLog(this.#lc, this.#attrs, this.#threshold);\n    this.safeIntegers(true).raw(true);\n    // Reuse the iterator of this statement's previous cursor, which is closed\n    // by then: creating one per fetch is a noticeable part of short fetches.\n    const it =\n      this.#iterator === undefined\n        ? (this.#iterator = this.#stmt.iterate(...params))\n        : this.#iterator.restart(...params);\n    return new BatchCursor(log, it, this.#columnCount);\n  }\n}\n\n/**\n * Reads a statement's rows a batch at a time with one native call per batch\n * (`nextBatch`), instead of one per row as `next()` does.\n */\nexport class BatchCursor {\n  readonly #log: IterationLog;\n  readonly #it: SQLite3StatementIterator;\n  readonly #columns: number;\n  #done = false;\n\n  constructor(\n    log: IterationLog,\n    it: SQLite3StatementIterator,\n    columns: number,\n  ) {\n    this.#log = log;\n    this.#it = it;\n    this.#columns = columns;\n  }\n\n  /**\n   * Reads up to `capacity` rows and returns their values in one row-major\n   * array, empty once the rows are exhausted.\n   */\n  next(capacity: number): (bigint | number | string | null)[] {\n    if (this.#done) {\n      return [];\n    }\n    const start = performance.now();\n    let values: (bigint | number | string | null)[];\n    try {\n      values = this.#it.nextBatch(capacity) as (\n        | bigint\n        | number\n        | string\n        | null\n      )[];\n    } catch (e) {\n      this.#done = true;\n      this.#log.log();\n      throw e;\n    } finally {\n      this.#log.addSQLiteTime(performance.now() - start);\n    }\n    if (values.length < capacity * this.#columns) {\n      // The iterator is finished, but the caller is still to consume this\n      // batch: close() logs, so that the total time includes that work.\n      this.#done = true;\n    }\n    return values;\n  }\n\n  /**\n   * Ends the cursor, abandoning any rows that were not read, and logs if the\n   * iteration was slow. Must be called once the rows are consumed.\n   */\n  close(): void {\n    if (!this.#done) {\n      this.#done = true;\n      this.#it.return?.();\n    }\n    this.#log.log();\n  }\n}\n\n// Bound consumer-time warnings across all databases and SQL statements in this\n// process. Nested iterators can all outlive the threshold during the same stall.\nconst ITERATOR_TOTAL_LOG_WINDOW_MS = 60_000;\nconst ITERATOR_TOTAL_LOG_LIMIT = 10;\nlet iteratorTotalLogWindowStart = -Infinity;\nlet iteratorTotalLogsInWindow = 0;\nlet suppressedIteratorTotalLogs = 0;\n\nfunction admitIteratorTotalLog(now: number): number | undefined {\n  if (now - iteratorTotalLogWindowStart >= ITERATOR_TOTAL_LOG_WINDOW_MS) {\n    iteratorTotalLogWindowStart = now;\n    iteratorTotalLogsInWindow = 0;\n  }\n  if (iteratorTotalLogsInWindow >= ITERATOR_TOTAL_LOG_LIMIT) {\n    suppressedIteratorTotalLogs++;\n    return undefined;\n  }\n  iteratorTotalLogsInWindow++;\n  const suppressedCount = suppressedIteratorTotalLogs;\n  suppressedIteratorTotalLogs = 0;\n  return suppressedCount;\n}\n\n/**\n * Logs slow iterations: once the time spent in SQLite, or the total time\n * including the consumer's work between rows, reaches the threshold.\n */\nclass IterationLog {\n  readonly #lc: LogContext;\n  readonly #threshold: number;\n  readonly #attrs: Attributes;\n  readonly #start: number;\n  #sqliteTimeSum = 0;\n  #logged = false;\n\n  constructor(lc: LogContext, attrs: Attributes, slowQueryThreshold: number) {\n    this.#lc = lc;\n    this.#attrs = attrs;\n    this.#start = performance.now();\n    this.#threshold = slowQueryThreshold;\n  }\n\n  addSQLiteTime(elapsed: number): void {\n    this.#sqliteTimeSum += elapsed;\n  }\n\n  log() {\n    // TableSource closes iterators in finally, including after next() is done.\n    if (this.#logged) {\n      return;\n    }\n    this.#logged = true;\n\n    // Total time includes downstream consumer work and waits between rows.\n    // Check it independently of the time spent stepping SQLite.\n    const now = performance.now();\n    const totalMs = now - this.#start;\n    if (totalMs >= this.#threshold) {\n      const suppressedCount = admitIteratorTotalLog(now);\n      if (suppressedCount !== undefined) {\n        logSlow(\n          this.#lc,\n          totalMs,\n          {\n            ...this.#attrs,\n            type: 'total',\n            method: 'iterate',\n            sqliteMs: this.#sqliteTimeSum,\n            ...(suppressedCount > 0 ? {suppressedCount} : undefined),\n          },\n          'Slow SQLite iterator total time (including consumer work and waits between rows)',\n        );\n      }\n    }\n    if (this.#sqliteTimeSum >= this.#threshold) {\n      logSlow(\n        this.#lc.withContext('method', 'iterate').withContext('type', 'sqlite'),\n        this.#sqliteTimeSum,\n        {\n          ...this.#attrs,\n          type: 'sqlite',\n          method: 'iterate',\n          totalMs,\n        },\n      );\n    }\n  }\n}\n\nclass LoggingIterableIterator<T> implements IterableIterator<T> {\n  readonly #it: IterableIterator<T>;\n  readonly #log: IterationLog;\n\n  constructor(\n    lc: LogContext,\n    attrs: Attributes,\n    it: IterableIterator<T>,\n    slowQueryThreshold: number,\n  ) {\n    this.#it = it;\n    this.#log = new IterationLog(lc, attrs, slowQueryThreshold);\n  }\n\n  next(): IteratorResult<T> {\n    const start = performance.now();\n    const ret = this.#it.next();\n    this.#log.addSQLiteTime(performance.now() - start);\n    if (ret.done) {\n      this.#log.log();\n    }\n    return ret;\n  }\n\n  [Symbol.iterator](): IterableIterator<T> {\n    return this;\n  }\n\n  return(): IteratorResult<T> {\n    this.#log.log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.return?.() as any;\n  }\n\n  throw(e: unknown): IteratorResult<T> {\n    this.#log.log();\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    return this.#it.throw?.(e) as any;\n  }\n}\n\nfunction logSlow(\n  lc: LogContext,\n  elapsed: number,\n  attrs: Attributes,\n  message = 'Slow SQLite query',\n): void {\n  for (const [key, value] of Object.entries(attrs)) {\n    lc = lc.withContext(key, value);\n  }\n  lc.warn?.(message, elapsed);\n  manualSpan(tracer, 'db.slow-query', elapsed, attrs);\n}\n\n/**\n * An error indicating that the Database failed to open. This essentially\n * wraps the TypeError thrown by the better-sqlite3 package with something\n * more specific.\n */\nexport class DatabaseInitError extends Error {}\n"],"mappings":"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"}

package/out/zqlite/src/explain-queries.js.map

@@ -1 +1 @@
-{"version":3,"file":"explain-queries.js","names":[],"sources":["../../../../zqlite/src/explain-queries.ts"],"sourcesContent":["import type {RowCountsBySource} from '../../zero-protocol/src/analyze-query-result.ts';\nimport type {Database} from './db.ts';\n\nexport function explainQueries(counts: RowCountsBySource, db: Database) {\n  const plans: Record<string, string[]> = {};\n  for (const querySet of Object.values(counts)) {\n    const queries = Object.keys(querySet);\n    for (const query of queries) {\n      const plan = db\n        // we should be more intelligent about value replacement.\n        // Different values result in different plans. E.g., picking a value at the start\n        // of an index will result in `scan` vs `search`. The scan is fine in that case.\n        .prepare(`EXPLAIN QUERY PLAN ${query.replaceAll('?', \"'sdfse'\")}`)\n        .all<{detail: string}>()\n        .map(r => r.detail);\n      plans[query] = plan;\n    }\n  }\n\n  return plans;\n}\n"],"mappings":";AAGA,SAAgB,eAAe,QAA2B,IAAc;CACtE,MAAM,QAAkC,CAAC;CACzC,KAAK,MAAM,YAAY,OAAO,OAAO,MAAM,GAAG;EAC5C,MAAM,UAAU,OAAO,KAAK,QAAQ;EACpC,KAAK,MAAM,SAAS,SAQlB,MAAM,SAPO,GAIV,QAAQ,sBAAsB,MAAM,WAAW,KAAK,SAAS,GAAG,EAChE,IAAsB,EACtB,KAAI,MAAK,EAAE,MACC;CAEnB;CAEA,OAAO;AACT"}
+{"version":3,"file":"explain-queries.js","names":[],"sources":["../../../../zqlite/src/explain-queries.ts"],"sourcesContent":["import type {RowCountsBySource} from '../../zero-protocol/src/analyze-query-result.ts';\nimport type {Database} from './db.ts';\n\nexport function explainQueries(counts: RowCountsBySource, db: Database) {\n  const plans: Record<string, string[]> = {};\n  for (const querySet of Object.values(counts)) {\n    const queries = Object.keys(querySet);\n    for (const query of queries) {\n      const plan = db\n        // we should be more intelligent about value replacement.\n        // Different values result in different plans. E.g., picking a value at the start\n        // of an index will result in `scan` vs `search`. The scan is fine in that case.\n        .prepare(`EXPLAIN QUERY PLAN ${query.replaceAll('?', \"'sdfse'\")}`)\n        .all<{detail: string}>()\n        .map(r => r.detail);\n      plans[query] = plan;\n    }\n  }\n\n  return plans;\n}\n"],"mappings":";AAGA,SAAgB,eAAe,QAA2B,IAAc;CACtE,MAAM,QAAkC,CAAC;CACzC,KAAK,MAAM,YAAY,OAAO,OAAO,MAAM,GAAG;EAC5C,MAAM,UAAU,OAAO,KAAK,QAAQ;EACpC,KAAK,MAAM,SAAS,SAQlB,MAAM,SAPO,GAIV,QAAQ,sBAAsB,MAAM,WAAW,KAAK,SAAS,GAAG,CAAC,CACjE,IAAsB,CAAC,CACvB,KAAI,MAAK,EAAE,MACC;CAEnB;CAEA,OAAO;AACT"}

package/out/zqlite/src/fetch-sql.d.ts

@@ -0,0 +1,27 @@
+import type { Ordering } from '../../zero-protocol/src/ast.ts';
+import type { SchemaValue } from '../../zero-schema/src/table-schema.ts';
+import type { FetchRequest } from '../../zql/src/ivm/operator.ts';
+import { type NoSubqueryCondition } from './query-builder.ts';
+export type FetchSQL = {
+    readonly text: string;
+    readonly values: readonly unknown[];
+};
+/**
+ * Builds the SELECTs of {@link buildSelectQueries} for the fetches of one
+ * connection, formatting the SQL text only once per fetch shape.
+ *
+ * Building and formatting the SQL is a fixed cost of every fetch that is
+ * comparable to running the statement for the small fetches IVM does most.
+ * The text depends only on the fetch's shape, though: which columns it
+ * constrains, how many entries each multi-constraint has, its direction,
+ * which columns of its start row are NULL, and its `req.filter`. The values
+ * are bound to `?` placeholders, so a shape's text is built once with a
+ * {@link Binding} in place of each value, and each fetch only reads its values
+ * from those.
+ */
+export declare class FetchSQLCache {
+    #private;
+    constructor(tableName: string, columns: Record<string, SchemaValue>, filters: NoSubqueryCondition | undefined, order: Ordering | undefined);
+    get(req: FetchRequest): FetchSQL[];
+}
+//# sourceMappingURL=fetch-sql.d.ts.map

package/out/zqlite/src/fetch-sql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-sql.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/fetch-sql.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gCAAgC,CAAC;AAE7D,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,uCAAuC,CAAC;AAEvE,OAAO,KAAK,EACV,YAAY,EAEb,MAAM,+BAA+B,CAAC;AAEvC,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,oBAAoB,CAAC;AAE5B,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC;CACrC,CAAC;AAYF;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAa;;IAOxB,YACE,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAM5B;IAED,GAAG,CAAC,GAAG,EAAE,YAAY,GAAG,QAAQ,EAAE,CAcjC;CA2GF"}

package/out/zqlite/src/fetch-sql.js

@@ -0,0 +1,112 @@
+import { assignProperty } from "../../shared/src/objects.js";
+import { format } from "./internal/sql.js";
+import { Binding, buildSelectQueries, toSQLiteType } from "./query-builder.js";
+//#region ../zqlite/src/fetch-sql.ts
+/**
+* More shapes than a connection is expected to fetch. Past it the cache is
+* cleared, which bounds it if some fetch parameter that is part of the shape
+* (a `req.filter` that is not the same object every time, say) never repeats.
+*/
+var MAX_SHAPES = 256;
+var filterIDs = /* @__PURE__ */ new WeakMap();
+var nextFilterID = 0;
+/**
+* Builds the SELECTs of {@link buildSelectQueries} for the fetches of one
+* connection, formatting the SQL text only once per fetch shape.
+*
+* Building and formatting the SQL is a fixed cost of every fetch that is
+* comparable to running the statement for the small fetches IVM does most.
+* The text depends only on the fetch's shape, though: which columns it
+* constrains, how many entries each multi-constraint has, its direction,
+* which columns of its start row are NULL, and its `req.filter`. The values
+* are bound to `?` placeholders, so a shape's text is built once with a
+* {@link Binding} in place of each value, and each fetch only reads its values
+* from those.
+*/
+var FetchSQLCache = class {
+	#tableName;
+	#columns;
+	#filters;
+	#order;
+	#templates = /* @__PURE__ */ new Map();
+	constructor(tableName, columns, filters, order) {
+		this.#tableName = tableName;
+		this.#columns = columns;
+		this.#filters = filters;
+		this.#order = order;
+	}
+	get(req) {
+		const key = this.#shapeKey(req);
+		let templates = this.#templates.get(key);
+		if (templates === void 0) {
+			templates = this.#buildTemplates(req);
+			if (this.#templates.size >= MAX_SHAPES) this.#templates.clear();
+			this.#templates.set(key, templates);
+		}
+		return templates.map(({ text, values }) => ({
+			text,
+			values: values.map((v) => v instanceof Binding ? v.get(req) : v)
+		}));
+	}
+	#shapeKey(req) {
+		const { constraint, multiConstraints, start, filter } = req;
+		let key = req.reverse ? "r" : "f";
+		if (constraint) for (const k in constraint) key += k + "\0";
+		key += "\0";
+		if (multiConstraints) for (const mc of multiConstraints) {
+			key += mc.length + "\0";
+			if (mc.length > 0) for (const k in mc[0]) key += k + "\0";
+			key += "\0";
+		}
+		key += "\0";
+		if (start) {
+			key += start.basis;
+			for (const [field] of this.#order ?? []) key += isNullish(start.row[field]) ? "0" : "1";
+		}
+		key += "\0";
+		if (filter) {
+			let id = filterIDs.get(filter);
+			if (id === void 0) {
+				id = nextFilterID++;
+				filterIDs.set(filter, id);
+			}
+			key += id;
+		}
+		return key;
+	}
+	#buildTemplates(req) {
+		const columns = this.#columns;
+		const binding = (get, field) => {
+			const { type } = columns[field];
+			return new Binding((req) => toSQLiteType(get(req), type));
+		};
+		let constraint;
+		if (req.constraint) {
+			const probe = {};
+			for (const k in req.constraint) assignProperty(probe, k, binding((req) => req.constraint[k], k));
+			constraint = probe;
+		}
+		const multiConstraints = req.multiConstraints?.map((mc, i) => mc.map((entry, j) => {
+			const probe = {};
+			for (const k in entry) assignProperty(probe, k, binding((req) => req.multiConstraints[i][j][k], k));
+			return probe;
+		}));
+		let start;
+		if (req.start) {
+			const row = {};
+			for (const [field] of this.#order ?? []) assignProperty(row, field, isNullish(req.start.row[field]) ? null : binding((req) => req.start.row[field], field));
+			start = {
+				basis: req.start.basis,
+				row
+			};
+		}
+		return buildSelectQueries(this.#tableName, columns, constraint, this.#filters, this.#order, req.reverse, start, multiConstraints, req.filter).map((query) => format(query));
+	}
+};
+function isNullish(v) {
+	return v === null || v === void 0;
+}
+//#endregion
+export { FetchSQLCache };
+
+//# sourceMappingURL=fetch-sql.js.map

package/out/zqlite/src/fetch-sql.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-sql.js","names":[],"sources":["../../../../zqlite/src/fetch-sql.ts"],"sourcesContent":["import {assignProperty} from '../../shared/src/objects.ts';\nimport type {Ordering} from '../../zero-protocol/src/ast.ts';\nimport type {Row} from '../../zero-protocol/src/data.ts';\nimport type {SchemaValue} from '../../zero-schema/src/table-schema.ts';\nimport type {Constraint} from '../../zql/src/ivm/constraint.ts';\nimport type {\n  FetchRequest,\n  MultiConstraint,\n} from '../../zql/src/ivm/operator.ts';\nimport {format} from './internal/sql.ts';\nimport {\n  Binding,\n  buildSelectQueries,\n  toSQLiteType,\n  type NoSubqueryCondition,\n} from './query-builder.ts';\n\nexport type FetchSQL = {\n  readonly text: string;\n  readonly values: readonly unknown[];\n};\n\n/**\n * More shapes than a connection is expected to fetch. Past it the cache is\n * cleared, which bounds it if some fetch parameter that is part of the shape\n * (a `req.filter` that is not the same object every time, say) never repeats.\n */\nconst MAX_SHAPES = 256;\n\nconst filterIDs = new WeakMap<NoSubqueryCondition, number>();\nlet nextFilterID = 0;\n\n/**\n * Builds the SELECTs of {@link buildSelectQueries} for the fetches of one\n * connection, formatting the SQL text only once per fetch shape.\n *\n * Building and formatting the SQL is a fixed cost of every fetch that is\n * comparable to running the statement for the small fetches IVM does most.\n * The text depends only on the fetch's shape, though: which columns it\n * constrains, how many entries each multi-constraint has, its direction,\n * which columns of its start row are NULL, and its `req.filter`. The values\n * are bound to `?` placeholders, so a shape's text is built once with a\n * {@link Binding} in place of each value, and each fetch only reads its values\n * from those.\n */\nexport class FetchSQLCache {\n  readonly #tableName: string;\n  readonly #columns: Record<string, SchemaValue>;\n  readonly #filters: NoSubqueryCondition | undefined;\n  readonly #order: Ordering | undefined;\n  readonly #templates = new Map<string, readonly FetchSQL[]>();\n\n  constructor(\n    tableName: string,\n    columns: Record<string, SchemaValue>,\n    filters: NoSubqueryCondition | undefined,\n    order: Ordering | undefined,\n  ) {\n    this.#tableName = tableName;\n    this.#columns = columns;\n    this.#filters = filters;\n    this.#order = order;\n  }\n\n  get(req: FetchRequest): FetchSQL[] {\n    const key = this.#shapeKey(req);\n    let templates = this.#templates.get(key);\n    if (templates === undefined) {\n      templates = this.#buildTemplates(req);\n      if (this.#templates.size >= MAX_SHAPES) {\n        this.#templates.clear();\n      }\n      this.#templates.set(key, templates);\n    }\n    return templates.map(({text, values}) => ({\n      text,\n      values: values.map(v => (v instanceof Binding ? v.get(req) : v)),\n    }));\n  }\n\n  // Column names are never empty and never contain NUL, so terminating each\n  // with NUL and each list with an extra NUL keeps distinct shapes distinct.\n  #shapeKey(req: FetchRequest): string {\n    const {constraint, multiConstraints, start, filter} = req;\n    let key = req.reverse ? 'r' : 'f';\n    if (constraint) {\n      for (const k in constraint) {\n        key += k + '\\0';\n      }\n    }\n    key += '\\0';\n    if (multiConstraints) {\n      for (const mc of multiConstraints) {\n        key += mc.length + '\\0';\n        if (mc.length > 0) {\n          for (const k in mc[0]) {\n            key += k + '\\0';\n          }\n        }\n        key += '\\0';\n      }\n    }\n    key += '\\0';\n    if (start) {\n      key += start.basis;\n      // Only the order's columns of the start row are read.\n      for (const [field] of this.#order ?? []) {\n        key += isNullish(start.row[field]) ? '0' : '1';\n      }\n    }\n    key += '\\0';\n    if (filter) {\n      let id = filterIDs.get(filter);\n      if (id === undefined) {\n        id = nextFilterID++;\n        filterIDs.set(filter, id);\n      }\n      key += id;\n    }\n    return key;\n  }\n\n  #buildTemplates(req: FetchRequest): FetchSQL[] {\n    const columns = this.#columns;\n    const binding = (\n      get: (req: FetchRequest) => unknown,\n      field: string,\n    ): Binding => {\n      const {type} = columns[field];\n      return new Binding(req => toSQLiteType(get(req), type));\n    };\n\n    let constraint: Constraint | undefined;\n    if (req.constraint) {\n      const probe: Record<string, unknown> = {};\n      for (const k in req.constraint) {\n        assignProperty(\n          probe,\n          k,\n          binding(req => req.constraint![k], k),\n        );\n      }\n      constraint = probe as Constraint;\n    }\n    const multiConstraints = req.multiConstraints?.map(\n      (mc, i): MultiConstraint =>\n        mc.map((entry, j) => {\n          const probe: Record<string, unknown> = {};\n          for (const k in entry) {\n            assignProperty(\n              probe,\n              k,\n              binding(req => req.multiConstraints![i][j][k], k),\n            );\n          }\n          return probe as Row;\n        }),\n    );\n    let start: FetchRequest['start'];\n    if (req.start) {\n      const row: Record<string, unknown> = {};\n      for (const [field] of this.#order ?? []) {\n        assignProperty(\n          row,\n          field,\n          isNullish(req.start.row[field])\n            ? null\n            : binding(req => req.start!.row[field], field),\n        );\n      }\n      start = {basis: req.start.basis, row: row as Row};\n    }\n\n    return buildSelectQueries(\n      this.#tableName,\n      columns,\n      constraint,\n      this.#filters,\n      this.#order,\n      req.reverse,\n      start,\n      multiConstraints,\n      req.filter,\n    ).map(query => format(query));\n  }\n}\n\nfunction isNullish(v: unknown): boolean {\n  return v === null || v === undefined;\n}\n"],"mappings":"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"}

package/out/zqlite/src/index-usage.js.map

@@ -1 +1 @@
-{"version":3,"file":"index-usage.js","names":[],"sources":["../../../../zqlite/src/index-usage.ts"],"sourcesContent":["import SQLite3Database from '@rocicorp/zero-sqlite3';\nimport type {Statement} from './db.ts';\n\nlet uses = new Map<string, number>();\n\n/**\n * The table-valued function that the SQL of `IN` and `NOT IN` conditions reads\n * its values from (see `simpleConditionToSQL()` in `query-builder.ts`).\n */\nconst JSON_EACH = 'json_each';\n\n/**\n * Counts a run of `stmt`, a read of `table`, against each index of the table\n * that SQLite's plan for it read. Loops that read the table itself (a scan,\n * or a lookup by rowid), or the values of an `IN` (from `json_each`), are not\n * counted, and an index that more than one loop of the plan reads (e.g. for\n * an `OR` of two of its ranges) is counted once.\n *\n * The plan is read after every run rather than once per statement: SQLite\n * plans a statement again when a new binding can change the best plan, as it\n * can with `sqlite_stat4` statistics or for `LIKE`.\n */\nexport function recordIndexUsage(stmt: Statement, table: string): void {\n  let counted: string[] | undefined;\n  // Without SQLITE_SCANSTAT_COMPLEX, scanstatus lists only the loops, each of\n  // which has the name of the index or table it reads, so the first missing\n  // name is the end of the list.\n  for (let i = 0; ; i++) {\n    const name = stmt.scanStatus(i, SQLite3Database.SQLITE_SCANSTAT_NAME, 0);\n    if (name === undefined) {\n      return;\n    }\n    if (\n      name === table ||\n      counted?.includes(name) ||\n      (name === JSON_EACH && readsJsonEach(stmt, i))\n    ) {\n      continue;\n    }\n    (counted ??= []).push(name);\n    uses.set(name, (uses.get(name) ?? 0) + 1);\n  }\n}\n\n/**\n * Whether loop `i` of `stmt` reads the values of `json_each`, rather than an\n * index that happens to have the same name.\n */\nfunction readsJsonEach(stmt: Statement, i: number): boolean {\n  const explain = stmt.scanStatus(\n    i,\n    SQLite3Database.SQLITE_SCANSTAT_EXPLAIN,\n    0,\n  );\n  return explain?.startsWith(`SCAN ${JSON_EACH} VIRTUAL TABLE`) ?? false;\n}\n\n/**\n * Returns the runs recorded by {@link recordIndexUsage} in this process since\n * the last call, by the name of the index they read.\n */\nexport function takeIndexUsage(): Map<string, number> {\n  const taken = uses;\n  uses = new Map();\n  return taken;\n}\n"],"mappings":";;AAGA,IAAI,uBAAO,IAAI,IAAoB;;;;;AAMnC,IAAM,YAAY;;;;;;;;;;;;AAalB,SAAgB,iBAAiB,MAAiB,OAAqB;CACrE,IAAI;CAIJ,KAAK,IAAI,IAAI,IAAK,KAAK;EACrB,MAAM,OAAO,KAAK,WAAW,GAAG,gBAAgB,sBAAsB,CAAC;EACvE,IAAI,SAAS,KAAA,GACX;EAEF,IACE,SAAS,SACT,SAAS,SAAS,IAAI,KACrB,SAAS,aAAa,cAAc,MAAM,CAAC,GAE5C;EAEF,CAAC,YAAY,CAAC,GAAG,KAAK,IAAI;EAC1B,KAAK,IAAI,OAAO,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC;CAC1C;AACF;;;;;AAMA,SAAS,cAAc,MAAiB,GAAoB;CAM1D,OALgB,KAAK,WACnB,GACA,gBAAgB,yBAChB,CAEK,GAAS,WAAW,QAAQ,UAAU,eAAe,KAAK;AACnE;;;;;AAMA,SAAgB,iBAAsC;CACpD,MAAM,QAAQ;CACd,uBAAO,IAAI,IAAI;CACf,OAAO;AACT"}
+{"version":3,"file":"index-usage.js","names":[],"sources":["../../../../zqlite/src/index-usage.ts"],"sourcesContent":["import SQLite3Database from '@rocicorp/zero-sqlite3';\nimport type {Statement} from './db.ts';\n\nlet uses = new Map<string, number>();\n\n/**\n * The table-valued function that the SQL of `IN` and `NOT IN` conditions reads\n * its values from (see `simpleConditionToSQL()` in `query-builder.ts`).\n */\nconst JSON_EACH = 'json_each';\n\n/**\n * Counts a run of `stmt`, a read of `table`, against each index of the table\n * that SQLite's plan for it read. Loops that read the table itself (a scan,\n * or a lookup by rowid), or the values of an `IN` (from `json_each`), are not\n * counted, and an index that more than one loop of the plan reads (e.g. for\n * an `OR` of two of its ranges) is counted once.\n *\n * The plan is read after every run rather than once per statement: SQLite\n * plans a statement again when a new binding can change the best plan, as it\n * can with `sqlite_stat4` statistics or for `LIKE`.\n */\nexport function recordIndexUsage(stmt: Statement, table: string): void {\n  let counted: string[] | undefined;\n  // Without SQLITE_SCANSTAT_COMPLEX, scanstatus lists only the loops, each of\n  // which has the name of the index or table it reads, so the first missing\n  // name is the end of the list.\n  for (let i = 0; ; i++) {\n    const name = stmt.scanStatus(i, SQLite3Database.SQLITE_SCANSTAT_NAME, 0);\n    if (name === undefined) {\n      return;\n    }\n    if (\n      name === table ||\n      counted?.includes(name) ||\n      (name === JSON_EACH && readsJsonEach(stmt, i))\n    ) {\n      continue;\n    }\n    (counted ??= []).push(name);\n    uses.set(name, (uses.get(name) ?? 0) + 1);\n  }\n}\n\n/**\n * Whether loop `i` of `stmt` reads the values of `json_each`, rather than an\n * index that happens to have the same name.\n */\nfunction readsJsonEach(stmt: Statement, i: number): boolean {\n  const explain = stmt.scanStatus(\n    i,\n    SQLite3Database.SQLITE_SCANSTAT_EXPLAIN,\n    0,\n  );\n  return explain?.startsWith(`SCAN ${JSON_EACH} VIRTUAL TABLE`) ?? false;\n}\n\n/**\n * Returns the runs recorded by {@link recordIndexUsage} in this process since\n * the last call, by the name of the index they read.\n */\nexport function takeIndexUsage(): Map<string, number> {\n  const taken = uses;\n  uses = new Map();\n  return taken;\n}\n"],"mappings":";;AAGA,IAAI,uBAAO,IAAI,IAAoB;;;;;AAMnC,IAAM,YAAY;;;;;;;;;;;;AAalB,SAAgB,iBAAiB,MAAiB,OAAqB;CACrE,IAAI;CAIJ,KAAK,IAAI,IAAI,IAAK,KAAK;EACrB,MAAM,OAAO,KAAK,WAAW,GAAG,gBAAgB,sBAAsB,CAAC;EACvE,IAAI,SAAS,KAAA,GACX;EAEF,IACE,SAAS,SACT,SAAS,SAAS,IAAI,KACrB,SAAS,aAAa,cAAc,MAAM,CAAC,GAE5C;EAEF,CAAC,YAAY,CAAC,EAAA,CAAG,KAAK,IAAI;EAC1B,KAAK,IAAI,OAAO,KAAK,IAAI,IAAI,KAAK,KAAK,CAAC;CAC1C;AACF;;;;;AAMA,SAAS,cAAc,MAAiB,GAAoB;CAM1D,OALgB,KAAK,WACnB,GACA,gBAAgB,yBAChB,CAEK,CAAA,EAAS,WAAW,QAAQ,UAAU,eAAe,KAAK;AACnE;;;;;AAMA,SAAgB,iBAAsC;CACpD,MAAM,QAAQ;CACd,uBAAO,IAAI,IAAI;CACf,OAAO;AACT"}

package/out/zqlite/src/internal/sql-inline.js.map

@@ -1 +1 @@
-{"version":3,"file":"sql-inline.js","names":[],"sources":["../../../../../zqlite/src/internal/sql-inline.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig} from '@databases/sql';\nimport type {SQLQuery} from '@databases/sql';\n\n/**\n * Escapes a SQLite string value by doubling single quotes.\n * SQLite uses single quotes for string literals and doubles them for escaping.\n */\nfunction escapeSQLiteString(str: string): string {\n  return `'${str.replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Formats a value for inline inclusion in SQL (not as a placeholder).\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner,\n * not for user-facing queries. All production queries must use parameterized\n * statements to prevent SQL injection.\n *\n * @param value The value to inline into SQL\n * @returns SQL literal representation of the value\n */\nfunction inlineValue(value: unknown): string {\n  if (value === null) {\n    return 'NULL';\n  }\n  if (typeof value === 'string') {\n    return escapeSQLiteString(value);\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'boolean') {\n    // SQLite uses 1 and 0 for booleans\n    return value ? '1' : '0';\n  }\n  if (Array.isArray(value)) {\n    // For arrays, use JSON representation (same as query-builder.ts does for IN clauses)\n    return escapeSQLiteString(JSON.stringify(value));\n  }\n  // For objects/other JSON types\n  return escapeSQLiteString(JSON.stringify(value));\n}\n\n/**\n * Format configuration that inlines values directly into SQL instead of using placeholders.\n *\n * This is used ONLY for cost estimation in the SQLite cost model, where we want SQLite's\n * query planner to see actual values to make better decisions about index usage and query plans.\n *\n * Production code must use the standard parameterized format from sql.ts.\n */\nconst sqliteInlineFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value =>\n    // undefined is our signal to use a placeholder\n    // IMPORTANT. Changing this will break the planner as it will assume `NULL`\n    // for constraints!\n    value === undefined\n      ? {\n          placeholder: '?',\n          value,\n        }\n      : {\n          placeholder: inlineValue(value),\n          value: undefined, // No binding needed since value is inlined\n        },\n};\n\n/**\n * Compiles a SQL query with values inlined directly into the SQL string.\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner.\n * Never use this for user-facing queries - always use the standard `compile()`\n * function from sql.ts which uses parameterized queries.\n *\n * @param sql The SQL query to compile\n * @returns SQL string with values inlined\n */\nexport function compileInline(sql: SQLQuery): string {\n  return sql.format(sqliteInlineFormat).text;\n}\n"],"mappings":";;;;;;AAQA,SAAS,mBAAmB,KAAqB;CAC/C,OAAO,IAAI,IAAI,QAAQ,MAAM,IAAI,EAAE;AACrC;;;;;;;;;;;AAYA,SAAS,YAAY,OAAwB;CAC3C,IAAI,UAAU,MACZ,OAAO;CAET,IAAI,OAAO,UAAU,UACnB,OAAO,mBAAmB,KAAK;CAEjC,IAAI,OAAO,UAAU,UACnB,OAAO,OAAO,KAAK;CAErB,IAAI,OAAO,UAAU,WAEnB,OAAO,QAAQ,MAAM;CAEvB,IAAI,MAAM,QAAQ,KAAK,GAErB,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;CAGjD,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;AACjD;;;;;;;;;AAUA,IAAM,qBAAmC;CACvC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,UAIX,UAAU,KAAA,IACN;EACE,aAAa;EACb;CACF,IACA;EACE,aAAa,YAAY,KAAK;EAC9B,OAAO,KAAA;CACT;AACR;;;;;;;;;;;AAYA,SAAgB,cAAc,KAAuB;CACnD,OAAO,IAAI,OAAO,kBAAkB,EAAE;AACxC"}
+{"version":3,"file":"sql-inline.js","names":[],"sources":["../../../../../zqlite/src/internal/sql-inline.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig} from '@databases/sql';\nimport type {SQLQuery} from '@databases/sql';\n\n/**\n * Escapes a SQLite string value by doubling single quotes.\n * SQLite uses single quotes for string literals and doubles them for escaping.\n */\nfunction escapeSQLiteString(str: string): string {\n  return `'${str.replace(/'/g, \"''\")}'`;\n}\n\n/**\n * Formats a value for inline inclusion in SQL (not as a placeholder).\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner,\n * not for user-facing queries. All production queries must use parameterized\n * statements to prevent SQL injection.\n *\n * @param value The value to inline into SQL\n * @returns SQL literal representation of the value\n */\nfunction inlineValue(value: unknown): string {\n  if (value === null) {\n    return 'NULL';\n  }\n  if (typeof value === 'string') {\n    return escapeSQLiteString(value);\n  }\n  if (typeof value === 'number') {\n    return String(value);\n  }\n  if (typeof value === 'boolean') {\n    // SQLite uses 1 and 0 for booleans\n    return value ? '1' : '0';\n  }\n  if (Array.isArray(value)) {\n    // For arrays, use JSON representation (same as query-builder.ts does for IN clauses)\n    return escapeSQLiteString(JSON.stringify(value));\n  }\n  // For objects/other JSON types\n  return escapeSQLiteString(JSON.stringify(value));\n}\n\n/**\n * Format configuration that inlines values directly into SQL instead of using placeholders.\n *\n * This is used ONLY for cost estimation in the SQLite cost model, where we want SQLite's\n * query planner to see actual values to make better decisions about index usage and query plans.\n *\n * Production code must use the standard parameterized format from sql.ts.\n */\nconst sqliteInlineFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value =>\n    // undefined is our signal to use a placeholder\n    // IMPORTANT. Changing this will break the planner as it will assume `NULL`\n    // for constraints!\n    value === undefined\n      ? {\n          placeholder: '?',\n          value,\n        }\n      : {\n          placeholder: inlineValue(value),\n          value: undefined, // No binding needed since value is inlined\n        },\n};\n\n/**\n * Compiles a SQL query with values inlined directly into the SQL string.\n *\n * WARNING: This should ONLY be used for cost estimation in the query planner.\n * Never use this for user-facing queries - always use the standard `compile()`\n * function from sql.ts which uses parameterized queries.\n *\n * @param sql The SQL query to compile\n * @returns SQL string with values inlined\n */\nexport function compileInline(sql: SQLQuery): string {\n  return sql.format(sqliteInlineFormat).text;\n}\n"],"mappings":";;;;;;AAQA,SAAS,mBAAmB,KAAqB;CAC/C,OAAO,IAAI,IAAI,QAAQ,MAAM,IAAI,EAAE;AACrC;;;;;;;;;;;AAYA,SAAS,YAAY,OAAwB;CAC3C,IAAI,UAAU,MACZ,OAAO;CAET,IAAI,OAAO,UAAU,UACnB,OAAO,mBAAmB,KAAK;CAEjC,IAAI,OAAO,UAAU,UACnB,OAAO,OAAO,KAAK;CAErB,IAAI,OAAO,UAAU,WAEnB,OAAO,QAAQ,MAAM;CAEvB,IAAI,MAAM,QAAQ,KAAK,GAErB,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;CAGjD,OAAO,mBAAmB,KAAK,UAAU,KAAK,CAAC;AACjD;;;;;;;;;AAUA,IAAM,qBAAmC;CACvC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,UAIX,UAAU,KAAA,IACN;EACE,aAAa;EACb;CACF,IACA;EACE,aAAa,YAAY,KAAK;EAC9B,OAAO,KAAA;CACT;AACR;;;;;;;;;;;AAYA,SAAgB,cAAc,KAAuB;CACnD,OAAO,IAAI,OAAO,kBAAkB,CAAC,CAAC;AACxC"}

package/out/zqlite/src/internal/sql.js.map

@@ -1 +1 @@
-{"version":3,"file":"sql.js","names":[],"sources":["../../../../../zqlite/src/internal/sql.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig, SQLQuery} from '@databases/sql';\nimport sql from '@databases/sql';\n\nconst sqliteFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value => ({placeholder: '?', value}),\n};\n\nexport function compile(sql: SQLQuery): string {\n  return sql.format(sqliteFormat).text;\n}\n\nexport function format(sql: SQLQuery) {\n  return sql.format(sqliteFormat);\n}\n\nexport {sql};\n"],"mappings":";;;AAIA,IAAM,eAA6B;CACjC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,WAAU;EAAC,aAAa;EAAK;CAAK;AACjD;AAEA,SAAgB,QAAQ,KAAuB;CAC7C,OAAO,IAAI,OAAO,YAAY,EAAE;AAClC;AAEA,SAAgB,OAAO,KAAe;CACpC,OAAO,IAAI,OAAO,YAAY;AAChC"}
+{"version":3,"file":"sql.js","names":[],"sources":["../../../../../zqlite/src/internal/sql.ts"],"sourcesContent":["import {escapeSQLiteIdentifier} from '@databases/escape-identifier';\nimport type {FormatConfig, SQLQuery} from '@databases/sql';\nimport sql from '@databases/sql';\n\nconst sqliteFormat: FormatConfig = {\n  escapeIdentifier: str => escapeSQLiteIdentifier(str),\n  formatValue: value => ({placeholder: '?', value}),\n};\n\nexport function compile(sql: SQLQuery): string {\n  return sql.format(sqliteFormat).text;\n}\n\nexport function format(sql: SQLQuery) {\n  return sql.format(sqliteFormat);\n}\n\nexport {sql};\n"],"mappings":";;;AAIA,IAAM,eAA6B;CACjC,mBAAkB,QAAO,uBAAuB,GAAG;CACnD,cAAa,WAAU;EAAC,aAAa;EAAK;CAAK;AACjD;AAEA,SAAgB,QAAQ,KAAuB;CAC7C,OAAO,IAAI,OAAO,YAAY,CAAC,CAAC;AAClC;AAEA,SAAgB,OAAO,KAAe;CACpC,OAAO,IAAI,OAAO,YAAY;AAChC"}

package/out/zqlite/src/internal/statement-cache.d.ts

@@ -74,6 +74,13 @@ export declare class StatementCache {
      * @returns
      */
     get(sql: string): CachedStatement;
+    /**
+     * Like {@link get}, but keys the statement by `sql` exactly as given,
+     * without normalizing its whitespace. This is for callers that pass the
+     * same text for a statement every time, such as the SQL of a fetch shape,
+     * which then skip the normalization on every call.
+     */
+    getExact(sql: string): CachedStatement;
     /**
      * Handles `get` and `return` for the caller by invoking them before
      * and after the callback.

package/out/zqlite/src/internal/statement-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"statement-cache.d.ts","sourceRoot":"","sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAE,SAAS,EAAC,MAAM,UAAU,CAAC;AAElD,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,cAAc;;IAUzB;;;;;OAKG;IACH,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAE,MAAsC,EAIxE;IAGD,IAAI,IAAI,WAEP;IAGD,IAAI,OAAO,WAEV;IAED,IAAI,CAAC,CAAC,EAAE,MAAM,QAOb;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAgBhC;IAED;;;OAGG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,CAAC,KAOxD;IAED;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,EAAE,eAAe,QAiBhC;CAYF"}
+{"version":3,"file":"statement-cache.d.ts","sourceRoot":"","sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,QAAQ,EAAE,SAAS,EAAC,MAAM,UAAU,CAAC;AAElD,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC;AAC1D,MAAM,MAAM,eAAe,GAAG;IAC5B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B,OAAQ,CAAC;AAEnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,qBAAa,cAAc;;IAUzB;;;;;OAKG;IACH,YAAY,EAAE,EAAE,QAAQ,EAAE,OAAO,GAAE,MAAsC,EAIxE;IAGD,IAAI,IAAI,WAEP;IAGD,IAAI,OAAO,WAEV;IAED,IAAI,CAAC,CAAC,EAAE,MAAM,QAOb;IAED;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAEhC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAerC;IAED;;;OAGG;IACH,GAAG,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,SAAS,EAAE,eAAe,KAAK,CAAC,KAOxD;IAED;;;;;;OAMG;IACH,MAAM,CAAC,SAAS,EAAE,eAAe,QAiBhC;CAYF"}

package/out/zqlite/src/internal/statement-cache.js

@@ -85,7 +85,15 @@ var StatementCache = class {
 	* @returns
 	*/
 	get(sql) {
-		sql = normalizeWhitespace(sql);
+		return this.getExact(normalizeWhitespace(sql));
+	}
+	/**
+	* Like {@link get}, but keys the statement by `sql` exactly as given,
+	* without normalizing its whitespace. This is for callers that pass the
+	* same text for a statement every time, such as the SQL of a fetch shape,
+	* which then skip the normalization on every call.
+	*/
+	getExact(sql) {
 		const statements = this.#cache.get(sql);
 		if (statements && statements.length > 0) {
 			const statement = statements.pop();
@@ -97,10 +105,9 @@ var StatementCache = class {
 				statement
 			};
 		}
-		const statement = this.#db.prepare(sql);
 		return {
 			sql,
-			statement
+			statement: this.#db.prepare(sql)
 		};
 	}
 	/**
@@ -145,6 +152,6 @@ function normalizeWhitespace(sql) {
 	return sql.replaceAll(/\s+/g, " ");
 }
 //#endregion
-export { StatementCache };
+export { DEFAULT_MAX_CACHED_STATEMENTS, StatementCache };
 
 //# sourceMappingURL=statement-cache.js.map

package/out/zqlite/src/internal/statement-cache.js.map

@@ -1 +1 @@
-{"version":3,"file":"statement-cache.js","names":["#db","#maxSize","#size","#evictLeastRecentlyUsed","#cache"],"sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../db.ts';\n\nexport type CachedStatementMap = Map<string, Statement[]>;\nexport type CachedStatement = {\n  sql: string;\n  statement: Statement;\n};\n\n/**\n * The default maximum number of statements retained by a StatementCache.\n *\n * Each cached statement holds a native `sqlite3_stmt` handle (prepared\n * bytecode + SQLite-side memory), so the cache must be bounded. The bound\n * needs enough headroom for callers with a large working set of distinct\n * SQL — e.g. the replication change-processor prepares several statements\n * per table (with additional variants for partial-column updates) through\n * a single cache — while still capping growth from unbounded key spaces\n * such as client-influenced query shapes.\n */\nexport const DEFAULT_MAX_CACHED_STATEMENTS = 1_000;\n\n/**\n * SQLite statement preparation isn't cheap as it involves evaluating possible\n * query plans and picking the best one (in addition to parsing the SQL).\n *\n * This statement cache prevents the need to re-prepare the same statement\n * multiple times.\n *\n * One extra wrinkle is that a single statement cannot be used by multiple\n * callers at the same time. As in, we can't `iterate` the same statement\n * many times concurrently.\n *\n * Given that, statements are removed from the cache while in use.\n * - `get` removes the statement from the cache\n * - `return` adds it back.\n *\n * If a request for the same sql is made while a\n * statement is gotten, a new statement will be prepared.\n * Both statements can be returned to the cache even though they both\n * serve the same SQL. Having both copies returned to the cache allows\n * the cache to serve multiple callers concurrently in the future.\n *\n * It is not an error to fail to call `return` on a statement.\n * Failing to call return will only prevent the statement from being reused\n * by other callers. It will not cause a resource leak.\n *\n * The cache is bounded: it retains at most `maxSize` statements, evicting\n * the least recently used statements when the bound is exceeded. Only idle\n * (returned) statements are ever evicted — statements checked out via `get`\n * are not in the cache and thus never touched by eviction. Evicting a\n * statement drops the cache's reference to it; the native `sqlite3_stmt`\n * handle is finalized when the Statement object is garbage collected.\n */\nexport class StatementCache {\n  // Map insertion order doubles as recency order: entries are re-inserted\n  // on every `get` hit and `return`, so the first entry in the map is the\n  // least recently used. Within an entry's array, the first statement is\n  // the least recently returned.\n  #cache: CachedStatementMap = new Map<string, Statement[]>();\n  readonly #db: Database;\n  readonly #maxSize: number;\n  #size: number = 0;\n\n  /**\n   * The db connection used to prepare the statement.\n   * It is an error to use a statement prepared on one connection with another connection.\n   * @param db\n   * @param maxSize the maximum number of statements to retain in the cache.\n   */\n  constructor(db: Database, maxSize: number = DEFAULT_MAX_CACHED_STATEMENTS) {\n    assert(maxSize >= 0, 'maxSize must not be negative');\n    this.#db = db;\n    this.#maxSize = maxSize;\n  }\n\n  // the number of statements in the cache\n  get size() {\n    return this.#size;\n  }\n\n  // the maximum number of statements the cache will retain\n  get maxSize() {\n    return this.#maxSize;\n  }\n\n  drop(n: number) {\n    assert(n >= 0, 'Cannot drop a negative number of items');\n    assert(n <= this.#size, 'Cannot drop more items than are in the cache');\n\n    for (let i = 0; i < n; i++) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  /**\n   * Prepares a statement for the given sql unless one is already cached.\n   * If one is cached, it is removed from the cache and returned.\n   *\n   * Since `get` removes the item from the cache it is not an error to fail to call\n   * `return`. The gotten statement will be correctly garbage collected.\n   *\n   * When a gotten statement is not returned, future calls to\n   * `get` with the same `sql` will prepare a new statement.\n   *\n   * @param sql\n   * @returns\n   */\n  get(sql: string): CachedStatement {\n    sql = normalizeWhitespace(sql);\n    const statements = this.#cache.get(sql);\n    if (statements && statements.length > 0) {\n      const statement = statements.pop()!;\n      this.#size--;\n      this.#cache.delete(sql);\n      if (statements.length > 0) {\n        // Re-insert so the remaining statements for this sql are marked\n        // as most recently used.\n        this.#cache.set(sql, statements);\n      }\n      return {sql, statement};\n    }\n    const statement = this.#db.prepare(sql);\n    return {sql, statement};\n  }\n\n  /**\n   * Handles `get` and `return` for the caller by invoking them before\n   * and after the callback.\n   */\n  use<T>(sql: string, cb: (statement: CachedStatement) => T) {\n    const statement = this.get(sql);\n    try {\n      return cb(statement);\n    } finally {\n      this.return(statement);\n    }\n  }\n\n  /**\n   * Add a statement back to the cache so someone else can use it later.\n   *\n   * If this pushes the cache over its maximum size, the least recently\n   * used statements are evicted.\n   * @param statement\n   */\n  return(statement: CachedStatement) {\n    const {sql} = statement;\n    let statements = this.#cache.get(sql);\n    if (statements === undefined) {\n      statements = [];\n    } else {\n      // Delete so the re-insert below moves this sql to the most recently\n      // used position.\n      this.#cache.delete(sql);\n    }\n    statements.push(statement.statement);\n    this.#cache.set(sql, statements);\n    this.#size++;\n\n    while (this.#size > this.#maxSize) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  #evictLeastRecentlyUsed() {\n    const lru = this.#cache.entries().next();\n    assert(!lru.done, 'Cannot evict from an empty cache');\n    const [sql, statements] = lru.value;\n    statements.shift();\n    this.#size--;\n    if (statements.length === 0) {\n      this.#cache.delete(sql);\n    }\n  }\n}\n\nfunction normalizeWhitespace(sql: string) {\n  return sql.replaceAll(/\\s+/g, ' ');\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,IAAa,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC7C,IAAa,iBAAb,MAA4B;CAK1B,yBAA6B,IAAI,IAAyB;CAC1D;CACA;CACA,QAAgB;;;;;;;CAQhB,YAAY,IAAc,UAAkB,+BAA+B;EACzE,OAAO,WAAW,GAAG,8BAA8B;EACnD,KAAKA,MAAM;EACX,KAAKC,WAAW;CAClB;CAGA,IAAI,OAAO;EACT,OAAO,KAAKC;CACd;CAGA,IAAI,UAAU;EACZ,OAAO,KAAKD;CACd;CAEA,KAAK,GAAW;EACd,OAAO,KAAK,GAAG,wCAAwC;EACvD,OAAO,KAAK,KAAKC,OAAO,8CAA8C;EAEtE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,KAAKC,wBAAwB;CAEjC;;;;;;;;;;;;;;CAeA,IAAI,KAA8B;EAChC,MAAM,oBAAoB,GAAG;EAC7B,MAAM,aAAa,KAAKC,OAAO,IAAI,GAAG;EACtC,IAAI,cAAc,WAAW,SAAS,GAAG;GACvC,MAAM,YAAY,WAAW,IAAI;GACjC,KAAKF;GACL,KAAKE,OAAO,OAAO,GAAG;GACtB,IAAI,WAAW,SAAS,GAGtB,KAAKA,OAAO,IAAI,KAAK,UAAU;GAEjC,OAAO;IAAC;IAAK;GAAS;EACxB;EACA,MAAM,YAAY,KAAKJ,IAAI,QAAQ,GAAG;EACtC,OAAO;GAAC;GAAK;EAAS;CACxB;;;;;CAMA,IAAO,KAAa,IAAuC;EACzD,MAAM,YAAY,KAAK,IAAI,GAAG;EAC9B,IAAI;GACF,OAAO,GAAG,SAAS;EACrB,UAAU;GACR,KAAK,OAAO,SAAS;EACvB;CACF;;;;;;;;CASA,OAAO,WAA4B;EACjC,MAAM,EAAC,QAAO;EACd,IAAI,aAAa,KAAKI,OAAO,IAAI,GAAG;EACpC,IAAI,eAAe,KAAA,GACjB,aAAa,CAAC;OAId,KAAKA,OAAO,OAAO,GAAG;EAExB,WAAW,KAAK,UAAU,SAAS;EACnC,KAAKA,OAAO,IAAI,KAAK,UAAU;EAC/B,KAAKF;EAEL,OAAO,KAAKA,QAAQ,KAAKD,UACvB,KAAKE,wBAAwB;CAEjC;CAEA,0BAA0B;EACxB,MAAM,MAAM,KAAKC,OAAO,QAAQ,EAAE,KAAK;EACvC,OAAO,CAAC,IAAI,MAAM,kCAAkC;EACpD,MAAM,CAAC,KAAK,cAAc,IAAI;EAC9B,WAAW,MAAM;EACjB,KAAKF;EACL,IAAI,WAAW,WAAW,GACxB,KAAKE,OAAO,OAAO,GAAG;CAE1B;AACF;AAEA,SAAS,oBAAoB,KAAa;CACxC,OAAO,IAAI,WAAW,QAAQ,GAAG;AACnC"}
+{"version":3,"file":"statement-cache.js","names":[],"sources":["../../../../../zqlite/src/internal/statement-cache.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../db.ts';\n\nexport type CachedStatementMap = Map<string, Statement[]>;\nexport type CachedStatement = {\n  sql: string;\n  statement: Statement;\n};\n\n/**\n * The default maximum number of statements retained by a StatementCache.\n *\n * Each cached statement holds a native `sqlite3_stmt` handle (prepared\n * bytecode + SQLite-side memory), so the cache must be bounded. The bound\n * needs enough headroom for callers with a large working set of distinct\n * SQL — e.g. the replication change-processor prepares several statements\n * per table (with additional variants for partial-column updates) through\n * a single cache — while still capping growth from unbounded key spaces\n * such as client-influenced query shapes.\n */\nexport const DEFAULT_MAX_CACHED_STATEMENTS = 1_000;\n\n/**\n * SQLite statement preparation isn't cheap as it involves evaluating possible\n * query plans and picking the best one (in addition to parsing the SQL).\n *\n * This statement cache prevents the need to re-prepare the same statement\n * multiple times.\n *\n * One extra wrinkle is that a single statement cannot be used by multiple\n * callers at the same time. As in, we can't `iterate` the same statement\n * many times concurrently.\n *\n * Given that, statements are removed from the cache while in use.\n * - `get` removes the statement from the cache\n * - `return` adds it back.\n *\n * If a request for the same sql is made while a\n * statement is gotten, a new statement will be prepared.\n * Both statements can be returned to the cache even though they both\n * serve the same SQL. Having both copies returned to the cache allows\n * the cache to serve multiple callers concurrently in the future.\n *\n * It is not an error to fail to call `return` on a statement.\n * Failing to call return will only prevent the statement from being reused\n * by other callers. It will not cause a resource leak.\n *\n * The cache is bounded: it retains at most `maxSize` statements, evicting\n * the least recently used statements when the bound is exceeded. Only idle\n * (returned) statements are ever evicted — statements checked out via `get`\n * are not in the cache and thus never touched by eviction. Evicting a\n * statement drops the cache's reference to it; the native `sqlite3_stmt`\n * handle is finalized when the Statement object is garbage collected.\n */\nexport class StatementCache {\n  // Map insertion order doubles as recency order: entries are re-inserted\n  // on every `get` hit and `return`, so the first entry in the map is the\n  // least recently used. Within an entry's array, the first statement is\n  // the least recently returned.\n  #cache: CachedStatementMap = new Map<string, Statement[]>();\n  readonly #db: Database;\n  readonly #maxSize: number;\n  #size: number = 0;\n\n  /**\n   * The db connection used to prepare the statement.\n   * It is an error to use a statement prepared on one connection with another connection.\n   * @param db\n   * @param maxSize the maximum number of statements to retain in the cache.\n   */\n  constructor(db: Database, maxSize: number = DEFAULT_MAX_CACHED_STATEMENTS) {\n    assert(maxSize >= 0, 'maxSize must not be negative');\n    this.#db = db;\n    this.#maxSize = maxSize;\n  }\n\n  // the number of statements in the cache\n  get size() {\n    return this.#size;\n  }\n\n  // the maximum number of statements the cache will retain\n  get maxSize() {\n    return this.#maxSize;\n  }\n\n  drop(n: number) {\n    assert(n >= 0, 'Cannot drop a negative number of items');\n    assert(n <= this.#size, 'Cannot drop more items than are in the cache');\n\n    for (let i = 0; i < n; i++) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  /**\n   * Prepares a statement for the given sql unless one is already cached.\n   * If one is cached, it is removed from the cache and returned.\n   *\n   * Since `get` removes the item from the cache it is not an error to fail to call\n   * `return`. The gotten statement will be correctly garbage collected.\n   *\n   * When a gotten statement is not returned, future calls to\n   * `get` with the same `sql` will prepare a new statement.\n   *\n   * @param sql\n   * @returns\n   */\n  get(sql: string): CachedStatement {\n    return this.getExact(normalizeWhitespace(sql));\n  }\n\n  /**\n   * Like {@link get}, but keys the statement by `sql` exactly as given,\n   * without normalizing its whitespace. This is for callers that pass the\n   * same text for a statement every time, such as the SQL of a fetch shape,\n   * which then skip the normalization on every call.\n   */\n  getExact(sql: string): CachedStatement {\n    const statements = this.#cache.get(sql);\n    if (statements && statements.length > 0) {\n      const statement = statements.pop()!;\n      this.#size--;\n      this.#cache.delete(sql);\n      if (statements.length > 0) {\n        // Re-insert so the remaining statements for this sql are marked\n        // as most recently used.\n        this.#cache.set(sql, statements);\n      }\n      return {sql, statement};\n    }\n    const statement = this.#db.prepare(sql);\n    return {sql, statement};\n  }\n\n  /**\n   * Handles `get` and `return` for the caller by invoking them before\n   * and after the callback.\n   */\n  use<T>(sql: string, cb: (statement: CachedStatement) => T) {\n    const statement = this.get(sql);\n    try {\n      return cb(statement);\n    } finally {\n      this.return(statement);\n    }\n  }\n\n  /**\n   * Add a statement back to the cache so someone else can use it later.\n   *\n   * If this pushes the cache over its maximum size, the least recently\n   * used statements are evicted.\n   * @param statement\n   */\n  return(statement: CachedStatement) {\n    const {sql} = statement;\n    let statements = this.#cache.get(sql);\n    if (statements === undefined) {\n      statements = [];\n    } else {\n      // Delete so the re-insert below moves this sql to the most recently\n      // used position.\n      this.#cache.delete(sql);\n    }\n    statements.push(statement.statement);\n    this.#cache.set(sql, statements);\n    this.#size++;\n\n    while (this.#size > this.#maxSize) {\n      this.#evictLeastRecentlyUsed();\n    }\n  }\n\n  #evictLeastRecentlyUsed() {\n    const lru = this.#cache.entries().next();\n    assert(!lru.done, 'Cannot evict from an empty cache');\n    const [sql, statements] = lru.value;\n    statements.shift();\n    this.#size--;\n    if (statements.length === 0) {\n      this.#cache.delete(sql);\n    }\n  }\n}\n\nfunction normalizeWhitespace(sql: string) {\n  return sql.replaceAll(/\\s+/g, ' ');\n}\n"],"mappings":";;;;;;;;;;;;;AAoBA,IAAa,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC7C,IAAa,iBAAb,MAA4B;CAK1B,yBAA6B,IAAI,IAAyB;CAC1D;CACA;CACA,QAAgB;;;;;;;CAQhB,YAAY,IAAc,UAAkB,+BAA+B;EACzE,OAAO,WAAW,GAAG,8BAA8B;EACnD,KAAK,MAAM;EACX,KAAK,WAAW;CAClB;CAGA,IAAI,OAAO;EACT,OAAO,KAAK;CACd;CAGA,IAAI,UAAU;EACZ,OAAO,KAAK;CACd;CAEA,KAAK,GAAW;EACd,OAAO,KAAK,GAAG,wCAAwC;EACvD,OAAO,KAAK,KAAK,OAAO,8CAA8C;EAEtE,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACrB,KAAK,wBAAwB;CAEjC;;;;;;;;;;;;;;CAeA,IAAI,KAA8B;EAChC,OAAO,KAAK,SAAS,oBAAoB,GAAG,CAAC;CAC/C;;;;;;;CAQA,SAAS,KAA8B;EACrC,MAAM,aAAa,KAAK,OAAO,IAAI,GAAG;EACtC,IAAI,cAAc,WAAW,SAAS,GAAG;GACvC,MAAM,YAAY,WAAW,IAAI;GACjC,KAAK;GACL,KAAK,OAAO,OAAO,GAAG;GACtB,IAAI,WAAW,SAAS,GAGtB,KAAK,OAAO,IAAI,KAAK,UAAU;GAEjC,OAAO;IAAC;IAAK;GAAS;EACxB;EAEA,OAAO;GAAC;GAAK,WADK,KAAK,IAAI,QAAQ,GACtB;EAAS;CACxB;;;;;CAMA,IAAO,KAAa,IAAuC;EACzD,MAAM,YAAY,KAAK,IAAI,GAAG;EAC9B,IAAI;GACF,OAAO,GAAG,SAAS;EACrB,UAAU;GACR,KAAK,OAAO,SAAS;EACvB;CACF;;;;;;;;CASA,OAAO,WAA4B;EACjC,MAAM,EAAC,QAAO;EACd,IAAI,aAAa,KAAK,OAAO,IAAI,GAAG;EACpC,IAAI,eAAe,KAAA,GACjB,aAAa,CAAC;OAId,KAAK,OAAO,OAAO,GAAG;EAExB,WAAW,KAAK,UAAU,SAAS;EACnC,KAAK,OAAO,IAAI,KAAK,UAAU;EAC/B,KAAK;EAEL,OAAO,KAAK,QAAQ,KAAK,UACvB,KAAK,wBAAwB;CAEjC;CAEA,0BAA0B;EACxB,MAAM,MAAM,KAAK,OAAO,QAAQ,CAAC,CAAC,KAAK;EACvC,OAAO,CAAC,IAAI,MAAM,kCAAkC;EACpD,MAAM,CAAC,KAAK,cAAc,IAAI;EAC9B,WAAW,MAAM;EACjB,KAAK;EACL,IAAI,WAAW,WAAW,GACxB,KAAK,OAAO,OAAO,GAAG;CAE1B;AACF;AAEA,SAAS,oBAAoB,KAAa;CACxC,OAAO,IAAI,WAAW,QAAQ,GAAG;AACnC"}

package/out/zqlite/src/mod.js

@@ -1,5 +1,5 @@
-import "../../zero-types/src/format.js";
-import "../../zql/src/query/query-impl.js";
-import "./db.js";
-import "./query-delegate.js";
-export {};
+import { defaultFormat } from "../../zero-types/src/format.js";
+import { QueryImpl } from "../../zql/src/query/query-impl.js";
+import { Database } from "./db.js";
+import { QueryDelegateImpl } from "./query-delegate.js";
+export { Database, QueryDelegateImpl as QueryDelegate, QueryImpl, defaultFormat };

package/out/zqlite/src/pending-delta.js.map

@@ -1 +1 @@
-{"version":3,"file":"pending-delta.js","names":["#primaryKey","#singleColumnKey","#firstKeyValues","#byKey","#indexes","#rowBytes","#indexBytes","#liveCount","#key","#track","#removeFromIndexes","#addToIndexes","#getOrCreateIndex"],"sources":["../../../../zqlite/src/pending-delta.ts"],"sourcesContent":["import {BTreeSet} from '../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../shared/src/has-own.ts';\nimport type {Ordering, OrderPart} 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 {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  type Constraint,\n} from '../../zql/src/ivm/constraint.ts';\nimport type {Comparator} from '../../zql/src/ivm/data.ts';\nimport {\n  generateRows,\n  makeBoundComparator,\n  maxValue,\n  minValue,\n  type RowBound,\n} from '../../zql/src/ivm/memory-source.ts';\nimport type {MultiConstraint} from '../../zql/src/ivm/operator.ts';\n\n/**\n * The batch overlay that lets a `TableSource` derive a transaction without\n * writing to the database it is reading from.\n *\n * A `TableSource` normally makes each change durable in its backing SQLite\n * connection as soon as it has been vended to every output, because change\n * *k+1* has to read a base that already includes changes *1..k* -- IVM's\n * joins fetch from the source mid-push. On the server that backing connection\n * is a `BEGIN CONCURRENT` snapshot that is never committed and always rolled\n * back, so those writes exist only to serve reads for the rest of the pass.\n *\n * A `PendingDelta` holds them in memory instead. The base stays pinned at the\n * state it had when the pass began and this object supplies *1..k*, merged\n * into every leaf scan. The durable copy comes from the replicator's own\n * commit, which the source picks up when it leapfrogs to the next snapshot.\n *\n * State is coalesced by primary key: whatever the batch did to a row, all that\n * matters downstream is the row's final value, or that it is gone. A key that\n * appears here overrides the base unconditionally -- an added row has no base\n * to override, an edited row's base copy is suppressed in favor of the new\n * value, and a removed row's base copy is suppressed with nothing to put in\n * its place.\n *\n * Live rows are additionally kept in lazily built sorted indexes, one per\n * `[...constraintKeys, ...sort]` shape a fetch has asked for, so that merging\n * the delta into a constrained scan costs `O(log D + matches)` rather than a\n * walk of the whole delta. This mirrors `MemorySource`'s index handling; see\n * its `#fetch` for the bound construction the scans here reproduce.\n */\nexport class PendingDelta {\n  readonly #primaryKey: PrimaryKey;\n  readonly #singleColumnKey: string | undefined;\n\n  /**\n   * For a composite primary key, the first key column's value of every key in\n   * `#byKey`. {@link overrides} runs for every base row of a merged fetch, and\n   * building a composite key allocates, so this rules most rows out first.\n   */\n  readonly #firstKeyValues = new Set<Value>();\n\n  /**\n   * The coalesced net state, keyed by primary key. A `undefined` value is a\n   * tombstone: the batch removed the row, so the base copy is suppressed and\n   * nothing replaces it. Membership alone is what suppresses a base row, so\n   * this map is also the \"is this key overridden\" test.\n   */\n  readonly #byKey = new Map<unknown, Row | undefined>();\n\n  /** Sorted views over the live (non-tombstone) rows, keyed by `JSON(sort)`. */\n  readonly #indexes = new Map<string, BTreeSet<Row>>();\n\n  #liveCount = 0;\n  #rowBytes = 0;\n  #indexBytes = 0;\n\n  constructor(primaryKey: PrimaryKey) {\n    this.#primaryKey = primaryKey;\n    this.#singleColumnKey = primaryKey.length === 1 ? primaryKey[0] : undefined;\n  }\n\n  /**\n   * True when the source can take its untouched fast path: no suppression\n   * test per base row, no merge, no index maintenance.\n   */\n  get isEmpty(): boolean {\n    return this.#byKey.size === 0;\n  }\n\n  /** The number of rows the batch has touched, tombstones included. */\n  get size(): number {\n    return this.#byKey.size;\n  }\n\n  /**\n   * Estimated retained bytes, including keys, tombstones, and sorted indexes.\n   * This is a budgeting heuristic, not a measurement of the JavaScript heap.\n   */\n  get estimatedBytes(): number {\n    // Budget 32 bytes per live row per index for references and B-tree nodes.\n    return (\n      this.#rowBytes +\n      this.#indexBytes +\n      this.#liveCount * this.#indexes.size * 32\n    );\n  }\n\n  #key(row: Row): unknown {\n    const single = this.#singleColumnKey;\n    if (single !== undefined) {\n      return row[single];\n    }\n    const key = this.#primaryKey.map(k => row[k]);\n    return JSON.stringify(key);\n  }\n\n  #track(row: Row, key: unknown): void {\n    if (this.#byKey.has(key)) {\n      return;\n    }\n    this.#rowBytes += 64 + estimateBytes(key as Value);\n    if (this.#singleColumnKey === undefined) {\n      this.#firstKeyValues.add(row[this.#primaryKey[0]]);\n    }\n  }\n\n  /** Records that `row` is now present with this value. */\n  set(row: Row): void {\n    const key = this.#key(row);\n    const existing = this.#byKey.get(key);\n    this.#track(row, key);\n    this.#rowBytes +=\n      estimateBytes(row) -\n      (existing === undefined ? 0 : estimateBytes(existing));\n    if (existing !== undefined) {\n      // A live row for this key is already indexed under its old value, which\n      // may sort differently. Retract it before inserting the new one.\n      this.#removeFromIndexes(existing);\n      this.#liveCount--;\n    }\n    this.#byKey.set(key, row);\n    this.#addToIndexes(row);\n    this.#liveCount++;\n  }\n\n  /** Records that `row` is now absent. */\n  delete(row: Row): void {\n    const key = this.#key(row);\n    const existing = this.#byKey.get(key);\n    this.#track(row, key);\n    if (existing !== undefined) {\n      this.#rowBytes -= estimateBytes(existing);\n      this.#removeFromIndexes(existing);\n      this.#liveCount--;\n    }\n    this.#byKey.set(key, undefined);\n  }\n\n  /**\n   * Whether the batch overrides this base row. Callers use it to suppress base\n   * rows during a merge, so it must be answered by primary key -- the value\n   * carried by the base row is exactly what the delta is replacing.\n   */\n  overrides(row: Row): boolean {\n    if (\n      this.#singleColumnKey === undefined &&\n      !this.#firstKeyValues.has(row[this.#primaryKey[0]])\n    ) {\n      return false;\n    }\n    return this.#byKey.has(this.#key(row));\n  }\n\n  /**\n   * The batch's value for a row, by primary key. Returns `NOT_OVERRIDDEN` when\n   * the batch has not touched the key at all (so the caller should consult the\n   * base) and `undefined` when the batch removed it.\n   */\n  get(row: Row): Row | undefined | typeof NOT_OVERRIDDEN {\n    const key = this.#key(row);\n    if (!this.#byKey.has(key)) {\n      return NOT_OVERRIDDEN;\n    }\n    return this.#byKey.get(key);\n  }\n\n  /**\n   * Looks a row up by an arbitrary (not necessarily primary) unique key. Only\n   * reachable when the delta is non-empty, which is never the case for the one\n   * caller that uses a non-primary key, so a walk is fine here.\n   */\n  getByColumns(keyCols: readonly string[], keyRow: Row): Row | undefined {\n    for (const row of this.#byKey.values()) {\n      if (row !== undefined && keyCols.every(c => row[c] === keyRow[c])) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  #addToIndexes(row: Row): void {\n    for (const data of this.#indexes.values()) {\n      data.add(row);\n    }\n  }\n\n  #removeFromIndexes(row: Row): void {\n    for (const data of this.#indexes.values()) {\n      data.delete(row);\n    }\n  }\n\n  #getOrCreateIndex(sort: Ordering): BTreeSet<Row> {\n    const indexKey = JSON.stringify(sort);\n    let data = this.#indexes.get(indexKey);\n    if (data === undefined) {\n      data = new BTreeSet<Row>(makeBoundComparator(sort) as Comparator);\n      for (const row of this.#byKey.values()) {\n        if (row !== undefined) {\n          data.add(row);\n        }\n      }\n      this.#indexes.set(indexKey, data);\n      this.#indexBytes += 128 + estimateBytes(indexKey) + estimateBytes(sort);\n    }\n    return data;\n  }\n\n  /**\n   * The live rows this batch contributes to a fetch, in the same order the\n   * backing SQL query returns its rows, so the two streams can be merged.\n   *\n   * `constraint`, `multiConstraints` and `filterPredicate` are the ones SQL\n   * already applied to the base rows; they are applied here so the delta rows\n   * are subject to the same query. `start` is the fetch's start row: the scan\n   * begins there rather than at the start of the constraint span. It is\n   * inclusive, so the caller still applies an `after` basis.\n   */\n  *rowsFor(\n    sort: Ordering,\n    constraint: Constraint | undefined,\n    reverse: boolean | undefined,\n    filterPredicate: ((row: Row) => boolean | undefined) | undefined,\n    multiConstraints: readonly MultiConstraint[] | undefined,\n    start?: Row | undefined,\n  ): Iterable<Row> {\n    if (this.#liveCount === 0) {\n      return;\n    }\n\n    // Lead the index with the constraint keys so a constrained fetch scans\n    // only the matching span; within that span rows come out in `sort` order,\n    // which is the order SQL returned the base rows in.\n    const indexSort: OrderPart[] = [];\n    if (constraint) {\n      for (const key of Object.keys(constraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n    // Constraining by the whole primary key admits at most one row, so the\n    // requested sort adds nothing.\n    const sorted =\n      !constraint || !constraintMatchesPrimaryKey(constraint, this.#primaryKey);\n    if (sorted) {\n      indexSort.push(...sort);\n    }\n\n    const data = this.#getOrCreateIndex(indexSort);\n\n    let scanStart: RowBound | undefined;\n    if (\n      start !== undefined &&\n      sorted &&\n      (!constraint || constraintMatchesRow(constraint, start))\n    ) {\n      // `start` carries every index column, and within the constraint span it\n      // agrees with the constraint, so it is the scan's bound as it stands.\n      // A `start` outside the span bounds nothing the scan can use.\n      scanStart = start;\n    } else if (constraint) {\n      // The first row matching the constraint is not simply the constraint\n      // values with everything else absent: a `desc` part puts absent values\n      // last. The min/max sentinels say \"the first row with these constraint\n      // values\" regardless of direction. Same construction as `MemorySource`.\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(constraint, key)) {\n          scanStart[key] = constraint[key] as Value;\n        } else if (reverse) {\n          scanStart[key] = dir === 'asc' ? maxValue : minValue;\n        } else {\n          scanStart[key] = dir === 'asc' ? minValue : maxValue;\n        }\n      }\n    }\n\n    for (const row of generateRows(data, scanStart, reverse)) {\n      if (constraint && !constraintMatchesRow(constraint, row)) {\n        // Rows are sorted by the constraint keys first, so matches are\n        // contiguous and the first miss ends the span.\n        break;\n      }\n      if (multiConstraints && !matchesMultiConstraints(row, multiConstraints)) {\n        continue;\n      }\n      if (filterPredicate && !filterPredicate(row)) {\n        continue;\n      }\n      yield row;\n    }\n  }\n\n  /**\n   * A row with the primary key of each row the batch has touched, removed\n   * rows included. A live row is returned as is.\n   */\n  *touchedKeys(): Iterable<Row> {\n    const single = this.#singleColumnKey;\n    for (const [key, row] of this.#byKey) {\n      if (row !== undefined) {\n        yield row;\n      } else if (single !== undefined) {\n        yield {[single]: key as Value};\n      } else {\n        const values = JSON.parse(key as string) as Value[];\n        yield Object.fromEntries(\n          this.#primaryKey.map((k, i) => [k, values[i]]),\n        );\n      }\n    }\n  }\n\n  /** The rows the batch has added or edited, and not since removed. */\n  *liveRows(): Iterable<Row> {\n    for (const row of this.#byKey.values()) {\n      if (row !== undefined) {\n        yield row;\n      }\n    }\n  }\n\n  /** Drops the batch. Called when the source moves to a snapshot that has it. */\n  clear(): void {\n    this.#byKey.clear();\n    this.#firstKeyValues.clear();\n    this.#indexes.clear();\n    this.#liveCount = 0;\n    this.#rowBytes = 0;\n    this.#indexBytes = 0;\n  }\n}\n\n// Allow for object/property storage and UTF-16 strings without allocating a\n// serialized copy. Shared values may be counted more than once intentionally.\nfunction estimateBytes(value: Value): number {\n  if (typeof value === 'string') {\n    return 24 + value.length * 2;\n  }\n  if (value === null || typeof value !== 'object') {\n    return 8;\n  }\n  let bytes = 32;\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      bytes += 8 + estimateBytes(item);\n    }\n  } else {\n    for (const key in value) {\n      bytes += 16 + estimateBytes(key) + estimateBytes((value as Row)[key]);\n    }\n  }\n  return bytes;\n}\n\nexport const NOT_OVERRIDDEN = Symbol('not-overridden');\n\nfunction matchesMultiConstraints(\n  row: Row,\n  multiConstraints: readonly MultiConstraint[],\n): boolean {\n  for (const mc of multiConstraints) {\n    if (mc.length === 0) {\n      continue;\n    }\n    let any = false;\n    for (const c of mc) {\n      if (constraintMatchesRow(c, row)) {\n        any = true;\n        break;\n      }\n    }\n    if (!any) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Merges a batch's rows into an ordered base stream and drops the base rows\n * the batch overrides.\n *\n * Both streams must already be in `compare` order. A delta row that ties with\n * a base row is the *same* row by primary key -- every fetch ordering includes\n * the primary key -- so the base copy is suppressed and the delta's value\n * takes its place at that position.\n */\nexport function* generateWithPendingDelta(\n  baseRows: Iterable<Row>,\n  deltaRows: Iterable<Row>,\n  delta: PendingDelta,\n  compare: Comparator,\n): IterableIterator<Row> {\n  const deltaIter = deltaRows[Symbol.iterator]();\n  let pending = deltaIter.next();\n  try {\n    for (const row of baseRows) {\n      while (!pending.done && compare(pending.value, row) < 0) {\n        yield pending.value;\n        pending = deltaIter.next();\n      }\n      if (!delta.overrides(row)) {\n        yield row;\n      }\n    }\n    while (!pending.done) {\n      yield pending.value;\n      pending = deltaIter.next();\n    }\n  } finally {\n    // Propagate early termination so the delta iterator can release the BTree\n    // cursor it is walking, the same contract `mergeSortedStreams` documents.\n    if (!pending.done) {\n      deltaIter.return?.(undefined);\n    }\n  }\n}\n\n/**\n * The unordered counterpart. Nothing downstream depends on position, so the\n * surviving base rows are emitted first and the batch's rows follow.\n */\nexport function* generateWithPendingDeltaUnordered(\n  baseRows: Iterable<Row>,\n  deltaRows: Iterable<Row>,\n  delta: PendingDelta,\n): IterableIterator<Row> {\n  for (const row of baseRows) {\n    if (!delta.overrides(row)) {\n      yield row;\n    }\n  }\n  yield* deltaRows;\n}\n"],"mappings":"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"}
+{"version":3,"file":"pending-delta.js","names":[],"sources":["../../../../zqlite/src/pending-delta.ts"],"sourcesContent":["import {BTreeSet} from '../../shared/src/btree-set.ts';\nimport {hasOwn} from '../../shared/src/has-own.ts';\nimport type {Ordering, OrderPart} 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 {\n  constraintMatchesPrimaryKey,\n  constraintMatchesRow,\n  type Constraint,\n} from '../../zql/src/ivm/constraint.ts';\nimport type {Comparator} from '../../zql/src/ivm/data.ts';\nimport {\n  generateRows,\n  makeBoundComparator,\n  maxValue,\n  minValue,\n  type RowBound,\n} from '../../zql/src/ivm/memory-source.ts';\nimport type {MultiConstraint} from '../../zql/src/ivm/operator.ts';\n\n/**\n * The batch overlay that lets a `TableSource` derive a transaction without\n * writing to the database it is reading from.\n *\n * A `TableSource` normally makes each change durable in its backing SQLite\n * connection as soon as it has been vended to every output, because change\n * *k+1* has to read a base that already includes changes *1..k* -- IVM's\n * joins fetch from the source mid-push. On the server that backing connection\n * is a `BEGIN CONCURRENT` snapshot that is never committed and always rolled\n * back, so those writes exist only to serve reads for the rest of the pass.\n *\n * A `PendingDelta` holds them in memory instead. The base stays pinned at the\n * state it had when the pass began and this object supplies *1..k*, merged\n * into every leaf scan. The durable copy comes from the replicator's own\n * commit, which the source picks up when it leapfrogs to the next snapshot.\n *\n * State is coalesced by primary key: whatever the batch did to a row, all that\n * matters downstream is the row's final value, or that it is gone. A key that\n * appears here overrides the base unconditionally -- an added row has no base\n * to override, an edited row's base copy is suppressed in favor of the new\n * value, and a removed row's base copy is suppressed with nothing to put in\n * its place.\n *\n * Live rows are additionally kept in lazily built sorted indexes, one per\n * `[...constraintKeys, ...sort]` shape a fetch has asked for, so that merging\n * the delta into a constrained scan costs `O(log D + matches)` rather than a\n * walk of the whole delta. This mirrors `MemorySource`'s index handling; see\n * its `#fetch` for the bound construction the scans here reproduce.\n */\nexport class PendingDelta {\n  readonly #primaryKey: PrimaryKey;\n  readonly #singleColumnKey: string | undefined;\n\n  /**\n   * For a composite primary key, the first key column's value of every key in\n   * `#byKey`. {@link overrides} runs for every base row of a merged fetch, and\n   * building a composite key allocates, so this rules most rows out first.\n   */\n  readonly #firstKeyValues = new Set<Value>();\n\n  /**\n   * The coalesced net state, keyed by primary key. A `undefined` value is a\n   * tombstone: the batch removed the row, so the base copy is suppressed and\n   * nothing replaces it. Membership alone is what suppresses a base row, so\n   * this map is also the \"is this key overridden\" test.\n   */\n  readonly #byKey = new Map<unknown, Row | undefined>();\n\n  /** Sorted views over the live (non-tombstone) rows, keyed by `JSON(sort)`. */\n  readonly #indexes = new Map<string, BTreeSet<Row>>();\n\n  #liveCount = 0;\n  #rowBytes = 0;\n  #indexBytes = 0;\n\n  constructor(primaryKey: PrimaryKey) {\n    this.#primaryKey = primaryKey;\n    this.#singleColumnKey = primaryKey.length === 1 ? primaryKey[0] : undefined;\n  }\n\n  /**\n   * True when the source can take its untouched fast path: no suppression\n   * test per base row, no merge, no index maintenance.\n   */\n  get isEmpty(): boolean {\n    return this.#byKey.size === 0;\n  }\n\n  /** The number of rows the batch has touched, tombstones included. */\n  get size(): number {\n    return this.#byKey.size;\n  }\n\n  /**\n   * Estimated retained bytes, including keys, tombstones, and sorted indexes.\n   * This is a budgeting heuristic, not a measurement of the JavaScript heap.\n   */\n  get estimatedBytes(): number {\n    // Budget 32 bytes per live row per index for references and B-tree nodes.\n    return (\n      this.#rowBytes +\n      this.#indexBytes +\n      this.#liveCount * this.#indexes.size * 32\n    );\n  }\n\n  #key(row: Row): unknown {\n    const single = this.#singleColumnKey;\n    if (single !== undefined) {\n      return row[single];\n    }\n    const key = this.#primaryKey.map(k => row[k]);\n    return JSON.stringify(key);\n  }\n\n  #track(row: Row, key: unknown): void {\n    if (this.#byKey.has(key)) {\n      return;\n    }\n    this.#rowBytes += 64 + estimateBytes(key as Value);\n    if (this.#singleColumnKey === undefined) {\n      this.#firstKeyValues.add(row[this.#primaryKey[0]]);\n    }\n  }\n\n  /** Records that `row` is now present with this value. */\n  set(row: Row): void {\n    const key = this.#key(row);\n    const existing = this.#byKey.get(key);\n    this.#track(row, key);\n    this.#rowBytes +=\n      estimateBytes(row) -\n      (existing === undefined ? 0 : estimateBytes(existing));\n    if (existing !== undefined) {\n      // A live row for this key is already indexed under its old value, which\n      // may sort differently. Retract it before inserting the new one.\n      this.#removeFromIndexes(existing);\n      this.#liveCount--;\n    }\n    this.#byKey.set(key, row);\n    this.#addToIndexes(row);\n    this.#liveCount++;\n  }\n\n  /** Records that `row` is now absent. */\n  delete(row: Row): void {\n    const key = this.#key(row);\n    const existing = this.#byKey.get(key);\n    this.#track(row, key);\n    if (existing !== undefined) {\n      this.#rowBytes -= estimateBytes(existing);\n      this.#removeFromIndexes(existing);\n      this.#liveCount--;\n    }\n    this.#byKey.set(key, undefined);\n  }\n\n  /**\n   * Whether the batch overrides this base row. Callers use it to suppress base\n   * rows during a merge, so it must be answered by primary key -- the value\n   * carried by the base row is exactly what the delta is replacing.\n   */\n  overrides(row: Row): boolean {\n    if (\n      this.#singleColumnKey === undefined &&\n      !this.#firstKeyValues.has(row[this.#primaryKey[0]])\n    ) {\n      return false;\n    }\n    return this.#byKey.has(this.#key(row));\n  }\n\n  /**\n   * The batch's value for a row, by primary key. Returns `NOT_OVERRIDDEN` when\n   * the batch has not touched the key at all (so the caller should consult the\n   * base) and `undefined` when the batch removed it.\n   */\n  get(row: Row): Row | undefined | typeof NOT_OVERRIDDEN {\n    const key = this.#key(row);\n    if (!this.#byKey.has(key)) {\n      return NOT_OVERRIDDEN;\n    }\n    return this.#byKey.get(key);\n  }\n\n  /**\n   * Looks a row up by an arbitrary (not necessarily primary) unique key. Only\n   * reachable when the delta is non-empty, which is never the case for the one\n   * caller that uses a non-primary key, so a walk is fine here.\n   */\n  getByColumns(keyCols: readonly string[], keyRow: Row): Row | undefined {\n    for (const row of this.#byKey.values()) {\n      if (row !== undefined && keyCols.every(c => row[c] === keyRow[c])) {\n        return row;\n      }\n    }\n    return undefined;\n  }\n\n  #addToIndexes(row: Row): void {\n    for (const data of this.#indexes.values()) {\n      data.add(row);\n    }\n  }\n\n  #removeFromIndexes(row: Row): void {\n    for (const data of this.#indexes.values()) {\n      data.delete(row);\n    }\n  }\n\n  #getOrCreateIndex(sort: Ordering): BTreeSet<Row> {\n    const indexKey = JSON.stringify(sort);\n    let data = this.#indexes.get(indexKey);\n    if (data === undefined) {\n      data = new BTreeSet<Row>(makeBoundComparator(sort) as Comparator);\n      for (const row of this.#byKey.values()) {\n        if (row !== undefined) {\n          data.add(row);\n        }\n      }\n      this.#indexes.set(indexKey, data);\n      this.#indexBytes += 128 + estimateBytes(indexKey) + estimateBytes(sort);\n    }\n    return data;\n  }\n\n  /**\n   * The live rows this batch contributes to a fetch, in the same order the\n   * backing SQL query returns its rows, so the two streams can be merged.\n   *\n   * `constraint`, `multiConstraints` and `filterPredicate` are the ones SQL\n   * already applied to the base rows; they are applied here so the delta rows\n   * are subject to the same query. `start` is the fetch's start row: the scan\n   * begins there rather than at the start of the constraint span. It is\n   * inclusive, so the caller still applies an `after` basis.\n   */\n  *rowsFor(\n    sort: Ordering,\n    constraint: Constraint | undefined,\n    reverse: boolean | undefined,\n    filterPredicate: ((row: Row) => boolean | undefined) | undefined,\n    multiConstraints: readonly MultiConstraint[] | undefined,\n    start?: Row | undefined,\n  ): Iterable<Row> {\n    if (this.#liveCount === 0) {\n      return;\n    }\n\n    // Lead the index with the constraint keys so a constrained fetch scans\n    // only the matching span; within that span rows come out in `sort` order,\n    // which is the order SQL returned the base rows in.\n    const indexSort: OrderPart[] = [];\n    if (constraint) {\n      for (const key of Object.keys(constraint)) {\n        indexSort.push([key, 'asc']);\n      }\n    }\n    // Constraining by the whole primary key admits at most one row, so the\n    // requested sort adds nothing.\n    const sorted =\n      !constraint || !constraintMatchesPrimaryKey(constraint, this.#primaryKey);\n    if (sorted) {\n      indexSort.push(...sort);\n    }\n\n    const data = this.#getOrCreateIndex(indexSort);\n\n    let scanStart: RowBound | undefined;\n    if (\n      start !== undefined &&\n      sorted &&\n      (!constraint || constraintMatchesRow(constraint, start))\n    ) {\n      // `start` carries every index column, and within the constraint span it\n      // agrees with the constraint, so it is the scan's bound as it stands.\n      // A `start` outside the span bounds nothing the scan can use.\n      scanStart = start;\n    } else if (constraint) {\n      // The first row matching the constraint is not simply the constraint\n      // values with everything else absent: a `desc` part puts absent values\n      // last. The min/max sentinels say \"the first row with these constraint\n      // values\" regardless of direction. Same construction as `MemorySource`.\n      scanStart = {};\n      for (const [key, dir] of indexSort) {\n        if (hasOwn(constraint, key)) {\n          scanStart[key] = constraint[key] as Value;\n        } else if (reverse) {\n          scanStart[key] = dir === 'asc' ? maxValue : minValue;\n        } else {\n          scanStart[key] = dir === 'asc' ? minValue : maxValue;\n        }\n      }\n    }\n\n    for (const row of generateRows(data, scanStart, reverse)) {\n      if (constraint && !constraintMatchesRow(constraint, row)) {\n        // Rows are sorted by the constraint keys first, so matches are\n        // contiguous and the first miss ends the span.\n        break;\n      }\n      if (multiConstraints && !matchesMultiConstraints(row, multiConstraints)) {\n        continue;\n      }\n      if (filterPredicate && !filterPredicate(row)) {\n        continue;\n      }\n      yield row;\n    }\n  }\n\n  /**\n   * A row with the primary key of each row the batch has touched, removed\n   * rows included. A live row is returned as is.\n   */\n  *touchedKeys(): Iterable<Row> {\n    const single = this.#singleColumnKey;\n    for (const [key, row] of this.#byKey) {\n      if (row !== undefined) {\n        yield row;\n      } else if (single !== undefined) {\n        yield {[single]: key as Value};\n      } else {\n        const values = JSON.parse(key as string) as Value[];\n        yield Object.fromEntries(\n          this.#primaryKey.map((k, i) => [k, values[i]]),\n        );\n      }\n    }\n  }\n\n  /** The rows the batch has added or edited, and not since removed. */\n  *liveRows(): Iterable<Row> {\n    for (const row of this.#byKey.values()) {\n      if (row !== undefined) {\n        yield row;\n      }\n    }\n  }\n\n  /** Drops the batch. Called when the source moves to a snapshot that has it. */\n  clear(): void {\n    this.#byKey.clear();\n    this.#firstKeyValues.clear();\n    this.#indexes.clear();\n    this.#liveCount = 0;\n    this.#rowBytes = 0;\n    this.#indexBytes = 0;\n  }\n}\n\n// Allow for object/property storage and UTF-16 strings without allocating a\n// serialized copy. Shared values may be counted more than once intentionally.\nfunction estimateBytes(value: Value): number {\n  if (typeof value === 'string') {\n    return 24 + value.length * 2;\n  }\n  if (value === null || typeof value !== 'object') {\n    return 8;\n  }\n  let bytes = 32;\n  if (Array.isArray(value)) {\n    for (const item of value) {\n      bytes += 8 + estimateBytes(item);\n    }\n  } else {\n    for (const key in value) {\n      bytes += 16 + estimateBytes(key) + estimateBytes((value as Row)[key]);\n    }\n  }\n  return bytes;\n}\n\nexport const NOT_OVERRIDDEN = Symbol('not-overridden');\n\nfunction matchesMultiConstraints(\n  row: Row,\n  multiConstraints: readonly MultiConstraint[],\n): boolean {\n  for (const mc of multiConstraints) {\n    if (mc.length === 0) {\n      continue;\n    }\n    let any = false;\n    for (const c of mc) {\n      if (constraintMatchesRow(c, row)) {\n        any = true;\n        break;\n      }\n    }\n    if (!any) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Merges a batch's rows into an ordered base stream and drops the base rows\n * the batch overrides.\n *\n * Both streams must already be in `compare` order. A delta row that ties with\n * a base row is the *same* row by primary key -- every fetch ordering includes\n * the primary key -- so the base copy is suppressed and the delta's value\n * takes its place at that position.\n */\nexport function* generateWithPendingDelta(\n  baseRows: Iterable<Row>,\n  deltaRows: Iterable<Row>,\n  delta: PendingDelta,\n  compare: Comparator,\n): IterableIterator<Row> {\n  const deltaIter = deltaRows[Symbol.iterator]();\n  let pending = deltaIter.next();\n  try {\n    for (const row of baseRows) {\n      while (!pending.done && compare(pending.value, row) < 0) {\n        yield pending.value;\n        pending = deltaIter.next();\n      }\n      if (!delta.overrides(row)) {\n        yield row;\n      }\n    }\n    while (!pending.done) {\n      yield pending.value;\n      pending = deltaIter.next();\n    }\n  } finally {\n    // Propagate early termination so the delta iterator can release the BTree\n    // cursor it is walking, the same contract `mergeSortedStreams` documents.\n    if (!pending.done) {\n      deltaIter.return?.(undefined);\n    }\n  }\n}\n\n/**\n * The unordered counterpart. Nothing downstream depends on position, so the\n * surviving base rows are emitted first and the batch's rows follow.\n */\nexport function* generateWithPendingDeltaUnordered(\n  baseRows: Iterable<Row>,\n  deltaRows: Iterable<Row>,\n  delta: PendingDelta,\n): IterableIterator<Row> {\n  for (const row of baseRows) {\n    if (!delta.overrides(row)) {\n      yield row;\n    }\n  }\n  yield* deltaRows;\n}\n"],"mappings":"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"}

package/out/zqlite/src/query-builder.d.ts

@@ -2,7 +2,7 @@ import type { SQLQuery } from '@databases/sql';
 import type { Condition, Ordering } from '../../zero-protocol/src/ast.ts';
 import type { SchemaValue, ValueType } from '../../zero-schema/src/table-schema.ts';
 import type { Constraint } from '../../zql/src/ivm/constraint.ts';
-import type { MultiConstraint, Start } from '../../zql/src/ivm/operator.ts';
+import type { FetchRequest, MultiConstraint, Start } from '../../zql/src/ivm/operator.ts';
 /**
  * Condition type without correlated subqueries.
  * This matches the output of transformFilters from zql/builder/filter.ts
@@ -27,7 +27,6 @@ export declare function buildSelectQueries(tableName: string, columns: Record<st
  * one without a start row.
  */
 export declare function buildSelectQuery(...args: Parameters<typeof buildSelectQueries>): SQLQuery;
-export declare function constraintsToSQL(constraint: Constraint | undefined, columns: Record<string, SchemaValue>): SQLQuery[];
 /**
  * Builds a single batched IN clause from a `MultiConstraint`. All entries
  * are assumed to share the same shape (the keys of the first entry);
@@ -40,11 +39,20 @@ export declare function constraintsToSQL(constraint: Constraint | undefined, col
  * verified via EXPLAIN QUERY PLAN — see query-builder.test.ts.
  */
 export declare function multiConstraintToSQL(multiConstraint: MultiConstraint, columns: Record<string, SchemaValue>): SQLQuery;
-export declare function orderByToSQL(order: Ordering, reverse: boolean): SQLQuery;
 /**
  * Converts filters (conditions) to SQL WHERE clause.
  * This applies all filters present in the AST for a query to the source.
  */
 export declare function filtersToSQL(filters: NoSubqueryCondition): SQLQuery;
 export declare function toSQLiteType(v: unknown, type: ValueType): unknown;
+/**
+ * A placeholder for a fetch's value that {@link buildSelectQueries} passes
+ * through to the bindings of its SELECTs, where `toSQLiteType` would convert
+ * the value itself. It lets a fetch's SQL text be built once and reused for
+ * every fetch of the same shape (see `fetch-sql.ts`).
+ */
+export declare class Binding {
+    readonly get: (req: FetchRequest) => unknown;
+    constructor(get: (req: FetchRequest) => unknown);
+}
 //# sourceMappingURL=query-builder.d.ts.map

package/out/zqlite/src/query-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/query-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EAGT,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACV,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAE,KAAK,EAAC,MAAM,+BAA+B,CAAC;AAG1E;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,SAAS,EACT;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAC,CAC7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAC3B,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EACzD,YAAY,CAAC,EAAE,mBAAmB,GAAG,SAAS,GAC7C,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CA4DnC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAC7C,QAAQ,CAOV;AA0DD,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,cAcrC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACnC,QAAQ,CAyCV;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,GAAG,QAAQ,CAmBxE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAuBnE;AAgGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAWjE"}
+{"version":3,"file":"query-builder.d.ts","sourceRoot":"","sources":["../../../../zqlite/src/query-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EACV,SAAS,EACT,QAAQ,EAGT,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EACV,WAAW,EACX,SAAS,EACV,MAAM,uCAAuC,CAAC;AAC/C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,iCAAiC,CAAC;AAChE,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,KAAK,EACN,MAAM,+BAA+B,CAAC;AAGvC;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,CACvC,SAAS,EACT;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAC,CAC7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,EACpC,UAAU,EAAE,UAAU,GAAG,SAAS,EAClC,OAAO,EAAE,mBAAmB,GAAG,SAAS,EACxC,KAAK,EAAE,QAAQ,GAAG,SAAS,EAC3B,OAAO,EAAE,OAAO,GAAG,SAAS,EAC5B,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,gBAAgB,CAAC,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,EACzD,YAAY,CAAC,EAAE,mBAAmB,GAAG,SAAS,GAC7C,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CA4DnC;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,GAC7C,QAAQ,CAOV;AA4ED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,eAAe,EAAE,eAAe,EAChC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GACnC,QAAQ,CAyCV;AAuBD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,QAAQ,CAuBnE;AAgGD,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,GAAG,OAAO,CAWjE;AAED;;;;;GAKG;AACH,qBAAa,OAAO;IAClB,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,CAAC;IAC7C,YAAY,GAAG,EAAE,CAAC,GAAG,EAAE,YAAY,KAAK,OAAO,EAE9C;CACF"}