@rocicorp/zero 1.12.0-canary.3 → 1.12.0-canary.5

package/out/zero-cache/src/services/replicator/sqlite-change-log-observability.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-change-log-observability.js","names":["#lc","#messageProcessing","#logCommitDuration","#transactionRows","#rollbackCounter","#invariantFailureCounter","#hashComparisonCounter","#hashUnpairedCounter","#cookieMutationCounter","#receivedHead","#sqliteHead","#rows","#estimatedBytes","#cookieRows","#sourceHasher","#invariantFailure","#sourcePos","#sourceCommitHash","#resetSourceHash","#transactionWatermark","#recordRollback","#recordUnpaired","#compareHashes","#cookieMutations","#rollbacks","#invariantFailures","#hashMatches","#hashMismatches","#hashUnpaired"],"sources":["../../../../../../zero-cache/src/services/replicator/sqlite-change-log-observability.ts"],"sourcesContent":["/**\n * Observability for the SQLite change log.\n *\n * Everything here now runs in the **change-streamer** process, which is where\n * the writer lives. The module stays beside the rest of the change-log code\n * under `services/replicator/` for the same reason `change-log-db.ts` and\n * `change-log-stream-writer.ts` do: moving files would obscure the topology\n * diff, and the writer's home is a property of who calls it rather than of\n * where it sits. Metric names are unchanged from 7H — only their emitting\n * process, and therefore their resource attributes, moved.\n */\n\nimport {stat} from 'node:fs/promises';\nimport type {LogContext} from '@rocicorp/logger';\nimport {unreachable} from '../../../../shared/src/asserts.ts';\nimport type {Database} from '../../../../zqlite/src/db.ts';\nimport {\n  getOrCreateCounter,\n  getOrCreateGauge,\n  getOrCreateLatencyHistogram,\n  getOrCreateValueHistogram,\n} from '../../observability/metrics.ts';\nimport {versionFromLexi} from '../../types/lexi-version.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport {extractChangeSubstring} from '../change-streamer/change-log-codec.ts';\nimport {ChangeLogTransactionHasher} from '../change-streamer/change-log-transaction-hash.ts';\nimport {\n  readCookieRowCounts,\n  type CookieOpTag,\n  type CookieRowCounts,\n} from './change-log-cookies.ts';\nimport {\n  CHANGE_LOG_STREAM_TABLE,\n  readChangeLogBounds,\n  readChangeLogMeta,\n  type ChangeLogMeta,\n  type ReconcileResult,\n} from './change-log-db.ts';\nimport type {ChangeLogStreamTransactionStats} from './change-log-stream-writer.ts';\n\n/**\n * Reports the reconciliation of the change-log database against the watermark\n * the stream connection resumes from. This runs once per stream connection, so\n * a reconnect storm is visible here as well as a restart.\n *\n * A wipe is not an error — it is how every abnormal change-log state is\n * collapsed into a correct one — but each wipe costs the retention window, so\n * every reconnecting subscriber below the head gets `too-old`. The `gap` reason\n * in particular means the log neither held the resume watermark nor could be\n * truncated to it, so a nonzero rate in steady state is an alert, not a\n * statistic.\n */\nexport function recordSQLiteChangeLogReconcile(\n  lc: LogContext,\n  result: ReconcileResult,\n): void {\n  switch (result.action) {\n    case 'truncated':\n      getOrCreateCounter(\n        'replica',\n        'sqlite_change_log.reconcile_truncated_rows',\n        'Phantom change-log rows removed at reconciliation, i.e. rows above ' +\n          'the watermark the change stream resumed from.',\n      ).add(result.rows);\n      break;\n    case 'reseeded':\n      getOrCreateCounter(\n        'replica',\n        'sqlite_change_log.reconcile_wipes',\n        'Change-log wipes at reconciliation, by reason. Each one resets the ' +\n          'retention window, so subscribers below the head get `too-old`.',\n      ).add(1, {reason: result.reason});\n      break;\n    case 'none':\n      break;\n    default:\n      unreachable(result);\n  }\n  if (result.cookiesStale) {\n    // The invariant-17 counter: after any reconcile that moved the head, the\n    // log's cookie set has to be replaced with the one that belongs to the\n    // resume watermark. A nonzero `truncated` series in steady state means\n    // phantom truncation is happening on a shard where it should not.\n    getOrCreateCounter(\n      'replica',\n      'sqlite_change_log.cookie_reseed',\n      'Change-log cookie sets invalidated at reconciliation, by the ' +\n        'reconcile action that invalidated them.',\n    ).add(1, {action: result.action});\n  }\n  lc.debug?.('SQLite change-log reconciliation', {\n    sqliteChangeLogReconcile: result,\n  });\n}\n\n/**\n * What the log says about itself. Nothing here reads the replica: after the\n * writer moved to the change-streamer, the replica's state version is a\n * consequence of this log rather than a fact about it.\n */\nexport type SQLiteChangeLogStartupInfo = ChangeLogMeta & {\n  readonly minWatermark: string;\n  readonly headWatermark: string;\n};\n\nexport type SQLiteChangeLogInfo = SQLiteChangeLogStartupInfo & {\n  readonly rows: number;\n  readonly estimatedBytes: number;\n  readonly cookieRows: CookieRowCounts;\n};\n\n/**\n * Reads the meta row and covered range. Unlike {@link getSQLiteChangeLogInfo}\n * this does not scan the log; see {@link readChangeLogBounds}.\n *\n * Call this after reconciliation, which is the only point at which the head is\n * known to be the resume watermark.\n */\nexport function getSQLiteChangeLogStartupInfo(\n  changeLog: Database,\n): SQLiteChangeLogStartupInfo {\n  const meta = readChangeLogMeta(changeLog);\n  const {minWatermark, headWatermark} = readChangeLogBounds(changeLog);\n  if (minWatermark === null || headWatermark === null) {\n    throw new Error('the SQLite change log must contain its seed transaction');\n  }\n  return {...meta, minWatermark, headWatermark};\n}\n\n/**\n * Extends {@link getSQLiteChangeLogStartupInfo} with the retained row and\n * estimated byte totals. Computing these scans the entire change-log table, so\n * only call it when the totals are consumed, i.e. when the writer (and thus the\n * observer) is enabled.\n */\nexport function getSQLiteChangeLogInfo(\n  changeLog: Database,\n): SQLiteChangeLogInfo {\n  const startup = getSQLiteChangeLogStartupInfo(changeLog);\n  const aggregate = changeLog\n    .prepare(/*sql*/ `\n      SELECT count(*) AS \"rows\",\n             coalesce(sum(\"estimatedBytes\"), 0) AS \"estimatedBytes\"\n        FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n    `)\n    .get<{rows: number; estimatedBytes: number}>();\n\n  return {\n    ...startup,\n    rows: aggregate.rows,\n    estimatedBytes: aggregate.estimatedBytes,\n    cookieRows: readCookieRowCounts(changeLog),\n  };\n}\n\nexport function logSQLiteChangeLogStartup(\n  lc: LogContext,\n  file: string,\n  info: SQLiteChangeLogStartupInfo,\n): void {\n  lc.info?.('SQLite change-log startup', {\n    sqliteChangeLog: {\n      file,\n      epoch: info.epoch,\n      generation: info.generation,\n      replicaID: info.replicaID,\n      schemaVersion: info.schemaVersion,\n      seedWatermark: info.seedWatermark,\n      seededAtMs: info.seededAtMs,\n      minWatermark: info.minWatermark,\n      headWatermark: info.headWatermark,\n    },\n  });\n}\n\n/**\n * The on-disk footprint of a SQLite database: its main file plus its `-wal` and\n * `-wal2` sidecars, whichever exist. `-shm` is excluded — it is a\n * shared-memory index rather than retained bytes.\n *\n * A missing file counts as zero rather than warning. Which sidecars exist\n * depends on the journal mode, and the change-log database is absent entirely\n * until the writer creates it.\n */\nexport async function sqliteFileBytes(\n  lc: LogContext,\n  file: string,\n): Promise<number> {\n  const sizes = await Promise.all(\n    [file, `${file}-wal`, `${file}-wal2`].map(async path => {\n      try {\n        return (await stat(path)).size;\n      } catch (e) {\n        if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {\n          lc.warn?.(`unable to stat ${path} for size metrics`, e);\n        }\n        return 0;\n      }\n    }),\n  );\n  return sizes.reduce((total, size) => total + size, 0);\n}\n\n/** What the writer reports back for a committed transaction. */\nexport type ChangeLogCommit = {\n  readonly watermark: string;\n  readonly stats: ChangeLogStreamTransactionStats;\n  /**\n   * Appending the commit row and committing the log's transaction. This is the\n   * cost that sits on the forward path, once per upstream transaction.\n   */\n  readonly logCommitMs: number;\n};\n\nexport type SQLiteChangeLogObservabilityState = {\n  readonly receivedHead: string;\n  readonly sqliteHead: string;\n  readonly headLag: number | undefined;\n  readonly rows: number;\n  readonly estimatedBytes: number;\n  readonly cookieRows: CookieRowCounts;\n  readonly cookieMutations: number;\n  readonly rollbacks: number;\n  readonly invariantFailures: number;\n  readonly hashMatches: number;\n  readonly hashMismatches: number;\n  readonly hashUnpaired: number;\n};\n\nconst TRANSACTION_ROW_BUCKETS = [2, 3, 5, 10, 25, 50, 100, 250, 1000, 5000];\n\n/**\n * Records writer metrics in the change-streamer process. State changes only\n * after the corresponding write succeeds, except receivedHead, which advances\n * when a commit message arrives so that transient lag behind the log is\n * observable.\n */\nexport class SQLiteChangeLogObserver {\n  readonly #lc: LogContext;\n  readonly #messageProcessing = getOrCreateLatencyHistogram(\n    'replica',\n    'sqlite_change_log.message_processing_duration',\n    'Sampled time to write a replication message to the SQLite change log.',\n  );\n  // The commit that sits on the forward path. There is no second commit to\n  // order against any more: the replica's belongs to a subscriber downstream of\n  // this loop, so `sqlite_change_log.replica_commit_duration` and the phantom\n  // window it measured are gone. Sampled failed commits are still timed by\n  // `message_processing_duration` keyed `tag=\"commit\"`.\n  readonly #logCommitDuration = getOrCreateLatencyHistogram(\n    'replica',\n    'sqlite_change_log.log_commit_duration',\n    'Time to append the commit row to the SQLite change log and commit its ' +\n      'transaction. This is on the forward path: it precedes the forward of ' +\n      \"that transaction's commit message.\",\n  );\n  readonly #transactionRows = getOrCreateValueHistogram(\n    'replica',\n    'sqlite_change_log.transaction_rows',\n    {\n      description: 'Rows stored per committed SQLite change-log transaction.',\n      unit: '{row}',\n      bucketBoundaries: TRANSACTION_ROW_BUCKETS,\n    },\n  );\n  readonly #rollbackCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.rollbacks',\n    'SQLite change-log transactions rolled back before commit.',\n  );\n  readonly #invariantFailureCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.invariant_failures',\n    'Detected SQLite change-log writer invariant failures.',\n  );\n  readonly #hashComparisonCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.hash_comparisons',\n    'Sampled ephemeral transaction hash comparisons between the received change stream and SQLite change-log writes.',\n  );\n  readonly #hashUnpairedCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.hash_unpaired',\n    'Committed change-log transactions without both ephemeral hashes available for comparison.',\n  );\n  // Near zero at steady state: cookie state only moves on schema changes.\n  readonly #cookieMutationCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.cookie_mutations',\n    'Change-log cookie mutations folded from schema changes, by operation.',\n  );\n\n  #receivedHead: string;\n  #sqliteHead: string;\n  #rows: number;\n  #estimatedBytes: number;\n  #cookieRows: CookieRowCounts;\n  #cookieMutations = 0;\n  #transactionWatermark: string | undefined;\n  #sourceHasher: ChangeLogTransactionHasher | undefined;\n  #sourcePos = 0;\n  #sourceCommitHash: string | undefined;\n  #rollbacks = 0;\n  #invariantFailures = 0;\n  #hashMatches = 0;\n  #hashMismatches = 0;\n  #hashUnpaired = 0;\n\n  constructor(lc: LogContext, info: SQLiteChangeLogInfo) {\n    this.#lc = lc.withContext('component', 'sqlite-change-log-observer');\n    // Reconciliation has just put the head at the resume watermark, which is\n    // also the point the stream is about to be received from.\n    this.#receivedHead = info.headWatermark;\n    this.#sqliteHead = info.headWatermark;\n    this.#rows = info.rows;\n    this.#estimatedBytes = info.estimatedBytes;\n    this.#cookieRows = info.cookieRows;\n\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.rows',\n      'Rows retained in the SQLite change log.',\n    ).addCallback(result => result.observe(this.#rows));\n    // Nonzero with no backfill in flight is a leaked cookie, i.e. a backfill\n    // that will be re-requested forever.\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.cookie_rows',\n      'Cookie rows retained in the SQLite change log, by cookie table.',\n    ).addCallback(result => {\n      result.observe(this.#cookieRows.tableMetadata, {table: 'tableMetadata'});\n      result.observe(this.#cookieRows.backfilling, {table: 'backfilling'});\n    });\n    getOrCreateGauge('replica', 'sqlite_change_log.retained_bytes', {\n      description:\n        'Estimated UTF-8 payload bytes retained in the SQLite change log.',\n      unit: 'By',\n    }).addCallback(result => result.observe(this.#estimatedBytes));\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.head',\n      'SQLite change-log head converted from its lexicographic watermark.',\n    ).addCallback(result => {\n      const head = watermarkValue(this.#sqliteHead);\n      if (head !== undefined) {\n        result.observe(head);\n      }\n    });\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.head_lag',\n      'Distance from the latest received commit to the SQLite change-log ' +\n        'head. The log commits before the forward, so this is zero except ' +\n        'within a transaction.',\n    ).addCallback(result => {\n      const lag = watermarkDistance(this.#receivedHead, this.#sqliteHead);\n      if (lag !== undefined) {\n        result.observe(lag);\n      }\n    });\n  }\n\n  /**\n   * Called as each message arrives, before it is written. For a sampled\n   * transaction, hashes the *received* stream and compares it with the hash the\n   * writer computes over what it *stored*.\n   */\n  messageReceived(\n    data: ChangeStreamData,\n    json: string,\n    validateHash = true,\n    storedChange = extractChangeSubstring(json, data[1].tag),\n  ): void {\n    const tag = data[1].tag;\n    if (data[0] === 'begin') {\n      if (this.#sourceHasher !== undefined) {\n        this.#invariantFailure(\n          'Received change-log begin while a source hash is already open',\n          {receivedWatermark: data[2].commitWatermark},\n        );\n      }\n      const watermark = data[2].commitWatermark;\n      this.#sourceHasher = validateHash\n        ? new ChangeLogTransactionHasher()\n        : undefined;\n      this.#sourcePos = 0;\n      this.#sourceCommitHash = undefined;\n      this.#sourceHasher?.add({\n        watermark,\n        pos: this.#sourcePos,\n        tag,\n        change: storedChange,\n        precommit: null,\n      });\n      return;\n    }\n\n    if (tag === 'rollback') {\n      this.#resetSourceHash();\n      return;\n    }\n\n    if (data[0] === 'commit') {\n      this.#receivedHead = data[2].watermark;\n    }\n\n    if (!validateHash) {\n      return;\n    }\n\n    const watermark = this.#transactionWatermark;\n    if (this.#sourceHasher === undefined || watermark === undefined) {\n      this.#invariantFailure(\n        'Received change-log message without an observed transaction',\n        {tag},\n      );\n      return;\n    }\n\n    const commitWatermark =\n      data[0] === 'commit' ? data[2].watermark : watermark;\n    this.#sourceHasher.add({\n      watermark: commitWatermark,\n      pos: ++this.#sourcePos,\n      tag,\n      change: storedChange,\n      precommit: data[0] === 'commit' ? watermark : null,\n    });\n    if (data[0] === 'commit') {\n      this.#sourceCommitHash = this.#sourceHasher.digest();\n      this.#sourceHasher = undefined;\n    }\n  }\n\n  /** Called after the message has been written to the log. */\n  messageProcessed(\n    data: ChangeStreamData,\n    commit: ChangeLogCommit | null,\n    durationMs: number | undefined,\n  ): void {\n    const tag = data[1].tag;\n    if (durationMs !== undefined) {\n      this.#messageProcessing.recordMs(durationMs, {tag, outcome: 'success'});\n    }\n\n    if (data[0] === 'begin') {\n      if (this.#transactionWatermark !== undefined) {\n        this.#invariantFailure('SQLite change-log transaction already open', {\n          openWatermark: this.#transactionWatermark,\n          receivedWatermark: data[2].commitWatermark,\n        });\n      }\n      this.#transactionWatermark = data[2].commitWatermark;\n      return;\n    }\n\n    if (tag === 'rollback') {\n      this.#recordRollback('upstream');\n      this.#transactionWatermark = undefined;\n      this.#resetSourceHash();\n      return;\n    }\n\n    if (data[0] !== 'commit') {\n      return;\n    }\n\n    const watermark = data[2].watermark;\n    if (commit !== null) {\n      this.#logCommitDuration.recordMs(commit.logCommitMs);\n    }\n    if (this.#transactionWatermark !== watermark) {\n      this.#invariantFailure(\n        'SQLite change-log commit does not match the observed begin',\n        {openWatermark: this.#transactionWatermark, commitWatermark: watermark},\n      );\n    }\n    if (commit === null) {\n      this.#invariantFailure(\n        'SQLite change-log commit result is missing writer statistics',\n        {commitWatermark: watermark},\n      );\n      this.#recordUnpaired(watermark, 'missing-sqlite-hash');\n    } else {\n      if (commit.watermark !== watermark) {\n        this.#invariantFailure(\n          'SQLite change-log commit result has an unexpected watermark',\n          {commitWatermark: watermark, resultWatermark: commit.watermark},\n        );\n      }\n      this.#rows += commit.stats.rows;\n      this.#estimatedBytes += commit.stats.estimatedBytes;\n      this.#transactionRows.record(commit.stats.rows);\n      if (\n        this.#sourceCommitHash !== undefined ||\n        commit.stats.hash !== undefined\n      ) {\n        this.#compareHashes(\n          watermark,\n          this.#sourceCommitHash,\n          commit.stats.hash,\n        );\n      }\n    }\n    if (watermark < this.#sqliteHead) {\n      this.#invariantFailure('SQLite change-log head regressed', {\n        previousHead: this.#sqliteHead,\n        commitWatermark: watermark,\n      });\n    }\n    this.#sqliteHead = watermark;\n    this.#transactionWatermark = undefined;\n    this.#resetSourceHash();\n  }\n\n  messageFailed(\n    data: ChangeStreamData,\n    error: unknown,\n    durationMs: number | undefined,\n  ): void {\n    const tag = data[1].tag;\n    if (durationMs !== undefined) {\n      this.#messageProcessing.recordMs(durationMs, {tag, outcome: 'error'});\n    }\n    if (data[0] === 'commit' && this.#sourceCommitHash !== undefined) {\n      // No commit duration here: a failed commit produces no statistics, so\n      // there is nothing to attribute. The attempt is timed by\n      // `message_processing_duration{tag=\"commit\",outcome=\"error\"}` above.\n      this.#recordUnpaired(data[2].watermark, 'sqlite-commit-failed');\n    }\n    if (\n      error instanceof Error &&\n      error.name === 'ChangeLogStreamInvariantError'\n    ) {\n      this.#invariantFailure(error.message);\n    }\n    if (this.#transactionWatermark !== undefined || data[0] === 'begin') {\n      this.#recordRollback('processing-error');\n    }\n    this.#transactionWatermark = undefined;\n    this.#resetSourceHash();\n  }\n\n  /**\n   * A committed transaction folded schema changes into the cookie jar. Reported\n   * separately from {@link messageProcessed} because it costs a read of the\n   * cookie tables, which is only worth taking when they actually moved.\n   */\n  cookiesMutated(ops: readonly CookieOpTag[], rows: CookieRowCounts): void {\n    for (const op of ops) {\n      this.#cookieMutations++;\n      this.#cookieMutationCounter.add(1, {op});\n    }\n    this.#cookieRows = rows;\n  }\n\n  /**\n   * A missed truncate-above surfaces as a constraint violation on the writer's\n   * plain `INSERT`, which the fail-soft policy would otherwise absorb quietly.\n   * Classifying it as an invariant failure is what keeps a reconciliation bug\n   * from looking like a lost cache.\n   */\n  invariantFailure(message: string, details?: Record<string, unknown>): void {\n    this.#invariantFailure(message, details);\n  }\n\n  /** The source interrupted the stream mid-transaction. */\n  abort(): void {\n    if (this.#transactionWatermark !== undefined) {\n      this.#recordRollback('source-interruption');\n      this.#transactionWatermark = undefined;\n    }\n    this.#resetSourceHash();\n  }\n\n  /** Reconciliation moved the head, so the observer's totals are restated. */\n  reconciled(info: SQLiteChangeLogInfo): void {\n    this.#receivedHead = info.headWatermark;\n    this.#sqliteHead = info.headWatermark;\n    this.#rows = info.rows;\n    this.#estimatedBytes = info.estimatedBytes;\n    this.#cookieRows = info.cookieRows;\n    this.#transactionWatermark = undefined;\n    this.#resetSourceHash();\n  }\n\n  state(): SQLiteChangeLogObservabilityState {\n    return {\n      receivedHead: this.#receivedHead,\n      sqliteHead: this.#sqliteHead,\n      headLag: watermarkDistance(this.#receivedHead, this.#sqliteHead),\n      rows: this.#rows,\n      estimatedBytes: this.#estimatedBytes,\n      cookieRows: this.#cookieRows,\n      cookieMutations: this.#cookieMutations,\n      rollbacks: this.#rollbacks,\n      invariantFailures: this.#invariantFailures,\n      hashMatches: this.#hashMatches,\n      hashMismatches: this.#hashMismatches,\n      hashUnpaired: this.#hashUnpaired,\n    };\n  }\n\n  #recordRollback(\n    reason: 'upstream' | 'processing-error' | 'source-interruption',\n  ) {\n    this.#rollbacks++;\n    this.#rollbackCounter.add(1, {reason});\n  }\n\n  #invariantFailure(message: string, details?: Record<string, unknown>) {\n    this.#invariantFailures++;\n    this.#invariantFailureCounter.add(1);\n    this.#lc.error?.(message, details);\n  }\n\n  #compareHashes(\n    watermark: string,\n    sourceHash: string | undefined,\n    sqliteHash: string | undefined,\n  ): void {\n    if (sourceHash === undefined) {\n      this.#recordUnpaired(watermark, 'missing-source-hash');\n      return;\n    }\n    if (sqliteHash === undefined) {\n      this.#recordUnpaired(watermark, 'missing-sqlite-hash');\n      return;\n    }\n    if (sourceHash === sqliteHash) {\n      this.#hashMatches++;\n      this.#hashComparisonCounter.add(1, {outcome: 'match'});\n      return;\n    }\n    this.#hashMismatches++;\n    this.#hashComparisonCounter.add(1, {outcome: 'mismatch'});\n    this.#lc.error?.('SQLite change-log transaction hash mismatch', {\n      sqliteChangeLogHashComparison: {\n        watermark,\n        sourceHash: sourceHash.slice(0, 16),\n        sqliteHash: sqliteHash.slice(0, 16),\n      },\n    });\n  }\n\n  #recordUnpaired(\n    watermark: string,\n    reason:\n      | 'missing-source-hash'\n      | 'missing-sqlite-hash'\n      | 'sqlite-commit-failed',\n  ): void {\n    this.#hashUnpaired++;\n    this.#hashUnpairedCounter.add(1, {reason});\n    this.#lc.warn?.('SQLite change-log transaction hash was not compared', {\n      sqliteChangeLogHashComparison: {watermark, reason},\n    });\n  }\n\n  #resetSourceHash(): void {\n    this.#sourceHasher = undefined;\n    this.#sourcePos = 0;\n    this.#sourceCommitHash = undefined;\n  }\n}\n\nfunction watermarkValue(watermark: string): number | undefined {\n  try {\n    const value = Number(versionFromLexi(watermark));\n    return Number.isFinite(value) ? value : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction watermarkDistance(\n  receivedHead: string,\n  sqliteHead: string,\n): number | undefined {\n  if (receivedHead <= sqliteHead) {\n    return 0;\n  }\n  try {\n    const distance =\n      versionFromLexi(receivedHead) - versionFromLexi(sqliteHead);\n    const value = Number(distance);\n    return Number.isFinite(value) ? value : undefined;\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"sqlite-change-log-observability.js","names":[],"sources":["../../../../../../zero-cache/src/services/replicator/sqlite-change-log-observability.ts"],"sourcesContent":["/**\n * Observability for the SQLite change log.\n *\n * Everything here now runs in the **change-streamer** process, which is where\n * the writer lives. The module stays beside the rest of the change-log code\n * under `services/replicator/` for the same reason `change-log-db.ts` and\n * `change-log-stream-writer.ts` do: moving files would obscure the topology\n * diff, and the writer's home is a property of who calls it rather than of\n * where it sits. Metric names are unchanged from 7H — only their emitting\n * process, and therefore their resource attributes, moved.\n */\n\nimport {stat} from 'node:fs/promises';\nimport type {LogContext} from '@rocicorp/logger';\nimport {unreachable} from '../../../../shared/src/asserts.ts';\nimport type {Database} from '../../../../zqlite/src/db.ts';\nimport {\n  getOrCreateCounter,\n  getOrCreateGauge,\n  getOrCreateLatencyHistogram,\n  getOrCreateValueHistogram,\n} from '../../observability/metrics.ts';\nimport {versionFromLexi} from '../../types/lexi-version.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport {extractChangeSubstring} from '../change-streamer/change-log-codec.ts';\nimport {ChangeLogTransactionHasher} from '../change-streamer/change-log-transaction-hash.ts';\nimport {\n  readCookieRowCounts,\n  type CookieOpTag,\n  type CookieRowCounts,\n} from './change-log-cookies.ts';\nimport {\n  CHANGE_LOG_STREAM_TABLE,\n  readChangeLogBounds,\n  readChangeLogMeta,\n  type ChangeLogMeta,\n  type ReconcileResult,\n} from './change-log-db.ts';\nimport type {ChangeLogStreamTransactionStats} from './change-log-stream-writer.ts';\n\n/**\n * Reports the reconciliation of the change-log database against the watermark\n * the stream connection resumes from. This runs once per stream connection, so\n * a reconnect storm is visible here as well as a restart.\n *\n * A wipe is not an error — it is how every abnormal change-log state is\n * collapsed into a correct one — but each wipe costs the retention window, so\n * every reconnecting subscriber below the head gets `too-old`. The `gap` reason\n * in particular means the log neither held the resume watermark nor could be\n * truncated to it, so a nonzero rate in steady state is an alert, not a\n * statistic.\n */\nexport function recordSQLiteChangeLogReconcile(\n  lc: LogContext,\n  result: ReconcileResult,\n): void {\n  switch (result.action) {\n    case 'truncated':\n      getOrCreateCounter(\n        'replica',\n        'sqlite_change_log.reconcile_truncated_rows',\n        'Phantom change-log rows removed at reconciliation, i.e. rows above ' +\n          'the watermark the change stream resumed from.',\n      ).add(result.rows);\n      break;\n    case 'reseeded':\n      getOrCreateCounter(\n        'replica',\n        'sqlite_change_log.reconcile_wipes',\n        'Change-log wipes at reconciliation, by reason. Each one resets the ' +\n          'retention window, so subscribers below the head get `too-old`.',\n      ).add(1, {reason: result.reason});\n      break;\n    case 'none':\n      break;\n    default:\n      unreachable(result);\n  }\n  if (result.cookiesStale) {\n    // The invariant-17 counter: after any reconcile that moved the head, the\n    // log's cookie set has to be replaced with the one that belongs to the\n    // resume watermark. A nonzero `truncated` series in steady state means\n    // phantom truncation is happening on a shard where it should not.\n    getOrCreateCounter(\n      'replica',\n      'sqlite_change_log.cookie_reseed',\n      'Change-log cookie sets invalidated at reconciliation, by the ' +\n        'reconcile action that invalidated them.',\n    ).add(1, {action: result.action});\n  }\n  lc.debug?.('SQLite change-log reconciliation', {\n    sqliteChangeLogReconcile: result,\n  });\n}\n\n/**\n * What the log says about itself. Nothing here reads the replica: after the\n * writer moved to the change-streamer, the replica's state version is a\n * consequence of this log rather than a fact about it.\n */\nexport type SQLiteChangeLogStartupInfo = ChangeLogMeta & {\n  readonly minWatermark: string;\n  readonly headWatermark: string;\n};\n\nexport type SQLiteChangeLogInfo = SQLiteChangeLogStartupInfo & {\n  readonly rows: number;\n  readonly estimatedBytes: number;\n  readonly cookieRows: CookieRowCounts;\n};\n\n/**\n * Reads the meta row and covered range. Unlike {@link getSQLiteChangeLogInfo}\n * this does not scan the log; see {@link readChangeLogBounds}.\n *\n * Call this after reconciliation, which is the only point at which the head is\n * known to be the resume watermark.\n */\nexport function getSQLiteChangeLogStartupInfo(\n  changeLog: Database,\n): SQLiteChangeLogStartupInfo {\n  const meta = readChangeLogMeta(changeLog);\n  const {minWatermark, headWatermark} = readChangeLogBounds(changeLog);\n  if (minWatermark === null || headWatermark === null) {\n    throw new Error('the SQLite change log must contain its seed transaction');\n  }\n  return {...meta, minWatermark, headWatermark};\n}\n\n/**\n * Extends {@link getSQLiteChangeLogStartupInfo} with the retained row and\n * estimated byte totals. Computing these scans the entire change-log table, so\n * only call it when the totals are consumed, i.e. when the writer (and thus the\n * observer) is enabled.\n */\nexport function getSQLiteChangeLogInfo(\n  changeLog: Database,\n): SQLiteChangeLogInfo {\n  const startup = getSQLiteChangeLogStartupInfo(changeLog);\n  const aggregate = changeLog\n    .prepare(/*sql*/ `\n      SELECT count(*) AS \"rows\",\n             coalesce(sum(\"estimatedBytes\"), 0) AS \"estimatedBytes\"\n        FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n    `)\n    .get<{rows: number; estimatedBytes: number}>();\n\n  return {\n    ...startup,\n    rows: aggregate.rows,\n    estimatedBytes: aggregate.estimatedBytes,\n    cookieRows: readCookieRowCounts(changeLog),\n  };\n}\n\nexport function logSQLiteChangeLogStartup(\n  lc: LogContext,\n  file: string,\n  info: SQLiteChangeLogStartupInfo,\n): void {\n  lc.info?.('SQLite change-log startup', {\n    sqliteChangeLog: {\n      file,\n      epoch: info.epoch,\n      generation: info.generation,\n      replicaID: info.replicaID,\n      schemaVersion: info.schemaVersion,\n      seedWatermark: info.seedWatermark,\n      seededAtMs: info.seededAtMs,\n      minWatermark: info.minWatermark,\n      headWatermark: info.headWatermark,\n    },\n  });\n}\n\n/**\n * The on-disk footprint of a SQLite database: its main file plus its `-wal` and\n * `-wal2` sidecars, whichever exist. `-shm` is excluded — it is a\n * shared-memory index rather than retained bytes.\n *\n * A missing file counts as zero rather than warning. Which sidecars exist\n * depends on the journal mode, and the change-log database is absent entirely\n * until the writer creates it.\n */\nexport async function sqliteFileBytes(\n  lc: LogContext,\n  file: string,\n): Promise<number> {\n  const sizes = await Promise.all(\n    [file, `${file}-wal`, `${file}-wal2`].map(async path => {\n      try {\n        return (await stat(path)).size;\n      } catch (e) {\n        if ((e as NodeJS.ErrnoException).code !== 'ENOENT') {\n          lc.warn?.(`unable to stat ${path} for size metrics`, e);\n        }\n        return 0;\n      }\n    }),\n  );\n  return sizes.reduce((total, size) => total + size, 0);\n}\n\n/** What the writer reports back for a committed transaction. */\nexport type ChangeLogCommit = {\n  readonly watermark: string;\n  readonly stats: ChangeLogStreamTransactionStats;\n  /**\n   * Appending the commit row and committing the log's transaction. This is the\n   * cost that sits on the forward path, once per upstream transaction.\n   */\n  readonly logCommitMs: number;\n};\n\nexport type SQLiteChangeLogObservabilityState = {\n  readonly receivedHead: string;\n  readonly sqliteHead: string;\n  readonly headLag: number | undefined;\n  readonly rows: number;\n  readonly estimatedBytes: number;\n  readonly cookieRows: CookieRowCounts;\n  readonly cookieMutations: number;\n  readonly rollbacks: number;\n  readonly invariantFailures: number;\n  readonly hashMatches: number;\n  readonly hashMismatches: number;\n  readonly hashUnpaired: number;\n};\n\nconst TRANSACTION_ROW_BUCKETS = [2, 3, 5, 10, 25, 50, 100, 250, 1000, 5000];\n\n/**\n * Records writer metrics in the change-streamer process. State changes only\n * after the corresponding write succeeds, except receivedHead, which advances\n * when a commit message arrives so that transient lag behind the log is\n * observable.\n */\nexport class SQLiteChangeLogObserver {\n  readonly #lc: LogContext;\n  readonly #messageProcessing = getOrCreateLatencyHistogram(\n    'replica',\n    'sqlite_change_log.message_processing_duration',\n    'Sampled time to write a replication message to the SQLite change log.',\n  );\n  // The commit that sits on the forward path. There is no second commit to\n  // order against any more: the replica's belongs to a subscriber downstream of\n  // this loop, so `sqlite_change_log.replica_commit_duration` and the phantom\n  // window it measured are gone. Sampled failed commits are still timed by\n  // `message_processing_duration` keyed `tag=\"commit\"`.\n  readonly #logCommitDuration = getOrCreateLatencyHistogram(\n    'replica',\n    'sqlite_change_log.log_commit_duration',\n    'Time to append the commit row to the SQLite change log and commit its ' +\n      'transaction. This is on the forward path: it precedes the forward of ' +\n      \"that transaction's commit message.\",\n  );\n  readonly #transactionRows = getOrCreateValueHistogram(\n    'replica',\n    'sqlite_change_log.transaction_rows',\n    {\n      description: 'Rows stored per committed SQLite change-log transaction.',\n      unit: '{row}',\n      bucketBoundaries: TRANSACTION_ROW_BUCKETS,\n    },\n  );\n  readonly #rollbackCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.rollbacks',\n    'SQLite change-log transactions rolled back before commit.',\n  );\n  readonly #invariantFailureCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.invariant_failures',\n    'Detected SQLite change-log writer invariant failures.',\n  );\n  readonly #hashComparisonCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.hash_comparisons',\n    'Sampled ephemeral transaction hash comparisons between the received change stream and SQLite change-log writes.',\n  );\n  readonly #hashUnpairedCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.hash_unpaired',\n    'Committed change-log transactions without both ephemeral hashes available for comparison.',\n  );\n  // Near zero at steady state: cookie state only moves on schema changes.\n  readonly #cookieMutationCounter = getOrCreateCounter(\n    'replica',\n    'sqlite_change_log.cookie_mutations',\n    'Change-log cookie mutations folded from schema changes, by operation.',\n  );\n\n  #receivedHead: string;\n  #sqliteHead: string;\n  #rows: number;\n  #estimatedBytes: number;\n  #cookieRows: CookieRowCounts;\n  #cookieMutations = 0;\n  #transactionWatermark: string | undefined;\n  #sourceHasher: ChangeLogTransactionHasher | undefined;\n  #sourcePos = 0;\n  #sourceCommitHash: string | undefined;\n  #rollbacks = 0;\n  #invariantFailures = 0;\n  #hashMatches = 0;\n  #hashMismatches = 0;\n  #hashUnpaired = 0;\n\n  constructor(lc: LogContext, info: SQLiteChangeLogInfo) {\n    this.#lc = lc.withContext('component', 'sqlite-change-log-observer');\n    // Reconciliation has just put the head at the resume watermark, which is\n    // also the point the stream is about to be received from.\n    this.#receivedHead = info.headWatermark;\n    this.#sqliteHead = info.headWatermark;\n    this.#rows = info.rows;\n    this.#estimatedBytes = info.estimatedBytes;\n    this.#cookieRows = info.cookieRows;\n\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.rows',\n      'Rows retained in the SQLite change log.',\n    ).addCallback(result => result.observe(this.#rows));\n    // Nonzero with no backfill in flight is a leaked cookie, i.e. a backfill\n    // that will be re-requested forever.\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.cookie_rows',\n      'Cookie rows retained in the SQLite change log, by cookie table.',\n    ).addCallback(result => {\n      result.observe(this.#cookieRows.tableMetadata, {table: 'tableMetadata'});\n      result.observe(this.#cookieRows.backfilling, {table: 'backfilling'});\n    });\n    getOrCreateGauge('replica', 'sqlite_change_log.retained_bytes', {\n      description:\n        'Estimated UTF-8 payload bytes retained in the SQLite change log.',\n      unit: 'By',\n    }).addCallback(result => result.observe(this.#estimatedBytes));\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.head',\n      'SQLite change-log head converted from its lexicographic watermark.',\n    ).addCallback(result => {\n      const head = watermarkValue(this.#sqliteHead);\n      if (head !== undefined) {\n        result.observe(head);\n      }\n    });\n    getOrCreateGauge(\n      'replica',\n      'sqlite_change_log.head_lag',\n      'Distance from the latest received commit to the SQLite change-log ' +\n        'head. The log commits before the forward, so this is zero except ' +\n        'within a transaction.',\n    ).addCallback(result => {\n      const lag = watermarkDistance(this.#receivedHead, this.#sqliteHead);\n      if (lag !== undefined) {\n        result.observe(lag);\n      }\n    });\n  }\n\n  /**\n   * Called as each message arrives, before it is written. For a sampled\n   * transaction, hashes the *received* stream and compares it with the hash the\n   * writer computes over what it *stored*.\n   */\n  messageReceived(\n    data: ChangeStreamData,\n    json: string,\n    validateHash = true,\n    storedChange = extractChangeSubstring(json, data[1].tag),\n  ): void {\n    const tag = data[1].tag;\n    if (data[0] === 'begin') {\n      if (this.#sourceHasher !== undefined) {\n        this.#invariantFailure(\n          'Received change-log begin while a source hash is already open',\n          {receivedWatermark: data[2].commitWatermark},\n        );\n      }\n      const watermark = data[2].commitWatermark;\n      this.#sourceHasher = validateHash\n        ? new ChangeLogTransactionHasher()\n        : undefined;\n      this.#sourcePos = 0;\n      this.#sourceCommitHash = undefined;\n      this.#sourceHasher?.add({\n        watermark,\n        pos: this.#sourcePos,\n        tag,\n        change: storedChange,\n        precommit: null,\n      });\n      return;\n    }\n\n    if (tag === 'rollback') {\n      this.#resetSourceHash();\n      return;\n    }\n\n    if (data[0] === 'commit') {\n      this.#receivedHead = data[2].watermark;\n    }\n\n    if (!validateHash) {\n      return;\n    }\n\n    const watermark = this.#transactionWatermark;\n    if (this.#sourceHasher === undefined || watermark === undefined) {\n      this.#invariantFailure(\n        'Received change-log message without an observed transaction',\n        {tag},\n      );\n      return;\n    }\n\n    const commitWatermark =\n      data[0] === 'commit' ? data[2].watermark : watermark;\n    this.#sourceHasher.add({\n      watermark: commitWatermark,\n      pos: ++this.#sourcePos,\n      tag,\n      change: storedChange,\n      precommit: data[0] === 'commit' ? watermark : null,\n    });\n    if (data[0] === 'commit') {\n      this.#sourceCommitHash = this.#sourceHasher.digest();\n      this.#sourceHasher = undefined;\n    }\n  }\n\n  /** Called after the message has been written to the log. */\n  messageProcessed(\n    data: ChangeStreamData,\n    commit: ChangeLogCommit | null,\n    durationMs: number | undefined,\n  ): void {\n    const tag = data[1].tag;\n    if (durationMs !== undefined) {\n      this.#messageProcessing.recordMs(durationMs, {tag, outcome: 'success'});\n    }\n\n    if (data[0] === 'begin') {\n      if (this.#transactionWatermark !== undefined) {\n        this.#invariantFailure('SQLite change-log transaction already open', {\n          openWatermark: this.#transactionWatermark,\n          receivedWatermark: data[2].commitWatermark,\n        });\n      }\n      this.#transactionWatermark = data[2].commitWatermark;\n      return;\n    }\n\n    if (tag === 'rollback') {\n      this.#recordRollback('upstream');\n      this.#transactionWatermark = undefined;\n      this.#resetSourceHash();\n      return;\n    }\n\n    if (data[0] !== 'commit') {\n      return;\n    }\n\n    const watermark = data[2].watermark;\n    if (commit !== null) {\n      this.#logCommitDuration.recordMs(commit.logCommitMs);\n    }\n    if (this.#transactionWatermark !== watermark) {\n      this.#invariantFailure(\n        'SQLite change-log commit does not match the observed begin',\n        {openWatermark: this.#transactionWatermark, commitWatermark: watermark},\n      );\n    }\n    if (commit === null) {\n      this.#invariantFailure(\n        'SQLite change-log commit result is missing writer statistics',\n        {commitWatermark: watermark},\n      );\n      this.#recordUnpaired(watermark, 'missing-sqlite-hash');\n    } else {\n      if (commit.watermark !== watermark) {\n        this.#invariantFailure(\n          'SQLite change-log commit result has an unexpected watermark',\n          {commitWatermark: watermark, resultWatermark: commit.watermark},\n        );\n      }\n      this.#rows += commit.stats.rows;\n      this.#estimatedBytes += commit.stats.estimatedBytes;\n      this.#transactionRows.record(commit.stats.rows);\n      if (\n        this.#sourceCommitHash !== undefined ||\n        commit.stats.hash !== undefined\n      ) {\n        this.#compareHashes(\n          watermark,\n          this.#sourceCommitHash,\n          commit.stats.hash,\n        );\n      }\n    }\n    if (watermark < this.#sqliteHead) {\n      this.#invariantFailure('SQLite change-log head regressed', {\n        previousHead: this.#sqliteHead,\n        commitWatermark: watermark,\n      });\n    }\n    this.#sqliteHead = watermark;\n    this.#transactionWatermark = undefined;\n    this.#resetSourceHash();\n  }\n\n  messageFailed(\n    data: ChangeStreamData,\n    error: unknown,\n    durationMs: number | undefined,\n  ): void {\n    const tag = data[1].tag;\n    if (durationMs !== undefined) {\n      this.#messageProcessing.recordMs(durationMs, {tag, outcome: 'error'});\n    }\n    if (data[0] === 'commit' && this.#sourceCommitHash !== undefined) {\n      // No commit duration here: a failed commit produces no statistics, so\n      // there is nothing to attribute. The attempt is timed by\n      // `message_processing_duration{tag=\"commit\",outcome=\"error\"}` above.\n      this.#recordUnpaired(data[2].watermark, 'sqlite-commit-failed');\n    }\n    if (\n      error instanceof Error &&\n      error.name === 'ChangeLogStreamInvariantError'\n    ) {\n      this.#invariantFailure(error.message);\n    }\n    if (this.#transactionWatermark !== undefined || data[0] === 'begin') {\n      this.#recordRollback('processing-error');\n    }\n    this.#transactionWatermark = undefined;\n    this.#resetSourceHash();\n  }\n\n  /**\n   * A committed transaction folded schema changes into the cookie jar. Reported\n   * separately from {@link messageProcessed} because it costs a read of the\n   * cookie tables, which is only worth taking when they actually moved.\n   */\n  cookiesMutated(ops: readonly CookieOpTag[], rows: CookieRowCounts): void {\n    for (const op of ops) {\n      this.#cookieMutations++;\n      this.#cookieMutationCounter.add(1, {op});\n    }\n    this.#cookieRows = rows;\n  }\n\n  /**\n   * A missed truncate-above surfaces as a constraint violation on the writer's\n   * plain `INSERT`, which the fail-soft policy would otherwise absorb quietly.\n   * Classifying it as an invariant failure is what keeps a reconciliation bug\n   * from looking like a lost cache.\n   */\n  invariantFailure(message: string, details?: Record<string, unknown>): void {\n    this.#invariantFailure(message, details);\n  }\n\n  /** The source interrupted the stream mid-transaction. */\n  abort(): void {\n    if (this.#transactionWatermark !== undefined) {\n      this.#recordRollback('source-interruption');\n      this.#transactionWatermark = undefined;\n    }\n    this.#resetSourceHash();\n  }\n\n  /** Reconciliation moved the head, so the observer's totals are restated. */\n  reconciled(info: SQLiteChangeLogInfo): void {\n    this.#receivedHead = info.headWatermark;\n    this.#sqliteHead = info.headWatermark;\n    this.#rows = info.rows;\n    this.#estimatedBytes = info.estimatedBytes;\n    this.#cookieRows = info.cookieRows;\n    this.#transactionWatermark = undefined;\n    this.#resetSourceHash();\n  }\n\n  state(): SQLiteChangeLogObservabilityState {\n    return {\n      receivedHead: this.#receivedHead,\n      sqliteHead: this.#sqliteHead,\n      headLag: watermarkDistance(this.#receivedHead, this.#sqliteHead),\n      rows: this.#rows,\n      estimatedBytes: this.#estimatedBytes,\n      cookieRows: this.#cookieRows,\n      cookieMutations: this.#cookieMutations,\n      rollbacks: this.#rollbacks,\n      invariantFailures: this.#invariantFailures,\n      hashMatches: this.#hashMatches,\n      hashMismatches: this.#hashMismatches,\n      hashUnpaired: this.#hashUnpaired,\n    };\n  }\n\n  #recordRollback(\n    reason: 'upstream' | 'processing-error' | 'source-interruption',\n  ) {\n    this.#rollbacks++;\n    this.#rollbackCounter.add(1, {reason});\n  }\n\n  #invariantFailure(message: string, details?: Record<string, unknown>) {\n    this.#invariantFailures++;\n    this.#invariantFailureCounter.add(1);\n    this.#lc.error?.(message, details);\n  }\n\n  #compareHashes(\n    watermark: string,\n    sourceHash: string | undefined,\n    sqliteHash: string | undefined,\n  ): void {\n    if (sourceHash === undefined) {\n      this.#recordUnpaired(watermark, 'missing-source-hash');\n      return;\n    }\n    if (sqliteHash === undefined) {\n      this.#recordUnpaired(watermark, 'missing-sqlite-hash');\n      return;\n    }\n    if (sourceHash === sqliteHash) {\n      this.#hashMatches++;\n      this.#hashComparisonCounter.add(1, {outcome: 'match'});\n      return;\n    }\n    this.#hashMismatches++;\n    this.#hashComparisonCounter.add(1, {outcome: 'mismatch'});\n    this.#lc.error?.('SQLite change-log transaction hash mismatch', {\n      sqliteChangeLogHashComparison: {\n        watermark,\n        sourceHash: sourceHash.slice(0, 16),\n        sqliteHash: sqliteHash.slice(0, 16),\n      },\n    });\n  }\n\n  #recordUnpaired(\n    watermark: string,\n    reason:\n      | 'missing-source-hash'\n      | 'missing-sqlite-hash'\n      | 'sqlite-commit-failed',\n  ): void {\n    this.#hashUnpaired++;\n    this.#hashUnpairedCounter.add(1, {reason});\n    this.#lc.warn?.('SQLite change-log transaction hash was not compared', {\n      sqliteChangeLogHashComparison: {watermark, reason},\n    });\n  }\n\n  #resetSourceHash(): void {\n    this.#sourceHasher = undefined;\n    this.#sourcePos = 0;\n    this.#sourceCommitHash = undefined;\n  }\n}\n\nfunction watermarkValue(watermark: string): number | undefined {\n  try {\n    const value = Number(versionFromLexi(watermark));\n    return Number.isFinite(value) ? value : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction watermarkDistance(\n  receivedHead: string,\n  sqliteHead: string,\n): number | undefined {\n  if (receivedHead <= sqliteHead) {\n    return 0;\n  }\n  try {\n    const distance =\n      versionFromLexi(receivedHead) - versionFromLexi(sqliteHead);\n    const value = Number(distance);\n    return Number.isFinite(value) ? value : undefined;\n  } catch {\n    return undefined;\n  }\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/replicator/sqlite-change-log-purger.js

