@rocicorp/zero 1.11.0-canary.11 → 1.11.0-canary.13

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

@@ -1 +1 @@
-{"version":3,"file":"snapshot.js","names":[],"sources":["../../../../../../zero-cache/src/services/change-streamer/snapshot.ts"],"sourcesContent":["/**\n * The `snapshot` API serves the purpose of:\n * - informing subscribers (i.e. view-syncers) of the (litestream)\n *   backup location from which to restore a replica snapshot\n * - checking whether a restored backup or existing replica is\n *   compatible with the change-streamer\n * - preventing change-log cleanup while a snapshot restore is in\n *   progress\n * - tracking the approximate time it takes from the beginning of\n *   snapshot \"reservation\" to the subsequent subscription, which\n *   serves as the minimum interval to wait before cleaning up\n *   backed up changes.\n */\n\nimport type {LogContext} from '@rocicorp/logger';\nimport {resolver} from '@rocicorp/resolver';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport {sleep} from '../../../../shared/src/sleep.ts';\nimport * as v from '../../../../shared/src/valita.ts';\nimport {type NormalizedZeroConfig} from '../../config/normalize.ts';\nimport {getShardConfig} from '../../types/shards.ts';\nimport type {Source} from '../../types/streams.ts';\nimport {ChangeStreamerHttpClient} from './change-streamer-http.ts';\n\nconst statusSchema = v.object({\n  tag: v.literal('status'),\n\n  /**\n   * The location from which litestream should perform the restore.\n   */\n  backupURL: v.string(),\n\n  /**\n   * The `replicaVersion` of the backup. If a subscriber's restored or\n   * existing replica is of a different version, it should delete it and\n   * retry the restore from litestream (i.e. equivalent to a\n   * `WrongReplicaVersion` response from a `/changes` subscription).\n   */\n  replicaVersion: v.string(),\n\n  /**\n   * The earliest watermark from which catchup is possible. If the\n   * subscriber's replica is older that this watermark, it should delete it\n   * and (retry the) restore from litestream (i.e. equivalent to a\n   * `WatermarkTooOld` response from a `/changes` subscription).\n   */\n  minWatermark: v.string(),\n\n  /**\n   * The size in bytes of the replication-manager's replica when the snapshot\n   * was reserved, used as an estimate of the size of the restored replica\n   * when reporting restore progress. Absent from older replication-managers.\n   */\n  replicaSize: v.number().optional(),\n});\n\nexport type SnapshotStatus = v.Infer<typeof statusSchema>;\n\nconst statusMessageSchema = v.tuple([v.literal('status'), statusSchema]);\n\nexport const snapshotMessageSchema = v.union(statusMessageSchema);\n\nexport type SnapshotMessage = v.Infer<typeof statusMessageSchema>;\n\nexport type ReserveSnapshot = (\n  lc: LogContext,\n  config: NormalizedZeroConfig,\n) => Promise<Source<SnapshotMessage>>;\n\nexport function reserveAndGetSnapshotStatus(\n  lc: LogContext,\n  config: NormalizedZeroConfig,\n  reserve: ReserveSnapshot = reserveSnapshot, // for testing\n): Promise<SnapshotStatus> {\n  const {promise: status, resolve, reject} = resolver<SnapshotStatus>();\n\n  void (async function () {\n    const abort = new AbortController();\n    const {signal} = abort;\n    const onSignal = () => abort.abort();\n    process.on('SIGINT', onSignal);\n    process.on('SIGTERM', onSignal);\n\n    try {\n      for (let i = 0; ; i++) {\n        let err: unknown;\n        try {\n          let resolved = false;\n          const stream = await untilAborted(reserve(lc, config), signal);\n          // A signal while the stream is open cancels it, which ends the\n          // iteration below with an AbortError.\n          const cancelStream = () => stream.cancel(new AbortError('Aborted'));\n          signal.addEventListener('abort', cancelStream, {once: true});\n          try {\n            for await (const msg of stream) {\n              // Capture the value of the status message that the change-streamer\n              // backup monitor returns, and hold the connection open to\n              // \"reserve\" the snapshot and prevent change log cleanup.\n              resolve(msg[1]);\n              resolved = true;\n            }\n          } finally {\n            signal.removeEventListener('abort', cancelStream);\n          }\n          // The change-streamer itself closes the connection when the\n          // subscription is started (or the reservation retried).\n          if (resolved) {\n            break;\n          }\n        } catch (e) {\n          err = e;\n        }\n        if (signal.aborted) {\n          // (A no-op if the status was already resolved.)\n          return reject(\n            err instanceof AbortError ? err : new AbortError('Aborted'),\n          );\n        }\n        // Retry in the view-syncer since it cannot proceed until it connects\n        // to a (compatible) replication-manager. In particular, a\n        // replication-manager that does not support the view-syncer's\n        // change-streamer protocol will close the stream with an error; this\n        // retry logic essentially delays the startup of a view-syncer until\n        // a compatible replication-manager has been rolled out, allowing\n        // replication-manager and view-syncer services to be updated in\n        // parallel.\n        lc.warn?.(\n          `Unable to reserve snapshot (attempt ${i + 1}). Retrying in 5 seconds.`,\n          String(err),\n        );\n        try {\n          await sleep(5000, abort.signal);\n        } catch (e) {\n          return reject(e);\n        }\n      }\n    } finally {\n      // This function is called repeatedly (e.g. by the replicator's restore\n      // loop), so the signal handlers must not outlive the reservation.\n      process.off('SIGINT', onSignal);\n      process.off('SIGTERM', onSignal);\n    }\n  })();\n\n  return status;\n}\n\n/**\n * Resolves with the reserved stream, or rejects with an AbortError if the\n * `signal` is aborted while the reservation is pending (in which case a\n * stream that arrives later is canceled rather than held open).\n */\nfunction untilAborted<T>(\n  reservation: Promise<Source<T>>,\n  signal: AbortSignal,\n): Promise<Source<T>> {\n  return new Promise((resolve, reject) => {\n    const onAbort = () => reject(new AbortError('Aborted'));\n    signal.addEventListener('abort', onAbort, {once: true});\n    reservation.then(\n      stream => {\n        signal.removeEventListener('abort', onAbort);\n        if (signal.aborted) {\n          stream.cancel();\n        } else {\n          resolve(stream);\n        }\n      },\n      e => {\n        signal.removeEventListener('abort', onAbort);\n        reject(e);\n      },\n    );\n  });\n}\n\nfunction reserveSnapshot(\n  lc: LogContext,\n  config: NormalizedZeroConfig,\n): Promise<Source<SnapshotMessage>> {\n  const {taskID, change, changeStreamer} = config;\n  const shardID = getShardConfig(config);\n\n  const changeStreamerClient = new ChangeStreamerHttpClient(\n    lc,\n    shardID,\n    change.db,\n    changeStreamer.uri,\n  );\n\n  return changeStreamerClient.reserveSnapshot(taskID);\n}\n"],"mappings":";;;;;;;;AAwBA,IAAM,eAAe,eAAE,OAAO;CAC5B,KAAK,eAAE,QAAQ,QAAQ;;;;CAKvB,WAAW,eAAE,OAAO;;;;;;;CAQpB,gBAAgB,eAAE,OAAO;;;;;;;CAQzB,cAAc,eAAE,OAAO;;;;;;CAOvB,aAAa,eAAE,OAAO,EAAE,SAAS;AACnC,CAAC;AAID,IAAM,sBAAsB,eAAE,MAAM,CAAC,eAAE,QAAQ,QAAQ,GAAG,YAAY,CAAC;AAEvE,IAAa,wBAAwB,eAAE,MAAM,mBAAmB;AAShE,SAAgB,4BACd,IACA,QACA,UAA2B,iBACF;CACzB,MAAM,EAAC,SAAS,QAAQ,SAAS,WAAU,SAAyB;CAEpE,CAAM,iBAAkB;EACtB,MAAM,QAAQ,IAAI,gBAAgB;EAClC,MAAM,EAAC,WAAU;EACjB,MAAM,iBAAiB,MAAM,MAAM;EACnC,QAAQ,GAAG,UAAU,QAAQ;EAC7B,QAAQ,GAAG,WAAW,QAAQ;EAE9B,IAAI;GACF,KAAK,IAAI,IAAI,IAAK,KAAK;IACrB,IAAI;IACJ,IAAI;KACF,IAAI,WAAW;KACf,MAAM,SAAS,MAAM,aAAa,QAAQ,IAAI,MAAM,GAAG,MAAM;KAG7D,MAAM,qBAAqB,OAAO,OAAO,IAAI,WAAW,SAAS,CAAC;KAClE,OAAO,iBAAiB,SAAS,cAAc,EAAC,MAAM,KAAI,CAAC;KAC3D,IAAI;MACF,WAAW,MAAM,OAAO,QAAQ;OAI9B,QAAQ,IAAI,EAAE;OACd,WAAW;MACb;KACF,UAAU;MACR,OAAO,oBAAoB,SAAS,YAAY;KAClD;KAGA,IAAI,UACF;IAEJ,SAAS,GAAG;KACV,MAAM;IACR;IACA,IAAI,OAAO,SAET,OAAO,OACL,eAAe,aAAa,MAAM,IAAI,WAAW,SAAS,CAC5D;IAUF,GAAG,OACD,uCAAuC,IAAI,EAAE,4BAC7C,OAAO,GAAG,CACZ;IACA,IAAI;KACF,MAAM,MAAM,KAAM,MAAM,MAAM;IAChC,SAAS,GAAG;KACV,OAAO,OAAO,CAAC;IACjB;GACF;EACF,UAAU;GAGR,QAAQ,IAAI,UAAU,QAAQ;GAC9B,QAAQ,IAAI,WAAW,QAAQ;EACjC;CACF,GAAG;CAEH,OAAO;AACT;;;;;;AAOA,SAAS,aACP,aACA,QACoB;CACpB,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,MAAM,gBAAgB,OAAO,IAAI,WAAW,SAAS,CAAC;EACtD,OAAO,iBAAiB,SAAS,SAAS,EAAC,MAAM,KAAI,CAAC;EACtD,YAAY,MACV,WAAU;GACR,OAAO,oBAAoB,SAAS,OAAO;GAC3C,IAAI,OAAO,SACT,OAAO,OAAO;QAEd,QAAQ,MAAM;EAElB,IACA,MAAK;GACH,OAAO,oBAAoB,SAAS,OAAO;GAC3C,OAAO,CAAC;EACV,CACF;CACF,CAAC;AACH;AAEA,SAAS,gBACP,IACA,QACkC;CAClC,MAAM,EAAC,QAAQ,QAAQ,mBAAkB;CAUzC,OAAO,IAP0B,yBAC/B,IAHc,eAAe,MAI7B,GACA,OAAO,IACP,eAAe,GAGV,EAAqB,gBAAgB,MAAM;AACpD"}
+{"version":3,"file":"snapshot.js","names":[],"sources":["../../../../../../zero-cache/src/services/change-streamer/snapshot.ts"],"sourcesContent":["/**\n * The `snapshot` API serves the purpose of:\n * - informing subscribers (i.e. view-syncers) of the (litestream)\n *   backup location from which to restore a replica snapshot\n * - checking whether a restored backup or existing replica is\n *   compatible with the change-streamer\n * - preventing change-log cleanup while a snapshot restore is in\n *   progress\n * - tracking the approximate time it takes from the beginning of\n *   snapshot \"reservation\" to the subsequent subscription, which\n *   serves as the minimum interval to wait before cleaning up\n *   backed up changes.\n */\n\nimport type {LogContext} from '@rocicorp/logger';\nimport {AbortError} from '../../../../shared/src/abort-error.ts';\nimport {promiseOrAbort} from '../../../../shared/src/promise-race.ts';\nimport {sleep} from '../../../../shared/src/sleep.ts';\n\n// The schema definitions live in the pure schema module (with no dependency on\n// the HTTP client) so that subscribe.ts can import them without forming an\n// import cycle through change-streamer-http.ts. Imported here for local use and\n// re-exported for existing consumers.\nimport type {\n  ReservationFollowup,\n  SnapshotReserver,\n} from './change-streamer-http.ts';\nimport type {SnapshotStatus} from './subscribe.ts';\n\nexport type {SnapshotStatus};\n\nexport async function reserveAndGetSnapshotStatus(\n  lc: LogContext,\n  taskID: string,\n  changeStreamer: SnapshotReserver,\n): Promise<{reserved: SnapshotStatus; followup: ReservationFollowup}> {\n  const abort = new AbortController();\n  const {signal} = abort;\n  // Use our own AbortError as the abort reason (rather than the native\n  // DOMException that AbortController.abort() defaults to) so that\n  // promiseOrAbort()'s rejection, which propagates `signal.reason` verbatim,\n  // is always an instance of the shared AbortError type.\n  const onSignal = () => abort.abort(new AbortError('SIGTERM/SIGINT'));\n  process.on('SIGINT', onSignal);\n  process.on('SIGTERM', onSignal);\n\n  try {\n    for (let i = 0; ; i++) {\n      let err: unknown;\n      const reservation = changeStreamer.reserveSnapshot(taskID);\n      try {\n        return await promiseOrAbort(reservation, signal);\n      } catch (e) {\n        err = e;\n      }\n      if (signal.aborted) {\n        // promiseOrAbort() does not cancel the loser of the race: the\n        // reservation may still resolve later. If it does, cancel its\n        // connection rather than leaking it, since this function has already\n        // given up and nobody will call followup.subscribe().\n        reservation.then(\n          ({followup}) => followup.cancel(),\n          () => {},\n        );\n        throw err;\n      }\n      // Retry in the view-syncer since it cannot proceed until it connects\n      // to a (compatible) replication-manager. In particular, a\n      // replication-manager that does not support the view-syncer's\n      // change-streamer protocol will close the stream with an error; this\n      // retry logic essentially delays the startup of a view-syncer until\n      // a compatible replication-manager has been rolled out, allowing\n      // replication-manager and view-syncer services to be updated in\n      // parallel.\n      lc.warn?.(\n        `Unable to reserve snapshot (attempt ${i + 1}). Retrying in 5 seconds.`,\n        String(err),\n      );\n      await sleep(5000, signal);\n    }\n  } finally {\n    // This function is called repeatedly (e.g. by the replicator's restore\n    // loop), so the signal handlers must not outlive the reservation.\n    process.off('SIGINT', onSignal);\n    process.off('SIGTERM', onSignal);\n  }\n}\n"],"mappings":";;;;AA+BA,eAAsB,4BACpB,IACA,QACA,gBACoE;CACpE,MAAM,QAAQ,IAAI,gBAAgB;CAClC,MAAM,EAAC,WAAU;CAKjB,MAAM,iBAAiB,MAAM,MAAM,IAAI,WAAW,gBAAgB,CAAC;CACnE,QAAQ,GAAG,UAAU,QAAQ;CAC7B,QAAQ,GAAG,WAAW,QAAQ;CAE9B,IAAI;EACF,KAAK,IAAI,IAAI,IAAK,KAAK;GACrB,IAAI;GACJ,MAAM,cAAc,eAAe,gBAAgB,MAAM;GACzD,IAAI;IACF,OAAO,MAAM,eAAe,aAAa,MAAM;GACjD,SAAS,GAAG;IACV,MAAM;GACR;GACA,IAAI,OAAO,SAAS;IAKlB,YAAY,MACT,EAAC,eAAc,SAAS,OAAO,SAC1B,CAAC,CACT;IACA,MAAM;GACR;GASA,GAAG,OACD,uCAAuC,IAAI,EAAE,4BAC7C,OAAO,GAAG,CACZ;GACA,MAAM,MAAM,KAAM,MAAM;EAC1B;CACF,UAAU;EAGR,QAAQ,IAAI,UAAU,QAAQ;EAC9B,QAAQ,IAAI,WAAW,QAAQ;CACjC;AACF"}

