@rocicorp/zero 0.26.1-canary.9 → 0.26.1

package/out/zero-cache/src/services/view-syncer/snapshotter.js

@@ -253,6 +253,10 @@ class Diff {
               throw new Error(`change for unknown table ${table}`);
             }
             const { tableSpec, zqlSpec } = specs;
+            assert(
+              (tableSpec.minRowVersion ?? "") < stateVersion,
+              () => `unexpected change @${stateVersion} for table ${table} with minRowVersion ${tableSpec.minRowVersion}: ${op}(${rowKey})`
+            );
             assert(rowKey !== null, "rowKey must be present for row changes");
             const nextValue = op === SET_OP ? this.curr.getRow(tableSpec, rowKey) : null;
             let prevValues;

package/out/zero-cache/src/services/view-syncer/snapshotter.js.map

@@ -1 +1 @@
-{"version":3,"file":"snapshotter.js","sources":["../../../../../../zero-cache/src/services/view-syncer/snapshotter.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport {stringify, type JSONValue} from '../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../shared/src/valita.ts';\nimport type {Row} from '../../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../../zero-types/src/schema.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {fromSQLiteTypes} from '../../../../zqlite/src/table-source.ts';\nimport type {LiteAndZqlSpec, LiteTableSpecWithKeys} from '../../db/specs.ts';\nimport {StatementRunner} from '../../db/statements.ts';\nimport {\n  normalizedKeyOrder,\n  type RowKey,\n  type RowValue,\n} from '../../types/row-key.ts';\nimport type {AppID} from '../../types/shards.ts';\nimport {id} from '../../types/sql.ts';\nimport {\n  RESET_OP,\n  changeLogEntrySchema as schema,\n  SET_OP,\n  TRUNCATE_OP,\n} from '../replicator/schema/change-log.ts';\nimport {\n  getReplicationState,\n  ZERO_VERSION_COLUMN_NAME as ROW_VERSION,\n} from '../replicator/schema/replication-state.ts';\n\n/**\n * A `Snapshotter` manages the progression of database snapshots for a\n * ViewSyncer.\n *\n * The Replicator and ViewSyncers operate on the same SQLite file, with the\n * Replicator being the sole writer to the database. The IVM logic in\n * ViewSyncers, however, rely on incrementally applying changes to the DB to\n * update the state of its pipelines.\n *\n * To avoid coupling the progress of the Replicator and all IVM pipelines on\n * each other, ViewSyncers operate on ephemeral forks of the database by holding\n * [concurrent](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md)\n * snapshots of the database and simulating (but ultimately rolling back)\n * mutations on these snapshots.\n *\n * Example:\n * 1. ViewSyncer takes `snapshot_a` at version `t1` of the database and\n *    hydrates its pipeline(s).\n * 2. Replicator applies a new transaction to the database and notifies\n *    subscribers.\n * 3. ViewSyncer takes `snapshot_b` at `t2`, and queries the `ChangeLog` at\n *    that snapshot for changes since `t1`.\n * 4. ViewSyncer applies those changes to `snapshot_a` for IVM, but does not\n *    commit them. (Recall that the Replicator is the sole writer to the db, so\n *    the ViewSyncer never commits any writes.)\n * 5. Replicator applies the next transaction and advances the database to `t3`.\n * 6. ViewSyncer rolls back `snapshot_a` and opens `snapshot_c` at `t3`, using\n *    `snapshot_b` to simulate changes from `t2` to `t3`.\n *\n * ```\n * Replicator:  t1 --------------> t2 --------------> t3 --------------->\n * ViewSyncer:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]\n * ```\n *\n * Note that the Replicator (and ViewSyncers) do not wait on the progress of\n * other ViewSyncers. If a ViewSyncer is busy hydrating at `t1`, the Replicator\n * and other ViewSyncers can progress through `t2`, `t3`, etc. independently,\n * as the busy ViewSyncer simply takes its own snapshot when it is ready.\n *\n * ```\n * Replicator:   t1 --------------> t2 --------------> t3 --------------->\n * ViewSyncer1:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]\n * ViewSyncer2:       [.......... snapshot_a ..........] ----> [snapshot_b]\n * ```\n *\n * To minimize Database connections (and statement preparation, etc.), the\n * Snapshotter reuses the connection from the previous (rolled back)\n * snapshot when opening the new one.\n *\n * ```\n * Replicator:  t1 --------------> t2 --------------> t3 --------------->\n * ViewSyncer:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]\n *                     (conn_1)           (conn_2)           (conn_1)\n * ```\n *\n * In this manner, each ViewSyncer uses two connections that continually\n * \"leapfrog\" each other to replay the timeline of changes in isolation from\n * the Replicator and other ViewSyncers.\n */\nexport class Snapshotter {\n  readonly #lc: LogContext;\n  readonly #dbFile: string;\n  readonly #appID: string;\n  readonly #pageCacheSizeKib: number | undefined;\n  #curr: Snapshot | undefined;\n  #prev: Snapshot | undefined;\n\n  constructor(\n    lc: LogContext,\n    dbFile: string,\n    {appID}: AppID,\n    pageCacheSizeKib?: number | undefined,\n  ) {\n    this.#lc = lc;\n    this.#dbFile = dbFile;\n    this.#appID = appID;\n    this.#pageCacheSizeKib = pageCacheSizeKib;\n  }\n\n  /**\n   * Initializes the snapshot to the current head of the database. This must be\n   * only be called once. The state of whether a Snapshotter has been initialized\n   * can be determined by calling {@link initialized()}.\n   */\n  init(): this {\n    assert(this.#curr === undefined, 'Already initialized');\n    this.#curr = Snapshot.create(\n      this.#lc,\n      this.#dbFile,\n      this.#appID,\n      this.#pageCacheSizeKib,\n    );\n    this.#lc.debug?.(`Initial snapshot at version ${this.#curr.version}`);\n    return this;\n  }\n\n  initialized(): boolean {\n    return this.#curr !== undefined;\n  }\n\n  /** Returns the current snapshot. Asserts if {@link initialized()} is false. */\n  current(): Snapshot {\n    assert(this.#curr !== undefined, 'Snapshotter has not been initialized');\n    return this.#curr;\n  }\n\n  /**\n   * Advances to the head of the Database, returning a diff between the\n   * previously current Snapshot and a new Snapshot at head. This is called\n   * in response to a notification from a Replicator subscription. Subsequent\n   * calls to {@link current()} return the new Snapshot. Note that the Snapshotter\n   * must be initialized before advancing.\n   *\n   * The returned {@link SnapshotDiff} contains snapshots at the endpoints\n   * of the database timeline. Iterating over the diff generates a sequence\n   * of {@link Change}s between the two snapshots.\n   *\n   * Note that this sequence is not chronological; rather, the sequence is\n   * ordered by `<table, row-key>`, such that a row can appear at most once\n   * in the common case, or twice if its table is `TRUNCATE`'d and a new value\n   * is subsequently `INSERT`'ed. This results in dropping most intermediate\n   * changes to a row and bounds the amount of work needed to catch up;\n   * however, as a consequence, a consistent database state is only guaranteed\n   * when the sequence has been fully consumed.\n   *\n   * Note that Change generation relies on the state of the underlying\n   * database connections, and because the connection for the previous snapshot\n   * is reused to produce the next snapshot, the diff object is only valid\n   * until the next call to `advance()`.\n   *\n   * It is okay for the caller to apply `Change`s to the `prev` snapshot\n   * during the iteration (e.g. this is necessary for IVM); the remainder\n   * of the iteration is not affected because a given row can appear at most\n   * once in the sequence (with the exception being TRUNCATE, after which the\n   * deleted rows can be re-inserted, but this will also behave correctly if\n   * the changes are applied).\n   *\n   * Once the changes have been applied, however, a _subsequent_ iteration\n   * will not produce the correct results. In order to perform multiple\n   * change-applying iterations, the caller must (1) create a save point\n   * on `prev` before each iteration, and (2) rollback to the save point after\n   * the iteration.\n   */\n  advance(\n    syncableTables: Map<string, LiteAndZqlSpec>,\n    allTableNames: Set<string>,\n  ): SnapshotDiff {\n    const {prev, curr} = this.advanceWithoutDiff();\n    return new Diff(this.#appID, syncableTables, allTableNames, prev, curr);\n  }\n\n  advanceWithoutDiff() {\n    assert(this.#curr !== undefined, 'Snapshotter has not been initialized');\n    const next = this.#prev\n      ? this.#prev.resetToHead()\n      : Snapshot.create(\n          this.#lc,\n          this.#curr.db.db.name,\n          this.#appID,\n          this.#pageCacheSizeKib,\n        );\n    this.#prev = this.#curr;\n    this.#curr = next;\n    return {prev: this.#prev, curr: this.#curr};\n  }\n\n  /**\n   * Call this to close the database connections when the Snapshotter is\n   * no longer needed.\n   */\n  destroy() {\n    this.#curr?.db.db.close();\n    this.#prev?.db.db.close();\n    this.#lc.debug?.('closed database connections');\n  }\n}\n\nexport type Change = {\n  readonly table: string;\n  /**\n   * If this change represents a remove the row to remove,\n   * if nextValue is not null then all rows that have a unique constraint\n   * violation with nextValue.\n   * In both cases these rows should be removed.\n   */\n  readonly prevValues: Readonly<Row>[];\n  readonly nextValue: Readonly<Row> | null;\n  readonly rowKey: RowKey;\n};\n\n/**\n * Represents the difference between two database Snapshots.\n * Iterating over the object will produce a sequence of {@link Change}s\n * between the two snapshots.\n *\n * See {@link Snapshotter.advance()} for semantics and usage.\n */\nexport interface SnapshotDiff extends Iterable<Change> {\n  readonly prev: {\n    readonly db: StatementRunner;\n    readonly version: string;\n  };\n  readonly curr: {\n    readonly db: StatementRunner;\n    readonly version: string;\n  };\n\n  /**\n   * The number of ChangeLog entries between the snapshots. Note that this\n   * may not necessarily equal the number of `Change` objects that the iteration\n   * will produce, as `TRUNCATE` entries are counted as a single log entry which\n   * may be expanded into many changes (i.e. row deletes).\n   *\n   * TODO: Determine if it is worth changing the definition to count the\n   *       truncated rows. This would make diff computation more expensive\n   *       (requiring the count to be aggregated by operation type), which\n   *       may not be worth it for a presumable rare operation.\n   */\n  readonly changes: number;\n}\n\n/**\n * Thrown during an iteration of a {@link SnapshotDiff} when a schema\n * change or truncate is encountered, which result in aborting the\n * advancement and resetting / rehydrating the pipelines.\n */\nexport class ResetPipelinesSignal extends Error {\n  readonly name = 'ResetPipelinesSignal';\n\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n\nclass Snapshot {\n  static create(\n    lc: LogContext,\n    dbFile: string,\n    appID: string,\n    pageCacheSizeKib: number | undefined,\n  ) {\n    const conn = new Database(lc, dbFile);\n    conn.pragma('synchronous = OFF'); // Applied changes are ephemeral; COMMIT is never called.\n    if (pageCacheSizeKib !== undefined) {\n      conn.pragma(`cache_size = -${pageCacheSizeKib}`); // Negative = size in KiB\n    }\n    const [{journal_mode: mode}] = conn.pragma('journal_mode') as [\n      {journal_mode: string},\n    ];\n    // The Snapshotter operates on the replica file with BEGIN CONCURRENT,\n    // which must be used in concert with the replicator using BEGIN CONCURRENT\n    // on a db in the wal2 journal_mode.\n    assert(\n      mode === 'wal2',\n      `replica db must be in wal2 mode (current: ${mode})`,\n    );\n\n    const db = new StatementRunner(conn);\n    return new Snapshot(db, appID);\n  }\n\n  readonly db: StatementRunner;\n  readonly #appID: string;\n  readonly version: string;\n\n  constructor(db: StatementRunner, appID: string) {\n    db.beginConcurrent();\n    // Note: The subsequent read is necessary to acquire the read lock\n    // (which results in the logical creation of the snapshot). Calling\n    // `BEGIN CONCURRENT` alone does not result in acquiring the read lock.\n    const {stateVersion} = getReplicationState(db);\n\n    this.db = db;\n    this.#appID = appID;\n    this.version = stateVersion;\n  }\n\n  numChangesSince(prevVersion: string) {\n    const {count} = this.db.get(\n      'SELECT COUNT(*) AS count FROM \"_zero.changeLog2\" WHERE stateVersion > ?',\n      prevVersion,\n    );\n    return count;\n  }\n\n  changesSince(prevVersion: string) {\n    // Note: The queried fields are constrained to only those that are relevant\n    // to the snapshot diff, i.e. those defined in the changeLogEntrySchema.\n    const cached = this.db.statementCache.get(\n      `SELECT \"stateVersion\", \"table\", \"rowKey\", \"op\" FROM \"_zero.changeLog2\"\n         WHERE \"stateVersion\" > ? ORDER BY \"stateVersion\" ASC, \"pos\" ASC`,\n    );\n    return {\n      changes: cached.statement.iterate(prevVersion),\n      cleanup: () => this.db.statementCache.return(cached),\n    };\n  }\n\n  getRow(table: LiteTableSpecWithKeys, rowKey: JSONValue) {\n    const key = normalizedKeyOrder(rowKey as RowKey);\n    const conds = Object.keys(key).map(c => `${id(c)}=?`);\n    const cols = Object.keys(table.columns);\n    const cached = this.db.statementCache.get(\n      `SELECT ${cols.map(c => id(c)).join(',')} FROM ${id(\n        table.name,\n      )} WHERE ${conds.join(' AND ')}`,\n    );\n    cached.statement.safeIntegers(true);\n    try {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n      return cached.statement.get<any>(Object.values(key));\n    } finally {\n      this.db.statementCache.return(cached);\n    }\n  }\n\n  getRows(table: LiteTableSpecWithKeys, keys: PrimaryKey[], row: RowValue) {\n    // Filter out keys where any column is NULL. This is both correct and\n    // critical for performance:\n    // 1. Correctness: NULL values can't violate uniqueness (NULL != NULL in SQL)\n    // 2. Performance: SQLite's MULTI-INDEX OR optimization completely fails when\n    //    any branch involves NULL, falling back to a full table scan. This was\n    //    causing slowdowns of hundreds of times on tables with nullable unique columns.\n    const validKeys = keys.filter(key =>\n      key.every(column => row[column] !== null && row[column] !== undefined),\n    );\n    if (validKeys.length === 0) {\n      return [];\n    }\n    const conds = validKeys.map(key => key.map(c => `${id(c)}=?`));\n    const cols = Object.keys(table.columns);\n    const cached = this.db.statementCache.get(\n      `SELECT ${cols.map(c => id(c)).join(',')} FROM ${id(\n        table.name,\n      )} WHERE ${conds.map(cond => cond.join(' AND ')).join(' OR ')}`,\n    );\n    cached.statement.safeIntegers(true);\n    try {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n      return cached.statement.all<any>(\n        validKeys.flatMap(key => key.map(column => row[column])),\n      );\n    } finally {\n      this.db.statementCache.return(cached);\n    }\n  }\n\n  resetToHead(): Snapshot {\n    this.db.rollback();\n    return new Snapshot(this.db, this.#appID);\n  }\n}\n\nclass Diff implements SnapshotDiff {\n  readonly #permissionsTable: string;\n  readonly #syncableTables: Map<string, LiteAndZqlSpec>;\n  readonly #allTableNames: Set<string>;\n  readonly prev: Snapshot;\n  readonly curr: Snapshot;\n  readonly changes: number;\n\n  constructor(\n    appID: string,\n    syncableTables: Map<string, LiteAndZqlSpec>,\n    allTableNames: Set<string>,\n    prev: Snapshot,\n    curr: Snapshot,\n  ) {\n    this.#permissionsTable = `${appID}.permissions`;\n    this.#syncableTables = syncableTables;\n    this.#allTableNames = allTableNames;\n    this.prev = prev;\n    this.curr = curr;\n    this.changes = curr.numChangesSince(prev.version);\n  }\n\n  [Symbol.iterator](): Iterator<Change> {\n    const {changes, cleanup: done} = this.curr.changesSince(this.prev.version);\n\n    const cleanup = () => {\n      try {\n        // Allow open iterators to clean up their state.\n        changes.return?.(undefined);\n      } finally {\n        done();\n      }\n    };\n\n    return {\n      next: () => {\n        try {\n          for (;;) {\n            const {value, done} = changes.next();\n            if (done) {\n              cleanup();\n              return {value, done: true};\n            }\n\n            const {table, rowKey, op, stateVersion} = v.parse(value, schema);\n            if (op === RESET_OP) {\n              // The current map of `TableSpec`s may not have the correct or complete information.\n              throw new ResetPipelinesSignal(\n                `schema for table ${table} has changed`,\n              );\n            }\n            if (op === TRUNCATE_OP) {\n              // Truncates are also processed by rehydrating pipelines at current.\n              throw new ResetPipelinesSignal(\n                `table ${table} has been truncated`,\n              );\n            }\n            const specs = this.#syncableTables.get(table);\n            if (!specs) {\n              if (this.#allTableNames.has(table)) {\n                continue; // skip change log entries for non-syncable tables.\n              }\n              throw new Error(`change for unknown table ${table}`);\n            }\n            const {tableSpec, zqlSpec} = specs;\n\n            assert(rowKey !== null, 'rowKey must be present for row changes');\n            const nextValue =\n              op === SET_OP ? this.curr.getRow(tableSpec, rowKey) : null;\n            let prevValues;\n            if (nextValue) {\n              prevValues = this.prev.getRows(\n                tableSpec,\n                tableSpec.uniqueKeys,\n                nextValue,\n              );\n            } else {\n              const prevValue = this.prev.getRow(tableSpec, rowKey);\n              prevValues = prevValue ? [prevValue] : [];\n            }\n            if (nextValue === undefined) {\n              throw new Error(\n                `Missing value for ${table} ${stringify(rowKey)}`,\n              );\n            }\n            // Sanity check detects if the diff is being accessed after the Snapshots have advanced.\n            this.checkThatDiffIsValid(stateVersion, op, prevValues, nextValue);\n\n            if (prevValues.length === 0 && nextValue === null) {\n              // Filter out no-op changes (e.g. a delete of a row that does not exist in prev).\n              // TODO: Consider doing this for deep-equal values.\n              continue;\n            }\n\n            if (\n              table === this.#permissionsTable &&\n              prevValues.find(\n                prevValue => prevValue.permissions !== nextValue.permissions,\n              )\n            ) {\n              throw new ResetPipelinesSignal(\n                `Permissions have changed ${\n                  prevValues.find(\n                    prevValue =>\n                      prevValue.permissions !== nextValue.permissions,\n                  ).hash\n                } => ${nextValue.hash}`,\n              );\n            }\n\n            // Modify the values in place when converting to ZQL rows\n            // This is safe since we're the first node in the iterator chain.\n            // TODO Can we get rid of these RowValue casts?\n            return {\n              value: {\n                table,\n                prevValues: prevValues.map(prevValue =>\n                  fromSQLiteTypes(zqlSpec, prevValue, table),\n                ),\n                nextValue: nextValue\n                  ? fromSQLiteTypes(zqlSpec, nextValue, table)\n                  : null,\n                rowKey,\n              } satisfies Change,\n            };\n          }\n        } catch (e) {\n          // This control flow path is not covered by the return() method (i.e. `break`).\n          cleanup();\n          throw e;\n        }\n      },\n\n      return: (value: unknown) => {\n        cleanup();\n        return {value, done: true};\n      },\n    };\n  }\n\n  checkThatDiffIsValid(\n    stateVersion: string,\n    op: string,\n    prevValues: RowValue[],\n    nextValue: RowValue,\n  ) {\n    // Sanity checks to detect that the diff is not being accessed after\n    // the Snapshots have advanced.\n    if (stateVersion > this.curr.version) {\n      throw new InvalidDiffError(\n        `Diff is no longer valid. curr db has advanced past ${this.curr.version}`,\n      );\n    }\n    if (\n      prevValues.findIndex(\n        prevValue => (prevValue[ROW_VERSION] ?? '~') > this.prev.version,\n      ) !== -1\n    ) {\n      throw new InvalidDiffError(\n        `Diff is no longer valid. prev db has advanced past ${this.prev.version}.`,\n      );\n    }\n    if (op === SET_OP && nextValue[ROW_VERSION] !== stateVersion) {\n      throw new InvalidDiffError(\n        'Diff is no longer valid. curr db has advanced.',\n      );\n    }\n  }\n}\n\nexport class InvalidDiffError extends Error {\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n"],"names":["done","v.parse","schema","ROW_VERSION"],"mappings":"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"}
+{"version":3,"file":"snapshotter.js","sources":["../../../../../../zero-cache/src/services/view-syncer/snapshotter.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../../shared/src/asserts.ts';\nimport {stringify, type JSONValue} from '../../../../shared/src/bigint-json.ts';\nimport * as v from '../../../../shared/src/valita.ts';\nimport type {Row} from '../../../../zero-protocol/src/data.ts';\nimport type {PrimaryKey} from '../../../../zero-types/src/schema.ts';\nimport {Database} from '../../../../zqlite/src/db.ts';\nimport {fromSQLiteTypes} from '../../../../zqlite/src/table-source.ts';\nimport type {\n  LiteAndZqlSpec,\n  LiteTableSpecWithKeysAndVersion,\n} from '../../db/specs.ts';\nimport {StatementRunner} from '../../db/statements.ts';\nimport {\n  normalizedKeyOrder,\n  type RowKey,\n  type RowValue,\n} from '../../types/row-key.ts';\nimport type {AppID} from '../../types/shards.ts';\nimport {id} from '../../types/sql.ts';\nimport {\n  RESET_OP,\n  changeLogEntrySchema as schema,\n  SET_OP,\n  TRUNCATE_OP,\n} from '../replicator/schema/change-log.ts';\nimport {\n  getReplicationState,\n  ZERO_VERSION_COLUMN_NAME as ROW_VERSION,\n} from '../replicator/schema/replication-state.ts';\n\n/**\n * A `Snapshotter` manages the progression of database snapshots for a\n * ViewSyncer.\n *\n * The Replicator and ViewSyncers operate on the same SQLite file, with the\n * Replicator being the sole writer to the database. The IVM logic in\n * ViewSyncers, however, rely on incrementally applying changes to the DB to\n * update the state of its pipelines.\n *\n * To avoid coupling the progress of the Replicator and all IVM pipelines on\n * each other, ViewSyncers operate on ephemeral forks of the database by holding\n * [concurrent](https://sqlite.org/src/doc/begin-concurrent/doc/begin_concurrent.md)\n * snapshots of the database and simulating (but ultimately rolling back)\n * mutations on these snapshots.\n *\n * Example:\n * 1. ViewSyncer takes `snapshot_a` at version `t1` of the database and\n *    hydrates its pipeline(s).\n * 2. Replicator applies a new transaction to the database and notifies\n *    subscribers.\n * 3. ViewSyncer takes `snapshot_b` at `t2`, and queries the `ChangeLog` at\n *    that snapshot for changes since `t1`.\n * 4. ViewSyncer applies those changes to `snapshot_a` for IVM, but does not\n *    commit them. (Recall that the Replicator is the sole writer to the db, so\n *    the ViewSyncer never commits any writes.)\n * 5. Replicator applies the next transaction and advances the database to `t3`.\n * 6. ViewSyncer rolls back `snapshot_a` and opens `snapshot_c` at `t3`, using\n *    `snapshot_b` to simulate changes from `t2` to `t3`.\n *\n * ```\n * Replicator:  t1 --------------> t2 --------------> t3 --------------->\n * ViewSyncer:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]\n * ```\n *\n * Note that the Replicator (and ViewSyncers) do not wait on the progress of\n * other ViewSyncers. If a ViewSyncer is busy hydrating at `t1`, the Replicator\n * and other ViewSyncers can progress through `t2`, `t3`, etc. independently,\n * as the busy ViewSyncer simply takes its own snapshot when it is ready.\n *\n * ```\n * Replicator:   t1 --------------> t2 --------------> t3 --------------->\n * ViewSyncer1:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]\n * ViewSyncer2:       [.......... snapshot_a ..........] ----> [snapshot_b]\n * ```\n *\n * To minimize Database connections (and statement preparation, etc.), the\n * Snapshotter reuses the connection from the previous (rolled back)\n * snapshot when opening the new one.\n *\n * ```\n * Replicator:  t1 --------------> t2 --------------> t3 --------------->\n * ViewSyncer:       [snapshot_a] ----> [snapshot_b] ----> [snapshot_c]\n *                     (conn_1)           (conn_2)           (conn_1)\n * ```\n *\n * In this manner, each ViewSyncer uses two connections that continually\n * \"leapfrog\" each other to replay the timeline of changes in isolation from\n * the Replicator and other ViewSyncers.\n */\nexport class Snapshotter {\n  readonly #lc: LogContext;\n  readonly #dbFile: string;\n  readonly #appID: string;\n  readonly #pageCacheSizeKib: number | undefined;\n  #curr: Snapshot | undefined;\n  #prev: Snapshot | undefined;\n\n  constructor(\n    lc: LogContext,\n    dbFile: string,\n    {appID}: AppID,\n    pageCacheSizeKib?: number | undefined,\n  ) {\n    this.#lc = lc;\n    this.#dbFile = dbFile;\n    this.#appID = appID;\n    this.#pageCacheSizeKib = pageCacheSizeKib;\n  }\n\n  /**\n   * Initializes the snapshot to the current head of the database. This must be\n   * only be called once. The state of whether a Snapshotter has been initialized\n   * can be determined by calling {@link initialized()}.\n   */\n  init(): this {\n    assert(this.#curr === undefined, 'Already initialized');\n    this.#curr = Snapshot.create(\n      this.#lc,\n      this.#dbFile,\n      this.#appID,\n      this.#pageCacheSizeKib,\n    );\n    this.#lc.debug?.(`Initial snapshot at version ${this.#curr.version}`);\n    return this;\n  }\n\n  initialized(): boolean {\n    return this.#curr !== undefined;\n  }\n\n  /** Returns the current snapshot. Asserts if {@link initialized()} is false. */\n  current(): Snapshot {\n    assert(this.#curr !== undefined, 'Snapshotter has not been initialized');\n    return this.#curr;\n  }\n\n  /**\n   * Advances to the head of the Database, returning a diff between the\n   * previously current Snapshot and a new Snapshot at head. This is called\n   * in response to a notification from a Replicator subscription. Subsequent\n   * calls to {@link current()} return the new Snapshot. Note that the Snapshotter\n   * must be initialized before advancing.\n   *\n   * The returned {@link SnapshotDiff} contains snapshots at the endpoints\n   * of the database timeline. Iterating over the diff generates a sequence\n   * of {@link Change}s between the two snapshots.\n   *\n   * Note that this sequence is not chronological; rather, the sequence is\n   * ordered by `<table, row-key>`, such that a row can appear at most once\n   * in the common case, or twice if its table is `TRUNCATE`'d and a new value\n   * is subsequently `INSERT`'ed. This results in dropping most intermediate\n   * changes to a row and bounds the amount of work needed to catch up;\n   * however, as a consequence, a consistent database state is only guaranteed\n   * when the sequence has been fully consumed.\n   *\n   * Note that Change generation relies on the state of the underlying\n   * database connections, and because the connection for the previous snapshot\n   * is reused to produce the next snapshot, the diff object is only valid\n   * until the next call to `advance()`.\n   *\n   * It is okay for the caller to apply `Change`s to the `prev` snapshot\n   * during the iteration (e.g. this is necessary for IVM); the remainder\n   * of the iteration is not affected because a given row can appear at most\n   * once in the sequence (with the exception being TRUNCATE, after which the\n   * deleted rows can be re-inserted, but this will also behave correctly if\n   * the changes are applied).\n   *\n   * Once the changes have been applied, however, a _subsequent_ iteration\n   * will not produce the correct results. In order to perform multiple\n   * change-applying iterations, the caller must (1) create a save point\n   * on `prev` before each iteration, and (2) rollback to the save point after\n   * the iteration.\n   */\n  advance(\n    syncableTables: Map<string, LiteAndZqlSpec>,\n    allTableNames: Set<string>,\n  ): SnapshotDiff {\n    const {prev, curr} = this.advanceWithoutDiff();\n    return new Diff(this.#appID, syncableTables, allTableNames, prev, curr);\n  }\n\n  advanceWithoutDiff() {\n    assert(this.#curr !== undefined, 'Snapshotter has not been initialized');\n    const next = this.#prev\n      ? this.#prev.resetToHead()\n      : Snapshot.create(\n          this.#lc,\n          this.#curr.db.db.name,\n          this.#appID,\n          this.#pageCacheSizeKib,\n        );\n    this.#prev = this.#curr;\n    this.#curr = next;\n    return {prev: this.#prev, curr: this.#curr};\n  }\n\n  /**\n   * Call this to close the database connections when the Snapshotter is\n   * no longer needed.\n   */\n  destroy() {\n    this.#curr?.db.db.close();\n    this.#prev?.db.db.close();\n    this.#lc.debug?.('closed database connections');\n  }\n}\n\nexport type Change = {\n  readonly table: string;\n  /**\n   * If this change represents a remove the row to remove,\n   * if nextValue is not null then all rows that have a unique constraint\n   * violation with nextValue.\n   * In both cases these rows should be removed.\n   */\n  readonly prevValues: Readonly<Row>[];\n  readonly nextValue: Readonly<Row> | null;\n  readonly rowKey: RowKey;\n};\n\n/**\n * Represents the difference between two database Snapshots.\n * Iterating over the object will produce a sequence of {@link Change}s\n * between the two snapshots.\n *\n * See {@link Snapshotter.advance()} for semantics and usage.\n */\nexport interface SnapshotDiff extends Iterable<Change> {\n  readonly prev: {\n    readonly db: StatementRunner;\n    readonly version: string;\n  };\n  readonly curr: {\n    readonly db: StatementRunner;\n    readonly version: string;\n  };\n\n  /**\n   * The number of ChangeLog entries between the snapshots. Note that this\n   * may not necessarily equal the number of `Change` objects that the iteration\n   * will produce, as `TRUNCATE` entries are counted as a single log entry which\n   * may be expanded into many changes (i.e. row deletes).\n   *\n   * TODO: Determine if it is worth changing the definition to count the\n   *       truncated rows. This would make diff computation more expensive\n   *       (requiring the count to be aggregated by operation type), which\n   *       may not be worth it for a presumable rare operation.\n   */\n  readonly changes: number;\n}\n\n/**\n * Thrown during an iteration of a {@link SnapshotDiff} when a schema\n * change or truncate is encountered, which result in aborting the\n * advancement and resetting / rehydrating the pipelines.\n */\nexport class ResetPipelinesSignal extends Error {\n  readonly name = 'ResetPipelinesSignal';\n\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n\nclass Snapshot {\n  static create(\n    lc: LogContext,\n    dbFile: string,\n    appID: string,\n    pageCacheSizeKib: number | undefined,\n  ) {\n    const conn = new Database(lc, dbFile);\n    conn.pragma('synchronous = OFF'); // Applied changes are ephemeral; COMMIT is never called.\n    if (pageCacheSizeKib !== undefined) {\n      conn.pragma(`cache_size = -${pageCacheSizeKib}`); // Negative = size in KiB\n    }\n    const [{journal_mode: mode}] = conn.pragma('journal_mode') as [\n      {journal_mode: string},\n    ];\n    // The Snapshotter operates on the replica file with BEGIN CONCURRENT,\n    // which must be used in concert with the replicator using BEGIN CONCURRENT\n    // on a db in the wal2 journal_mode.\n    assert(\n      mode === 'wal2',\n      `replica db must be in wal2 mode (current: ${mode})`,\n    );\n\n    const db = new StatementRunner(conn);\n    return new Snapshot(db, appID);\n  }\n\n  readonly db: StatementRunner;\n  readonly #appID: string;\n  readonly version: string;\n\n  constructor(db: StatementRunner, appID: string) {\n    db.beginConcurrent();\n    // Note: The subsequent read is necessary to acquire the read lock\n    // (which results in the logical creation of the snapshot). Calling\n    // `BEGIN CONCURRENT` alone does not result in acquiring the read lock.\n    const {stateVersion} = getReplicationState(db);\n\n    this.db = db;\n    this.#appID = appID;\n    this.version = stateVersion;\n  }\n\n  numChangesSince(prevVersion: string) {\n    const {count} = this.db.get(\n      'SELECT COUNT(*) AS count FROM \"_zero.changeLog2\" WHERE stateVersion > ?',\n      prevVersion,\n    );\n    return count;\n  }\n\n  changesSince(prevVersion: string) {\n    // Note: The queried fields are constrained to only those that are relevant\n    // to the snapshot diff, i.e. those defined in the changeLogEntrySchema.\n    const cached = this.db.statementCache.get(\n      `SELECT \"stateVersion\", \"table\", \"rowKey\", \"op\" FROM \"_zero.changeLog2\"\n         WHERE \"stateVersion\" > ? ORDER BY \"stateVersion\" ASC, \"pos\" ASC`,\n    );\n    return {\n      changes: cached.statement.iterate(prevVersion),\n      cleanup: () => this.db.statementCache.return(cached),\n    };\n  }\n\n  getRow(table: LiteTableSpecWithKeysAndVersion, rowKey: JSONValue) {\n    const key = normalizedKeyOrder(rowKey as RowKey);\n    const conds = Object.keys(key).map(c => `${id(c)}=?`);\n    const cols = Object.keys(table.columns);\n    const cached = this.db.statementCache.get(\n      `SELECT ${cols.map(c => id(c)).join(',')} FROM ${id(\n        table.name,\n      )} WHERE ${conds.join(' AND ')}`,\n    );\n    cached.statement.safeIntegers(true);\n    try {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n      return cached.statement.get<any>(Object.values(key));\n    } finally {\n      this.db.statementCache.return(cached);\n    }\n  }\n\n  getRows(\n    table: LiteTableSpecWithKeysAndVersion,\n    keys: PrimaryKey[],\n    row: RowValue,\n  ) {\n    // Filter out keys where any column is NULL. This is both correct and\n    // critical for performance:\n    // 1. Correctness: NULL values can't violate uniqueness (NULL != NULL in SQL)\n    // 2. Performance: SQLite's MULTI-INDEX OR optimization completely fails when\n    //    any branch involves NULL, falling back to a full table scan. This was\n    //    causing slowdowns of hundreds of times on tables with nullable unique columns.\n    const validKeys = keys.filter(key =>\n      key.every(column => row[column] !== null && row[column] !== undefined),\n    );\n    if (validKeys.length === 0) {\n      return [];\n    }\n    const conds = validKeys.map(key => key.map(c => `${id(c)}=?`));\n    const cols = Object.keys(table.columns);\n    const cached = this.db.statementCache.get(\n      `SELECT ${cols.map(c => id(c)).join(',')} FROM ${id(\n        table.name,\n      )} WHERE ${conds.map(cond => cond.join(' AND ')).join(' OR ')}`,\n    );\n    cached.statement.safeIntegers(true);\n    try {\n      // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n      return cached.statement.all<any>(\n        validKeys.flatMap(key => key.map(column => row[column])),\n      );\n    } finally {\n      this.db.statementCache.return(cached);\n    }\n  }\n\n  resetToHead(): Snapshot {\n    this.db.rollback();\n    return new Snapshot(this.db, this.#appID);\n  }\n}\n\nclass Diff implements SnapshotDiff {\n  readonly #permissionsTable: string;\n  readonly #syncableTables: Map<string, LiteAndZqlSpec>;\n  readonly #allTableNames: Set<string>;\n  readonly prev: Snapshot;\n  readonly curr: Snapshot;\n  readonly changes: number;\n\n  constructor(\n    appID: string,\n    syncableTables: Map<string, LiteAndZqlSpec>,\n    allTableNames: Set<string>,\n    prev: Snapshot,\n    curr: Snapshot,\n  ) {\n    this.#permissionsTable = `${appID}.permissions`;\n    this.#syncableTables = syncableTables;\n    this.#allTableNames = allTableNames;\n    this.prev = prev;\n    this.curr = curr;\n    this.changes = curr.numChangesSince(prev.version);\n  }\n\n  [Symbol.iterator](): Iterator<Change> {\n    const {changes, cleanup: done} = this.curr.changesSince(this.prev.version);\n\n    const cleanup = () => {\n      try {\n        // Allow open iterators to clean up their state.\n        changes.return?.(undefined);\n      } finally {\n        done();\n      }\n    };\n\n    return {\n      next: () => {\n        try {\n          for (;;) {\n            const {value, done} = changes.next();\n            if (done) {\n              cleanup();\n              return {value, done: true};\n            }\n\n            const {table, rowKey, op, stateVersion} = v.parse(value, schema);\n            if (op === RESET_OP) {\n              // The current map of `TableSpec`s may not have the correct or complete information.\n              throw new ResetPipelinesSignal(\n                `schema for table ${table} has changed`,\n              );\n            }\n            if (op === TRUNCATE_OP) {\n              // Truncates are also processed by rehydrating pipelines at current.\n              throw new ResetPipelinesSignal(\n                `table ${table} has been truncated`,\n              );\n            }\n            const specs = this.#syncableTables.get(table);\n            if (!specs) {\n              if (this.#allTableNames.has(table)) {\n                continue; // skip change log entries for non-syncable tables.\n              }\n              throw new Error(`change for unknown table ${table}`);\n            }\n            const {tableSpec, zqlSpec} = specs;\n\n            // Sanity check: All change log ops should have a stateVersion\n            // greater than minRowVersion in the table metadata. This is a\n            // mini-proof that the overlay does not need to be applied to\n            // rows produced in incremental catchup, based on the invariant in\n            // change-processor's #bumpVersions(), whereby the setting of the\n            // minRowVersion is always followed by a RESET OP, meaning that\n            // subsequent change-log traversal happens at a later version.\n            assert(\n              (tableSpec.minRowVersion ?? '') < stateVersion,\n              () =>\n                `unexpected change @${stateVersion} for table ${table} with ` +\n                `minRowVersion ${tableSpec.minRowVersion}: ${op}(${rowKey})`,\n            );\n\n            assert(rowKey !== null, 'rowKey must be present for row changes');\n            const nextValue =\n              op === SET_OP ? this.curr.getRow(tableSpec, rowKey) : null;\n            let prevValues;\n            if (nextValue) {\n              prevValues = this.prev.getRows(\n                tableSpec,\n                tableSpec.uniqueKeys,\n                nextValue,\n              );\n            } else {\n              const prevValue = this.prev.getRow(tableSpec, rowKey);\n              prevValues = prevValue ? [prevValue] : [];\n            }\n            if (nextValue === undefined) {\n              throw new Error(\n                `Missing value for ${table} ${stringify(rowKey)}`,\n              );\n            }\n            // Sanity check detects if the diff is being accessed after the Snapshots have advanced.\n            this.checkThatDiffIsValid(stateVersion, op, prevValues, nextValue);\n\n            if (prevValues.length === 0 && nextValue === null) {\n              // Filter out no-op changes (e.g. a delete of a row that does not exist in prev).\n              // TODO: Consider doing this for deep-equal values.\n              continue;\n            }\n\n            if (\n              table === this.#permissionsTable &&\n              prevValues.find(\n                prevValue => prevValue.permissions !== nextValue.permissions,\n              )\n            ) {\n              throw new ResetPipelinesSignal(\n                `Permissions have changed ${\n                  prevValues.find(\n                    prevValue =>\n                      prevValue.permissions !== nextValue.permissions,\n                  ).hash\n                } => ${nextValue.hash}`,\n              );\n            }\n\n            // Modify the values in place when converting to ZQL rows\n            // This is safe since we're the first node in the iterator chain.\n            // TODO Can we get rid of these RowValue casts?\n            return {\n              value: {\n                table,\n                prevValues: prevValues.map(prevValue =>\n                  fromSQLiteTypes(zqlSpec, prevValue, table),\n                ),\n                nextValue: nextValue\n                  ? fromSQLiteTypes(zqlSpec, nextValue, table)\n                  : null,\n                rowKey,\n              } satisfies Change,\n            };\n          }\n        } catch (e) {\n          // This control flow path is not covered by the return() method (i.e. `break`).\n          cleanup();\n          throw e;\n        }\n      },\n\n      return: (value: unknown) => {\n        cleanup();\n        return {value, done: true};\n      },\n    };\n  }\n\n  checkThatDiffIsValid(\n    stateVersion: string,\n    op: string,\n    prevValues: RowValue[],\n    nextValue: RowValue,\n  ) {\n    // Sanity checks to detect that the diff is not being accessed after\n    // the Snapshots have advanced.\n    if (stateVersion > this.curr.version) {\n      throw new InvalidDiffError(\n        `Diff is no longer valid. curr db has advanced past ${this.curr.version}`,\n      );\n    }\n    if (\n      prevValues.findIndex(\n        prevValue => (prevValue[ROW_VERSION] ?? '~') > this.prev.version,\n      ) !== -1\n    ) {\n      throw new InvalidDiffError(\n        `Diff is no longer valid. prev db has advanced past ${this.prev.version}.`,\n      );\n    }\n    if (op === SET_OP && nextValue[ROW_VERSION] !== stateVersion) {\n      throw new InvalidDiffError(\n        'Diff is no longer valid. curr db has advanced.',\n      );\n    }\n  }\n}\n\nexport class InvalidDiffError extends Error {\n  constructor(msg: string) {\n    super(msg);\n  }\n}\n"],"names":["done","v.parse","schema","ROW_VERSION"],"mappings":"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"}