@@ -278,6 +278,6 @@ var SQLiteChangeLogPurger = class {
 	}
 };
 //#endregion
-export { SQLiteChangeLogPurger };
+export { SQLITE_CHANGE_LOG_COUNT_TRANSACTION_SQL, SQLITE_CHANGE_LOG_ELIGIBLE_COMMITS_SQL, SQLiteChangeLogPurger };
 
 //# sourceMappingURL=sqlite-change-log-purger.js.map

package/out/zero-cache/src/services/replicator/sqlite-change-log-purger.js.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-change-log-purger.js","names":["#db","#now","#stmts","#budgetRows","#purge","#budget","#tear","#timed","#anyEligible"],"sources":["../../../../../../zero-cache/src/services/replicator/sqlite-change-log-purger.ts"],"sourcesContent":["/**\n * Deletes aged-out transactions from the change-log database, one bounded write\n * transaction at a time.\n *\n * The purger is a pure function of one database: it takes the floors its caller\n * has already gated on and narrows them, never widens them, and it reads no\n * replication state. That is what makes it testable without a scheduler and\n * what lets slice 9 run it from the change-streamer's stream loop, between the\n * writer's commits, on the writer's own connection.\n */\n\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../../../../zqlite/src/db.ts';\nimport {CHANGE_LOG_STREAM_TABLE} from './change-log-db.ts';\n\n/**\n * The eligible set, as three ANDed bounds. Only the `externalFloor` is a safety\n * property; the other two make the log serviceable and make purge conservative.\n *\n * `\"watermark\" < @externalFloor` is deliberately strict. A follower that lost\n * its replica restores it from S3 at watermark `W` and then asks this log for\n * everything after `W`, which requires the `commit` row *at* `W` to still be\n * here (`SQLITE_CHANGE_LOG_BOUNDARY_SQL`). Deleting it returns `too-old` to the\n * very subscriber the floor exists to protect.\n *\n * The head cap reads `max(\"watermark\")` from the log's own database, which\n * keeps the purger a pure function of one file. The cap is inert in normal\n * operation: the floor is derived from a backup of a replica that consumes this\n * loop's output, and the log commits before that output is forwarded, so\n * `externalFloor <= head` holds by construction. It engages only on a *stale*\n * log — writer stopped, mode flipped to `off`, another task took over — where\n * deleting to a floor that has run past a frozen log would empty the file. Note\n * that head can be a phantom — committed here but not yet re-deliverable by a\n * resumed stream — for as long as it takes the watermark the stream would\n * resume from to advance past it. That is harmless precisely because head is\n * never a purge candidate, and it is why the purger asserts nothing about\n * anything outside its own file.\n *\n * Ordered by `(\"writeTimeMs\", \"watermark\")` so it rides the partial index,\n * which carries one entry per transaction rather than one per change. The\n * `LIMIT` keeps a drain from re-scanning the remaining history on every batch,\n * which would be quadratic in the number of eligible transactions and would do\n * it inside the `BEGIN IMMEDIATE`, holding the write lock alongside the delete.\n *\n * Exported so the focused query-plan test covers the production query.\n */\nexport const SQLITE_CHANGE_LOG_ELIGIBLE_COMMITS_SQL = /*sql*/ `\n  SELECT \"watermark\"\n  FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n  WHERE \"writeTimeMs\" IS NOT NULL\n    AND \"writeTimeMs\" < @retentionCutoffMs\n    AND \"watermark\" < @externalFloor\n    AND \"watermark\" < (SELECT max(\"watermark\") FROM \"${CHANGE_LOG_STREAM_TABLE}\")\n  ORDER BY \"writeTimeMs\", \"watermark\"\n  LIMIT @limit\n`;\n\n/**\n * Counts the rows at `@watermark`, capped at `@limit`. The cap is what keeps\n * batch sizing O(budget): this runs per candidate inside the\n * `BEGIN IMMEDIATE`, and the transaction being sized can be arbitrarily\n * large — an uncapped count of a multi-million-row backfill would rescan\n * every remaining row on every tear batch, holding the write lock (and the\n * appending path behind it) for the duration, quadratically over the drain.\n * The caller only needs to know whether the transaction fits its remaining\n * budget, so it passes `remaining + 1` and reads a count above `remaining`\n * as \"does not fit\".\n *\n * Exported so the focused tests cover the production query.\n */\nexport const SQLITE_CHANGE_LOG_COUNT_TRANSACTION_SQL = /*sql*/ `\n  SELECT count(*) AS \"rows\" FROM (\n    SELECT 1\n    FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n    WHERE \"watermark\" = @watermark\n    LIMIT @limit\n  )\n`;\n\n/**\n * A prefix delete, so no transaction between the minimum and the head is ever\n * split. The `<=` is correct and is not the floor comparison: `deletedThrough`\n * is a watermark this batch already established as wholly eligible.\n */\nconst DELETE_THROUGH_SQL = /*sql*/ `\n  DELETE FROM \"${CHANGE_LOG_STREAM_TABLE}\" WHERE \"watermark\" <= ?\n`;\n\nconst MIN_WATERMARK_SQL = /*sql*/ `\n  SELECT min(\"watermark\") AS \"minWatermark\" FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n`;\n\n/**\n * The `pos` at `@offset` rows into the torn transaction, ascending. `undefined`\n * when fewer than `@offset` rows remain, which is how the tear knows it is on\n * its final chunk.\n */\nconst TEAR_BOUNDARY_SQL = /*sql*/ `\n  SELECT \"pos\"\n  FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n  WHERE \"watermark\" = @watermark\n  ORDER BY \"pos\"\n  LIMIT 1 OFFSET @offset\n`;\n\n/**\n * A range scan on the primary key. Expressed as `\"pos\" < @pos` rather than\n * `DELETE ... LIMIT n`, which is both non-portable and the wrong bound: it\n * carries no guarantee about *which* rows it removes, and the commit row must\n * survive until the chunk that finishes the tear.\n */\nconst DELETE_BELOW_POS_SQL = /*sql*/ `\n  DELETE FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n  WHERE \"watermark\" = @watermark AND \"pos\" < @pos\n`;\n\nexport type PurgeBatchResult = {\n  readonly deletedRows: number;\n  /**\n   * The watermark through which whole transactions were removed. `undefined`\n   * when the batch only tore rows off the minimum transaction without\n   * completing it — in that case `deletedRows > 0` and `moreEligible` is true.\n   */\n  readonly deletedThrough: string | undefined;\n  /** True while a tear is in progress, as well as while whole transactions remain eligible. */\n  readonly moreEligible: boolean;\n};\n\nexport type PurgeBatchOptions = {\n  /**\n   * The floor the caller has already gated on subscriber ACKs and snapshot\n   * reservations — normally the confirmed S3 backup watermark. Transactions at\n   * or above it are NOT durable anywhere else: the change log is excluded from\n   * the litestream backup, so this is the boundary a follower restores to and\n   * then catches up from. Compared strictly (`<`), so the transaction *at* the\n   * floor survives as that follower's catchup boundary. The purger narrows this\n   * input and never widens it.\n   */\n  readonly externalFloor: string;\n  /**\n   * A *minimum* retention, ANDed on top of `externalFloor` rather than an\n   * alternative to it. Which of the two binds depends on the backup interval.\n   */\n  readonly retentionCutoffMs: number;\n  /** Starting chunk size. Not the bound — `maxDurationMs` is. */\n  readonly maxRows: number;\n  /**\n   * The statement duration target, enforced by feedback rather than by\n   * interruption: SQLite cannot yield mid-statement, so the purger measures\n   * each delete and shrinks the next batch's row budget when one overruns\n   * (see {@link SQLiteChangeLogPurger.budgetRows}) — which means the first\n   * delete after a restart, sized by `maxRows` alone, can still overrun it.\n   * The target is this consequential because purge shares the writer's\n   * connection: there is no lock to arbitrate and no `busy_timeout` to bound\n   * the wait — a long statement blocks the appending path, and the forward\n   * behind it, directly and for its full duration. That is why this is a\n   * precondition of purging from the stream loop rather than a tuning knob.\n   */\n  readonly maxDurationMs: number;\n};\n\ntype Statements = {\n  readonly eligibleCommits: Statement;\n  readonly countTransaction: Statement;\n  readonly deleteThrough: Statement;\n  readonly minWatermark: Statement;\n  readonly tearBoundary: Statement;\n  readonly deleteBelowPos: Statement;\n};\n\nexport class SQLiteChangeLogPurger {\n  readonly #db: Database;\n  readonly #now: () => number;\n  readonly #stmts: Statements;\n\n  /**\n   * The measured row budget, carried across batches. Row cost varies with\n   * payload size, so `maxRows` alone cannot bound a statement's duration; this\n   * shrinks when a delete overruns `maxDurationMs` and grows back when the\n   * budget — rather than the eligible set — was what limited the batch.\n   */\n  #budgetRows: number | undefined;\n\n  /**\n   * @param db a writable connection to a change log the writer has already\n   *     created and reconciled — in slice 9, the writer's own connection.\n   *     Statements are prepared eagerly, so a caller that may run before the\n   *     log exists opens the connection lazily and treats construction failure\n   *     as a skipped cycle.\n   */\n  constructor(\n    db: Database,\n    now: () => number = performance.now.bind(performance),\n  ) {\n    this.#db = db;\n    this.#now = now;\n    this.#stmts = {\n      eligibleCommits: db.prepare(SQLITE_CHANGE_LOG_ELIGIBLE_COMMITS_SQL),\n      countTransaction: db.prepare(SQLITE_CHANGE_LOG_COUNT_TRANSACTION_SQL),\n      deleteThrough: db.prepare(DELETE_THROUGH_SQL),\n      minWatermark: db.prepare(MIN_WATERMARK_SQL),\n      tearBoundary: db.prepare(TEAR_BOUNDARY_SQL),\n      deleteBelowPos: db.prepare(DELETE_BELOW_POS_SQL),\n    };\n  }\n\n  /** The row budget the next batch would use. Exposed for tests and metrics. */\n  get budgetRows(): number | undefined {\n    return this.#budgetRows;\n  }\n\n  /**\n   * Removes one bounded batch of aged-out history, in one `BEGIN IMMEDIATE`\n   * transaction. Callers loop while `moreEligible`, releasing whatever guards\n   * they hold between batches.\n   */\n  purgeBatch(opts: PurgeBatchOptions): PurgeBatchResult {\n    const {maxRows, maxDurationMs} = opts;\n    assert(\n      Number.isSafeInteger(maxRows) && maxRows > 0,\n      'change-log purge maxRows must be a positive safe integer',\n    );\n    assert(\n      maxDurationMs > 0,\n      'change-log purge maxDurationMs must be positive',\n    );\n\n    this.#db.exec('BEGIN IMMEDIATE');\n    try {\n      const result = this.#purge(opts);\n      this.#db.exec('COMMIT');\n      return result;\n    } catch (e) {\n      if (this.#db.inTransaction) {\n        this.#db.exec('ROLLBACK');\n      }\n      throw e;\n    }\n  }\n\n  #purge(opts: PurgeBatchOptions): PurgeBatchResult {\n    const {externalFloor, retentionCutoffMs} = opts;\n    const budget = this.#budget(opts.maxRows);\n    // Each transaction is at least a `begin` and a `commit`, so this is the\n    // most candidates that can fit in the budget.\n    const limit = Math.max(1, Math.ceil(budget / 2));\n    const candidates = this.#stmts.eligibleCommits.all<{watermark: string}>({\n      retentionCutoffMs,\n      externalFloor,\n      limit,\n    });\n    if (candidates.length === 0) {\n      return {deletedRows: 0, deletedThrough: undefined, moreEligible: false};\n    }\n\n    // Accounted per candidate rather than per prefix, which is exact as long as\n    // the candidates arrive in watermark order — they do, because the single\n    // writer stamps `writeTimeMs` at commit time. A clock that went backwards\n    // can put a non-candidate below `deletedThrough`, and the prefix delete\n    // then removes more rows than were counted. Not a safety problem: both\n    // watermark bounds are prefix-closed, only the minimum-retention courtesy\n    // is crossed, and `maxRows` is the starting chunk size rather than the\n    // bound — `maxDurationMs` is, and the governor measures what actually ran.\n    let rows = 0;\n    let deletedThrough: string | undefined;\n    for (const {watermark} of candidates) {\n      // The count is capped at one past the remaining budget: `n > remaining`\n      // is exactly `rows + n > budget` for a fitting transaction, and a\n      // too-large one stops scanning as soon as it is known not to fit.\n      const remaining = budget - rows;\n      const {rows: n} = this.#stmts.countTransaction.get<{rows: number}>({\n        watermark,\n        limit: remaining + 1,\n      });\n      if (n > remaining) {\n        break;\n      }\n      rows += n;\n      deletedThrough = watermark;\n    }\n\n    if (deletedThrough === undefined) {\n      return this.#tear(opts, budget);\n    }\n    const deletedRows = this.#timed(\n      opts,\n      budget,\n      () => this.#stmts.deleteThrough.run(deletedThrough).changes,\n    );\n    return {\n      deletedRows,\n      deletedThrough,\n      moreEligible: this.#anyEligible(opts),\n    };\n  }\n\n  /**\n   * Removes one bounded chunk of the minimum transaction, which is the only\n   * transaction that is ever torn.\n   *\n   * A single upstream transaction can be arbitrarily large — a backfill, a\n   * schema migration — and SQLite cannot yield mid-statement, so the only way\n   * to bound the lock hold is to delete it across several statements. That is\n   * unobservable given three constraints, all of which live here:\n   *\n   * 1. Only `min(\"watermark\")` is torn, so at most one transaction is ever\n   *    partial. A reader never reads *into* a transaction — `read()` starts\n   *    strictly after `(fromWatermark, MAX_SAFE_INTEGER)` — so the only\n   *    transaction a tear can touch is one a subscriber reads *from*, and\n   *    reading from it does not read its rows.\n   * 2. Rows go ascending by `pos`, commit row last. `plan()`'s boundary check\n   *    reads the *highest* `pos` at the watermark and requires it to be the\n   *    `commit`; removing that row first would give a subscriber sitting\n   *    exactly there a spurious `too-old`.\n   * 3. The commit row is removed by a prefix delete, which advances\n   *    `min(\"watermark\")` in the same SQLite transaction, so no state exposes\n   *    the boundary as gone while the minimum still points at it. Normally that\n   *    is {@link SQLiteChangeLogPurger.purgeBatch}'s ordinary whole-transaction\n   *    delete, taken on the batch where what is left of the torn transaction\n   *    finally fits the budget; the branch below is the same delete for the\n   *    case where the minimum is not itself in the eligible set.\n   *\n   * A crash mid-tear needs no recovery state: the torn transaction is still the\n   * minimum and still eligible, so the next batch continues it. Reconciliation\n   * is unaffected — it tests the head, and a tear is at the tail.\n   *\n   * Tearing the minimum is safe even in the unusual case where it is not itself\n   * in the eligible set (a writer whose clock went backwards can put a later\n   * watermark at an earlier `writeTimeMs`). Both watermark bounds are\n   * prefix-closed — a non-empty eligible set implies `min < externalFloor` and\n   * `min < head` — and the prefix delete this batch would otherwise run removes\n   * the minimum anyway. Only the time floor, which is a minimum-retention\n   * courtesy rather than a safety property, can be crossed that way.\n   */\n  #tear(opts: PurgeBatchOptions, budget: number): PurgeBatchResult {\n    const {minWatermark} = this.#stmts.minWatermark.get<{\n      minWatermark: string | null;\n    }>();\n    assert(\n      minWatermark !== null,\n      'change-log purge found eligible transactions in an empty log',\n    );\n\n    const boundary = this.#stmts.tearBoundary.get<{pos: number} | undefined>({\n      watermark: minWatermark,\n      offset: budget,\n    });\n    if (boundary === undefined) {\n      // At most `budget` rows are left at the minimum, which is reachable only\n      // when the minimum is not the transaction that failed to fit — i.e. when\n      // it is not itself eligible. The prefix delete removes it whole and\n      // advances `min(\"watermark\")`.\n      const deletedRows = this.#timed(\n        opts,\n        budget,\n        () => this.#stmts.deleteThrough.run(minWatermark).changes,\n      );\n      return {\n        deletedRows,\n        deletedThrough: minWatermark,\n        moreEligible: this.#anyEligible(opts),\n      };\n    }\n    // `boundary.pos` is the `budget`-th row by `pos`, so this removes exactly\n    // `budget` rows and always makes progress. The commit row is the highest\n    // `pos`, so it can only be reached by the branch above.\n    const deletedRows = this.#timed(\n      opts,\n      budget,\n      () =>\n        this.#stmts.deleteBelowPos.run({\n          watermark: minWatermark,\n          pos: boundary.pos,\n        }).changes,\n    );\n    return {deletedRows, deletedThrough: undefined, moreEligible: true};\n  }\n\n  #anyEligible({externalFloor, retentionCutoffMs}: PurgeBatchOptions): boolean {\n    return (\n      this.#stmts.eligibleCommits.get<{watermark: string} | undefined>({\n        retentionCutoffMs,\n        externalFloor,\n        limit: 1,\n      }) !== undefined\n    );\n  }\n\n  #budget(maxRows: number): number {\n    return Math.max(1, Math.min(maxRows, this.#budgetRows ?? maxRows));\n  }\n\n  /**\n   * Runs a delete and feeds its measured duration back into the row budget.\n   * Growth is gated on the budget having been the binding constraint: a batch\n   * that finished quickly because only four rows were eligible is no evidence\n   * that a larger statement would stay under the target.\n   */\n  #timed(\n    {maxRows, maxDurationMs}: PurgeBatchOptions,\n    budget: number,\n    run: () => number,\n  ): number {\n    const start = this.#now();\n    const deletedRows = run();\n    const elapsedMs = this.#now() - start;\n\n    if (elapsedMs > maxDurationMs) {\n      this.#budgetRows = Math.max(1, Math.floor(budget / 2));\n    } else if (deletedRows >= budget && elapsedMs * 2 <= maxDurationMs) {\n      this.#budgetRows = Math.min(maxRows, budget * 2);\n    } else {\n      this.#budgetRows = budget;\n    }\n    return deletedRows;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"sqlite-change-log-purger.js","names":[],"sources":["../../../../../../zero-cache/src/services/replicator/sqlite-change-log-purger.ts"],"sourcesContent":["/**\n * Deletes aged-out transactions from the change-log database, one bounded write\n * transaction at a time.\n *\n * The purger is a pure function of one database: it takes the floors its caller\n * has already gated on and narrows them, never widens them, and it reads no\n * replication state. That is what makes it testable without a scheduler and\n * what lets slice 9 run it from the change-streamer's stream loop, between the\n * writer's commits, on the writer's own connection.\n */\n\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {Database, Statement} from '../../../../zqlite/src/db.ts';\nimport {CHANGE_LOG_STREAM_TABLE} from './change-log-db.ts';\n\n/**\n * The eligible set, as three ANDed bounds. Only the `externalFloor` is a safety\n * property; the other two make the log serviceable and make purge conservative.\n *\n * `\"watermark\" < @externalFloor` is deliberately strict. A follower that lost\n * its replica restores it from S3 at watermark `W` and then asks this log for\n * everything after `W`, which requires the `commit` row *at* `W` to still be\n * here (`SQLITE_CHANGE_LOG_BOUNDARY_SQL`). Deleting it returns `too-old` to the\n * very subscriber the floor exists to protect.\n *\n * The head cap reads `max(\"watermark\")` from the log's own database, which\n * keeps the purger a pure function of one file. The cap is inert in normal\n * operation: the floor is derived from a backup of a replica that consumes this\n * loop's output, and the log commits before that output is forwarded, so\n * `externalFloor <= head` holds by construction. It engages only on a *stale*\n * log — writer stopped, mode flipped to `off`, another task took over — where\n * deleting to a floor that has run past a frozen log would empty the file. Note\n * that head can be a phantom — committed here but not yet re-deliverable by a\n * resumed stream — for as long as it takes the watermark the stream would\n * resume from to advance past it. That is harmless precisely because head is\n * never a purge candidate, and it is why the purger asserts nothing about\n * anything outside its own file.\n *\n * Ordered by `(\"writeTimeMs\", \"watermark\")` so it rides the partial index,\n * which carries one entry per transaction rather than one per change. The\n * `LIMIT` keeps a drain from re-scanning the remaining history on every batch,\n * which would be quadratic in the number of eligible transactions and would do\n * it inside the `BEGIN IMMEDIATE`, holding the write lock alongside the delete.\n *\n * Exported so the focused query-plan test covers the production query.\n */\nexport const SQLITE_CHANGE_LOG_ELIGIBLE_COMMITS_SQL = /*sql*/ `\n  SELECT \"watermark\"\n  FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n  WHERE \"writeTimeMs\" IS NOT NULL\n    AND \"writeTimeMs\" < @retentionCutoffMs\n    AND \"watermark\" < @externalFloor\n    AND \"watermark\" < (SELECT max(\"watermark\") FROM \"${CHANGE_LOG_STREAM_TABLE}\")\n  ORDER BY \"writeTimeMs\", \"watermark\"\n  LIMIT @limit\n`;\n\n/**\n * Counts the rows at `@watermark`, capped at `@limit`. The cap is what keeps\n * batch sizing O(budget): this runs per candidate inside the\n * `BEGIN IMMEDIATE`, and the transaction being sized can be arbitrarily\n * large — an uncapped count of a multi-million-row backfill would rescan\n * every remaining row on every tear batch, holding the write lock (and the\n * appending path behind it) for the duration, quadratically over the drain.\n * The caller only needs to know whether the transaction fits its remaining\n * budget, so it passes `remaining + 1` and reads a count above `remaining`\n * as \"does not fit\".\n *\n * Exported so the focused tests cover the production query.\n */\nexport const SQLITE_CHANGE_LOG_COUNT_TRANSACTION_SQL = /*sql*/ `\n  SELECT count(*) AS \"rows\" FROM (\n    SELECT 1\n    FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n    WHERE \"watermark\" = @watermark\n    LIMIT @limit\n  )\n`;\n\n/**\n * A prefix delete, so no transaction between the minimum and the head is ever\n * split. The `<=` is correct and is not the floor comparison: `deletedThrough`\n * is a watermark this batch already established as wholly eligible.\n */\nconst DELETE_THROUGH_SQL = /*sql*/ `\n  DELETE FROM \"${CHANGE_LOG_STREAM_TABLE}\" WHERE \"watermark\" <= ?\n`;\n\nconst MIN_WATERMARK_SQL = /*sql*/ `\n  SELECT min(\"watermark\") AS \"minWatermark\" FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n`;\n\n/**\n * The `pos` at `@offset` rows into the torn transaction, ascending. `undefined`\n * when fewer than `@offset` rows remain, which is how the tear knows it is on\n * its final chunk.\n */\nconst TEAR_BOUNDARY_SQL = /*sql*/ `\n  SELECT \"pos\"\n  FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n  WHERE \"watermark\" = @watermark\n  ORDER BY \"pos\"\n  LIMIT 1 OFFSET @offset\n`;\n\n/**\n * A range scan on the primary key. Expressed as `\"pos\" < @pos` rather than\n * `DELETE ... LIMIT n`, which is both non-portable and the wrong bound: it\n * carries no guarantee about *which* rows it removes, and the commit row must\n * survive until the chunk that finishes the tear.\n */\nconst DELETE_BELOW_POS_SQL = /*sql*/ `\n  DELETE FROM \"${CHANGE_LOG_STREAM_TABLE}\"\n  WHERE \"watermark\" = @watermark AND \"pos\" < @pos\n`;\n\nexport type PurgeBatchResult = {\n  readonly deletedRows: number;\n  /**\n   * The watermark through which whole transactions were removed. `undefined`\n   * when the batch only tore rows off the minimum transaction without\n   * completing it — in that case `deletedRows > 0` and `moreEligible` is true.\n   */\n  readonly deletedThrough: string | undefined;\n  /** True while a tear is in progress, as well as while whole transactions remain eligible. */\n  readonly moreEligible: boolean;\n};\n\nexport type PurgeBatchOptions = {\n  /**\n   * The floor the caller has already gated on subscriber ACKs and snapshot\n   * reservations — normally the confirmed S3 backup watermark. Transactions at\n   * or above it are NOT durable anywhere else: the change log is excluded from\n   * the litestream backup, so this is the boundary a follower restores to and\n   * then catches up from. Compared strictly (`<`), so the transaction *at* the\n   * floor survives as that follower's catchup boundary. The purger narrows this\n   * input and never widens it.\n   */\n  readonly externalFloor: string;\n  /**\n   * A *minimum* retention, ANDed on top of `externalFloor` rather than an\n   * alternative to it. Which of the two binds depends on the backup interval.\n   */\n  readonly retentionCutoffMs: number;\n  /** Starting chunk size. Not the bound — `maxDurationMs` is. */\n  readonly maxRows: number;\n  /**\n   * The statement duration target, enforced by feedback rather than by\n   * interruption: SQLite cannot yield mid-statement, so the purger measures\n   * each delete and shrinks the next batch's row budget when one overruns\n   * (see {@link SQLiteChangeLogPurger.budgetRows}) — which means the first\n   * delete after a restart, sized by `maxRows` alone, can still overrun it.\n   * The target is this consequential because purge shares the writer's\n   * connection: there is no lock to arbitrate and no `busy_timeout` to bound\n   * the wait — a long statement blocks the appending path, and the forward\n   * behind it, directly and for its full duration. That is why this is a\n   * precondition of purging from the stream loop rather than a tuning knob.\n   */\n  readonly maxDurationMs: number;\n};\n\ntype Statements = {\n  readonly eligibleCommits: Statement;\n  readonly countTransaction: Statement;\n  readonly deleteThrough: Statement;\n  readonly minWatermark: Statement;\n  readonly tearBoundary: Statement;\n  readonly deleteBelowPos: Statement;\n};\n\nexport class SQLiteChangeLogPurger {\n  readonly #db: Database;\n  readonly #now: () => number;\n  readonly #stmts: Statements;\n\n  /**\n   * The measured row budget, carried across batches. Row cost varies with\n   * payload size, so `maxRows` alone cannot bound a statement's duration; this\n   * shrinks when a delete overruns `maxDurationMs` and grows back when the\n   * budget — rather than the eligible set — was what limited the batch.\n   */\n  #budgetRows: number | undefined;\n\n  /**\n   * @param db a writable connection to a change log the writer has already\n   *     created and reconciled — in slice 9, the writer's own connection.\n   *     Statements are prepared eagerly, so a caller that may run before the\n   *     log exists opens the connection lazily and treats construction failure\n   *     as a skipped cycle.\n   */\n  constructor(\n    db: Database,\n    now: () => number = performance.now.bind(performance),\n  ) {\n    this.#db = db;\n    this.#now = now;\n    this.#stmts = {\n      eligibleCommits: db.prepare(SQLITE_CHANGE_LOG_ELIGIBLE_COMMITS_SQL),\n      countTransaction: db.prepare(SQLITE_CHANGE_LOG_COUNT_TRANSACTION_SQL),\n      deleteThrough: db.prepare(DELETE_THROUGH_SQL),\n      minWatermark: db.prepare(MIN_WATERMARK_SQL),\n      tearBoundary: db.prepare(TEAR_BOUNDARY_SQL),\n      deleteBelowPos: db.prepare(DELETE_BELOW_POS_SQL),\n    };\n  }\n\n  /** The row budget the next batch would use. Exposed for tests and metrics. */\n  get budgetRows(): number | undefined {\n    return this.#budgetRows;\n  }\n\n  /**\n   * Removes one bounded batch of aged-out history, in one `BEGIN IMMEDIATE`\n   * transaction. Callers loop while `moreEligible`, releasing whatever guards\n   * they hold between batches.\n   */\n  purgeBatch(opts: PurgeBatchOptions): PurgeBatchResult {\n    const {maxRows, maxDurationMs} = opts;\n    assert(\n      Number.isSafeInteger(maxRows) && maxRows > 0,\n      'change-log purge maxRows must be a positive safe integer',\n    );\n    assert(\n      maxDurationMs > 0,\n      'change-log purge maxDurationMs must be positive',\n    );\n\n    this.#db.exec('BEGIN IMMEDIATE');\n    try {\n      const result = this.#purge(opts);\n      this.#db.exec('COMMIT');\n      return result;\n    } catch (e) {\n      if (this.#db.inTransaction) {\n        this.#db.exec('ROLLBACK');\n      }\n      throw e;\n    }\n  }\n\n  #purge(opts: PurgeBatchOptions): PurgeBatchResult {\n    const {externalFloor, retentionCutoffMs} = opts;\n    const budget = this.#budget(opts.maxRows);\n    // Each transaction is at least a `begin` and a `commit`, so this is the\n    // most candidates that can fit in the budget.\n    const limit = Math.max(1, Math.ceil(budget / 2));\n    const candidates = this.#stmts.eligibleCommits.all<{watermark: string}>({\n      retentionCutoffMs,\n      externalFloor,\n      limit,\n    });\n    if (candidates.length === 0) {\n      return {deletedRows: 0, deletedThrough: undefined, moreEligible: false};\n    }\n\n    // Accounted per candidate rather than per prefix, which is exact as long as\n    // the candidates arrive in watermark order — they do, because the single\n    // writer stamps `writeTimeMs` at commit time. A clock that went backwards\n    // can put a non-candidate below `deletedThrough`, and the prefix delete\n    // then removes more rows than were counted. Not a safety problem: both\n    // watermark bounds are prefix-closed, only the minimum-retention courtesy\n    // is crossed, and `maxRows` is the starting chunk size rather than the\n    // bound — `maxDurationMs` is, and the governor measures what actually ran.\n    let rows = 0;\n    let deletedThrough: string | undefined;\n    for (const {watermark} of candidates) {\n      // The count is capped at one past the remaining budget: `n > remaining`\n      // is exactly `rows + n > budget` for a fitting transaction, and a\n      // too-large one stops scanning as soon as it is known not to fit.\n      const remaining = budget - rows;\n      const {rows: n} = this.#stmts.countTransaction.get<{rows: number}>({\n        watermark,\n        limit: remaining + 1,\n      });\n      if (n > remaining) {\n        break;\n      }\n      rows += n;\n      deletedThrough = watermark;\n    }\n\n    if (deletedThrough === undefined) {\n      return this.#tear(opts, budget);\n    }\n    const deletedRows = this.#timed(\n      opts,\n      budget,\n      () => this.#stmts.deleteThrough.run(deletedThrough).changes,\n    );\n    return {\n      deletedRows,\n      deletedThrough,\n      moreEligible: this.#anyEligible(opts),\n    };\n  }\n\n  /**\n   * Removes one bounded chunk of the minimum transaction, which is the only\n   * transaction that is ever torn.\n   *\n   * A single upstream transaction can be arbitrarily large — a backfill, a\n   * schema migration — and SQLite cannot yield mid-statement, so the only way\n   * to bound the lock hold is to delete it across several statements. That is\n   * unobservable given three constraints, all of which live here:\n   *\n   * 1. Only `min(\"watermark\")` is torn, so at most one transaction is ever\n   *    partial. A reader never reads *into* a transaction — `read()` starts\n   *    strictly after `(fromWatermark, MAX_SAFE_INTEGER)` — so the only\n   *    transaction a tear can touch is one a subscriber reads *from*, and\n   *    reading from it does not read its rows.\n   * 2. Rows go ascending by `pos`, commit row last. `plan()`'s boundary check\n   *    reads the *highest* `pos` at the watermark and requires it to be the\n   *    `commit`; removing that row first would give a subscriber sitting\n   *    exactly there a spurious `too-old`.\n   * 3. The commit row is removed by a prefix delete, which advances\n   *    `min(\"watermark\")` in the same SQLite transaction, so no state exposes\n   *    the boundary as gone while the minimum still points at it. Normally that\n   *    is {@link SQLiteChangeLogPurger.purgeBatch}'s ordinary whole-transaction\n   *    delete, taken on the batch where what is left of the torn transaction\n   *    finally fits the budget; the branch below is the same delete for the\n   *    case where the minimum is not itself in the eligible set.\n   *\n   * A crash mid-tear needs no recovery state: the torn transaction is still the\n   * minimum and still eligible, so the next batch continues it. Reconciliation\n   * is unaffected — it tests the head, and a tear is at the tail.\n   *\n   * Tearing the minimum is safe even in the unusual case where it is not itself\n   * in the eligible set (a writer whose clock went backwards can put a later\n   * watermark at an earlier `writeTimeMs`). Both watermark bounds are\n   * prefix-closed — a non-empty eligible set implies `min < externalFloor` and\n   * `min < head` — and the prefix delete this batch would otherwise run removes\n   * the minimum anyway. Only the time floor, which is a minimum-retention\n   * courtesy rather than a safety property, can be crossed that way.\n   */\n  #tear(opts: PurgeBatchOptions, budget: number): PurgeBatchResult {\n    const {minWatermark} = this.#stmts.minWatermark.get<{\n      minWatermark: string | null;\n    }>();\n    assert(\n      minWatermark !== null,\n      'change-log purge found eligible transactions in an empty log',\n    );\n\n    const boundary = this.#stmts.tearBoundary.get<{pos: number} | undefined>({\n      watermark: minWatermark,\n      offset: budget,\n    });\n    if (boundary === undefined) {\n      // At most `budget` rows are left at the minimum, which is reachable only\n      // when the minimum is not the transaction that failed to fit — i.e. when\n      // it is not itself eligible. The prefix delete removes it whole and\n      // advances `min(\"watermark\")`.\n      const deletedRows = this.#timed(\n        opts,\n        budget,\n        () => this.#stmts.deleteThrough.run(minWatermark).changes,\n      );\n      return {\n        deletedRows,\n        deletedThrough: minWatermark,\n        moreEligible: this.#anyEligible(opts),\n      };\n    }\n    // `boundary.pos` is the `budget`-th row by `pos`, so this removes exactly\n    // `budget` rows and always makes progress. The commit row is the highest\n    // `pos`, so it can only be reached by the branch above.\n    const deletedRows = this.#timed(\n      opts,\n      budget,\n      () =>\n        this.#stmts.deleteBelowPos.run({\n          watermark: minWatermark,\n          pos: boundary.pos,\n        }).changes,\n    );\n    return {deletedRows, deletedThrough: undefined, moreEligible: true};\n  }\n\n  #anyEligible({externalFloor, retentionCutoffMs}: PurgeBatchOptions): boolean {\n    return (\n      this.#stmts.eligibleCommits.get<{watermark: string} | undefined>({\n        retentionCutoffMs,\n        externalFloor,\n        limit: 1,\n      }) !== undefined\n    );\n  }\n\n  #budget(maxRows: number): number {\n    return Math.max(1, Math.min(maxRows, this.#budgetRows ?? maxRows));\n  }\n\n  /**\n   * Runs a delete and feeds its measured duration back into the row budget.\n   * Growth is gated on the budget having been the binding constraint: a batch\n   * that finished quickly because only four rows were eligible is no evidence\n   * that a larger statement would stay under the target.\n   */\n  #timed(\n    {maxRows, maxDurationMs}: PurgeBatchOptions,\n    budget: number,\n    run: () => number,\n  ): number {\n    const start = this.#now();\n    const deletedRows = run();\n    const elapsedMs = this.#now() - start;\n\n    if (elapsedMs > maxDurationMs) {\n      this.#budgetRows = Math.max(1, Math.floor(budget / 2));\n    } else if (deletedRows >= budget && elapsedMs * 2 <= maxDurationMs) {\n      this.#budgetRows = Math.min(maxRows, budget * 2);\n    } else {\n      this.#budgetRows = budget;\n    }\n    return deletedRows;\n  }\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/replicator/write-worker-client.js