package/out/zero-cache/src/services/change-streamer/subscribe.d.ts

@@ -0,0 +1,358 @@
+/**
+ * The `subscribe` API (protocol v7+) merges the previous `/snapshot` and
+ * `/changes` connections into a single bidirectional WebSocket, so that the
+ * replication-manager that reserves change-log entries for a soon-to-be
+ * subscriber is the same replication-manager that serves the subscription.
+ *
+ * The connection is driven by an upstream (view-syncer → replication-manager)
+ * application message that selects the flow:
+ *
+ * - **Fresh startup:** the view-syncer sends `['reserve-snapshot', {taskID}]`.
+ *   The change-streamer opens a snapshot reservation (pinning the change log)
+ *   and replies downstream with a single `['reserved', …]` message telling the
+ *   view-syncer where to restore the backup from and the watermark from which
+ *   catchup is possible. Once the backup is restored, the view-syncer sends
+ *   `['start-subscription', ctx]`, which transitions the same connection into
+ *   the subscription phase (change stream downstream). The reservation is
+ *   released only after the subscriber is registered, so there is never a gap
+ *   in which the change-streamer does not know the client's watermark.
+ *
+ * - **Reconnect (replica already valid):** the view-syncer sends
+ *   `['start-subscription', ctx]` immediately, with no reservation.
+ *
+ * The reservation status uses a distinct `'reserved'` tag (rather than the
+ * change stream's `'status'`) so the downstream union is unambiguous under
+ * passthrough parsing.
+ */
+import * as v from '../../../../shared/src/valita.ts';
+declare const snapshotStatusSchema: v.ObjectType<Omit<{
+    tag: v.Type<"status">;
+    backupURL: v.Type<string>;
+    replicaVersion: v.Type<string>;
+    minWatermark: v.Type<string>;
+    replicaSize: v.Optional<number>;
+}, "tag"> & {
+    tag: v.Type<"snapshot">;
+}, undefined>;
+export type SnapshotStatus = v.Infer<typeof snapshotStatusSchema>;
+export declare const reserveSnapshotMessageSchema: v.TupleType<[v.Type<"reserve-snapshot">, v.ObjectType<{
+    taskID: v.Type<string>;
+}, undefined>]>;
+/**
+ * The subscription-initialization context, sent in the `start-subscription`
+ * message. Equivalent to the previous URL-encoded `SubscriberContext`, minus
+ * the fields that are now implicit on the merged connection:
+ * - `protocolVersion` comes from the request path.
+ * - `wsBatched` is always on (the transport batches internally).
+ *
+ * Parsed in `passthrough` mode so a forthcoming, orthogonal change can add
+ * arbitrary table/column/backfill state without a protocol bump.
+ */
+export declare const subscribeContextSchema: v.ObjectType<{
+    /** Task ID, links the subscription to a preceding snapshot reservation. */
+    taskID: v.Type<string>;
+    /** Subscriber id (debugging only). */
+    id: v.Type<string>;
+    /** 'serving' (user-facing) or 'backup' (in-RM replicator). */
+    mode: v.UnionType<[v.Type<"serving">, v.Type<"backup">]>;
+    /** The replica version the subscriber restored / is running. */
+    replicaVersion: v.Type<string>;
+    /** The watermark up to which the subscriber is up to date. */
+    watermark: v.Type<string>;
+}, undefined>;
+export type SubscribeContext = v.Infer<typeof subscribeContextSchema>;
+export declare const startSubscriptionMessageSchema: v.TupleType<[v.Type<"start-subscription">, v.ObjectType<{
+    /** Task ID, links the subscription to a preceding snapshot reservation. */
+    taskID: v.Type<string>;
+    /** Subscriber id (debugging only). */
+    id: v.Type<string>;
+    /** 'serving' (user-facing) or 'backup' (in-RM replicator). */
+    mode: v.UnionType<[v.Type<"serving">, v.Type<"backup">]>;
+    /** The replica version the subscriber restored / is running. */
+    replicaVersion: v.Type<string>;
+    /** The watermark up to which the subscriber is up to date. */
+    watermark: v.Type<string>;
+}, undefined>]>;
+export declare const subscribeUpstreamSchema: v.UnionType<[v.TupleType<[v.Type<"reserve-snapshot">, v.ObjectType<{
+    taskID: v.Type<string>;
+}, undefined>]>, v.TupleType<[v.Type<"start-subscription">, v.ObjectType<{
+    /** Task ID, links the subscription to a preceding snapshot reservation. */
+    taskID: v.Type<string>;
+    /** Subscriber id (debugging only). */
+    id: v.Type<string>;
+    /** 'serving' (user-facing) or 'backup' (in-RM replicator). */
+    mode: v.UnionType<[v.Type<"serving">, v.Type<"backup">]>;
+    /** The replica version the subscriber restored / is running. */
+    replicaVersion: v.Type<string>;
+    /** The watermark up to which the subscriber is up to date. */
+    watermark: v.Type<string>;
+}, undefined>]>]>;
+export type SubscribeUpstream = v.Infer<typeof subscribeUpstreamSchema>;
+/**
+ * The reservation confirmation. Carries the same payload as the legacy
+ * `/snapshot` status (`backupURL`, `replicaVersion`, `minWatermark`,
+ * `replicaSize?`) but under a distinct `'reserved'` tag so it does not collide
+ * with the change stream's `['status', …]` message.
+ */
+export declare const reservedMessageSchema: v.TupleType<[v.Type<"reserved">, v.ObjectType<Omit<{
+    tag: v.Type<"status">;
+    backupURL: v.Type<string>;
+    replicaVersion: v.Type<string>;
+    minWatermark: v.Type<string>;
+    replicaSize: v.Optional<number>;
+}, "tag"> & {
+    tag: v.Type<"snapshot">;
+}, undefined>]>;
+export type ReservedMessage = v.Infer<typeof reservedMessageSchema>;
+export declare const subscribeDownstreamSchema: v.UnionType<[v.TupleType<[v.Type<"reserved">, v.ObjectType<Omit<{
+    tag: v.Type<"status">;
+    backupURL: v.Type<string>;
+    replicaVersion: v.Type<string>;
+    minWatermark: v.Type<string>;
+    replicaSize: v.Optional<number>;
+}, "tag"> & {
+    tag: v.Type<"snapshot">;
+}, undefined>]>, v.UnionType<[v.TupleType<[v.Type<"status">, v.ObjectType<{
+    tag: v.Type<"status">;
+    lagReport: v.Optional<{
+        lastTimings?: {
+            sendTimeMs: number;
+            commitTimeMs: number;
+            receiveTimeMs: number;
+        } | undefined;
+        nextSendTimeMs: number;
+    }>;
+}, undefined>]>, v.UnionType<[v.TupleType<[v.Type<"begin">, v.ObjectType<{
+    tag: v.Type<"begin">;
+    json: v.Optional<"p" | "s">;
+    skipAck: v.Optional<boolean>;
+}, undefined>, v.ObjectType<{
+    commitWatermark: v.Type<string>;
+}, undefined>]>, v.TupleType<[v.Type<"data">, v.UnionType<[v.UnionType<[v.ObjectType<{
+    tag: v.Type<"insert">;
+    relation: v.Type<{
+        schema: string;
+        name: string;
+        keyColumns?: string[] | undefined;
+        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
+        rowKey: {
+            columns: string[];
+            type?: "default" | "full" | "index" | "nothing" | undefined;
+        };
+    }>;
+    new: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update">;
+    relation: v.Type<{
+        schema: string;
+        name: string;
+        keyColumns?: string[] | undefined;
+        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
+        rowKey: {
+            columns: string[];
+            type?: "default" | "full" | "index" | "nothing" | undefined;
+        };
+    }>;
+    key: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue> | null>;
+    new: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"delete">;
+    relation: v.Type<{
+        schema: string;
+        name: string;
+        keyColumns?: string[] | undefined;
+        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
+        rowKey: {
+            columns: string[];
+            type?: "default" | "full" | "index" | "nothing" | undefined;
+        };
+    }>;
+    key: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"truncate">;
+    relations: v.ArrayType<v.Type<{
+        schema: string;
+        name: string;
+        keyColumns?: string[] | undefined;
+        replicaIdentity?: "default" | "full" | "index" | "nothing" | undefined;
+        rowKey: {
+            columns: string[];
+            type?: "default" | "full" | "index" | "nothing" | undefined;
+        };
+    }>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"backfill">;
+    relation: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        rowKey: v.ObjectType<{
+            columns: v.ArrayType<v.Type<string>>;
+            type: v.Optional<"default" | "full" | "index" | "nothing">;
+        }, undefined>;
+    }, undefined>;
+    columns: v.ArrayType<v.Type<string>>;
+    watermark: v.Type<string>;
+    rowValues: v.ArrayType<v.ArrayType<v.Type<import("../../../../shared/src/bigint-json.ts").JSONValue>>>;
+    status: v.Optional<{
+        rows: number;
+        totalRows: number;
+        totalBytes?: number | undefined;
+    }>;
+}, undefined>]>, v.UnionType<[v.ObjectType<{
+    tag: v.Type<"create-table">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        columns: v.Type<Record<string, {
+            pos: number;
+            dataType: string;
+            pgTypeClass?: "b" | "c" | "d" | "e" | "m" | "p" | "r" | undefined;
+            elemPgTypeClass?: "b" | "c" | "d" | "e" | "m" | "p" | "r" | null | undefined;
+            characterMaximumLength?: number | null | undefined;
+            notNull?: boolean | null | undefined;
+            dflt?: string | null | undefined;
+        }>>;
+        primaryKey: v.Optional<string[]>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+    metadata: v.Optional<{
+        [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
+        rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
+    }>;
+    backfill: v.Optional<Record<string, Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"rename-table">;
+    old: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    new: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update-table-metadata">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    old: v.ObjectType<{
+        rowKey: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+    }, v.Type<import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+    new: v.ObjectType<{
+        rowKey: v.Type<Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+    }, v.Type<import("../../../../shared/src/bigint-json.ts").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"add-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r">;
+            elemPgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r" | null>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+    tableMetadata: v.Optional<{
+        [x: string]: import("../../../../shared/src/bigint-json.ts").JSONValue;
+        rowKey: Record<string, import("../../../../shared/src/bigint-json.ts").JSONValue>;
+    }>;
+    backfill: v.Optional<Record<string, import("../change-source/protocol/current.ts").JSONValue | undefined>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    old: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r">;
+            elemPgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r" | null>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+    new: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r">;
+            elemPgTypeClass: v.Optional<"b" | "c" | "d" | "e" | "m" | "p" | "r" | null>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.Type<string>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-table">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-index">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        tableName: v.Type<string>;
+        unique: v.Type<boolean>;
+        columns: v.Type<Record<string, "ASC" | "DESC">>;
+        predicate: v.Optional<import("../../db/specs.ts").IndexPredicate>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-index">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"backfill-completed">;
+    relation: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        rowKey: v.ObjectType<{
+            columns: v.ArrayType<v.Type<string>>;
+            type: v.Optional<"default" | "full" | "index" | "nothing">;
+        }, undefined>;
+    }, undefined>;
+    columns: v.ArrayType<v.Type<string>>;
+    watermark: v.Type<string>;
+    status: v.Optional<{
+        rows: number;
+        totalRows: number;
+        totalBytes?: number | undefined;
+    }>;
+}, undefined>]>]>]>, v.TupleType<[v.Type<"commit">, v.ObjectType<{
+    tag: v.Type<"commit">;
+    commitTimeMs: v.Optional<number>;
+}, undefined>, v.ObjectType<{
+    watermark: v.Type<string>;
+}, undefined>]>, v.TupleType<[v.Type<"rollback">, v.ObjectType<{
+    tag: v.Type<"rollback">;
+}, undefined>]>]>, v.TupleType<[v.Type<"error">, v.ObjectType<{
+    type: v.Type<number>;
+    message: v.Optional<string>;
+}, undefined>]>]>]>;
+export type SubscribeDownstream = v.Infer<typeof subscribeDownstreamSchema>;
+export {};
+//# sourceMappingURL=subscribe.d.ts.map