package/out/zero-cache/src/types/subscription.d.ts

@@ -86,8 +86,10 @@ export declare class Subscription<T, M = T> implements Source<T>, Sink<M> {
     push(value: M): PendingResult;
     /** False if the subscription has been canceled or has failed. */
     get active(): boolean;
-    /** The number messages waiting to be consumed. */
+    /** The number of messages waiting to be dequeued. */
     get queued(): number;
+    /** The number of messages dequeued but not yet "consumed" */
+    get consuming(): number;
     /**
      * Cancels the subscription after any queued messages are consumed. This is
      * meant for the producer-side code.

package/out/zero-cache/src/types/subscription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAE,MAAM,EAAC,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;;IAC/D;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,EAC9B,OAAO,GAAE,OAAO,CAAC,CAAC,CAAM,EACxB,OAAO,GAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAU;IAmB/B;;;OAGG;gBACS,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAK,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAoC1D;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa;IA4B7B,iEAAiE;IACjE,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,kDAAkD;IAClD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;;;;;;OAWG;IACH,GAAG;IAUH;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK;IAIlB,wEAAwE;IACxE,IAAI,CAAC,GAAG,EAAE,KAAK;IAyBf,IAAI,QAAQ,IAAI,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAI1E;IA8CD,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CA0B3C;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;IAEnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC"}
+{"version":3,"file":"subscription.d.ts","sourceRoot":"","sources":["../../../../../zero-cache/src/types/subscription.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,IAAI,EAAE,MAAM,EAAC,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,qBAAa,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;;IAC/D;;;;OAIG;IACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,EAC9B,OAAO,GAAE,OAAO,CAAC,CAAC,CAAM,EACxB,OAAO,GAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAU;IAqB/B;;;OAGG;gBACS,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,YAAK,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC;IAqC1D;;;;;;;;;;;OAWG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,aAAa;IA4B7B,iEAAiE;IACjE,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,qDAAqD;IACrD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,6DAA6D;IAC7D,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;;;;;;;;;OAWG;IACH,GAAG;IAUH;;;;;;;;OAQG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,KAAK;IAIlB,wEAAwE;IACxE,IAAI,CAAC,GAAG,EAAE,KAAK;IAyBf,IAAI,QAAQ,IAAI,aAAa,CAAC;QAAC,KAAK,EAAE,CAAC,CAAC;QAAC,QAAQ,EAAE,MAAM,IAAI,CAAA;KAAC,CAAC,GAAG,SAAS,CAI1E;IAiDD,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,aAAa,CAAC,CAAC,CAAC;CA0B3C;AAED,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC;IAEnC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;IAE7B;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,GAAG,CAAC,EAAE,KAAK,KAAK,IAAI,CAAC;IAEjD;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,yCAAyC;AACzC,MAAM,MAAM,MAAM,GAAG,UAAU,GAAG,WAAW,GAAG,YAAY,CAAC;AAE7D;;;;GAIG;AACH,MAAM,MAAM,aAAa,GAAG;IAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAA;CAAC,CAAC"}

package/out/zero-cache/src/types/subscription.js

@@ -11,8 +11,10 @@ class Subscription {
   }
   // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).
   #consumers = [];
-  // Messages waiting to be consumed.
+  // Messages waiting to be dequeued.
   #messages = [];
+  // Messages dequeued but not yet consumed.
+  #consuming = /* @__PURE__ */ new Set();
   #pipelineEnabled;
   // Sentinel value signaling that the subscription is "done" and no more
   // messages can be added.
@@ -43,6 +45,7 @@ class Subscription {
     };
     this.#consumed = (entry) => {
       consumed(entry.value);
+      this.#consuming.delete(entry);
       entry.resolve("consumed");
     };
     this.#cleanup = (entries, err) => {