@@ -121,6 +121,6 @@ var ThreadWriteWorkerClient = class {
 	}
 };
 //#endregion
-export { ThreadWriteWorkerClient, applyPragmas, serializeError };
+export { ThreadWriteWorkerClient, applyPragmas, deserializeError, serializeError };
 
 //# sourceMappingURL=write-worker-client.js.map

package/out/zero-cache/src/services/replicator/write-worker-client.js.map

@@ -1 +1 @@
-{"version":3,"file":"write-worker-client.js","names":["#worker","#rejectAll","#errorHandler","#pending","#terminated","#call"],"sources":["../../../../../../zero-cache/src/services/replicator/write-worker-client.ts"],"sourcesContent":["import {Worker} from 'node:worker_threads';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {LogConfig} from '../../../../shared/src/logging.ts';\nimport type {Database} from '../../../../zqlite/src/db.ts';\nimport {WRITE_WORKER_URL} from '../../server/worker-urls.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport type {BackfillRequest} from '../change-source/protocol/current/upstream.ts';\nimport type {ChangeProcessorMode, CommitResult} from './change-processor.ts';\nimport type {SubscriptionState} from './schema/replication-state.ts';\n\nexport type PragmaConfig = {\n  busyTimeout: number;\n  analysisLimit: number;\n  walAutocheckpoint?: number | undefined;\n};\n\n/**\n * Enables write-path checkpoint backpressure in the write worker. At each\n * commit boundary, if the WAL has grown to at least `checkpointThresholdPages`,\n * the worker forces an immediate litestream sync (sealing the WAL to LTX and\n * running litestream's checkpoint).\n *\n * The optional `walMaxPages` is an emergency break that pauses until the WAL drains,\n * rather than letting it exceed available disk space. This replaces litestream's\n * analogous `truncate-page-n` emergency break, which is more disruptive because of\n * https://github.com/benbjohnson/litestream/issues/1332. Note, however, this should\n * never been needed if non-initial snapshots are disabled (which is the default).\n *\n * Set only for the backup replicator when replicating with litestream v5; `null`\n * disables the feature entirely (no per-commit overhead).\n */\nexport type ForceCheckpointConfig = {\n  checkpointThresholdPages: number;\n  maxWalPages?: number | undefined;\n};\n\ntype ErrorHandler = (err: Error) => void;\n\n/**\n * Interface for a write worker that processes replication messages.\n */\n/**\n * The replica's {@link SubscriptionState}, along with its pending backfills,\n * read in the same snapshot.\n */\nexport type SubscriptionStateWithBackfills = SubscriptionState & {\n  backfills: BackfillRequest[];\n};\n\nexport interface WriteWorkerClient {\n  getSubscriptionState(): Promise<SubscriptionStateWithBackfills>;\n  processMessages(\n    downstream: readonly ChangeStreamData[],\n  ): Promise<CommitResult | null>;\n  abort(): void;\n  stop(): Promise<void>;\n  onError(handler: ErrorHandler): void;\n}\n\nexport type SerializedError = {\n  name: string;\n  message: string;\n  stack?: string | undefined;\n  cause?: SerializedError | string | undefined;\n  details?: Record<string, unknown> | undefined;\n};\n\nexport function serializeError(err: unknown): SerializedError {\n  if (!(err instanceof Error)) {\n    return {\n      name: 'Error',\n      message: String(err),\n      details: err && typeof err === 'object' ? {...err} : undefined,\n    };\n  }\n\n  // Error fields such as message, stack, and some native error details are\n  // non-enumerable, so JSON.stringify(err) would usually return \"{}\".\n  const details = Object.fromEntries(\n    Object.getOwnPropertyNames(err)\n      .filter(key => !['name', 'message', 'stack', 'cause'].includes(key))\n      .map(key => [key, (err as unknown as Record<string, unknown>)[key]]),\n  );\n  const cause =\n    err.cause instanceof Error\n      ? serializeError(err.cause)\n      : err.cause === undefined\n        ? undefined\n        : String(err.cause);\n\n  return {\n    name: err.name,\n    message: err.message,\n    stack: err.stack,\n    cause,\n    details: Object.keys(details).length ? details : undefined,\n  };\n}\n\nexport function deserializeError(serialized: SerializedError): Error {\n  const err = new Error(serialized.message);\n  err.name = serialized.name;\n  if (serialized.stack !== undefined) {\n    err.stack = serialized.stack;\n  }\n  if (serialized.cause !== undefined) {\n    err.cause =\n      typeof serialized.cause === 'string'\n        ? serialized.cause\n        : deserializeError(serialized.cause);\n  }\n  if (serialized.details) {\n    Object.assign(err, serialized.details);\n  }\n  return err;\n}\n\n// Wire protocol types.\nexport type ArgsMap = {\n  init: [\n    string,\n    ChangeProcessorMode,\n    PragmaConfig,\n    LogConfig,\n    ForceCheckpointConfig | null,\n  ];\n  getSubscriptionState: [];\n  processMessages: [readonly ChangeStreamData[]];\n  abort: [];\n  stop: [];\n};\n\nexport type Method = keyof ArgsMap;\n\nexport type Request<M extends Method = Method> = {method: M; args: ArgsMap[M]};\n\nexport type ResultMap = {\n  init: void;\n  getSubscriptionState: SubscriptionStateWithBackfills;\n  processMessages: CommitResult | null;\n  abort: void;\n  stop: void;\n};\n\nexport type Response<M extends Method = Method> =\n  | {method: M; result: ResultMap[M]; error?: undefined}\n  | {method: M; error: SerializedError; result?: undefined};\n\nexport type WriteError = {writeError: SerializedError};\n\nexport function applyPragmas(db: Database, pragmas: PragmaConfig) {\n  db.pragma(`busy_timeout = ${pragmas.busyTimeout}`);\n  db.pragma(`analysis_limit = ${pragmas.analysisLimit}`);\n  if (pragmas.walAutocheckpoint !== undefined) {\n    db.pragma(`wal_autocheckpoint = ${pragmas.walAutocheckpoint}`);\n  }\n}\n\n/**\n * Delegates SQLite writes to a worker_thread,\n * keeping the main event loop free for WebSocket heartbeats and IPC.\n */\nexport class ThreadWriteWorkerClient implements WriteWorkerClient {\n  readonly #worker: Worker;\n  #pending: Resolver<unknown, Error> | null = null;\n  #errorHandler: ErrorHandler = () => {};\n  #terminated = false;\n\n  constructor() {\n    this.#worker = new Worker(WRITE_WORKER_URL);\n\n    this.#worker.on('message', (msg: Response | WriteError) => {\n      if ('writeError' in msg) {\n        const error = deserializeError(msg.writeError);\n        this.#rejectAll(error);\n        this.#errorHandler(error);\n        return;\n      }\n      const r = this.#pending;\n      if (!r) return; // stale abort response\n      this.#pending = null;\n      if (msg.error !== undefined) {\n        r.reject(deserializeError(msg.error));\n      } else {\n        r.resolve(msg.result);\n      }\n    });\n\n    this.#worker.on('error', (err: Error) => {\n      this.#rejectAll(err);\n      this.#errorHandler(err);\n    });\n\n    this.#worker.on('exit', (code: number) => {\n      this.#terminated = true;\n      if (code !== 0) {\n        const err = new Error(`Worker exited with code ${code}`);\n        this.#rejectAll(err);\n        this.#errorHandler(err);\n      }\n    });\n  }\n\n  #rejectAll(err: Error) {\n    const r = this.#pending;\n    if (r) {\n      this.#pending = null;\n      r.reject(err);\n    }\n  }\n\n  #call<M extends Method>(method: M, args: ArgsMap[M]): Promise<ResultMap[M]> {\n    assert(this.#pending === null, `concurrent call: ${method}`);\n    const r = resolver<ResultMap[M]>();\n    this.#pending = r as Resolver<unknown, Error>;\n    this.#worker.postMessage({method, args} satisfies Request);\n    return r.promise;\n  }\n\n  init(\n    dbPath: string,\n    mode: ChangeProcessorMode,\n    pragmas: PragmaConfig,\n    logConfig: LogConfig,\n    checkpoint: ForceCheckpointConfig | null = null,\n  ): Promise<void> {\n    return this.#call('init', [dbPath, mode, pragmas, logConfig, checkpoint]);\n  }\n\n  getSubscriptionState(): Promise<SubscriptionStateWithBackfills> {\n    return this.#call('getSubscriptionState', []);\n  }\n\n  processMessages(\n    downstream: readonly ChangeStreamData[],\n  ): Promise<CommitResult | null> {\n    return this.#call('processMessages', [downstream]);\n  }\n\n  abort(): void {\n    if (!this.#terminated) {\n      this.#worker.postMessage({method: 'abort', args: []} satisfies Request);\n    }\n  }\n\n  async stop(): Promise<void> {\n    await this.#call('stop', []);\n    if (!this.#terminated) {\n      await this.#worker.terminate();\n    }\n  }\n\n  onError(handler: ErrorHandler): void {\n    this.#errorHandler = handler;\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"write-worker-client.js","names":[],"sources":["../../../../../../zero-cache/src/services/replicator/write-worker-client.ts"],"sourcesContent":["import {Worker} from 'node:worker_threads';\nimport {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {LogConfig} from '../../../../shared/src/logging.ts';\nimport type {Database} from '../../../../zqlite/src/db.ts';\nimport {WRITE_WORKER_URL} from '../../server/worker-urls.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport type {BackfillRequest} from '../change-source/protocol/current/upstream.ts';\nimport type {ChangeProcessorMode, CommitResult} from './change-processor.ts';\nimport type {SubscriptionState} from './schema/replication-state.ts';\n\nexport type PragmaConfig = {\n  busyTimeout: number;\n  analysisLimit: number;\n  walAutocheckpoint?: number | undefined;\n};\n\n/**\n * Enables write-path checkpoint backpressure in the write worker. At each\n * commit boundary, if the WAL has grown to at least `checkpointThresholdPages`,\n * the worker forces an immediate litestream sync (sealing the WAL to LTX and\n * running litestream's checkpoint).\n *\n * The optional `walMaxPages` is an emergency break that pauses until the WAL drains,\n * rather than letting it exceed available disk space. This replaces litestream's\n * analogous `truncate-page-n` emergency break, which is more disruptive because of\n * https://github.com/benbjohnson/litestream/issues/1332. Note, however, this should\n * never been needed if non-initial snapshots are disabled (which is the default).\n *\n * Set only for the backup replicator when replicating with litestream v5; `null`\n * disables the feature entirely (no per-commit overhead).\n */\nexport type ForceCheckpointConfig = {\n  checkpointThresholdPages: number;\n  maxWalPages?: number | undefined;\n};\n\ntype ErrorHandler = (err: Error) => void;\n\n/**\n * Interface for a write worker that processes replication messages.\n */\n/**\n * The replica's {@link SubscriptionState}, along with its pending backfills,\n * read in the same snapshot.\n */\nexport type SubscriptionStateWithBackfills = SubscriptionState & {\n  backfills: BackfillRequest[];\n};\n\nexport interface WriteWorkerClient {\n  getSubscriptionState(): Promise<SubscriptionStateWithBackfills>;\n  processMessages(\n    downstream: readonly ChangeStreamData[],\n  ): Promise<CommitResult | null>;\n  abort(): void;\n  stop(): Promise<void>;\n  onError(handler: ErrorHandler): void;\n}\n\nexport type SerializedError = {\n  name: string;\n  message: string;\n  stack?: string | undefined;\n  cause?: SerializedError | string | undefined;\n  details?: Record<string, unknown> | undefined;\n};\n\nexport function serializeError(err: unknown): SerializedError {\n  if (!(err instanceof Error)) {\n    return {\n      name: 'Error',\n      message: String(err),\n      details: err && typeof err === 'object' ? {...err} : undefined,\n    };\n  }\n\n  // Error fields such as message, stack, and some native error details are\n  // non-enumerable, so JSON.stringify(err) would usually return \"{}\".\n  const details = Object.fromEntries(\n    Object.getOwnPropertyNames(err)\n      .filter(key => !['name', 'message', 'stack', 'cause'].includes(key))\n      .map(key => [key, (err as unknown as Record<string, unknown>)[key]]),\n  );\n  const cause =\n    err.cause instanceof Error\n      ? serializeError(err.cause)\n      : err.cause === undefined\n        ? undefined\n        : String(err.cause);\n\n  return {\n    name: err.name,\n    message: err.message,\n    stack: err.stack,\n    cause,\n    details: Object.keys(details).length ? details : undefined,\n  };\n}\n\nexport function deserializeError(serialized: SerializedError): Error {\n  const err = new Error(serialized.message);\n  err.name = serialized.name;\n  if (serialized.stack !== undefined) {\n    err.stack = serialized.stack;\n  }\n  if (serialized.cause !== undefined) {\n    err.cause =\n      typeof serialized.cause === 'string'\n        ? serialized.cause\n        : deserializeError(serialized.cause);\n  }\n  if (serialized.details) {\n    Object.assign(err, serialized.details);\n  }\n  return err;\n}\n\n// Wire protocol types.\nexport type ArgsMap = {\n  init: [\n    string,\n    ChangeProcessorMode,\n    PragmaConfig,\n    LogConfig,\n    ForceCheckpointConfig | null,\n  ];\n  getSubscriptionState: [];\n  processMessages: [readonly ChangeStreamData[]];\n  abort: [];\n  stop: [];\n};\n\nexport type Method = keyof ArgsMap;\n\nexport type Request<M extends Method = Method> = {method: M; args: ArgsMap[M]};\n\nexport type ResultMap = {\n  init: void;\n  getSubscriptionState: SubscriptionStateWithBackfills;\n  processMessages: CommitResult | null;\n  abort: void;\n  stop: void;\n};\n\nexport type Response<M extends Method = Method> =\n  | {method: M; result: ResultMap[M]; error?: undefined}\n  | {method: M; error: SerializedError; result?: undefined};\n\nexport type WriteError = {writeError: SerializedError};\n\nexport function applyPragmas(db: Database, pragmas: PragmaConfig) {\n  db.pragma(`busy_timeout = ${pragmas.busyTimeout}`);\n  db.pragma(`analysis_limit = ${pragmas.analysisLimit}`);\n  if (pragmas.walAutocheckpoint !== undefined) {\n    db.pragma(`wal_autocheckpoint = ${pragmas.walAutocheckpoint}`);\n  }\n}\n\n/**\n * Delegates SQLite writes to a worker_thread,\n * keeping the main event loop free for WebSocket heartbeats and IPC.\n */\nexport class ThreadWriteWorkerClient implements WriteWorkerClient {\n  readonly #worker: Worker;\n  #pending: Resolver<unknown, Error> | null = null;\n  #errorHandler: ErrorHandler = () => {};\n  #terminated = false;\n\n  constructor() {\n    this.#worker = new Worker(WRITE_WORKER_URL);\n\n    this.#worker.on('message', (msg: Response | WriteError) => {\n      if ('writeError' in msg) {\n        const error = deserializeError(msg.writeError);\n        this.#rejectAll(error);\n        this.#errorHandler(error);\n        return;\n      }\n      const r = this.#pending;\n      if (!r) return; // stale abort response\n      this.#pending = null;\n      if (msg.error !== undefined) {\n        r.reject(deserializeError(msg.error));\n      } else {\n        r.resolve(msg.result);\n      }\n    });\n\n    this.#worker.on('error', (err: Error) => {\n      this.#rejectAll(err);\n      this.#errorHandler(err);\n    });\n\n    this.#worker.on('exit', (code: number) => {\n      this.#terminated = true;\n      if (code !== 0) {\n        const err = new Error(`Worker exited with code ${code}`);\n        this.#rejectAll(err);\n        this.#errorHandler(err);\n      }\n    });\n  }\n\n  #rejectAll(err: Error) {\n    const r = this.#pending;\n    if (r) {\n      this.#pending = null;\n      r.reject(err);\n    }\n  }\n\n  #call<M extends Method>(method: M, args: ArgsMap[M]): Promise<ResultMap[M]> {\n    assert(this.#pending === null, `concurrent call: ${method}`);\n    const r = resolver<ResultMap[M]>();\n    this.#pending = r as Resolver<unknown, Error>;\n    this.#worker.postMessage({method, args} satisfies Request);\n    return r.promise;\n  }\n\n  init(\n    dbPath: string,\n    mode: ChangeProcessorMode,\n    pragmas: PragmaConfig,\n    logConfig: LogConfig,\n    checkpoint: ForceCheckpointConfig | null = null,\n  ): Promise<void> {\n    return this.#call('init', [dbPath, mode, pragmas, logConfig, checkpoint]);\n  }\n\n  getSubscriptionState(): Promise<SubscriptionStateWithBackfills> {\n    return this.#call('getSubscriptionState', []);\n  }\n\n  processMessages(\n    downstream: readonly ChangeStreamData[],\n  ): Promise<CommitResult | null> {\n    return this.#call('processMessages', [downstream]);\n  }\n\n  abort(): void {\n    if (!this.#terminated) {\n      this.#worker.postMessage({method: 'abort', args: []} satisfies Request);\n    }\n  }\n\n  async stop(): Promise<void> {\n    await this.#call('stop', []);\n    if (!this.#terminated) {\n      await this.#worker.terminate();\n    }\n  }\n\n  onError(handler: ErrorHandler): void {\n    this.#errorHandler = handler;\n  }\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/replicator/write-worker.js

@@ -1,11 +1,11 @@
 import { assert } from "../../../../shared/src/asserts.js";
 import { must } from "../../../../shared/src/must.js";
 import { Database } from "../../../../zqlite/src/db.js";
-import { readReplicaBackfills } from "./schema/backfilling.js";
-import { getSubscriptionState } from "./schema/replication-state.js";
-import { StatementRunner } from "../../db/statements.js";
 import { isSQLiteCorruption, logSQLiteCorruptionDiagnostics, registerSQLiteCorruptionDiagnosticTarget } from "../../db/sqlite-corruption.js";
 import { createLogContext } from "../../server/logging.js";
+import { StatementRunner } from "../../db/statements.js";
+import { readReplicaBackfills } from "./schema/backfilling.js";
+import { getSubscriptionState } from "./schema/replication-state.js";
 import { deleteLiteDB } from "../../db/delete-lite-db.js";
 import { ChangeProcessor } from "./change-processor.js";
 import { LitestreamController } from "../litestream/litestream-controller.js";

package/out/zero-cache/src/services/replicator/write-worker.js.map

@@ -1 +1 @@
-{"version":3,"file":"write-worker.js","names":[],"sources":["../../../../../../zero-cache/src/services/replicator/write-worker.ts"],"sourcesContent":["import {parentPort} from 'node:worker_threads';\nimport type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {LogConfig} from '../../../../shared/src/logging.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {deleteLiteDB} from '../../db/delete-lite-db.ts';\nimport {\n  isSQLiteCorruption,\n  logSQLiteCorruptionDiagnostics,\n  registerSQLiteCorruptionDiagnosticTarget,\n} from '../../db/sqlite-corruption.ts';\nimport {StatementRunner} from '../../db/statements.ts';\nimport {createLogContext} from '../../server/logging.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport {LitestreamCheckpointer} from '../litestream/litestream-checkpointer.ts';\nimport {LitestreamController} from '../litestream/litestream-controller.ts';\nimport {ChangeProcessor, type ChangeProcessorMode} from './change-processor.ts';\nimport {readReplicaBackfills} from './schema/backfilling.ts';\nimport {getSubscriptionState} from './schema/replication-state.ts';\nimport {\n  applyPragmas,\n  serializeError,\n  type ArgsMap,\n  type ForceCheckpointConfig,\n  type Method,\n  type PragmaConfig,\n  type Request,\n  type Response,\n  type ResultMap,\n  type WriteError,\n} from './write-worker-client.ts';\n\nif (!parentPort) {\n  throw new Error('write-worker must be run as a worker thread');\n}\n\nconst port = parentPort;\n\ntype API = {\n  [M in Method]: (...args: ArgsMap[M]) => ResultMap[M] | Promise<ResultMap[M]>;\n};\n\nfunction createAPI(): API {\n  let db: Database | undefined;\n  let runner: StatementRunner | undefined;\n  let processor: ChangeProcessor | undefined;\n  let mode: ChangeProcessorMode | undefined;\n  let lc: LogContext | undefined;\n  let replicaDbPath: string | undefined;\n  let unregisterCorruptionDiagnosticTargets: (() => void)[] = [];\n\n  // Set when write-path checkpoint backpressure is enabled (backup replicator\n  // on litestream v5). `undefined` disables the feature.\n  let checkpointerConfig: ForceCheckpointConfig | undefined;\n  let checkpointer: LitestreamCheckpointer | undefined;\n\n  function unregisterCorruptionDiagnostics() {\n    unregisterCorruptionDiagnosticTargets.forEach(unregister => unregister());\n    unregisterCorruptionDiagnosticTargets = [];\n  }\n\n  function handleCorruptedDb(err: unknown) {\n    if (!lc || !replicaDbPath || !isSQLiteCorruption(err)) {\n      return;\n    }\n    logSQLiteCorruptionDiagnostics(lc, 'write-worker', replicaDbPath, err);\n    try {\n      lc.warn?.(`deleting corrupted db at ${replicaDbPath}`);\n      deleteLiteDB(replicaDbPath);\n    } catch (e) {\n      lc.warn?.(`error deleting corrupted db at ${replicaDbPath}`, e);\n    }\n  }\n\n  function createProcessor() {\n    processor = new ChangeProcessor(must(runner), must(mode), (_lc, err) => {\n      handleCorruptedDb(err);\n      port.postMessage({\n        writeError: serializeError(err),\n      } satisfies WriteError);\n    });\n  }\n\n  function createCheckpointer() {\n    if (checkpointerConfig) {\n      assert(lc && db && replicaDbPath, `not initialized`);\n      checkpointer = new LitestreamCheckpointer(\n        lc,\n        db,\n        new LitestreamController(lc, replicaDbPath),\n        checkpointerConfig,\n      );\n    }\n  }\n\n  return {\n    init(\n      dbPath: string,\n      cpMode: ChangeProcessorMode,\n      pragmas: PragmaConfig,\n      logConfig: LogConfig,\n      checkpointConfig: ForceCheckpointConfig | null,\n    ): void {\n      replicaDbPath = dbPath;\n      lc = createLogContext({log: logConfig}, 'write-worker');\n      unregisterCorruptionDiagnostics();\n      unregisterCorruptionDiagnosticTargets.push(\n        registerSQLiteCorruptionDiagnosticTarget({\n          debugName: 'write-worker',\n          dbPath,\n        }),\n      );\n      try {\n        db = new Database(lc, dbPath);\n        applyPragmas(db, pragmas);\n        runner = new StatementRunner(db);\n        mode = cpMode;\n        checkpointerConfig = checkpointConfig ?? undefined;\n        createProcessor();\n        createCheckpointer();\n      } catch (e) {\n        handleCorruptedDb(e);\n        throw e;\n      }\n    },\n\n    getSubscriptionState() {\n      try {\n        // The write worker is the replica's only writer, so these reads are\n        // of the same snapshot.\n        return {\n          ...getSubscriptionState(must(runner)),\n          backfills: readReplicaBackfills(must(runner).db),\n        };\n      } catch (e) {\n        handleCorruptedDb(e);\n        throw e;\n      }\n    },\n\n    async processMessages(downstream: readonly ChangeStreamData[]) {\n      try {\n        let commitResult = null;\n        for (const message of downstream) {\n          const committed = must(processor).processMessage(must(lc), message);\n          if (committed) {\n            commitResult = committed;\n            if (checkpointer) {\n              await checkpointer.maybeCheckpoint();\n            }\n          }\n        }\n        return commitResult;\n      } catch (e) {\n        handleCorruptedDb(e);\n        throw e;\n      }\n    },\n\n    abort() {\n      must(processor).abort(must(lc));\n      checkpointer?.close();\n      createProcessor();\n      createCheckpointer();\n    },\n\n    stop() {\n      checkpointer?.close();\n      checkpointer = undefined;\n      db?.close();\n      db = undefined;\n      runner = undefined;\n      processor = undefined;\n      replicaDbPath = undefined;\n      unregisterCorruptionDiagnostics();\n    },\n  };\n}\n\nconst api = createAPI();\n\nport.on('message', async (msg: Request) => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- TS can't narrow msg.method + msg.args together\n    const result = await (api[msg.method] as (...args: any[]) => unknown)(\n      ...msg.args,\n    );\n    // abort is fire-and-forget — no pending slot on the client side.\n    if (msg.method !== 'abort') {\n      port.postMessage({method: msg.method, result} as Response);\n    }\n  } catch (e) {\n    if (msg.method !== 'abort') {\n      port.postMessage({\n        method: msg.method,\n        error: serializeError(e),\n      } as Response);\n    }\n  }\n});\n"],"mappings":"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"}
+{"version":3,"file":"write-worker.js","names":[],"sources":["../../../../../../zero-cache/src/services/replicator/write-worker.ts"],"sourcesContent":["import {parentPort} from 'node:worker_threads';\nimport type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport type {LogConfig} from '../../../../shared/src/logging.ts';\nimport {must} from '../../../../shared/src/must.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {deleteLiteDB} from '../../db/delete-lite-db.ts';\nimport {\n  isSQLiteCorruption,\n  logSQLiteCorruptionDiagnostics,\n  registerSQLiteCorruptionDiagnosticTarget,\n} from '../../db/sqlite-corruption.ts';\nimport {StatementRunner} from '../../db/statements.ts';\nimport {createLogContext} from '../../server/logging.ts';\nimport type {ChangeStreamData} from '../change-source/protocol/current/downstream.ts';\nimport {LitestreamCheckpointer} from '../litestream/litestream-checkpointer.ts';\nimport {LitestreamController} from '../litestream/litestream-controller.ts';\nimport {ChangeProcessor, type ChangeProcessorMode} from './change-processor.ts';\nimport {readReplicaBackfills} from './schema/backfilling.ts';\nimport {getSubscriptionState} from './schema/replication-state.ts';\nimport {\n  applyPragmas,\n  serializeError,\n  type ArgsMap,\n  type ForceCheckpointConfig,\n  type Method,\n  type PragmaConfig,\n  type Request,\n  type Response,\n  type ResultMap,\n  type WriteError,\n} from './write-worker-client.ts';\n\nif (!parentPort) {\n  throw new Error('write-worker must be run as a worker thread');\n}\n\nconst port = parentPort;\n\ntype API = {\n  [M in Method]: (...args: ArgsMap[M]) => ResultMap[M] | Promise<ResultMap[M]>;\n};\n\nfunction createAPI(): API {\n  let db: Database | undefined;\n  let runner: StatementRunner | undefined;\n  let processor: ChangeProcessor | undefined;\n  let mode: ChangeProcessorMode | undefined;\n  let lc: LogContext | undefined;\n  let replicaDbPath: string | undefined;\n  let unregisterCorruptionDiagnosticTargets: (() => void)[] = [];\n\n  // Set when write-path checkpoint backpressure is enabled (backup replicator\n  // on litestream v5). `undefined` disables the feature.\n  let checkpointerConfig: ForceCheckpointConfig | undefined;\n  let checkpointer: LitestreamCheckpointer | undefined;\n\n  function unregisterCorruptionDiagnostics() {\n    unregisterCorruptionDiagnosticTargets.forEach(unregister => unregister());\n    unregisterCorruptionDiagnosticTargets = [];\n  }\n\n  function handleCorruptedDb(err: unknown) {\n    if (!lc || !replicaDbPath || !isSQLiteCorruption(err)) {\n      return;\n    }\n    logSQLiteCorruptionDiagnostics(lc, 'write-worker', replicaDbPath, err);\n    try {\n      lc.warn?.(`deleting corrupted db at ${replicaDbPath}`);\n      deleteLiteDB(replicaDbPath);\n    } catch (e) {\n      lc.warn?.(`error deleting corrupted db at ${replicaDbPath}`, e);\n    }\n  }\n\n  function createProcessor() {\n    processor = new ChangeProcessor(must(runner), must(mode), (_lc, err) => {\n      handleCorruptedDb(err);\n      port.postMessage({\n        writeError: serializeError(err),\n      } satisfies WriteError);\n    });\n  }\n\n  function createCheckpointer() {\n    if (checkpointerConfig) {\n      assert(lc && db && replicaDbPath, `not initialized`);\n      checkpointer = new LitestreamCheckpointer(\n        lc,\n        db,\n        new LitestreamController(lc, replicaDbPath),\n        checkpointerConfig,\n      );\n    }\n  }\n\n  return {\n    init(\n      dbPath: string,\n      cpMode: ChangeProcessorMode,\n      pragmas: PragmaConfig,\n      logConfig: LogConfig,\n      checkpointConfig: ForceCheckpointConfig | null,\n    ): void {\n      replicaDbPath = dbPath;\n      lc = createLogContext({log: logConfig}, 'write-worker');\n      unregisterCorruptionDiagnostics();\n      unregisterCorruptionDiagnosticTargets.push(\n        registerSQLiteCorruptionDiagnosticTarget({\n          debugName: 'write-worker',\n          dbPath,\n        }),\n      );\n      try {\n        db = new Database(lc, dbPath);\n        applyPragmas(db, pragmas);\n        runner = new StatementRunner(db);\n        mode = cpMode;\n        checkpointerConfig = checkpointConfig ?? undefined;\n        createProcessor();\n        createCheckpointer();\n      } catch (e) {\n        handleCorruptedDb(e);\n        throw e;\n      }\n    },\n\n    getSubscriptionState() {\n      try {\n        // The write worker is the replica's only writer, so these reads are\n        // of the same snapshot.\n        return {\n          ...getSubscriptionState(must(runner)),\n          backfills: readReplicaBackfills(must(runner).db),\n        };\n      } catch (e) {\n        handleCorruptedDb(e);\n        throw e;\n      }\n    },\n\n    async processMessages(downstream: readonly ChangeStreamData[]) {\n      try {\n        let commitResult = null;\n        for (const message of downstream) {\n          const committed = must(processor).processMessage(must(lc), message);\n          if (committed) {\n            commitResult = committed;\n            if (checkpointer) {\n              await checkpointer.maybeCheckpoint();\n            }\n          }\n        }\n        return commitResult;\n      } catch (e) {\n        handleCorruptedDb(e);\n        throw e;\n      }\n    },\n\n    abort() {\n      must(processor).abort(must(lc));\n      checkpointer?.close();\n      createProcessor();\n      createCheckpointer();\n    },\n\n    stop() {\n      checkpointer?.close();\n      checkpointer = undefined;\n      db?.close();\n      db = undefined;\n      runner = undefined;\n      processor = undefined;\n      replicaDbPath = undefined;\n      unregisterCorruptionDiagnostics();\n    },\n  };\n}\n\nconst api = createAPI();\n\nport.on('message', async (msg: Request) => {\n  try {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- TS can't narrow msg.method + msg.args together\n    const result = await (api[msg.method] as (...args: any[]) => unknown)(\n      ...msg.args,\n    );\n    // abort is fire-and-forget — no pending slot on the client side.\n    if (msg.method !== 'abort') {\n      port.postMessage({method: msg.method, result} as Response);\n    }\n  } catch (e) {\n    if (msg.method !== 'abort') {\n      port.postMessage({\n        method: msg.method,\n        error: serializeError(e),\n      } as Response);\n    }\n  }\n});\n"],"mappings":"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"}

package/out/zero-cache/src/services/run-ast.js

@@ -6,9 +6,9 @@ import { hashOfAST } from "../../../zero-protocol/src/query-hash.js";
 import { buildPipeline } from "../../../zql/src/builder/builder.js";
 import { astToZQL } from "../../../ast-to-zql/src/ast-to-zql.js";
 import { formatOutput } from "../../../ast-to-zql/src/format.js";
+import { transformAndHashQuery } from "../auth/read-authorizer.js";
 import { computeZqlSpecs } from "../db/lite-tables.js";
 import { resolveSimpleScalarSubqueries } from "../../../zqlite/src/resolve-scalar-subqueries.js";
-import { transformAndHashQuery } from "../auth/read-authorizer.js";
 import { fetchScalarValue, hydrate } from "./view-syncer/pipeline-driver.js";
 //#region ../zero-cache/src/services/run-ast.ts
 /**

package/out/zero-cache/src/services/run-ast.js.map

@@ -1 +1 @@
-{"version":3,"file":"run-ast.js","names":[],"sources":["../../../../../zero-cache/src/services/run-ast.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\n// @circular-dep-ignore\nimport {astToZQL} from '../../../ast-to-zql/src/ast-to-zql.ts';\n// @circular-dep-ignore\nimport {formatOutput} from '../../../ast-to-zql/src/format.ts';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {sleep} from '../../../shared/src/sleep.ts';\nimport type {AnalyzeQueryResult} from '../../../zero-protocol/src/analyze-query-result.ts';\nimport type {AST, LiteralValue} from '../../../zero-protocol/src/ast.ts';\nimport {mapAST} from '../../../zero-protocol/src/ast.ts';\nimport type {ClientSchema} from '../../../zero-protocol/src/client-schema.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {hashOfAST} from '../../../zero-protocol/src/query-hash.ts';\nimport type {PermissionsConfig} from '../../../zero-schema/src/compiled-permissions.ts';\nimport type {NameMapper} from '../../../zero-schema/src/name-mapper.ts';\nimport {\n  buildPipeline,\n  type BuilderDelegate,\n} from '../../../zql/src/builder/builder.ts';\nimport {ChangeType} from '../../../zql/src/ivm/change-type.ts';\nimport type {Input} from '../../../zql/src/ivm/operator.ts';\nimport type {ConnectionCostModel} from '../../../zql/src/planner/planner-connection.ts';\nimport type {PlanDebugger} from '../../../zql/src/planner/planner-debug.ts';\nimport type {Database} from '../../../zqlite/src/db.ts';\nimport {resolveSimpleScalarSubqueries} from '../../../zqlite/src/resolve-scalar-subqueries.ts';\nimport type {JWTAuth} from '../auth/auth.ts';\nimport {transformAndHashQuery} from '../auth/read-authorizer.ts';\nimport {computeZqlSpecs} from '../db/lite-tables.ts';\nimport type {LiteAndZqlSpec} from '../db/specs.ts';\nimport {\n  fetchScalarValue,\n  hydrate,\n  type RowChange,\n} from './view-syncer/pipeline-driver.ts';\n\n/**\n * Maximum number of synced rows returned per table, and read rows returned\n * per table/query, when analyzing a query in zero-cache. Rows past this are\n * still counted. Keeping every row can exhaust the heap when analyzing queries\n * over large tables.\n */\nexport const MAX_ANALYZE_ROWS = 1000;\n\nexport type RunAstOptions = {\n  applyPermissions?: boolean | undefined;\n  auth?: JWTAuth | undefined;\n  clientToServerMapper?: NameMapper | undefined;\n  costModel?: ConnectionCostModel | undefined;\n  db: Database;\n  host: BuilderDelegate;\n  /**\n   * Maximum number of synced rows returned per table. Rows past this are still\n   * counted. Defaults to no limit.\n   */\n  maxSyncedRowsPerTable?: number | undefined;\n  permissions?: PermissionsConfig | undefined;\n  planDebugger?: PlanDebugger | undefined;\n  syncedRows?: boolean | undefined;\n  tableSpecs: Map<string, LiteAndZqlSpec>;\n  vendedRows?: boolean | undefined;\n};\n\nexport async function runAst(\n  lc: LogContext,\n  clientSchema: ClientSchema,\n  ast: AST,\n  isTransformed: boolean,\n  options: RunAstOptions,\n  yieldProcess: () => Promise<void>,\n): Promise<AnalyzeQueryResult> {\n  const {\n    clientToServerMapper,\n    permissions,\n    host,\n    db,\n    maxSyncedRowsPerTable = Infinity,\n  } = options;\n  const result: AnalyzeQueryResult = {\n    warnings: [],\n    syncedRows: undefined,\n    syncedRowCount: 0,\n    start: 0,\n    end: 0,\n    elapsed: 0,\n    afterPermissions: undefined,\n    readRows: undefined,\n    readRowCountsByQuery: {},\n    readRowCount: undefined,\n  };\n\n  if (!isTransformed) {\n    // map the AST to server names if not already transformed\n    ast = mapAST(ast, must(clientToServerMapper));\n  }\n  if (options.applyPermissions) {\n    const auth = options.auth;\n    if (!auth) {\n      result.warnings.push(\n        'No auth data provided. Permission rules will compare to `NULL` wherever an auth data field is referenced.',\n      );\n    }\n    ast = transformAndHashQuery(\n      lc,\n      'clientGroupIDForAnalyze',\n      ast,\n      must(permissions),\n      auth,\n      false,\n    ).transformedAst;\n    result.afterPermissions = await formatOutput(ast.table + astToZQL(ast));\n  }\n\n  const hash = hashOfAST(ast);\n  const zqlSpecs = computeZqlSpecs(lc, db, {includeBackfillingColumns: false});\n\n  // Resolve scalar subqueries (e.g. whereExists with {scalar: true}) to\n  // literal equality conditions so that SQLite can use indexes effectively.\n  // Without this, correlated subqueries get stripped from SQL filters and\n  // queries on large tables fall back to full table scans.\n  // As in zero-cache, the rows the client reads for the gates are synced too,\n  // so the gates' pipelines are kept to be hydrated after the query's.\n  const companionInputs: Input[] = [];\n  const executor = (\n    subqueryAST: AST,\n    childField: string,\n  ): LiteralValue | null | undefined => {\n    const input = buildPipeline(subqueryAST, host, 'scalar-subquery');\n    companionInputs.push(input);\n    return fetchScalarValue(input, childField);\n  };\n\n  const {\n    ast: resolvedAst,\n    companions,\n    ignoredScalarHints,\n  } = resolveSimpleScalarSubqueries(ast, options.tableSpecs, executor);\n  for (const {table, uniqueKeys} of ignoredScalarHints) {\n    lc.warn?.(\n      `Ignoring {scalar: true} on the \"${table}\" subquery: it does not ` +\n        `constrain every column of any unique key ` +\n        `[${uniqueKeys.map(k => `(${k.join(', ')})`).join(', ')}] to a ` +\n        `literal with \"=\", so it is not provably limited to one row. ` +\n        `The gate runs as a plain EXISTS.`,\n    );\n  }\n\n  const pipeline = buildPipeline(\n    resolvedAst,\n    host,\n    'query-id',\n    options.costModel,\n    lc,\n    options.planDebugger,\n  );\n\n  // As in zero-cache, the rows of the gates follow the rows of the query,\n  // except for gates from a permission rule: rows read for a rule are never\n  // synced.\n  const syncedCompanionInputs = companionInputs.filter(\n    (_, i) => companions[i].system !== 'permissions',\n  );\n  function* rowChanges(): Iterable<RowChange | 'yield'> {\n    try {\n      for (const input of [pipeline, ...syncedCompanionInputs]) {\n        yield* hydrate(input, hash, clientSchema, zqlSpecs);\n      }\n    } finally {\n      for (const input of companionInputs) {\n        input.destroy();\n      }\n    }\n  }\n\n  const start = performance.now();\n\n  let syncedRowCount = 0;\n  const rowsByTable: Record<string, Row[]> = {};\n  // Dedupe on the row key rather than the whole row to bound memory.\n  const seen: Set<string> = new Set();\n  const truncatedTables: Set<string> = new Set();\n  for (const rowChange of rowChanges()) {\n    if (rowChange === 'yield') {\n      await yieldProcess();\n      continue;\n    }\n    assert(\n      rowChange.type === ChangeType.ADD,\n      'Hydration only handles add row changes',\n    );\n\n    // yield to other tasks to avoid blocking for too long\n    if (syncedRowCount % 10 === 0) {\n      await Promise.resolve();\n    }\n    if (syncedRowCount % 100 === 0) {\n      await sleep(1);\n    }\n\n    const key = JSON.stringify([rowChange.table, rowChange.rowKey]);\n    if (seen.has(key)) {\n      continue; // skip duplicates\n    }\n    syncedRowCount++;\n    seen.add(key);\n    if (options.syncedRows) {\n      const rows = (rowsByTable[rowChange.table] ??= []);\n      if (rows.length < maxSyncedRowsPerTable) {\n        rows.push(rowChange.row);\n      } else {\n        truncatedTables.add(rowChange.table);\n      }\n    }\n  }\n\n  const end = performance.now();\n  if (options.syncedRows) {\n    result.syncedRows = rowsByTable;\n    for (const table of truncatedTables) {\n      result.warnings.push(\n        `Only the first ${maxSyncedRowsPerTable} synced rows of \"${table}\" are included.`,\n      );\n    }\n  }\n  result.start = start;\n  result.end = end;\n  result.elapsed = end - start;\n\n  // Always include the count of synced and vended rows.\n  result.syncedRowCount = syncedRowCount;\n  result.readRowCountsByQuery = host.debug?.getVendedRowCounts() ?? {};\n  let readRowCount = 0;\n  for (const c of Object.values(result.readRowCountsByQuery)) {\n    for (const v of Object.values(c)) {\n      readRowCount += v;\n    }\n  }\n  result.readRowCount = readRowCount;\n  result.dbScansByQuery = host.debug?.getNVisitCounts() ?? {};\n  result.sqlitePlans = host.debug?.getSQLitePlans() ?? {};\n\n  if (options.vendedRows) {\n    const readRows = host.debug?.getVendedRows();\n    result.readRows = readRows;\n    for (const [table, byQuery] of Object.entries(readRows ?? {})) {\n      for (const [query, rows] of Object.entries(byQuery)) {\n        if ((result.readRowCountsByQuery[table]?.[query] ?? 0) > rows.length) {\n          result.warnings.push(\n            `Only the first ${rows.length} read rows of \"${table}\" are included for: ${query}`,\n          );\n        }\n      }\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}
+{"version":3,"file":"run-ast.js","names":[],"sources":["../../../../../zero-cache/src/services/run-ast.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\n// @circular-dep-ignore\nimport {astToZQL} from '../../../ast-to-zql/src/ast-to-zql.ts';\n// @circular-dep-ignore\nimport {formatOutput} from '../../../ast-to-zql/src/format.ts';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {sleep} from '../../../shared/src/sleep.ts';\nimport type {AnalyzeQueryResult} from '../../../zero-protocol/src/analyze-query-result.ts';\nimport type {AST, LiteralValue} from '../../../zero-protocol/src/ast.ts';\nimport {mapAST} from '../../../zero-protocol/src/ast.ts';\nimport type {ClientSchema} from '../../../zero-protocol/src/client-schema.ts';\nimport type {Row} from '../../../zero-protocol/src/data.ts';\nimport {hashOfAST} from '../../../zero-protocol/src/query-hash.ts';\nimport type {PermissionsConfig} from '../../../zero-schema/src/compiled-permissions.ts';\nimport type {NameMapper} from '../../../zero-schema/src/name-mapper.ts';\nimport {\n  buildPipeline,\n  type BuilderDelegate,\n} from '../../../zql/src/builder/builder.ts';\nimport {ChangeType} from '../../../zql/src/ivm/change-type.ts';\nimport type {Input} from '../../../zql/src/ivm/operator.ts';\nimport type {ConnectionCostModel} from '../../../zql/src/planner/planner-connection.ts';\nimport type {PlanDebugger} from '../../../zql/src/planner/planner-debug.ts';\nimport type {Database} from '../../../zqlite/src/db.ts';\nimport {resolveSimpleScalarSubqueries} from '../../../zqlite/src/resolve-scalar-subqueries.ts';\nimport type {JWTAuth} from '../auth/auth.ts';\nimport {transformAndHashQuery} from '../auth/read-authorizer.ts';\nimport {computeZqlSpecs} from '../db/lite-tables.ts';\nimport type {LiteAndZqlSpec} from '../db/specs.ts';\nimport {\n  fetchScalarValue,\n  hydrate,\n  type RowChange,\n} from './view-syncer/pipeline-driver.ts';\n\n/**\n * Maximum number of synced rows returned per table, and read rows returned\n * per table/query, when analyzing a query in zero-cache. Rows past this are\n * still counted. Keeping every row can exhaust the heap when analyzing queries\n * over large tables.\n */\nexport const MAX_ANALYZE_ROWS = 1000;\n\nexport type RunAstOptions = {\n  applyPermissions?: boolean | undefined;\n  auth?: JWTAuth | undefined;\n  clientToServerMapper?: NameMapper | undefined;\n  costModel?: ConnectionCostModel | undefined;\n  db: Database;\n  host: BuilderDelegate;\n  /**\n   * Maximum number of synced rows returned per table. Rows past this are still\n   * counted. Defaults to no limit.\n   */\n  maxSyncedRowsPerTable?: number | undefined;\n  permissions?: PermissionsConfig | undefined;\n  planDebugger?: PlanDebugger | undefined;\n  syncedRows?: boolean | undefined;\n  tableSpecs: Map<string, LiteAndZqlSpec>;\n  vendedRows?: boolean | undefined;\n};\n\nexport async function runAst(\n  lc: LogContext,\n  clientSchema: ClientSchema,\n  ast: AST,\n  isTransformed: boolean,\n  options: RunAstOptions,\n  yieldProcess: () => Promise<void>,\n): Promise<AnalyzeQueryResult> {\n  const {\n    clientToServerMapper,\n    permissions,\n    host,\n    db,\n    maxSyncedRowsPerTable = Infinity,\n  } = options;\n  const result: AnalyzeQueryResult = {\n    warnings: [],\n    syncedRows: undefined,\n    syncedRowCount: 0,\n    start: 0,\n    end: 0,\n    elapsed: 0,\n    afterPermissions: undefined,\n    readRows: undefined,\n    readRowCountsByQuery: {},\n    readRowCount: undefined,\n  };\n\n  if (!isTransformed) {\n    // map the AST to server names if not already transformed\n    ast = mapAST(ast, must(clientToServerMapper));\n  }\n  if (options.applyPermissions) {\n    const auth = options.auth;\n    if (!auth) {\n      result.warnings.push(\n        'No auth data provided. Permission rules will compare to `NULL` wherever an auth data field is referenced.',\n      );\n    }\n    ast = transformAndHashQuery(\n      lc,\n      'clientGroupIDForAnalyze',\n      ast,\n      must(permissions),\n      auth,\n      false,\n    ).transformedAst;\n    result.afterPermissions = await formatOutput(ast.table + astToZQL(ast));\n  }\n\n  const hash = hashOfAST(ast);\n  const zqlSpecs = computeZqlSpecs(lc, db, {includeBackfillingColumns: false});\n\n  // Resolve scalar subqueries (e.g. whereExists with {scalar: true}) to\n  // literal equality conditions so that SQLite can use indexes effectively.\n  // Without this, correlated subqueries get stripped from SQL filters and\n  // queries on large tables fall back to full table scans.\n  // As in zero-cache, the rows the client reads for the gates are synced too,\n  // so the gates' pipelines are kept to be hydrated after the query's.\n  const companionInputs: Input[] = [];\n  const executor = (\n    subqueryAST: AST,\n    childField: string,\n  ): LiteralValue | null | undefined => {\n    const input = buildPipeline(subqueryAST, host, 'scalar-subquery');\n    companionInputs.push(input);\n    return fetchScalarValue(input, childField);\n  };\n\n  const {\n    ast: resolvedAst,\n    companions,\n    ignoredScalarHints,\n  } = resolveSimpleScalarSubqueries(ast, options.tableSpecs, executor);\n  for (const {table, uniqueKeys} of ignoredScalarHints) {\n    lc.warn?.(\n      `Ignoring {scalar: true} on the \"${table}\" subquery: it does not ` +\n        `constrain every column of any unique key ` +\n        `[${uniqueKeys.map(k => `(${k.join(', ')})`).join(', ')}] to a ` +\n        `literal with \"=\", so it is not provably limited to one row. ` +\n        `The gate runs as a plain EXISTS.`,\n    );\n  }\n\n  const pipeline = buildPipeline(\n    resolvedAst,\n    host,\n    'query-id',\n    options.costModel,\n    lc,\n    options.planDebugger,\n  );\n\n  // As in zero-cache, the rows of the gates follow the rows of the query,\n  // except for gates from a permission rule: rows read for a rule are never\n  // synced.\n  const syncedCompanionInputs = companionInputs.filter(\n    (_, i) => companions[i].system !== 'permissions',\n  );\n  function* rowChanges(): Iterable<RowChange | 'yield'> {\n    try {\n      for (const input of [pipeline, ...syncedCompanionInputs]) {\n        yield* hydrate(input, hash, clientSchema, zqlSpecs);\n      }\n    } finally {\n      for (const input of companionInputs) {\n        input.destroy();\n      }\n    }\n  }\n\n  const start = performance.now();\n\n  let syncedRowCount = 0;\n  const rowsByTable: Record<string, Row[]> = {};\n  // Dedupe on the row key rather than the whole row to bound memory.\n  const seen: Set<string> = new Set();\n  const truncatedTables: Set<string> = new Set();\n  for (const rowChange of rowChanges()) {\n    if (rowChange === 'yield') {\n      await yieldProcess();\n      continue;\n    }\n    assert(\n      rowChange.type === ChangeType.ADD,\n      'Hydration only handles add row changes',\n    );\n\n    // yield to other tasks to avoid blocking for too long\n    if (syncedRowCount % 10 === 0) {\n      await Promise.resolve();\n    }\n    if (syncedRowCount % 100 === 0) {\n      await sleep(1);\n    }\n\n    const key = JSON.stringify([rowChange.table, rowChange.rowKey]);\n    if (seen.has(key)) {\n      continue; // skip duplicates\n    }\n    syncedRowCount++;\n    seen.add(key);\n    if (options.syncedRows) {\n      const rows = (rowsByTable[rowChange.table] ??= []);\n      if (rows.length < maxSyncedRowsPerTable) {\n        rows.push(rowChange.row);\n      } else {\n        truncatedTables.add(rowChange.table);\n      }\n    }\n  }\n\n  const end = performance.now();\n  if (options.syncedRows) {\n    result.syncedRows = rowsByTable;\n    for (const table of truncatedTables) {\n      result.warnings.push(\n        `Only the first ${maxSyncedRowsPerTable} synced rows of \"${table}\" are included.`,\n      );\n    }\n  }\n  result.start = start;\n  result.end = end;\n  result.elapsed = end - start;\n\n  // Always include the count of synced and vended rows.\n  result.syncedRowCount = syncedRowCount;\n  result.readRowCountsByQuery = host.debug?.getVendedRowCounts() ?? {};\n  let readRowCount = 0;\n  for (const c of Object.values(result.readRowCountsByQuery)) {\n    for (const v of Object.values(c)) {\n      readRowCount += v;\n    }\n  }\n  result.readRowCount = readRowCount;\n  result.dbScansByQuery = host.debug?.getNVisitCounts() ?? {};\n  result.sqlitePlans = host.debug?.getSQLitePlans() ?? {};\n\n  if (options.vendedRows) {\n    const readRows = host.debug?.getVendedRows();\n    result.readRows = readRows;\n    for (const [table, byQuery] of Object.entries(readRows ?? {})) {\n      for (const [query, rows] of Object.entries(byQuery)) {\n        if ((result.readRowCountsByQuery[table]?.[query] ?? 0) > rows.length) {\n          result.warnings.push(\n            `Only the first ${rows.length} read rows of \"${table}\" are included for: ${query}`,\n          );\n        }\n      }\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}

package/out/zero-cache/src/services/runner.js.map

@@ -1 +1 @@
-{"version":3,"file":"runner.js","names":["#lc","#instances","#create","#isValid","#onStop"],"sources":["../../../../../zero-cache/src/services/runner.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Service} from './service.ts';\n\n/**\n * Manages the creation and lifecycle of objects that implement\n * {@link Service}.\n */\nexport class ServiceRunner<S extends Service> {\n  readonly #lc: LogContext;\n  readonly #instances = new Map<string, S>();\n  readonly #create: (id: string) => S;\n  readonly #isValid: (existing: S) => boolean;\n  readonly #onStop?: ((id: string) => void) | undefined;\n\n  constructor(\n    lc: LogContext,\n    factory: (id: string) => S,\n    isValid: (existing: S) => boolean = () => true,\n    onStop?: ((id: string) => void) | undefined,\n  ) {\n    this.#lc = lc;\n    this.#create = factory;\n    this.#isValid = isValid;\n    this.#onStop = onStop;\n  }\n\n  /**\n   * Creates and runs the Service with the given `id`, returning\n   * an existing one if it is still running a valid.\n   */\n  getService(id: string): S {\n    const existing = this.#instances.get(id);\n    if (existing && this.#isValid(existing)) {\n      return existing;\n    }\n    const service = this.#create(id);\n    this.#instances.set(id, service);\n    void service\n      .run()\n      .catch(e =>\n        this.#lc.error?.(\n          `Error running ${service.constructor?.name} ${service.id}`,\n          e,\n        ),\n      )\n      .finally(() => {\n        // Only remove the instance that just finished. If it was already\n        // replaced (e.g. because it became invalid and a new instance was\n        // created under the same id while it was still shutting down), the\n        // replacement must stay tracked; otherwise the next getService()\n        // would spawn a duplicate and the untracked one would never be\n        // stopped by this runner.\n        if (this.#instances.get(id) === service) {\n          this.#instances.delete(id);\n          this.#onStop?.(id);\n        }\n      });\n    return service;\n  }\n\n  hasService(id: string): boolean {\n    return this.#instances.has(id);\n  }\n\n  get size() {\n    return this.#instances.size;\n  }\n\n  getServices(): Iterable<S> {\n    return this.#instances.values();\n  }\n}\n"],"mappings":";;;;;AAOA,IAAa,gBAAb,MAA8C;CAC5C;CACA,6BAAsB,IAAI,IAAe;CACzC;CACA;CACA;CAEA,YACE,IACA,SACA,gBAA0C,MAC1C,QACA;EACA,KAAKA,MAAM;EACX,KAAKE,UAAU;EACf,KAAKC,WAAW;EAChB,KAAKC,UAAU;CACjB;;;;;CAMA,WAAW,IAAe;EACxB,MAAM,WAAW,KAAKH,WAAW,IAAI,EAAE;EACvC,IAAI,YAAY,KAAKE,SAAS,QAAQ,GACpC,OAAO;EAET,MAAM,UAAU,KAAKD,QAAQ,EAAE;EAC/B,KAAKD,WAAW,IAAI,IAAI,OAAO;EAC/B,QACG,IAAI,EACJ,OAAM,MACL,KAAKD,IAAI,QACP,iBAAiB,QAAQ,aAAa,KAAK,GAAG,QAAQ,MACtD,CACF,CACF,EACC,cAAc;GAOb,IAAI,KAAKC,WAAW,IAAI,EAAE,MAAM,SAAS;IACvC,KAAKA,WAAW,OAAO,EAAE;IACzB,KAAKG,UAAU,EAAE;GACnB;EACF,CAAC;EACH,OAAO;CACT;CAEA,WAAW,IAAqB;EAC9B,OAAO,KAAKH,WAAW,IAAI,EAAE;CAC/B;CAEA,IAAI,OAAO;EACT,OAAO,KAAKA,WAAW;CACzB;CAEA,cAA2B;EACzB,OAAO,KAAKA,WAAW,OAAO;CAChC;AACF"}
+{"version":3,"file":"runner.js","names":[],"sources":["../../../../../zero-cache/src/services/runner.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport type {Service} from './service.ts';\n\n/**\n * Manages the creation and lifecycle of objects that implement\n * {@link Service}.\n */\nexport class ServiceRunner<S extends Service> {\n  readonly #lc: LogContext;\n  readonly #instances = new Map<string, S>();\n  readonly #create: (id: string) => S;\n  readonly #isValid: (existing: S) => boolean;\n  readonly #onStop?: ((id: string) => void) | undefined;\n\n  constructor(\n    lc: LogContext,\n    factory: (id: string) => S,\n    isValid: (existing: S) => boolean = () => true,\n    onStop?: ((id: string) => void) | undefined,\n  ) {\n    this.#lc = lc;\n    this.#create = factory;\n    this.#isValid = isValid;\n    this.#onStop = onStop;\n  }\n\n  /**\n   * Creates and runs the Service with the given `id`, returning\n   * an existing one if it is still running a valid.\n   */\n  getService(id: string): S {\n    const existing = this.#instances.get(id);\n    if (existing && this.#isValid(existing)) {\n      return existing;\n    }\n    const service = this.#create(id);\n    this.#instances.set(id, service);\n    void service\n      .run()\n      .catch(e =>\n        this.#lc.error?.(\n          `Error running ${service.constructor?.name} ${service.id}`,\n          e,\n        ),\n      )\n      .finally(() => {\n        // Only remove the instance that just finished. If it was already\n        // replaced (e.g. because it became invalid and a new instance was\n        // created under the same id while it was still shutting down), the\n        // replacement must stay tracked; otherwise the next getService()\n        // would spawn a duplicate and the untracked one would never be\n        // stopped by this runner.\n        if (this.#instances.get(id) === service) {\n          this.#instances.delete(id);\n          this.#onStop?.(id);\n        }\n      });\n    return service;\n  }\n\n  hasService(id: string): boolean {\n    return this.#instances.has(id);\n  }\n\n  get size() {\n    return this.#instances.size;\n  }\n\n  getServices(): Iterable<S> {\n    return this.#instances.values();\n  }\n}\n"],"mappings":";;;;;AAOA,IAAa,gBAAb,MAA8C;CAC5C;CACA,6BAAsB,IAAI,IAAe;CACzC;CACA;CACA;CAEA,YACE,IACA,SACA,gBAA0C,MAC1C,QACA;EACA,KAAK,MAAM;EACX,KAAK,UAAU;EACf,KAAK,WAAW;EAChB,KAAK,UAAU;CACjB;;;;;CAMA,WAAW,IAAe;EACxB,MAAM,WAAW,KAAK,WAAW,IAAI,EAAE;EACvC,IAAI,YAAY,KAAK,SAAS,QAAQ,GACpC,OAAO;EAET,MAAM,UAAU,KAAK,QAAQ,EAAE;EAC/B,KAAK,WAAW,IAAI,IAAI,OAAO;EAC/B,QACG,IAAI,CAAC,CACL,OAAM,MACL,KAAK,IAAI,QACP,iBAAiB,QAAQ,aAAa,KAAK,GAAG,QAAQ,MACtD,CACF,CACF,CAAC,CACA,cAAc;GAOb,IAAI,KAAK,WAAW,IAAI,EAAE,MAAM,SAAS;IACvC,KAAK,WAAW,OAAO,EAAE;IACzB,KAAK,UAAU,EAAE;GACnB;EACF,CAAC;EACH,OAAO;CACT;CAEA,WAAW,IAAqB;EAC9B,OAAO,KAAK,WAAW,IAAI,EAAE;CAC/B;CAEA,IAAI,OAAO;EACT,OAAO,KAAK,WAAW;CACzB;CAEA,cAA2B;EACzB,OAAO,KAAK,WAAW,OAAO;CAChC;AACF"}

package/out/zero-cache/src/services/running-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"running-state.js","names":["#serviceName","#controller","#sleep","#setTimeout","#stopped","#initialRetryDelay","#maxRetryDelay","#pendingTimeouts","#retryDelay"],"sources":["../../../../../zero-cache/src/services/running-state.ts"],"sourcesContent":["import {PG_UNDEFINED_TABLE} from '@drdgvhbh/postgres-error-codes';\nimport type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../../shared/src/abort-error.ts';\nimport {sleepWithAbort} from '../../../shared/src/sleep.ts';\nimport {isPostgresError} from '../types/pg.ts';\n\nconst DEFAULT_INITIAL_RETRY_DELAY_MS = 25;\nexport const DEFAULT_MAX_RETRY_DELAY_MS = 10000;\n\nexport type RetryConfig = {\n  initialRetryDelay?: number;\n  maxRetryDelay?: number;\n};\n\nexport interface Cancelable {\n  cancel(): void;\n}\n\nexport type UnregisterFn = () => void;\n\n/**\n * Facilitates lifecycle control with exponential backoff.\n */\nexport class RunningState {\n  readonly #serviceName: string;\n  readonly #controller: AbortController;\n  readonly #sleep: typeof sleepWithAbort;\n  readonly #setTimeout: typeof setTimeout;\n  readonly #stopped: Promise<void>;\n\n  readonly #initialRetryDelay: number;\n  readonly #maxRetryDelay: number;\n  readonly #pendingTimeouts = new Set<NodeJS.Timeout>();\n  #retryDelay: number;\n\n  constructor(\n    serviceName: string,\n    retryConfig?: RetryConfig,\n    setTimeoutFn = setTimeout,\n    sleeper = sleepWithAbort,\n  ) {\n    const {\n      initialRetryDelay = DEFAULT_INITIAL_RETRY_DELAY_MS,\n      maxRetryDelay = DEFAULT_MAX_RETRY_DELAY_MS,\n    } = retryConfig ?? {};\n\n    this.#serviceName = serviceName;\n    this.#initialRetryDelay = initialRetryDelay;\n    this.#maxRetryDelay = maxRetryDelay;\n    this.#retryDelay = initialRetryDelay;\n\n    this.#controller = new AbortController();\n    this.#sleep = sleeper;\n    this.#setTimeout = setTimeoutFn;\n\n    const {promise, resolve} = resolver();\n    this.#stopped = promise;\n    this.#controller.signal.addEventListener(\n      'abort',\n      () => {\n        resolve();\n        for (const timeout of this.#pendingTimeouts) {\n          clearTimeout(timeout);\n        }\n        this.#pendingTimeouts.clear();\n      },\n      {once: true},\n    );\n  }\n\n  get signal(): AbortSignal {\n    return this.#controller.signal;\n  }\n\n  get retryDelay() {\n    return this.#retryDelay;\n  }\n\n  /**\n   * Returns `true` until {@link stop()} has been called.\n   *\n   * This is usually called as part of the service's main loop\n   * conditional to determine if the next iteration should execute.\n   */\n  shouldRun(): boolean {\n    return !this.#controller.signal.aborted;\n  }\n\n  /**\n   * Registers a Cancelable object to be invoked when {@link stop()} is called.\n   * Returns a method to unregister the object.\n   */\n  cancelOnStop(c: Cancelable): UnregisterFn {\n    const onStop = () => c.cancel();\n    this.#controller.signal.addEventListener('abort', onStop, {once: true});\n    return () => this.#controller.signal.removeEventListener('abort', onStop);\n  }\n\n  /**\n   * Sets a Timeout that is automatically cancelled if the service is cancelled.\n   */\n  setTimeout<TArgs extends unknown[]>(\n    fn: (...args: TArgs) => void,\n    timeoutMs: number,\n    ...args: TArgs\n  ) {\n    const timeout = this.#setTimeout(() => {\n      clearTimeout(timeout);\n      this.#pendingTimeouts.delete(timeout);\n      return fn(...args);\n    }, timeoutMs);\n\n    this.#pendingTimeouts.add(timeout);\n    return timeout;\n  }\n\n  /**\n   * Returns a promise that resolves after `ms` milliseconds or when\n   * the service is stopped.\n   */\n  async sleep(ms: number): Promise<void> {\n    await Promise.race(this.#sleep(ms, this.#controller.signal));\n  }\n\n  /**\n   * Called to stop the service. After this is called, {@link shouldRun()}\n   * will return `false` and the {@link stopped()} Promise will be resolved.\n   */\n  stop(lc: LogContext, err?: unknown): void {\n    if (this.shouldRun()) {\n      const log = !err || err instanceof AbortError ? 'info' : 'error';\n      lc[log]?.(`stopping ${this.#serviceName}`, err ?? '');\n      this.#controller.abort();\n    }\n  }\n\n  /**\n   * Returns a Promise that resolves when {@link stop()} is called.\n   */\n  stopped(): Promise<void> {\n    return this.#stopped;\n  }\n\n  /**\n   * Call in response to an error or unexpected termination in the main\n   * loop of the service. The returned Promise will resolve after an\n   * exponential delay, or once {@link stop()} is called.\n   *\n   * If the supplied `err` is an `AbortError`, the service will shut down.\n   */\n  async backoff(lc: LogContext, err: unknown): Promise<void> {\n    const delay = this.#retryDelay;\n    this.#retryDelay = Math.min(delay * 2, this.#maxRetryDelay);\n\n    // Common failure mode when the user deletes a pg schema out from under\n    // us after init. Turn into an AbortError to force restart, which will\n    // restart and re-init the schema.\n    if (isPostgresError(err, PG_UNDEFINED_TABLE)) {\n      err = new AbortError('undefined table', {cause: err});\n    }\n\n    if (err instanceof AbortError || err instanceof UnrecoverableError) {\n      this.resetBackoff();\n      this.stop(lc, err);\n    } else if (this.shouldRun()) {\n      // Use delay-based log level: higher delay means more retries\n      const log: 'info' | 'warn' | 'error' =\n        delay < 1000 ? 'info' : delay < 6500 ? 'warn' : 'error';\n\n      lc[log]?.(`retrying ${this.#serviceName} in ${delay} ms`, err);\n      await this.sleep(delay);\n    }\n  }\n\n  /**\n   * When using {@link backoff()}, this method should be called when the\n   * implementation receives a healthy signal (e.g. a successful\n   * response). This resets the delay used in {@link backoff()}.\n   *\n   * @returns The previous backoff delay\n   */\n  resetBackoff() {\n    const prevDelay = this.#retryDelay;\n    this.#retryDelay = this.#initialRetryDelay;\n    return prevDelay;\n  }\n}\n\n/**\n * Superclass for Errors that should bypass exponential backoff\n * and immediately shut down the server.\n */\nexport class UnrecoverableError extends Error {\n  readonly name = 'UnrecoverableError';\n}\n"],"mappings":";;;;;;AAOA,IAAM,iCAAiC;AACvC,IAAa,6BAA6B;;;;AAgB1C,IAAa,eAAb,MAA0B;CACxB;CACA;CACA;CACA;CACA;CAEA;CACA;CACA,mCAA4B,IAAI,IAAoB;CACpD;CAEA,YACE,aACA,aACA,eAAe,YACf,UAAU,gBACV;EACA,MAAM,EACJ,oBAAoB,gCACpB,gBAAgB,+BACd,eAAe,CAAC;EAEpB,KAAKA,eAAe;EACpB,KAAKK,qBAAqB;EAC1B,KAAKC,iBAAiB;EACtB,KAAKE,cAAc;EAEnB,KAAKP,cAAc,IAAI,gBAAgB;EACvC,KAAKC,SAAS;EACd,KAAKC,cAAc;EAEnB,MAAM,EAAC,SAAS,YAAW,SAAS;EACpC,KAAKC,WAAW;EAChB,KAAKH,YAAY,OAAO,iBACtB,eACM;GACJ,QAAQ;GACR,KAAK,MAAM,WAAW,KAAKM,kBACzB,aAAa,OAAO;GAEtB,KAAKA,iBAAiB,MAAM;EAC9B,GACA,EAAC,MAAM,KAAI,CACb;CACF;CAEA,IAAI,SAAsB;EACxB,OAAO,KAAKN,YAAY;CAC1B;CAEA,IAAI,aAAa;EACf,OAAO,KAAKO;CACd;;;;;;;CAQA,YAAqB;EACnB,OAAO,CAAC,KAAKP,YAAY,OAAO;CAClC;;;;;CAMA,aAAa,GAA6B;EACxC,MAAM,eAAe,EAAE,OAAO;EAC9B,KAAKA,YAAY,OAAO,iBAAiB,SAAS,QAAQ,EAAC,MAAM,KAAI,CAAC;EACtE,aAAa,KAAKA,YAAY,OAAO,oBAAoB,SAAS,MAAM;CAC1E;;;;CAKA,WACE,IACA,WACA,GAAG,MACH;EACA,MAAM,UAAU,KAAKE,kBAAkB;GACrC,aAAa,OAAO;GACpB,KAAKI,iBAAiB,OAAO,OAAO;GACpC,OAAO,GAAG,GAAG,IAAI;EACnB,GAAG,SAAS;EAEZ,KAAKA,iBAAiB,IAAI,OAAO;EACjC,OAAO;CACT;;;;;CAMA,MAAM,MAAM,IAA2B;EACrC,MAAM,QAAQ,KAAK,KAAKL,OAAO,IAAI,KAAKD,YAAY,MAAM,CAAC;CAC7D;;;;;CAMA,KAAK,IAAgB,KAAqB;EACxC,IAAI,KAAK,UAAU,GAAG;GAEpB,GADY,CAAC,OAAO,eAAe,aAAa,SAAS,WAC/C,YAAY,KAAKD,gBAAgB,OAAO,EAAE;GACpD,KAAKC,YAAY,MAAM;EACzB;CACF;;;;CAKA,UAAyB;EACvB,OAAO,KAAKG;CACd;;;;;;;;CASA,MAAM,QAAQ,IAAgB,KAA6B;EACzD,MAAM,QAAQ,KAAKI;EACnB,KAAKA,cAAc,KAAK,IAAI,QAAQ,GAAG,KAAKF,cAAc;EAK1D,IAAI,gBAAgB,KAAK,kBAAkB,GACzC,MAAM,IAAI,WAAW,mBAAmB,EAAC,OAAO,IAAG,CAAC;EAGtD,IAAI,eAAe,cAAc,eAAe,oBAAoB;GAClE,KAAK,aAAa;GAClB,KAAK,KAAK,IAAI,GAAG;EACnB,OAAO,IAAI,KAAK,UAAU,GAAG;GAK3B,GAFE,QAAQ,MAAO,SAAS,QAAQ,OAAO,SAAS,WAExC,YAAY,KAAKN,aAAa,MAAM,MAAM,MAAM,GAAG;GAC7D,MAAM,KAAK,MAAM,KAAK;EACxB;CACF;;;;;;;;CASA,eAAe;EACb,MAAM,YAAY,KAAKQ;EACvB,KAAKA,cAAc,KAAKH;EACxB,OAAO;CACT;AACF;;;;;AAMA,IAAa,qBAAb,cAAwC,MAAM;CAC5C,OAAgB;AAClB"}
+{"version":3,"file":"running-state.js","names":[],"sources":["../../../../../zero-cache/src/services/running-state.ts"],"sourcesContent":["import {PG_UNDEFINED_TABLE} from '@drdgvhbh/postgres-error-codes';\nimport type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../../shared/src/abort-error.ts';\nimport {sleepWithAbort} from '../../../shared/src/sleep.ts';\nimport {isPostgresError} from '../types/pg.ts';\n\nconst DEFAULT_INITIAL_RETRY_DELAY_MS = 25;\nexport const DEFAULT_MAX_RETRY_DELAY_MS = 10000;\n\nexport type RetryConfig = {\n  initialRetryDelay?: number;\n  maxRetryDelay?: number;\n};\n\nexport interface Cancelable {\n  cancel(): void;\n}\n\nexport type UnregisterFn = () => void;\n\n/**\n * Facilitates lifecycle control with exponential backoff.\n */\nexport class RunningState {\n  readonly #serviceName: string;\n  readonly #controller: AbortController;\n  readonly #sleep: typeof sleepWithAbort;\n  readonly #setTimeout: typeof setTimeout;\n  readonly #stopped: Promise<void>;\n\n  readonly #initialRetryDelay: number;\n  readonly #maxRetryDelay: number;\n  readonly #pendingTimeouts = new Set<NodeJS.Timeout>();\n  #retryDelay: number;\n\n  constructor(\n    serviceName: string,\n    retryConfig?: RetryConfig,\n    setTimeoutFn = setTimeout,\n    sleeper = sleepWithAbort,\n  ) {\n    const {\n      initialRetryDelay = DEFAULT_INITIAL_RETRY_DELAY_MS,\n      maxRetryDelay = DEFAULT_MAX_RETRY_DELAY_MS,\n    } = retryConfig ?? {};\n\n    this.#serviceName = serviceName;\n    this.#initialRetryDelay = initialRetryDelay;\n    this.#maxRetryDelay = maxRetryDelay;\n    this.#retryDelay = initialRetryDelay;\n\n    this.#controller = new AbortController();\n    this.#sleep = sleeper;\n    this.#setTimeout = setTimeoutFn;\n\n    const {promise, resolve} = resolver();\n    this.#stopped = promise;\n    this.#controller.signal.addEventListener(\n      'abort',\n      () => {\n        resolve();\n        for (const timeout of this.#pendingTimeouts) {\n          clearTimeout(timeout);\n        }\n        this.#pendingTimeouts.clear();\n      },\n      {once: true},\n    );\n  }\n\n  get signal(): AbortSignal {\n    return this.#controller.signal;\n  }\n\n  get retryDelay() {\n    return this.#retryDelay;\n  }\n\n  /**\n   * Returns `true` until {@link stop()} has been called.\n   *\n   * This is usually called as part of the service's main loop\n   * conditional to determine if the next iteration should execute.\n   */\n  shouldRun(): boolean {\n    return !this.#controller.signal.aborted;\n  }\n\n  /**\n   * Registers a Cancelable object to be invoked when {@link stop()} is called.\n   * Returns a method to unregister the object.\n   */\n  cancelOnStop(c: Cancelable): UnregisterFn {\n    const onStop = () => c.cancel();\n    this.#controller.signal.addEventListener('abort', onStop, {once: true});\n    return () => this.#controller.signal.removeEventListener('abort', onStop);\n  }\n\n  /**\n   * Sets a Timeout that is automatically cancelled if the service is cancelled.\n   */\n  setTimeout<TArgs extends unknown[]>(\n    fn: (...args: TArgs) => void,\n    timeoutMs: number,\n    ...args: TArgs\n  ) {\n    const timeout = this.#setTimeout(() => {\n      clearTimeout(timeout);\n      this.#pendingTimeouts.delete(timeout);\n      return fn(...args);\n    }, timeoutMs);\n\n    this.#pendingTimeouts.add(timeout);\n    return timeout;\n  }\n\n  /**\n   * Returns a promise that resolves after `ms` milliseconds or when\n   * the service is stopped.\n   */\n  async sleep(ms: number): Promise<void> {\n    await Promise.race(this.#sleep(ms, this.#controller.signal));\n  }\n\n  /**\n   * Called to stop the service. After this is called, {@link shouldRun()}\n   * will return `false` and the {@link stopped()} Promise will be resolved.\n   */\n  stop(lc: LogContext, err?: unknown): void {\n    if (this.shouldRun()) {\n      const log = !err || err instanceof AbortError ? 'info' : 'error';\n      lc[log]?.(`stopping ${this.#serviceName}`, err ?? '');\n      this.#controller.abort();\n    }\n  }\n\n  /**\n   * Returns a Promise that resolves when {@link stop()} is called.\n   */\n  stopped(): Promise<void> {\n    return this.#stopped;\n  }\n\n  /**\n   * Call in response to an error or unexpected termination in the main\n   * loop of the service. The returned Promise will resolve after an\n   * exponential delay, or once {@link stop()} is called.\n   *\n   * If the supplied `err` is an `AbortError`, the service will shut down.\n   */\n  async backoff(lc: LogContext, err: unknown): Promise<void> {\n    const delay = this.#retryDelay;\n    this.#retryDelay = Math.min(delay * 2, this.#maxRetryDelay);\n\n    // Common failure mode when the user deletes a pg schema out from under\n    // us after init. Turn into an AbortError to force restart, which will\n    // restart and re-init the schema.\n    if (isPostgresError(err, PG_UNDEFINED_TABLE)) {\n      err = new AbortError('undefined table', {cause: err});\n    }\n\n    if (err instanceof AbortError || err instanceof UnrecoverableError) {\n      this.resetBackoff();\n      this.stop(lc, err);\n    } else if (this.shouldRun()) {\n      // Use delay-based log level: higher delay means more retries\n      const log: 'info' | 'warn' | 'error' =\n        delay < 1000 ? 'info' : delay < 6500 ? 'warn' : 'error';\n\n      lc[log]?.(`retrying ${this.#serviceName} in ${delay} ms`, err);\n      await this.sleep(delay);\n    }\n  }\n\n  /**\n   * When using {@link backoff()}, this method should be called when the\n   * implementation receives a healthy signal (e.g. a successful\n   * response). This resets the delay used in {@link backoff()}.\n   *\n   * @returns The previous backoff delay\n   */\n  resetBackoff() {\n    const prevDelay = this.#retryDelay;\n    this.#retryDelay = this.#initialRetryDelay;\n    return prevDelay;\n  }\n}\n\n/**\n * Superclass for Errors that should bypass exponential backoff\n * and immediately shut down the server.\n */\nexport class UnrecoverableError extends Error {\n  readonly name = 'UnrecoverableError';\n}\n"],"mappings":";;;;;;AAOA,IAAM,iCAAiC;AACvC,IAAa,6BAA6B;;;;AAgB1C,IAAa,eAAb,MAA0B;CACxB;CACA;CACA;CACA;CACA;CAEA;CACA;CACA,mCAA4B,IAAI,IAAoB;CACpD;CAEA,YACE,aACA,aACA,eAAe,YACf,UAAU,gBACV;EACA,MAAM,EACJ,oBAAoB,gCACpB,gBAAgB,+BACd,eAAe,CAAC;EAEpB,KAAK,eAAe;EACpB,KAAK,qBAAqB;EAC1B,KAAK,iBAAiB;EACtB,KAAK,cAAc;EAEnB,KAAK,cAAc,IAAI,gBAAgB;EACvC,KAAK,SAAS;EACd,KAAK,cAAc;EAEnB,MAAM,EAAC,SAAS,YAAW,SAAS;EACpC,KAAK,WAAW;EAChB,KAAK,YAAY,OAAO,iBACtB,eACM;GACJ,QAAQ;GACR,KAAK,MAAM,WAAW,KAAK,kBACzB,aAAa,OAAO;GAEtB,KAAK,iBAAiB,MAAM;EAC9B,GACA,EAAC,MAAM,KAAI,CACb;CACF;CAEA,IAAI,SAAsB;EACxB,OAAO,KAAK,YAAY;CAC1B;CAEA,IAAI,aAAa;EACf,OAAO,KAAK;CACd;;;;;;;CAQA,YAAqB;EACnB,OAAO,CAAC,KAAK,YAAY,OAAO;CAClC;;;;;CAMA,aAAa,GAA6B;EACxC,MAAM,eAAe,EAAE,OAAO;EAC9B,KAAK,YAAY,OAAO,iBAAiB,SAAS,QAAQ,EAAC,MAAM,KAAI,CAAC;EACtE,aAAa,KAAK,YAAY,OAAO,oBAAoB,SAAS,MAAM;CAC1E;;;;CAKA,WACE,IACA,WACA,GAAG,MACH;EACA,MAAM,UAAU,KAAK,kBAAkB;GACrC,aAAa,OAAO;GACpB,KAAK,iBAAiB,OAAO,OAAO;GACpC,OAAO,GAAG,GAAG,IAAI;EACnB,GAAG,SAAS;EAEZ,KAAK,iBAAiB,IAAI,OAAO;EACjC,OAAO;CACT;;;;;CAMA,MAAM,MAAM,IAA2B;EACrC,MAAM,QAAQ,KAAK,KAAK,OAAO,IAAI,KAAK,YAAY,MAAM,CAAC;CAC7D;;;;;CAMA,KAAK,IAAgB,KAAqB;EACxC,IAAI,KAAK,UAAU,GAAG;GAEpB,GADY,CAAC,OAAO,eAAe,aAAa,SAAS,QAClD,GAAG,YAAY,KAAK,gBAAgB,OAAO,EAAE;GACpD,KAAK,YAAY,MAAM;EACzB;CACF;;;;CAKA,UAAyB;EACvB,OAAO,KAAK;CACd;;;;;;;;CASA,MAAM,QAAQ,IAAgB,KAA6B;EACzD,MAAM,QAAQ,KAAK;EACnB,KAAK,cAAc,KAAK,IAAI,QAAQ,GAAG,KAAK,cAAc;EAK1D,IAAI,gBAAgB,KAAK,kBAAkB,GACzC,MAAM,IAAI,WAAW,mBAAmB,EAAC,OAAO,IAAG,CAAC;EAGtD,IAAI,eAAe,cAAc,eAAe,oBAAoB;GAClE,KAAK,aAAa;GAClB,KAAK,KAAK,IAAI,GAAG;EACnB,OAAO,IAAI,KAAK,UAAU,GAAG;GAK3B,GAFE,QAAQ,MAAO,SAAS,QAAQ,OAAO,SAAS,QAE3C,GAAG,YAAY,KAAK,aAAa,MAAM,MAAM,MAAM,GAAG;GAC7D,MAAM,KAAK,MAAM,KAAK;EACxB;CACF;;;;;;;;CASA,eAAe;EACb,MAAM,YAAY,KAAK;EACvB,KAAK,cAAc,KAAK;EACxB,OAAO;CACT;AACF;;;;;AAMA,IAAa,qBAAb,cAAwC,MAAM;CAC5C,OAAgB;AAClB"}

package/out/zero-cache/src/services/shadow-sync/shadow-sync-service.js.map

@@ -1 +1 @@
-{"version":3,"file":"shadow-sync-service.js","names":["#lc","#shard","#upstreamURI","#context","#options","#state"],"sources":["../../../../../../zero-cache/src/services/shadow-sync/shadow-sync-service.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport {\n  getOrCreateCounter,\n  getOrCreateLatencyHistogram,\n} from '../../observability/metrics.ts';\nimport type {ShardConfig} from '../../types/shards.ts';\nimport type {ServerContext} from '../change-source/pg/initial-sync.ts';\nimport {shadowInitialSync} from '../change-source/pg/initial-sync.ts';\nimport {RunningState} from '../running-state.ts';\nimport type {Service} from '../service.ts';\n\nfunction shadowSyncRuns() {\n  return getOrCreateCounter(\n    'replication',\n    'shadow-sync-runs',\n    'Number of shadow initial-sync runs, labeled by result.',\n  );\n}\n\nfunction shadowSyncDuration() {\n  return getOrCreateLatencyHistogram(\n    'replication',\n    'shadow-sync-duration',\n    'Wall-clock duration of a shadow initial-sync run, labeled by result.',\n  );\n}\n\nexport type ShadowSyncOptions = {\n  intervalMs: number;\n  sampleRate: number;\n  maxRowsPerTable: number;\n  textCopy?: boolean | undefined;\n};\n\nexport class ShadowSyncService implements Service {\n  readonly id = 'shadow-syncer';\n\n  readonly #lc: LogContext;\n  readonly #shard: ShardConfig;\n  readonly #upstreamURI: string;\n  readonly #context: ServerContext;\n  readonly #options: ShadowSyncOptions;\n  readonly #state = new RunningState('shadow-syncer');\n\n  constructor(\n    lc: LogContext,\n    shard: ShardConfig,\n    upstreamURI: string,\n    context: ServerContext,\n    options: ShadowSyncOptions,\n  ) {\n    this.#lc = lc;\n    this.#shard = shard;\n    this.#upstreamURI = upstreamURI;\n    this.#context = context;\n    this.#options = options;\n  }\n\n  async run() {\n    const {intervalMs, sampleRate, maxRowsPerTable, textCopy} = this.#options;\n\n    // Why: first run fires in [intervalMs * 2/3, intervalMs) — late enough\n    // that shadow sync never fires immediately on task startup, but always\n    // before one full interval elapses so the canary completes at least once\n    // per task lifetime (the replication manager is restarted every ~24h).\n    // The last third is randomized so a fleet-wide restart does not cause\n    // every task to canary simultaneously.\n    const minFirstRunDelay = Math.floor((intervalMs * 2) / 3);\n    const firstRunDelay =\n      minFirstRunDelay +\n      Math.floor(Math.random() * (intervalMs - minFirstRunDelay));\n    this.#lc.info?.(\n      `shadow-syncer started; first run in ${firstRunDelay} ms, then every ${intervalMs} ms`,\n    );\n    await this.#state.sleep(firstRunDelay);\n\n    while (this.#state.shouldRun()) {\n      const start = performance.now();\n      try {\n        await shadowInitialSync(\n          this.#lc,\n          this.#shard,\n          this.#upstreamURI,\n          {sampleRate, maxRowsPerTable},\n          this.#context,\n          textCopy !== undefined ? {textCopy} : undefined,\n        );\n        const elapsed = performance.now() - start;\n        shadowSyncRuns().add(1, {result: 'success'});\n        shadowSyncDuration().recordMs(elapsed, {result: 'success'});\n        this.#lc.info?.(\n          `shadow initial-sync completed (${elapsed.toFixed(0)} ms)`,\n        );\n      } catch (e) {\n        const elapsed = performance.now() - start;\n        shadowSyncRuns().add(1, {result: 'error'});\n        shadowSyncDuration().recordMs(elapsed, {result: 'error'});\n        this.#lc.error?.(\n          `shadow initial-sync failed after ${elapsed.toFixed(0)} ms`,\n          e,\n        );\n      }\n      await this.#state.sleep(intervalMs);\n    }\n  }\n\n  stop(): Promise<void> {\n    this.#state.stop(this.#lc);\n    return promiseVoid;\n  }\n}\n"],"mappings":";;;;;AAYA,SAAS,iBAAiB;CACxB,OAAO,mBACL,eACA,oBACA,wDACF;AACF;AAEA,SAAS,qBAAqB;CAC5B,OAAO,4BACL,eACA,wBACA,sEACF;AACF;AASA,IAAa,oBAAb,MAAkD;CAChD,KAAc;CAEd;CACA;CACA;CACA;CACA;CACA,SAAkB,IAAI,aAAa,eAAe;CAElD,YACE,IACA,OACA,aACA,SACA,SACA;EACA,KAAKA,MAAM;EACX,KAAKC,SAAS;EACd,KAAKC,eAAe;EACpB,KAAKC,WAAW;EAChB,KAAKC,WAAW;CAClB;CAEA,MAAM,MAAM;EACV,MAAM,EAAC,YAAY,YAAY,iBAAiB,aAAY,KAAKA;EAQjE,MAAM,mBAAmB,KAAK,MAAO,aAAa,IAAK,CAAC;EACxD,MAAM,gBACJ,mBACA,KAAK,MAAM,KAAK,OAAO,KAAK,aAAa,iBAAiB;EAC5D,KAAKJ,IAAI,OACP,uCAAuC,cAAc,kBAAkB,WAAW,IACpF;EACA,MAAM,KAAKK,OAAO,MAAM,aAAa;EAErC,OAAO,KAAKA,OAAO,UAAU,GAAG;GAC9B,MAAM,QAAQ,YAAY,IAAI;GAC9B,IAAI;IACF,MAAM,kBACJ,KAAKL,KACL,KAAKC,QACL,KAAKC,cACL;KAAC;KAAY;IAAe,GAC5B,KAAKC,UACL,aAAa,KAAA,IAAY,EAAC,SAAQ,IAAI,KAAA,CACxC;IACA,MAAM,UAAU,YAAY,IAAI,IAAI;IACpC,eAAe,EAAE,IAAI,GAAG,EAAC,QAAQ,UAAS,CAAC;IAC3C,mBAAmB,EAAE,SAAS,SAAS,EAAC,QAAQ,UAAS,CAAC;IAC1D,KAAKH,IAAI,OACP,kCAAkC,QAAQ,QAAQ,CAAC,EAAE,KACvD;GACF,SAAS,GAAG;IACV,MAAM,UAAU,YAAY,IAAI,IAAI;IACpC,eAAe,EAAE,IAAI,GAAG,EAAC,QAAQ,QAAO,CAAC;IACzC,mBAAmB,EAAE,SAAS,SAAS,EAAC,QAAQ,QAAO,CAAC;IACxD,KAAKA,IAAI,QACP,oCAAoC,QAAQ,QAAQ,CAAC,EAAE,MACvD,CACF;GACF;GACA,MAAM,KAAKK,OAAO,MAAM,UAAU;EACpC;CACF;CAEA,OAAsB;EACpB,KAAKA,OAAO,KAAK,KAAKL,GAAG;EACzB,OAAO;CACT;AACF"}
+{"version":3,"file":"shadow-sync-service.js","names":[],"sources":["../../../../../../zero-cache/src/services/shadow-sync/shadow-sync-service.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {promiseVoid} from '../../../../shared/src/resolved-promises.ts';\nimport {\n  getOrCreateCounter,\n  getOrCreateLatencyHistogram,\n} from '../../observability/metrics.ts';\nimport type {ShardConfig} from '../../types/shards.ts';\nimport type {ServerContext} from '../change-source/pg/initial-sync.ts';\nimport {shadowInitialSync} from '../change-source/pg/initial-sync.ts';\nimport {RunningState} from '../running-state.ts';\nimport type {Service} from '../service.ts';\n\nfunction shadowSyncRuns() {\n  return getOrCreateCounter(\n    'replication',\n    'shadow-sync-runs',\n    'Number of shadow initial-sync runs, labeled by result.',\n  );\n}\n\nfunction shadowSyncDuration() {\n  return getOrCreateLatencyHistogram(\n    'replication',\n    'shadow-sync-duration',\n    'Wall-clock duration of a shadow initial-sync run, labeled by result.',\n  );\n}\n\nexport type ShadowSyncOptions = {\n  intervalMs: number;\n  sampleRate: number;\n  maxRowsPerTable: number;\n  textCopy?: boolean | undefined;\n};\n\nexport class ShadowSyncService implements Service {\n  readonly id = 'shadow-syncer';\n\n  readonly #lc: LogContext;\n  readonly #shard: ShardConfig;\n  readonly #upstreamURI: string;\n  readonly #context: ServerContext;\n  readonly #options: ShadowSyncOptions;\n  readonly #state = new RunningState('shadow-syncer');\n\n  constructor(\n    lc: LogContext,\n    shard: ShardConfig,\n    upstreamURI: string,\n    context: ServerContext,\n    options: ShadowSyncOptions,\n  ) {\n    this.#lc = lc;\n    this.#shard = shard;\n    this.#upstreamURI = upstreamURI;\n    this.#context = context;\n    this.#options = options;\n  }\n\n  async run() {\n    const {intervalMs, sampleRate, maxRowsPerTable, textCopy} = this.#options;\n\n    // Why: first run fires in [intervalMs * 2/3, intervalMs) — late enough\n    // that shadow sync never fires immediately on task startup, but always\n    // before one full interval elapses so the canary completes at least once\n    // per task lifetime (the replication manager is restarted every ~24h).\n    // The last third is randomized so a fleet-wide restart does not cause\n    // every task to canary simultaneously.\n    const minFirstRunDelay = Math.floor((intervalMs * 2) / 3);\n    const firstRunDelay =\n      minFirstRunDelay +\n      Math.floor(Math.random() * (intervalMs - minFirstRunDelay));\n    this.#lc.info?.(\n      `shadow-syncer started; first run in ${firstRunDelay} ms, then every ${intervalMs} ms`,\n    );\n    await this.#state.sleep(firstRunDelay);\n\n    while (this.#state.shouldRun()) {\n      const start = performance.now();\n      try {\n        await shadowInitialSync(\n          this.#lc,\n          this.#shard,\n          this.#upstreamURI,\n          {sampleRate, maxRowsPerTable},\n          this.#context,\n          textCopy !== undefined ? {textCopy} : undefined,\n        );\n        const elapsed = performance.now() - start;\n        shadowSyncRuns().add(1, {result: 'success'});\n        shadowSyncDuration().recordMs(elapsed, {result: 'success'});\n        this.#lc.info?.(\n          `shadow initial-sync completed (${elapsed.toFixed(0)} ms)`,\n        );\n      } catch (e) {\n        const elapsed = performance.now() - start;\n        shadowSyncRuns().add(1, {result: 'error'});\n        shadowSyncDuration().recordMs(elapsed, {result: 'error'});\n        this.#lc.error?.(\n          `shadow initial-sync failed after ${elapsed.toFixed(0)} ms`,\n          e,\n        );\n      }\n      await this.#state.sleep(intervalMs);\n    }\n  }\n\n  stop(): Promise<void> {\n    this.#state.stop(this.#lc);\n    return promiseVoid;\n  }\n}\n"],"mappings":";;;;;AAYA,SAAS,iBAAiB;CACxB,OAAO,mBACL,eACA,oBACA,wDACF;AACF;AAEA,SAAS,qBAAqB;CAC5B,OAAO,4BACL,eACA,wBACA,sEACF;AACF;AASA,IAAa,oBAAb,MAAkD;CAChD,KAAc;CAEd;CACA;CACA;CACA;CACA;CACA,SAAkB,IAAI,aAAa,eAAe;CAElD,YACE,IACA,OACA,aACA,SACA,SACA;EACA,KAAK,MAAM;EACX,KAAK,SAAS;EACd,KAAK,eAAe;EACpB,KAAK,WAAW;EAChB,KAAK,WAAW;CAClB;CAEA,MAAM,MAAM;EACV,MAAM,EAAC,YAAY,YAAY,iBAAiB,aAAY,KAAK;EAQjE,MAAM,mBAAmB,KAAK,MAAO,aAAa,IAAK,CAAC;EACxD,MAAM,gBACJ,mBACA,KAAK,MAAM,KAAK,OAAO,KAAK,aAAa,iBAAiB;EAC5D,KAAK,IAAI,OACP,uCAAuC,cAAc,kBAAkB,WAAW,IACpF;EACA,MAAM,KAAK,OAAO,MAAM,aAAa;EAErC,OAAO,KAAK,OAAO,UAAU,GAAG;GAC9B,MAAM,QAAQ,YAAY,IAAI;GAC9B,IAAI;IACF,MAAM,kBACJ,KAAK,KACL,KAAK,QACL,KAAK,cACL;KAAC;KAAY;IAAe,GAC5B,KAAK,UACL,aAAa,KAAA,IAAY,EAAC,SAAQ,IAAI,KAAA,CACxC;IACA,MAAM,UAAU,YAAY,IAAI,IAAI;IACpC,eAAe,CAAC,CAAC,IAAI,GAAG,EAAC,QAAQ,UAAS,CAAC;IAC3C,mBAAmB,CAAC,CAAC,SAAS,SAAS,EAAC,QAAQ,UAAS,CAAC;IAC1D,KAAK,IAAI,OACP,kCAAkC,QAAQ,QAAQ,CAAC,EAAE,KACvD;GACF,SAAS,GAAG;IACV,MAAM,UAAU,YAAY,IAAI,IAAI;IACpC,eAAe,CAAC,CAAC,IAAI,GAAG,EAAC,QAAQ,QAAO,CAAC;IACzC,mBAAmB,CAAC,CAAC,SAAS,SAAS,EAAC,QAAQ,QAAO,CAAC;IACxD,KAAK,IAAI,QACP,oCAAoC,QAAQ,QAAQ,CAAC,EAAE,MACvD,CACF;GACF;GACA,MAAM,KAAK,OAAO,MAAM,UAAU;EACpC;CACF;CAEA,OAAsB;EACpB,KAAK,OAAO,KAAK,KAAK,GAAG;EACzB,OAAO;CACT;AACF"}

package/out/zero-cache/src/services/statz.js

@@ -2,9 +2,9 @@ import { BigIntJSON } from "../../../shared/src/bigint-json.js";
 import { getShardID, upstreamSchema } from "../types/shards.js";
 import { getOperatorAccess } from "../config/zero-config.js";
 import { Database } from "../../../zqlite/src/db.js";
-import { getReplicationState } from "./replicator/schema/replication-state.js";
-import { StatementRunner } from "../db/statements.js";
 import { pgClient } from "../types/pg.js";
+import { StatementRunner } from "../db/statements.js";
+import { getReplicationState } from "./replicator/schema/replication-state.js";
 import { fromStateVersionString } from "./change-source/pg/lsn.js";
 import os from "os";
 import fs from "fs";
@@ -221,7 +221,8 @@ function printStats(group, statsObject) {
 * * `pretty`: formats the JSON object with indentation
 */
 async function handleStatzRequest(lc, config, req, res) {
-	if (getOperatorAccess(lc, config, auth(req)?.pass) === void 0) {
+	const credentials = auth(req);
+	if (getOperatorAccess(lc, config, credentials?.pass) === void 0) {
 		res.code(401).header("WWW-Authenticate", "Basic realm=\"Statz Protected Area\"").send("Unauthorized");
 		return;
 	}