package/out/zero-cache/src/services/change-streamer/subscribe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/change-streamer/subscribe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,CAAC,MAAM,kCAAkC,CAAC;AAItD,QAAA,MAAM,oBAAoB;;;;;;;;aAExB,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAMlE,eAAO,MAAM,4BAA4B;;eAGvC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,sBAAsB;IACjC,2EAA2E;;IAE3E,sCAAsC;;IAEtC,8DAA8D;;IAE9D,gEAAgE;;IAEhE,8DAA8D;;aAE9D,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,8BAA8B;IAdzC,2EAA2E;;IAE3E,sCAAsC;;IAEtC,8DAA8D;;IAE9D,gEAAgE;;IAEhE,8DAA8D;;eAS9D,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;IAnBlC,2EAA2E;;IAE3E,sCAAsC;;IAEtC,8DAA8D;;IAE9D,gEAAgE;;IAEhE,8DAA8D;;iBAc/D,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAMxE;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;eAGhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAGrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/out/zero-cache/src/services/change-streamer/subscribe.js

@@ -0,0 +1,68 @@
+import { valita_exports } from "../../../../shared/src/valita.js";
+import { downstreamSchema } from "./change-streamer.js";
+import { statusSchema } from "./snapshot-message.js";
+//#region ../zero-cache/src/services/change-streamer/subscribe.ts
+/**
+* The `subscribe` API (protocol v7+) merges the previous `/snapshot` and
+* `/changes` connections into a single bidirectional WebSocket, so that the
+* replication-manager that reserves change-log entries for a soon-to-be
+* subscriber is the same replication-manager that serves the subscription.
+*
+* The connection is driven by an upstream (view-syncer → replication-manager)
+* application message that selects the flow:
+*
+* - **Fresh startup:** the view-syncer sends `['reserve-snapshot', {taskID}]`.
+*   The change-streamer opens a snapshot reservation (pinning the change log)
+*   and replies downstream with a single `['reserved', …]` message telling the
+*   view-syncer where to restore the backup from and the watermark from which
+*   catchup is possible. Once the backup is restored, the view-syncer sends
+*   `['start-subscription', ctx]`, which transitions the same connection into
+*   the subscription phase (change stream downstream). The reservation is
+*   released only after the subscriber is registered, so there is never a gap
+*   in which the change-streamer does not know the client's watermark.
+*
+* - **Reconnect (replica already valid):** the view-syncer sends
+*   `['start-subscription', ctx]` immediately, with no reservation.
+*
+* The reservation status uses a distinct `'reserved'` tag (rather than the
+* change stream's `'status'`) so the downstream union is unambiguous under
+* passthrough parsing.
+*/
+var snapshotStatusSchema = statusSchema.extend({ tag: valita_exports.literal("snapshot") });
+var reserveSnapshotMessageSchema = valita_exports.tuple([valita_exports.literal("reserve-snapshot"), valita_exports.object({ taskID: valita_exports.string() })]);
+/**
+* The subscription-initialization context, sent in the `start-subscription`
+* message. Equivalent to the previous URL-encoded `SubscriberContext`, minus
+* the fields that are now implicit on the merged connection:
+* - `protocolVersion` comes from the request path.
+* - `wsBatched` is always on (the transport batches internally).
+*
+* Parsed in `passthrough` mode so a forthcoming, orthogonal change can add
+* arbitrary table/column/backfill state without a protocol bump.
+*/
+var subscribeContextSchema = valita_exports.object({
+	/** Task ID, links the subscription to a preceding snapshot reservation. */
+	taskID: valita_exports.string(),
+	/** Subscriber id (debugging only). */
+	id: valita_exports.string(),
+	/** 'serving' (user-facing) or 'backup' (in-RM replicator). */
+	mode: valita_exports.union(valita_exports.literal("serving"), valita_exports.literal("backup")),
+	/** The replica version the subscriber restored / is running. */
+	replicaVersion: valita_exports.string(),
+	/** The watermark up to which the subscriber is up to date. */
+	watermark: valita_exports.string()
+});
+var startSubscriptionMessageSchema = valita_exports.tuple([valita_exports.literal("start-subscription"), subscribeContextSchema]);
+var subscribeUpstreamSchema = valita_exports.union(reserveSnapshotMessageSchema, startSubscriptionMessageSchema);
+/**
+* The reservation confirmation. Carries the same payload as the legacy
+* `/snapshot` status (`backupURL`, `replicaVersion`, `minWatermark`,
+* `replicaSize?`) but under a distinct `'reserved'` tag so it does not collide
+* with the change stream's `['status', …]` message.
+*/
+var reservedMessageSchema = valita_exports.tuple([valita_exports.literal("reserved"), snapshotStatusSchema]);
+var subscribeDownstreamSchema = valita_exports.union(reservedMessageSchema, downstreamSchema);
+//#endregion
+export { subscribeDownstreamSchema, subscribeUpstreamSchema };
+
+//# sourceMappingURL=subscribe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe.js","names":[],"sources":["../../../../../../zero-cache/src/services/change-streamer/subscribe.ts"],"sourcesContent":["/**\n * The `subscribe` API (protocol v7+) merges the previous `/snapshot` and\n * `/changes` connections into a single bidirectional WebSocket, so that the\n * replication-manager that reserves change-log entries for a soon-to-be\n * subscriber is the same replication-manager that serves the subscription.\n *\n * The connection is driven by an upstream (view-syncer → replication-manager)\n * application message that selects the flow:\n *\n * - **Fresh startup:** the view-syncer sends `['reserve-snapshot', {taskID}]`.\n *   The change-streamer opens a snapshot reservation (pinning the change log)\n *   and replies downstream with a single `['reserved', …]` message telling the\n *   view-syncer where to restore the backup from and the watermark from which\n *   catchup is possible. Once the backup is restored, the view-syncer sends\n *   `['start-subscription', ctx]`, which transitions the same connection into\n *   the subscription phase (change stream downstream). The reservation is\n *   released only after the subscriber is registered, so there is never a gap\n *   in which the change-streamer does not know the client's watermark.\n *\n * - **Reconnect (replica already valid):** the view-syncer sends\n *   `['start-subscription', ctx]` immediately, with no reservation.\n *\n * The reservation status uses a distinct `'reserved'` tag (rather than the\n * change stream's `'status'`) so the downstream union is unambiguous under\n * passthrough parsing.\n */\n\nimport * as v from '../../../../shared/src/valita.ts';\nimport {downstreamSchema} from './change-streamer.ts';\nimport {statusSchema} from './snapshot-message.ts';\n\nconst snapshotStatusSchema = statusSchema.extend({\n  tag: v.literal('snapshot'), // Replace tag: 'status' with tag: 'snapshot'\n});\n\nexport type SnapshotStatus = v.Infer<typeof snapshotStatusSchema>;\n\n// ---------------------------------------------------------------------------\n// Upstream (view-syncer → replication-manager) — application control messages.\n// ---------------------------------------------------------------------------\n\nexport const reserveSnapshotMessageSchema = v.tuple([\n  v.literal('reserve-snapshot'),\n  v.object({taskID: v.string()}),\n]);\n\n/**\n * The subscription-initialization context, sent in the `start-subscription`\n * message. Equivalent to the previous URL-encoded `SubscriberContext`, minus\n * the fields that are now implicit on the merged connection:\n * - `protocolVersion` comes from the request path.\n * - `wsBatched` is always on (the transport batches internally).\n *\n * Parsed in `passthrough` mode so a forthcoming, orthogonal change can add\n * arbitrary table/column/backfill state without a protocol bump.\n */\nexport const subscribeContextSchema = v.object({\n  /** Task ID, links the subscription to a preceding snapshot reservation. */\n  taskID: v.string(),\n  /** Subscriber id (debugging only). */\n  id: v.string(),\n  /** 'serving' (user-facing) or 'backup' (in-RM replicator). */\n  mode: v.union(v.literal('serving'), v.literal('backup')),\n  /** The replica version the subscriber restored / is running. */\n  replicaVersion: v.string(),\n  /** The watermark up to which the subscriber is up to date. */\n  watermark: v.string(),\n});\n\nexport type SubscribeContext = v.Infer<typeof subscribeContextSchema>;\n\nexport const startSubscriptionMessageSchema = v.tuple([\n  v.literal('start-subscription'),\n  subscribeContextSchema,\n]);\n\nexport const subscribeUpstreamSchema = v.union(\n  reserveSnapshotMessageSchema,\n  startSubscriptionMessageSchema,\n);\n\nexport type SubscribeUpstream = v.Infer<typeof subscribeUpstreamSchema>;\n\n// ---------------------------------------------------------------------------\n// Downstream (replication-manager → view-syncer).\n// ---------------------------------------------------------------------------\n\n/**\n * The reservation confirmation. Carries the same payload as the legacy\n * `/snapshot` status (`backupURL`, `replicaVersion`, `minWatermark`,\n * `replicaSize?`) but under a distinct `'reserved'` tag so it does not collide\n * with the change stream's `['status', …]` message.\n */\nexport const reservedMessageSchema = v.tuple([\n  v.literal('reserved'),\n  snapshotStatusSchema,\n]);\n\nexport type ReservedMessage = v.Infer<typeof reservedMessageSchema>;\n\nexport const subscribeDownstreamSchema = v.union(\n  reservedMessageSchema,\n  downstreamSchema,\n);\n\nexport type SubscribeDownstream = v.Infer<typeof subscribeDownstreamSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAM,uBAAuB,aAAa,OAAO,EAC/C,KAAK,eAAE,QAAQ,UAAU,EAC3B,CAAC;AAQD,IAAa,+BAA+B,eAAE,MAAM,CAClD,eAAE,QAAQ,kBAAkB,GAC5B,eAAE,OAAO,EAAC,QAAQ,eAAE,OAAO,EAAC,CAAC,CAC/B,CAAC;;;;;;;;;;;AAYD,IAAa,yBAAyB,eAAE,OAAO;;CAE7C,QAAQ,eAAE,OAAO;;CAEjB,IAAI,eAAE,OAAO;;CAEb,MAAM,eAAE,MAAM,eAAE,QAAQ,SAAS,GAAG,eAAE,QAAQ,QAAQ,CAAC;;CAEvD,gBAAgB,eAAE,OAAO;;CAEzB,WAAW,eAAE,OAAO;AACtB,CAAC;AAID,IAAa,iCAAiC,eAAE,MAAM,CACpD,eAAE,QAAQ,oBAAoB,GAC9B,sBACF,CAAC;AAED,IAAa,0BAA0B,eAAE,MACvC,8BACA,8BACF;;;;;;;AAcA,IAAa,wBAAwB,eAAE,MAAM,CAC3C,eAAE,QAAQ,UAAU,GACpB,oBACF,CAAC;AAID,IAAa,4BAA4B,eAAE,MACzC,uBACA,gBACF"}