@@ -93,10 +96,14 @@ class Subscription {
   get active() {
     return this.#sentinel === void 0;
   }
-  /** The number messages waiting to be consumed. */
+  /** The number of messages waiting to be dequeued. */
   get queued() {
     return this.#messages.length;
   }
+  /** The number of messages dequeued but not yet "consumed" */
+  get consuming() {
+    return this.#consuming.size;
+  }
   /**
    * Cancels the subscription after any queued messages are consumed. This is
    * meant for the producer-side code.
@@ -137,7 +144,7 @@ class Subscription {
     if (!this.#sentinel) {
       this.#sentinel = sentinel;
       this.#cleanup(
-        this.#messages.filter((m) => m !== "terminus"),
+        [...this.#consuming, ...this.#messages.filter((m) => m !== "terminus")],
         sentinel instanceof Error ? sentinel : void 0
       );
       this.#messages.splice(0);
@@ -158,6 +165,7 @@ class Subscription {
           return { value: void 0, done: true };
         }
         if (entry !== void 0) {
+          this.#consuming.add(entry);
           return {
             value: {
               value: this.#publish(entry.value),
@@ -174,12 +182,16 @@ class Subscription {
         const consumer = resolver();
         this.#consumers.push(consumer);
         const result = await consumer.promise;
-        return result ? {
-          value: {
-            value: this.#publish(result.value),
-            consumed: () => this.#consumed(result)
-          }
-        } : { value: void 0, done: true };
+        if (result !== null) {
+          this.#consuming.add(result);
+          return {
+            value: {
+              value: this.#publish(result.value),
+              consumed: () => this.#consumed(result)
+            }
+          };
+        }
+        return { value: void 0, done: true };
       },
       return: (value) => {
         this.cancel();

package/out/zero-cache/src/types/subscription.js.map

@@ -1 +1 @@
-{"version":3,"file":"subscription.js","sources":["../../../../../zero-cache/src/types/subscription.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Sink, Source} from './streams.ts';\n\n/**\n * A Subscription abstracts a continuous, logically infinite stream of messages intended\n * for serial processing. Unlike the more general Node `Stream` API, a Subscription has\n * a limited API with specific semantics:\n *\n * * **Serial processing**: Messages must be consumed via the {@link AsyncIterable}\n *   interface, e.g.\n *   ```ts\n *   const subscription = server.subscribe(parameters);\n *\n *   for await (const message of subscription) {\n *     await process(message);  // fully process the message before consuming the next\n *   }\n *   ```\n *\n *   Moreover, the consumer is expected to completely process each message before\n *   requesting the next. This is important for cleanup semantics (explained later).\n *\n * * **cancel()**, not close(): The underlying data in a subscription is logically infinite\n *   and only terminated when the consumer is no longer interested in receiving the messages\n *   (or requires a Subscription with a different configuration). As such, there is no API\n *   for gracefully closing the subscription after pending messages are consumed; rather,\n *   cancellation is immediate, and upon cancellation, pending messages are dropped. A\n *   Subscription can also be terminated with exceptional (i.e. `Error`) circumstances,\n *   for which the behavior is equivalent.\n *\n * * **Coalescing** (optional): A producer can configure pending messages in the Subscription\n *   to be merged together with a {@link Options.coalesce coalesce} function. This is useful\n *   for semantics in which the consumer is not necessarily interested in every incremental\n *   change, but rather the cumulative change since the last processed message. A\n *   Subscription with coalescing is guaranteed to have at most one outstanding message,\n *   regardless of how quickly messages are produced and consumed. This effectively constrains\n *   the amount of outstanding work in the system.\n *\n * ### Resource Tracking and Cleanup\n *\n * Because message consumption is constrained to the async iteration API, standard\n * control flow mechanisms allow the producer to perform bookkeeping without any\n * explicit cleanup actions on the part of the consumer. This includes:\n *\n * * **Per-message cleanup**: Each request for the {@link AsyncIterator.next next}\n *   message, or the termination of the iteration, signals that the consumer has\n *   finished processing the previous message. The producer of a Subscription can\n *   supply a {@link Options.consumed consumed} callback to receive these processed\n *   messages, allowing it to clean up attached resources (e.g. TransactionPools, etc.).\n *\n * * **Per-subscription cleanup**: The producer of a Subscription can supply a\n *   {@link Options.cleanup cleanup} callback that is invoked when the Subscription\n *   is terminated, either explicitly via {@link Subscription.cancel cancel()} /\n *   {@link Subscription.fail fail()}, or implicitly when an iteration is exited via a\n *  `break`, `return`, or `throw` statement. All unconsumed messages are passed to the\n *   call back to facilitate bookkeeping.\n *\n * @param T The external message type, published to the AsyncIterable\n * @param M The internal message type used in the producer-side interfaces\n *          (e.g. {@link push}, {@link Options.consumed}, {@link Options.coalesce},\n *          and {@link Options.cleanup}). This is often the same as the external type\n *          T, but may be diverged to facilitate internal bookkeeping.\n */\nexport class Subscription<T, M = T> implements Source<T>, Sink<M> {\n  /**\n   * Convenience factory method for creating a {@link Subscription} with internal message type\n   * `M` as a subtype of `T`, defaulting to the same type. The default `publish` method publishes\n   * the message of type `M` directly to the AsyncIterable.\n   */\n  static create<T, M extends T = T>(\n    options: Options<M> = {},\n    publish: (m: M) => T = m => m,\n  ) {\n    return new Subscription(options, publish);\n  }\n\n  // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).\n  readonly #consumers: Resolver<Entry<M> | null>[] = [];\n  // Messages waiting to be consumed.\n  readonly #messages: (Entry<M> | 'terminus')[] = [];\n  readonly #pipelineEnabled: boolean;\n  // Sentinel value signaling that the subscription is \"done\" and no more\n  // messages can be added.\n  #sentinel: 'canceled' | Error | undefined = undefined;\n\n  #coalesce: ((curr: Entry<M>, prev: Entry<M>) => M) | undefined;\n  #consumed: (prev: Entry<M>) => void;\n  #cleanup: (unconsumed: Entry<M>[], err?: Error) => void;\n  #publish: (internal: M) => T;\n\n  /**\n   * @param publish function for converting the internally pushed / coalesced message\n   *        of type `M` to the external type `T` exposed via async iteration.\n   */\n  constructor(options: Options<M> = {}, publish: (m: M) => T) {\n    const {\n      coalesce,\n      consumed = () => {},\n      cleanup = () => {},\n      pipeline = coalesce === undefined,\n    } = options;\n\n    this.#coalesce = !coalesce\n      ? undefined\n      : (curr, prev) => {\n          try {\n            return coalesce(curr.value, prev.value);\n          } finally {\n            prev.resolve('coalesced');\n          }\n        };\n\n    this.#consumed = entry => {\n      consumed(entry.value);\n      entry.resolve('consumed');\n    };\n\n    this.#cleanup = (entries, err) => {\n      cleanup(\n        entries.map(e => e.value),\n        err,\n      );\n      entries.forEach(e => e.resolve('unconsumed'));\n    };\n\n    this.#publish = publish;\n\n    this.#pipelineEnabled = pipeline;\n  }\n\n  /**\n   * Pushes the next message to be consumed, and returns a `result` that resolves to the\n   * eventual {@link Result} of the `value`.\n   *\n   * If there is an existing unconsumed message and the Subscription has a\n   * {@link Options#coalesce coalesce} function, the specified `value` will be coalesced\n   * with the pending message. In this case, the result of the pending message\n   * is resolved to `coalesced`, regardless of the `coalesce` function implementation.\n   *\n   * If the subscription is in a terminal state, the message is dropped and the\n   * result resolves to `unconsumed`.\n   */\n  push(value: M): PendingResult {\n    const {promise: result, resolve} = resolver<Result>();\n    const entry = {value, resolve};\n\n    if (this.#sentinel) {\n      entry.resolve('unconsumed');\n      return {result};\n    }\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolve(entry);\n    } else if (\n      this.#coalesce &&\n      this.#messages.length &&\n      this.#messages[this.#messages.length - 1] !== 'terminus'\n    ) {\n      const prev = this.#messages[this.#messages.length - 1];\n      assert(prev !== 'terminus', 'prev should not be terminus after check');\n      this.#messages[this.#messages.length - 1] = {\n        value: this.#coalesce(entry, prev),\n        resolve,\n      };\n    } else {\n      this.#messages.push(entry);\n    }\n    return {result};\n  }\n\n  /** False if the subscription has been canceled or has failed. */\n  get active(): boolean {\n    return this.#sentinel === undefined;\n  }\n\n  /** The number messages waiting to be consumed. */\n  get queued(): number {\n    return this.#messages.length;\n  }\n\n  /**\n   * Cancels the subscription after any queued messages are consumed. This is\n   * meant for the producer-side code.\n   *\n   * Any messages pushed after calling `end()` will be unconsumed as if\n   * `cancel()` were called (once the first set of pending messages is\n   * consumed). In particular, if a coalesce function is defined, the new\n   * messages will not be coalesced with the messages enqueued before `end()`\n   * was called. However, to effect the intent of memory efficiency, multiple\n   * messages pushed after calling `end()` will be coalesced together.\n   *\n   */\n  end() {\n    if (this.#sentinel) {\n      // already terminated\n    } else if (this.#messages.length === 0) {\n      this.cancel();\n    } else {\n      this.#messages.push('terminus');\n    }\n  }\n\n  /**\n   * Cancels the subscription immediately, cleans up, and terminates any iteration.\n   * This is intended for the consumer to call when it is no longer interested\n   * in the subscription.\n   *\n   * @param err If an `err` is specified, an iteration over the Subscription /\n   *        Sink will throw the `err` (equivalent to the producer calling\n   *        {@link fail()}). If undefined, the iteration will exit gracefully.\n   */\n  cancel(err?: Error) {\n    this.#terminate(err ?? 'canceled');\n  }\n\n  /** Fails the subscription, cleans up, and throws from any iteration. */\n  fail(err: Error) {\n    this.#terminate(err);\n  }\n\n  #terminate(sentinel: 'canceled' | Error) {\n    if (!this.#sentinel) {\n      this.#sentinel = sentinel;\n      this.#cleanup(\n        this.#messages.filter(m => m !== 'terminus'),\n        sentinel instanceof Error ? sentinel : undefined,\n      );\n      this.#messages.splice(0);\n\n      for (\n        let consumer = this.#consumers.shift();\n        consumer;\n        consumer = this.#consumers.shift()\n      ) {\n        sentinel === 'canceled'\n          ? consumer.resolve(null)\n          : consumer.reject(sentinel);\n      }\n    }\n  }\n\n  get pipeline(): AsyncIterable<{value: T; consumed: () => void}> | undefined {\n    return this.#pipelineEnabled\n      ? {[Symbol.asyncIterator]: () => this.#pipeline()}\n      : undefined;\n  }\n\n  #pipeline(): AsyncIterator<{value: T; consumed: () => void}> {\n    return {\n      next: async () => {\n        const entry = this.#messages.shift();\n        if (entry === 'terminus') {\n          this.cancel();\n          return {value: undefined, done: true};\n        }\n        if (entry !== undefined) {\n          return {\n            value: {\n              value: this.#publish(entry.value),\n              consumed: () => this.#consumed(entry),\n            },\n          };\n        }\n        if (this.#sentinel === 'canceled') {\n          return {value: undefined, done: true};\n        }\n        if (this.#sentinel) {\n          return Promise.reject(this.#sentinel);\n        }\n        const consumer = resolver<Entry<M> | null>();\n        this.#consumers.push(consumer);\n\n        // Wait for push() (or termination) to resolve the consumer.\n        const result = await consumer.promise;\n        return result\n          ? {\n              value: {\n                value: this.#publish(result.value),\n                consumed: () => this.#consumed(result),\n              },\n            }\n          : {value: undefined, done: true};\n      },\n\n      return: value => {\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    const delegate = this.#pipeline();\n\n    let prevConsumed = () => {};\n    return {\n      next: async () => {\n        prevConsumed();\n\n        const entry = await delegate.next();\n        if (entry.done) {\n          return entry;\n        }\n\n        const {value, consumed} = entry.value;\n        prevConsumed = consumed;\n        return {value};\n      },\n\n      return: value => {\n        prevConsumed();\n\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n}\n\nexport type Options<M> = {\n  /**\n   * Coalesces messages waiting to be consumed. This is useful for \"watermark\" type\n   * subscriptions in which the consumer is only interested in the cumulative state\n   * change since the last processed message. When a `coalesce` function is specified,\n   * there is guaranteed to be at most one message waiting to be consumed.\n   *\n   * Note that the `curr` argument comes before `prev`. This facilitates a common\n   * scenario in which coalescing just means using the newest value; in such a case,\n   * `coalesce` can simply be the identity function (e.g. `msg => msg`).\n   */\n  coalesce?: (curr: M, prev: M) => M;\n\n  /**\n   * Called on the previous message in an iteration (1) when the next message is requested,\n   * or (2) when the iteration is terminated. This allows the producer to perform\n   * per-message cleanup.\n   *\n   * Note that when a {@link Options.coalesce coalesce} function is defined,\n   * `consumed` is _not_ called on the `prev` message; it is the responsibility of\n   * producers requiring both coalescing and consumption notification to perform any\n   * necessary cleanup of `prev` messages when coalescing.\n   */\n  consumed?: (prev: M) => void;\n\n  /**\n   * `cleanup` is called exactly once when the subscription is terminated via a failure or\n   * cancelation (whichever happens first), which includes implicit cancelation when\n   * the consumer exits an iteration via a `break`, `return`, or `throw` statement.\n   *\n   * Note that the `err` argument will only reflect an explicit cancelation via a call\n   * to {@link Subscription.fail()}. On the other hand, if the iteration is canceled via\n   * a `throw` statement, the thrown reason is not reflected in the `err` parameter, as that\n   * information is not made available to the AsyncIterator implementation.\n   */\n  cleanup?: (unconsumed: M[], err?: Error) => void;\n\n  /**\n   * Enable or disable pipelining when streaming messages over a websocket.\n   *\n   * If unspecified, pipelining is enabled if there is no {@link Options.coalesce coalesce}\n   * method, as pipelining is counter to the semantics of coalescing. However, the\n   * application can explicitly enable pipelining even if there is a coalesce method\n   * by specifying `true` for this option. This assumes that coalescing is either\n   * not important for websocket semantics, or that the receiving end of the websocket\n   * transport performs the desired coalescing.\n   */\n  pipeline?: boolean;\n};\n\n/** Post-queueing results of messages. */\nexport type Result = 'consumed' | 'coalesced' | 'unconsumed';\n\n/**\n * {@link Subscription.subscribe()} wraps the `Promise<Result>` in a `PendingResult`\n * object to avoid forcing all callers to handle the Promise, as most logic does not\n * need to.\n */\nexport type PendingResult = {result: Promise<Result>};\n\ntype Entry<M> = {\n  readonly value: M;\n  readonly resolve: (r: Result) => void;\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"subscription.js","sources":["../../../../../zero-cache/src/types/subscription.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Sink, Source} from './streams.ts';\n\n/**\n * A Subscription abstracts a continuous, logically infinite stream of messages intended\n * for serial processing. Unlike the more general Node `Stream` API, a Subscription has\n * a limited API with specific semantics:\n *\n * * **Serial processing**: Messages must be consumed via the {@link AsyncIterable}\n *   interface, e.g.\n *   ```ts\n *   const subscription = server.subscribe(parameters);\n *\n *   for await (const message of subscription) {\n *     await process(message);  // fully process the message before consuming the next\n *   }\n *   ```\n *\n *   Moreover, the consumer is expected to completely process each message before\n *   requesting the next. This is important for cleanup semantics (explained later).\n *\n * * **cancel()**, not close(): The underlying data in a subscription is logically infinite\n *   and only terminated when the consumer is no longer interested in receiving the messages\n *   (or requires a Subscription with a different configuration). As such, there is no API\n *   for gracefully closing the subscription after pending messages are consumed; rather,\n *   cancellation is immediate, and upon cancellation, pending messages are dropped. A\n *   Subscription can also be terminated with exceptional (i.e. `Error`) circumstances,\n *   for which the behavior is equivalent.\n *\n * * **Coalescing** (optional): A producer can configure pending messages in the Subscription\n *   to be merged together with a {@link Options.coalesce coalesce} function. This is useful\n *   for semantics in which the consumer is not necessarily interested in every incremental\n *   change, but rather the cumulative change since the last processed message. A\n *   Subscription with coalescing is guaranteed to have at most one outstanding message,\n *   regardless of how quickly messages are produced and consumed. This effectively constrains\n *   the amount of outstanding work in the system.\n *\n * ### Resource Tracking and Cleanup\n *\n * Because message consumption is constrained to the async iteration API, standard\n * control flow mechanisms allow the producer to perform bookkeeping without any\n * explicit cleanup actions on the part of the consumer. This includes:\n *\n * * **Per-message cleanup**: Each request for the {@link AsyncIterator.next next}\n *   message, or the termination of the iteration, signals that the consumer has\n *   finished processing the previous message. The producer of a Subscription can\n *   supply a {@link Options.consumed consumed} callback to receive these processed\n *   messages, allowing it to clean up attached resources (e.g. TransactionPools, etc.).\n *\n * * **Per-subscription cleanup**: The producer of a Subscription can supply a\n *   {@link Options.cleanup cleanup} callback that is invoked when the Subscription\n *   is terminated, either explicitly via {@link Subscription.cancel cancel()} /\n *   {@link Subscription.fail fail()}, or implicitly when an iteration is exited via a\n *  `break`, `return`, or `throw` statement. All unconsumed messages are passed to the\n *   call back to facilitate bookkeeping.\n *\n * @param T The external message type, published to the AsyncIterable\n * @param M The internal message type used in the producer-side interfaces\n *          (e.g. {@link push}, {@link Options.consumed}, {@link Options.coalesce},\n *          and {@link Options.cleanup}). This is often the same as the external type\n *          T, but may be diverged to facilitate internal bookkeeping.\n */\nexport class Subscription<T, M = T> implements Source<T>, Sink<M> {\n  /**\n   * Convenience factory method for creating a {@link Subscription} with internal message type\n   * `M` as a subtype of `T`, defaulting to the same type. The default `publish` method publishes\n   * the message of type `M` directly to the AsyncIterable.\n   */\n  static create<T, M extends T = T>(\n    options: Options<M> = {},\n    publish: (m: M) => T = m => m,\n  ) {\n    return new Subscription(options, publish);\n  }\n\n  // Consumers waiting to consume messages (i.e. an async iteration awaiting the next message).\n  readonly #consumers: Resolver<Entry<M> | null>[] = [];\n  // Messages waiting to be dequeued.\n  readonly #messages: (Entry<M> | 'terminus')[] = [];\n  // Messages dequeued but not yet consumed.\n  readonly #consuming = new Set<Entry<M>>();\n  readonly #pipelineEnabled: boolean;\n  // Sentinel value signaling that the subscription is \"done\" and no more\n  // messages can be added.\n  #sentinel: 'canceled' | Error | undefined = undefined;\n\n  #coalesce: ((curr: Entry<M>, prev: Entry<M>) => M) | undefined;\n  #consumed: (prev: Entry<M>) => void;\n  #cleanup: (unconsumed: Entry<M>[], err?: Error) => void;\n  #publish: (internal: M) => T;\n\n  /**\n   * @param publish function for converting the internally pushed / coalesced message\n   *        of type `M` to the external type `T` exposed via async iteration.\n   */\n  constructor(options: Options<M> = {}, publish: (m: M) => T) {\n    const {\n      coalesce,\n      consumed = () => {},\n      cleanup = () => {},\n      pipeline = coalesce === undefined,\n    } = options;\n\n    this.#coalesce = !coalesce\n      ? undefined\n      : (curr, prev) => {\n          try {\n            return coalesce(curr.value, prev.value);\n          } finally {\n            prev.resolve('coalesced');\n          }\n        };\n\n    this.#consumed = entry => {\n      consumed(entry.value);\n      this.#consuming.delete(entry);\n      entry.resolve('consumed');\n    };\n\n    this.#cleanup = (entries, err) => {\n      cleanup(\n        entries.map(e => e.value),\n        err,\n      );\n      entries.forEach(e => e.resolve('unconsumed'));\n    };\n\n    this.#publish = publish;\n\n    this.#pipelineEnabled = pipeline;\n  }\n\n  /**\n   * Pushes the next message to be consumed, and returns a `result` that resolves to the\n   * eventual {@link Result} of the `value`.\n   *\n   * If there is an existing unconsumed message and the Subscription has a\n   * {@link Options#coalesce coalesce} function, the specified `value` will be coalesced\n   * with the pending message. In this case, the result of the pending message\n   * is resolved to `coalesced`, regardless of the `coalesce` function implementation.\n   *\n   * If the subscription is in a terminal state, the message is dropped and the\n   * result resolves to `unconsumed`.\n   */\n  push(value: M): PendingResult {\n    const {promise: result, resolve} = resolver<Result>();\n    const entry = {value, resolve};\n\n    if (this.#sentinel) {\n      entry.resolve('unconsumed');\n      return {result};\n    }\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolve(entry);\n    } else if (\n      this.#coalesce &&\n      this.#messages.length &&\n      this.#messages[this.#messages.length - 1] !== 'terminus'\n    ) {\n      const prev = this.#messages[this.#messages.length - 1];\n      assert(prev !== 'terminus', 'prev should not be terminus after check');\n      this.#messages[this.#messages.length - 1] = {\n        value: this.#coalesce(entry, prev),\n        resolve,\n      };\n    } else {\n      this.#messages.push(entry);\n    }\n    return {result};\n  }\n\n  /** False if the subscription has been canceled or has failed. */\n  get active(): boolean {\n    return this.#sentinel === undefined;\n  }\n\n  /** The number of messages waiting to be dequeued. */\n  get queued(): number {\n    return this.#messages.length;\n  }\n\n  /** The number of messages dequeued but not yet \"consumed\" */\n  get consuming(): number {\n    return this.#consuming.size;\n  }\n\n  /**\n   * Cancels the subscription after any queued messages are consumed. This is\n   * meant for the producer-side code.\n   *\n   * Any messages pushed after calling `end()` will be unconsumed as if\n   * `cancel()` were called (once the first set of pending messages is\n   * consumed). In particular, if a coalesce function is defined, the new\n   * messages will not be coalesced with the messages enqueued before `end()`\n   * was called. However, to effect the intent of memory efficiency, multiple\n   * messages pushed after calling `end()` will be coalesced together.\n   *\n   */\n  end() {\n    if (this.#sentinel) {\n      // already terminated\n    } else if (this.#messages.length === 0) {\n      this.cancel();\n    } else {\n      this.#messages.push('terminus');\n    }\n  }\n\n  /**\n   * Cancels the subscription immediately, cleans up, and terminates any iteration.\n   * This is intended for the consumer to call when it is no longer interested\n   * in the subscription.\n   *\n   * @param err If an `err` is specified, an iteration over the Subscription /\n   *        Sink will throw the `err` (equivalent to the producer calling\n   *        {@link fail()}). If undefined, the iteration will exit gracefully.\n   */\n  cancel(err?: Error) {\n    this.#terminate(err ?? 'canceled');\n  }\n\n  /** Fails the subscription, cleans up, and throws from any iteration. */\n  fail(err: Error) {\n    this.#terminate(err);\n  }\n\n  #terminate(sentinel: 'canceled' | Error) {\n    if (!this.#sentinel) {\n      this.#sentinel = sentinel;\n      this.#cleanup(\n        [...this.#consuming, ...this.#messages.filter(m => m !== 'terminus')],\n        sentinel instanceof Error ? sentinel : undefined,\n      );\n      this.#messages.splice(0);\n\n      for (\n        let consumer = this.#consumers.shift();\n        consumer;\n        consumer = this.#consumers.shift()\n      ) {\n        sentinel === 'canceled'\n          ? consumer.resolve(null)\n          : consumer.reject(sentinel);\n      }\n    }\n  }\n\n  get pipeline(): AsyncIterable<{value: T; consumed: () => void}> | undefined {\n    return this.#pipelineEnabled\n      ? {[Symbol.asyncIterator]: () => this.#pipeline()}\n      : undefined;\n  }\n\n  #pipeline(): AsyncIterator<{value: T; consumed: () => void}> {\n    return {\n      next: async () => {\n        const entry = this.#messages.shift();\n        if (entry === 'terminus') {\n          this.cancel();\n          return {value: undefined, done: true};\n        }\n        if (entry !== undefined) {\n          this.#consuming.add(entry);\n          return {\n            value: {\n              value: this.#publish(entry.value),\n              consumed: () => this.#consumed(entry),\n            },\n          };\n        }\n        if (this.#sentinel === 'canceled') {\n          return {value: undefined, done: true};\n        }\n        if (this.#sentinel) {\n          return Promise.reject(this.#sentinel);\n        }\n        const consumer = resolver<Entry<M> | null>();\n        this.#consumers.push(consumer);\n\n        // Wait for push() (or termination) to resolve the consumer.\n        const result = await consumer.promise;\n        if (result !== null) {\n          this.#consuming.add(result);\n          return {\n            value: {\n              value: this.#publish(result.value),\n              consumed: () => this.#consumed(result),\n            },\n          };\n        }\n        return {value: undefined, done: true};\n      },\n\n      return: value => {\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    const delegate = this.#pipeline();\n\n    let prevConsumed = () => {};\n    return {\n      next: async () => {\n        prevConsumed();\n\n        const entry = await delegate.next();\n        if (entry.done) {\n          return entry;\n        }\n\n        const {value, consumed} = entry.value;\n        prevConsumed = consumed;\n        return {value};\n      },\n\n      return: value => {\n        prevConsumed();\n\n        this.cancel();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n}\n\nexport type Options<M> = {\n  /**\n   * Coalesces messages waiting to be consumed. This is useful for \"watermark\" type\n   * subscriptions in which the consumer is only interested in the cumulative state\n   * change since the last processed message. When a `coalesce` function is specified,\n   * there is guaranteed to be at most one message waiting to be consumed.\n   *\n   * Note that the `curr` argument comes before `prev`. This facilitates a common\n   * scenario in which coalescing just means using the newest value; in such a case,\n   * `coalesce` can simply be the identity function (e.g. `msg => msg`).\n   */\n  coalesce?: (curr: M, prev: M) => M;\n\n  /**\n   * Called on the previous message in an iteration (1) when the next message is requested,\n   * or (2) when the iteration is terminated. This allows the producer to perform\n   * per-message cleanup.\n   *\n   * Note that when a {@link Options.coalesce coalesce} function is defined,\n   * `consumed` is _not_ called on the `prev` message; it is the responsibility of\n   * producers requiring both coalescing and consumption notification to perform any\n   * necessary cleanup of `prev` messages when coalescing.\n   */\n  consumed?: (prev: M) => void;\n\n  /**\n   * `cleanup` is called exactly once when the subscription is terminated via a failure or\n   * cancelation (whichever happens first), which includes implicit cancelation when\n   * the consumer exits an iteration via a `break`, `return`, or `throw` statement.\n   *\n   * Note that the `err` argument will only reflect an explicit cancelation via a call\n   * to {@link Subscription.fail()}. On the other hand, if the iteration is canceled via\n   * a `throw` statement, the thrown reason is not reflected in the `err` parameter, as that\n   * information is not made available to the AsyncIterator implementation.\n   */\n  cleanup?: (unconsumed: M[], err?: Error) => void;\n\n  /**\n   * Enable or disable pipelining when streaming messages over a websocket.\n   *\n   * If unspecified, pipelining is enabled if there is no {@link Options.coalesce coalesce}\n   * method, as pipelining is counter to the semantics of coalescing. However, the\n   * application can explicitly enable pipelining even if there is a coalesce method\n   * by specifying `true` for this option. This assumes that coalescing is either\n   * not important for websocket semantics, or that the receiving end of the websocket\n   * transport performs the desired coalescing.\n   */\n  pipeline?: boolean;\n};\n\n/** Post-queueing results of messages. */\nexport type Result = 'consumed' | 'coalesced' | 'unconsumed';\n\n/**\n * {@link Subscription.subscribe()} wraps the `Promise<Result>` in a `PendingResult`\n * object to avoid forcing all callers to handle the Promise, as most logic does not\n * need to.\n */\nexport type PendingResult = {result: Promise<Result>};\n\ntype Entry<M> = {\n  readonly value: M;\n  readonly resolve: (r: Result) => void;\n};\n"],"names":[],"mappings":"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"}

package/out/zero-client/src/client/version.js

@@ -1,4 +1,4 @@
-const version = "0.26.1-canary.9";
+const version = "0.26.1";
 export {
   version
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rocicorp/zero",
-  "version": "0.26.1-canary.9",
+  "version": "0.26.1",
   "description": "Zero is a web framework for serverless web development.",
   "author": "Rocicorp, Inc.",
   "repository": {
@@ -49,6 +49,7 @@
     "@rocicorp/zero-sqlite3": "^1.0.15",
     "@standard-schema/spec": "^1.0.0",
     "@types/basic-auth": "^1.1.8",
+    "@types/ws": "^8.5.12",
     "basic-auth": "^2.0.1",
     "chalk": "^5.3.0",
     "chalk-template": "^1.1.0",