package/out/zero-cache/src/services/litestream/commands.d.ts

@@ -7,7 +7,7 @@ export type ReplicaConstraints = {
     minWatermark: string;
 };
 export type RestoreResult = 'success' | 'no_backup' | 'invalid_replica' | 'error';
-type RestoreAttempt = {
+export type RestoreAttempt = {
     restored: boolean;
     backupURL: string | undefined;
     result: RestoreResult;
@@ -16,7 +16,7 @@ export declare class BackupNotFoundException extends Error {
     static readonly name = "BackupNotFoundException";
     constructor(backupURL: string | undefined);
 }
-export declare function tryRestore(lc: LogContext, config: LitestreamConfig, replicaFile: string, replicaConstraints: ReplicaConstraints | undefined, role: LitestreamRole): Promise<RestoreAttempt>;
+export declare function tryRestore(lc: LogContext, config: LitestreamConfig, replicaFile: string, replicaConstraints: ReplicaConstraints | undefined, role: LitestreamRole, signal?: AbortSignal): Promise<RestoreAttempt>;
 export declare function startReplicaBackupProcess(lc: LogContext, config: LitestreamConfig, replicaFile: string): ChildProcess;
 /**
  * Returns the time of the most recent object (snapshot or WAL segment)
@@ -41,5 +41,4 @@ export declare function getLastBackupTime(lc: LogContext, config: LitestreamConf
  * Exported for testing.
  */
 export declare function parseBackupCreatedTimes(lc: LogContext, command: 'snapshots' | 'wal', output: string): Date[];
-export {};
 //# sourceMappingURL=commands.d.ts.map

package/out/zero-cache/src/services/litestream/commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAIrD,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAI3D,OAAO,EAAC,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAUhE,OAAO,EAWL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,WAAW,GACX,iBAAiB,GACjB,OAAO,CAAC;AAEZ,KAAK,cAAc,GAAG;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAKF,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA6B;IAEjD,YAAY,SAAS,EAAE,MAAM,GAAG,SAAS,EAExC;CACF;AAyFD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAClD,IAAI,EAAE,cAAc,GACnB,OAAO,CAAC,cAAc,CAAC,CAwIzB;AAoGD,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,YAAY,CAuCd;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf;AA8DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,WAAW,GAAG,KAAK,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CAoBR"}
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../../../../../zero-cache/src/services/litestream/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAIrD,OAAO,KAAK,EAAC,UAAU,EAAW,MAAM,kBAAkB,CAAC;AAI3D,OAAO,EAAC,KAAK,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAUhE,OAAO,EAWL,KAAK,cAAc,EACpB,MAAM,cAAc,CAAC;AAEtB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,WAAW,GACX,iBAAiB,GACjB,OAAO,CAAC;AAEZ,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,EAAE,aAAa,CAAC;CACvB,CAAC;AAKF,qBAAa,uBAAwB,SAAQ,KAAK;IAChD,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA6B;IAEjD,YAAY,SAAS,EAAE,MAAM,GAAG,SAAS,EAExC;CACF;AAyFD,wBAAsB,UAAU,CAC9B,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,EACnB,kBAAkB,EAAE,kBAAkB,GAAG,SAAS,EAClD,IAAI,EAAE,cAAc,EACpB,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,cAAc,CAAC,CAwIzB;AAoGD,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,YAAY,CAuCd;AAQD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CACrC,EAAE,EAAE,UAAU,EACd,MAAM,EAAE,gBAAgB,EACxB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAgBf;AA8DD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,EAAE,UAAU,EACd,OAAO,EAAE,WAAW,GAAG,KAAK,EAC5B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CAoBR"}

package/out/zero-cache/src/services/litestream/commands.js

@@ -47,7 +47,7 @@ function getLitestream(mode, config, replicaFile, logLevelOverride) {
 		}
 	};
 }
-async function tryRestore(lc, config, replicaFile, replicaConstraints, role) {
+async function tryRestore(lc, config, replicaFile, replicaConstraints, role, signal) {
 	const { backupURL } = config;
 	const attrs = litestreamRestoreMetricAttrs(config, role, backupURL);
 	let result = "error";
@@ -76,7 +76,8 @@ async function tryRestore(lc, config, replicaFile, replicaConstraints, role) {
 				"pipe",
 				"pipe"
 			],
-			windowsHide: true
+			windowsHide: true,
+			signal
 		});
 		let stdout = "";
 		let stderr = "";