@smthrs/sync 0.0.0-stage → 1.0.0-rc.4

package/dist/cjs/SyncClient.js

@@ -0,0 +1,474 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SyncClient_exports = {};
+__export(SyncClient_exports, {
+  Sync: () => Sync,
+  SyncClient: () => SyncClient,
+  defaultBootstrapLimit: () => defaultBootstrapLimit,
+  defaultCredit: () => defaultCredit,
+  layer: () => layer,
+  layerNoop: () => layerNoop,
+  layerWith: () => layerWith,
+  make: () => make,
+  makeNoop: () => makeNoop,
+  makeWith: () => makeWith
+});
+module.exports = __toCommonJS(SyncClient_exports);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Context = __toESM(require("effect/Context"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var Ref = __toESM(require("effect/Ref"), 1);
+var Schedule = __toESM(require("effect/Schedule"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var Stream = __toESM(require("effect/Stream"), 1);
+var RpcClient = __toESM(require("effect/unstable/rpc/RpcClient"), 1);
+var RpcClientError = __toESM(require("effect/unstable/rpc/RpcClientError"), 1);
+var Admission = __toESM(require("./internal/Admission.js"), 1);
+var import_CauseText = require("./internal/CauseText.js");
+var import_PolicyOptions = require("./internal/PolicyOptions.js");
+var SnapshotBoundary = __toESM(require("./internal/SnapshotBoundary.js"), 1);
+var import_SyncError = require("./SyncError.js");
+var import_SyncProtocol = require("./SyncProtocol.js");
+var import_SyncRpcs = require("./SyncRpcs.js");
+const defaultCredit = 256;
+const defaultBootstrapLimit = 256;
+const defaults = {
+  maxFrameBytes: import_SyncProtocol.defaultMaxFrameBytes,
+  bootstrapLimit: defaultBootstrapLimit
+};
+class SyncClient extends Context.Service()("@smthrs/sync/SyncClient") {
+}
+const Sync = SyncClient;
+const makeNoop = (overrides = {}) => SyncClient.of({
+  snapshot: () => Effect.fail(new import_SyncError.SyncError({ code: "closed", message: "Sync client is closed" })),
+  subscribe: () => Stream.fail(new import_SyncError.SyncError({ code: "closed", message: "Sync client is closed" })),
+  progress: Effect.succeed({ delivered: [], applied: [] }),
+  ...overrides
+});
+const layerNoop = (overrides = {}) => Layer.succeed(SyncClient, makeNoop(overrides));
+const transportError = (cause) => cause instanceof import_SyncError.SyncError ? cause : cause instanceof RpcClientError.RpcClientError && cause.reason._tag === "RpcClientDefect" ? new import_SyncError.SyncError({ code: "protocol_violation", message: "Sync RPC protocol failed", cause: (0, import_CauseText.causeCode)(cause.reason) }) : new import_SyncError.SyncError({
+  code: "transport_failed",
+  // Bounded like `cause`. `message` is `Schema.String` and it is the
+  // declared error schema of every RPC, so a host's own sentence must not
+  // be able to be the largest thing this error carries.
+  message: cause instanceof Error ? (0, import_CauseText.boundedText)(cause.message) : "Sync RPC transport failed",
+  cause: (0, import_CauseText.causeText)(cause)
+});
+const rpcCause = (cause) => Cause.fromReasons(
+  Cause.map(cause, transportError).reasons.map(
+    (reason) => Cause.isDieReason(reason) && Schema.isSchemaError(reason.defect) ? Cause.makeFailReason(
+      new import_SyncError.SyncError({ code: "decode_failed", message: "Invalid sync RPC response", cause: "SchemaError" })
+    ).annotate(Context.makeUnsafe(reason.annotations)) : reason
+  )
+);
+const cursorMap = (cursors) => new Map(cursors.map((cursor) => [cursor.runId, { ...cursor }]));
+const canonicalCursors = (cursors) => Array.from(cursors.values(), (cursor) => ({ ...cursor })).sort(
+  (left, right) => (
+    // A Map has one value per key, so this comparator never receives equal
+    // run IDs. `cursorMap` and the acknowledged cursor state both establish
+    // that invariant before reaching this boundary.
+    left.runId > right.runId ? 1 : -1
+  )
+);
+const advance = (cursors, runId, throughSeq, generation) => {
+  const current = cursors.get(runId);
+  if (current !== void 0 && current.afterSeq >= throughSeq) return cursors;
+  const next = new Map(cursors);
+  next.set(runId, { runId, afterSeq: throughSeq, generation });
+  return next;
+};
+const reconnectPolicy = Schedule.min([
+  Schedule.exponential(500, 1.5),
+  Schedule.spaced(5e3)
+]).pipe(
+  Schedule.while(({ input }) => isTransportCause(input))
+);
+const isTransportCause = (cause) => {
+  const reason = cause.reasons[0];
+  return cause.reasons.length === 1 && Cause.isFailReason(reason) && import_SyncError.SyncError.is(reason.error) && reason.error.code === "transport_failed";
+};
+const lineageChanged = (runId) => new import_SyncError.SyncError({
+  code: "lineage_changed",
+  message: `Run ${runId} was rewound; rebuild from its archive boundary with a fresh sync client`
+});
+const entriesByteLength = (entries) => entries.reduce((bytes, entry) => bytes + (0, import_SyncProtocol.encodedByteLength)(entry), 0);
+const oversized = (bytes, maxFrameBytes) => new import_SyncError.SyncError({
+  code: "frame_too_large",
+  message: `Encoded entries of ${bytes} bytes exceed the ${maxFrameBytes}-byte frame ceiling`
+});
+const frameViolation = (frame) => {
+  let previous = -1;
+  for (const entry of frame.entries) {
+    if (entry.runId !== frame.runId) {
+      return new import_SyncError.SyncError({
+        code: "protocol_violation",
+        cause: "foreign_run",
+        message: `Frame for run ${frame.runId} carried an entry for run ${entry.runId}`
+      });
+    }
+    if (entry.seq <= previous) {
+      return new import_SyncError.SyncError({
+        code: "protocol_violation",
+        cause: "non_monotonic_sequence",
+        message: `Frame entries must ascend strictly: sequence ${entry.seq} arrived after ${previous}`
+      });
+    }
+    if (entry.seq < frame.fromSeq || frame.toSeq < entry.seq) {
+      return new import_SyncError.SyncError({
+        code: "protocol_violation",
+        cause: "invalid_frame_interval",
+        message: `Entry ${entry.seq} lies outside the frame's covered interval ${frame.fromSeq}..${frame.toSeq}`
+      });
+    }
+    previous = entry.seq;
+  }
+  return void 0;
+};
+const pageViolation = (scope, requested, response) => {
+  const violation = (message) => new import_SyncError.SyncError({ code: "protocol_violation", message, cause: "invalid_read_page" });
+  const generations = /* @__PURE__ */ new Set();
+  for (const cursor of response.cursors) {
+    generations.add(cursor.runId);
+    if (cursor.generation === void 0) return violation("Read response lacks a generation");
+    const previous = requested.get(cursor.runId);
+    if (previous !== void 0 && (previous.generation ?? 0) !== cursor.generation) {
+      return lineageChanged(cursor.runId);
+    }
+  }
+  const highest = /* @__PURE__ */ new Map();
+  for (const entry of response.entries) {
+    if (!(0, import_SyncProtocol.covers)(scope, entry.runId)) {
+      return violation(`Read page carried an entry for run ${entry.runId}, which the request's scope excludes`);
+    }
+    const floor = requested.get(entry.runId)?.afterSeq;
+    if (floor !== void 0 && entry.seq <= floor) {
+      return violation(
+        `Read page carried sequence ${entry.seq} for run ${entry.runId}, at or below the requested cursor ${floor}`
+      );
+    }
+    const previous = highest.get(entry.runId);
+    if (previous !== void 0 && entry.seq <= previous) {
+      return violation(
+        `Read page entries for run ${entry.runId} must ascend strictly: sequence ${entry.seq} arrived after ${previous}`
+      );
+    }
+    highest.set(entry.runId, entry.seq);
+  }
+  for (const runId of highest.keys()) {
+    if (!generations.has(runId)) return violation(`Read page lacks a generation cursor for run ${runId}`);
+  }
+  const duplicate = (0, import_SyncProtocol.duplicateCursorRunId)(response.cursors);
+  return duplicate === void 0 ? void 0 : violation(`Read page echoed run ${duplicate} more than once`);
+};
+const make = ({ client }) => service(client, defaults);
+const makeWith = ({
+  bootstrapLimit,
+  client,
+  maxFrameBytes
+}) => Effect.flatMap(
+  Effect.all({
+    maxFrameBytes: (0, import_PolicyOptions.positiveInt)("SyncClient.Options.maxFrameBytes", maxFrameBytes, defaults.maxFrameBytes),
+    bootstrapLimit: (0, import_PolicyOptions.boundedInt)(
+      "SyncClient.Options.bootstrapLimit",
+      bootstrapLimit,
+      defaults.bootstrapLimit,
+      import_SyncProtocol.maxReadLimit
+    )
+  }),
+  (policy) => service(client, policy)
+);
+const service = (client, { bootstrapLimit, maxFrameBytes }) => Effect.sync(() => {
+  const delivered = Ref.makeUnsafe(/* @__PURE__ */ new Map());
+  const applied = Ref.makeUnsafe(/* @__PURE__ */ new Map());
+  const progress = Effect.gen(function* () {
+    return {
+      delivered: canonicalCursors(yield* Ref.get(delivered)),
+      applied: canonicalCursors(yield* Ref.get(applied))
+    };
+  });
+  const snapshot = (input) => Effect.gen(function* () {
+    const request = yield* SnapshotBoundary.request(input);
+    const supplied = yield* client["Sync.Snapshot"]({ ...request }).pipe(
+      Effect.catchCause((cause) => Effect.failCause(rpcCause(cause)))
+    );
+    return yield* SnapshotBoundary.response(request, supplied, maxFrameBytes);
+  });
+  const subscribe = (input) => Stream.unwrap(Effect.gen(function* () {
+    const options = {
+      ...input,
+      ...yield* Admission.decode(import_SyncProtocol.RequestEnvelope, input, "invalid_request")
+    };
+    const credit = yield* (0, import_PolicyOptions.boundedInt)(
+      "SyncClient.SubscribeOptions.credit",
+      options.credit,
+      defaultCredit,
+      import_SyncProtocol.maxSubscribeCredit
+    );
+    const cursor = cursorMap(options.cursors);
+    for (const [runId, position] of yield* Ref.get(options.apply === void 0 ? delivered : applied)) {
+      const supplied = cursor.get(runId);
+      if (supplied !== void 0 && (supplied.generation ?? 0) !== position.generation) {
+        return yield* Effect.fail(lineageChanged(runId));
+      }
+      if (supplied === void 0 || supplied.afterSeq < position.afterSeq) cursor.set(runId, position);
+    }
+    const snapshot2 = () => canonicalCursors(cursor);
+    const commit = (runId, throughSeq, generation, wasApplied) => Effect.gen(function* () {
+      for (const view of wasApplied ? [delivered, applied] : [delivered]) {
+        const previous = (yield* Ref.get(view)).get(runId);
+        if (previous !== void 0 && previous.generation !== generation) {
+          return yield* Effect.fail(lineageChanged(runId));
+        }
+      }
+      yield* Ref.update(delivered, (shared) => advance(shared, runId, throughSeq, generation));
+      if (wasApplied) yield* Ref.update(applied, (shared) => advance(shared, runId, throughSeq, generation));
+      cursor.set(runId, { runId, afterSeq: throughSeq, generation });
+    }).pipe(Effect.uninterruptible);
+    const applyEntry = options.apply;
+    const deliver = (runId, entry, generation) => {
+      const through = entry.seq;
+      return Stream.concat(
+        Stream.drain(Stream.fromEffect(
+          applyEntry === void 0 ? commit(runId, through, generation, false) : Effect.uninterruptibleMask(
+            (restore) => Effect.andThen(restore(applyEntry(entry)), commit(runId, through, generation, true))
+          )
+        )),
+        Stream.succeed(entry)
+      );
+    };
+    const batch = (frame) => {
+      if (frame.generation === void 0) {
+        return Stream.fail(
+          new import_SyncError.SyncError({ code: "protocol_violation", message: "Entries frame lacks a generation" })
+        );
+      }
+      if (!(0, import_SyncProtocol.covers)(options.scope, frame.runId)) {
+        return Stream.fail(
+          new import_SyncError.SyncError({
+            code: "protocol_violation",
+            message: "Live frame is outside the subscription scope",
+            cause: "foreign_run"
+          })
+        );
+      }
+      const frameBytes = entriesByteLength(frame.entries);
+      if (frameBytes > maxFrameBytes) return Stream.fail(oversized(frameBytes, maxFrameBytes));
+      const violation = frameViolation(frame);
+      if (violation !== void 0) return Stream.fail(violation);
+      const position = cursor.get(frame.runId);
+      const generation = frame.generation;
+      if (position !== void 0 && (position.generation ?? 0) !== generation) {
+        return Stream.fail(lineageChanged(frame.runId));
+      }
+      const afterSeq = position?.afterSeq ?? -1;
+      if (frame.fromSeq > afterSeq + 1) {
+        return Stream.fail(
+          new import_SyncError.SyncGapError({
+            runId: frame.runId,
+            expectedFrom: afterSeq + 1,
+            receivedFrom: frame.fromSeq
+          })
+        );
+      }
+      if (frame.toSeq <= afterSeq) return Stream.empty;
+      const entries = frame.entries.filter((entry) => entry.seq > afterSeq);
+      return Stream.flatMap(Stream.fromIterable(entries), (entry) => deliver(frame.runId, entry, generation));
+    };
+    const livePage = (onFrame) => Stream.unwrap(
+      Effect.sync(
+        () => client["Sync.Subscribe"]({
+          protocolVersion: import_SyncProtocol.protocolVersion,
+          scope: options.scope,
+          cursors: snapshot2(),
+          credit,
+          ...options.capability === void 0 ? {} : { capability: options.capability }
+        })
+      )
+    ).pipe(
+      Stream.catchCause((cause) => Stream.failCause(rpcCause(cause))),
+      Stream.mapEffect((frame) => Admission.decode(import_SyncProtocol.Frame, frame)),
+      Stream.mapEffect(
+        (frame) => frame._tag === "Entries" ? Effect.map(Admission.records(frame.entries), (entries) => ({ ...frame, entries })) : Effect.succeed(frame)
+      ),
+      Stream.flatMap((frame) => {
+        onFrame();
+        switch (frame._tag) {
+          case "Entries":
+            return batch(frame);
+          case "Closed":
+            return Stream.fail(new import_SyncError.SyncError({ code: "closed", message: "Sync subscription closed" }));
+          default:
+            return Stream.empty;
+        }
+      })
+    );
+    const live = () => Stream.unwrap(Effect.sync(() => {
+      let receivedFrame = false;
+      return Stream.concat(
+        livePage(() => {
+          receivedFrame = true;
+        }),
+        Stream.unwrap(Effect.sync(
+          () => receivedFrame ? live() : Stream.fail(
+            new import_SyncError.SyncError({
+              code: "protocol_violation",
+              message: "Subscription window closed without frames"
+            })
+          )
+        ))
+      );
+    }));
+    const follow = () => live().pipe(
+      Stream.tapCause(
+        (cause) => isTransportCause(cause) ? Effect.logWarning("sync live follow transport failed; reconnecting with backoff", cause) : Effect.void
+      ),
+      // Schedule the complete cause so retry refusal cannot discard an
+      // accompanying defect, interruption, or tracing annotation.
+      Stream.catchCause((cause) => Stream.fail(cause)),
+      Stream.retry(reconnectPolicy),
+      Stream.catch((cause) => Stream.failCause(cause))
+    );
+    const bootstrap = () => Stream.unwrap(
+      // SUSPENDED, exactly as `livePage` is. Building the payload where
+      // the recursive call is written snapshotted the cursors as page N
+      // was mapped, before a single one of its entries had reached
+      // `commit` — so read N+1 carried read N's request cursors and the
+      // server correctly re-served the page it had just served. Every
+      // catch-up page past the first arrived twice.
+      Effect.suspend(() => {
+        const requested = snapshot2();
+        return client["Sync.Read"]({
+          protocolVersion: import_SyncProtocol.protocolVersion,
+          scope: options.scope,
+          cursors: requested,
+          limit: bootstrapLimit,
+          ...options.capability === void 0 ? {} : { capability: options.capability }
+        }).pipe(
+          Effect.catchCause((cause) => Effect.failCause(rpcCause(cause))),
+          Effect.flatMap((response) => Admission.decode(import_SyncProtocol.ReadResponse, response)),
+          Effect.flatMap(
+            (response) => Effect.map(Admission.records(response.entries), (entries) => ({ ...response, entries }))
+          ),
+          Effect.map((response) => {
+            const pageBytes = entriesByteLength(response.entries);
+            if (pageBytes > maxFrameBytes) return Stream.fail(oversized(pageBytes, maxFrameBytes));
+            const violation = pageViolation(options.scope, cursorMap(requested), response);
+            if (violation !== void 0) return Stream.fail(violation);
+            const generations = new Map(response.cursors.map((cursor2) => [cursor2.runId, cursor2.generation]));
+            const page = Stream.flatMap(
+              Stream.fromIterable(response.entries),
+              (entry) => deliver(
+                entry.runId,
+                entry,
+                generations.get(entry.runId)
+              )
+            );
+            if (response.done) return Stream.concat(page, follow());
+            if (response.entries.length === 0) {
+              return Stream.fail(
+                new import_SyncError.SyncError({
+                  code: "protocol_violation",
+                  message: "Bootstrap read reported more durable entries but returned an empty page"
+                })
+              );
+            }
+            return Stream.concat(page, bootstrap());
+          })
+        );
+      })
+    );
+    const resyncTarget = (failure) => {
+      if (!import_SyncError.SyncError.is(failure) || failure.code !== "compacted" || failure.resync === void 0) {
+        return void 0;
+      }
+      const covered = cursor.get(failure.resync.runId)?.afterSeq ?? -1;
+      return covered >= failure.resync.checkpointSeq ? void 0 : failure.resync;
+    };
+    const onResync = options.onResync;
+    const resynced = () => Stream.catchCause(bootstrap(), (cause) => {
+      const reason = cause.reasons[0];
+      if (cause.reasons.length !== 1 || !Cause.isFailReason(reason)) return Stream.failCause(cause);
+      const failure = reason.error;
+      const resync = resyncTarget(failure);
+      if (resync === void 0) return Stream.failCause(cause);
+      if (!(0, import_SyncProtocol.covers)(options.scope, resync.runId)) {
+        return Stream.fail(
+          new import_SyncError.SyncError({
+            code: "protocol_violation",
+            message: "Compaction target is outside the subscription scope"
+          })
+        );
+      }
+      if (onResync === void 0) return Stream.failCause(cause);
+      const runId = resync.runId;
+      const checkpointSeq = resync.checkpointSeq;
+      const refusedGeneration = resync.generation;
+      return Stream.unwrap(Effect.uninterruptibleMask(
+        (restore) => Effect.gen(function* () {
+          const receipt = yield* restore(onResync(resync));
+          const restoredCursor = () => new import_SyncError.SyncError({
+            code: "invalid_request",
+            message: "Recovery must return the restored run cursor at or above its compaction floor"
+          });
+          const captured = yield* Effect.try({
+            try: () => ({
+              runId: receipt.runId,
+              afterSeq: receipt.afterSeq,
+              generation: receipt.generation ?? refusedGeneration
+            }),
+            catch: restoredCursor
+          });
+          if (!Schema.is(import_SyncProtocol.RunCursor)(captured) || captured.runId !== runId || captured.afterSeq < checkpointSeq) {
+            return yield* Effect.fail(restoredCursor());
+          }
+          const applied2 = captured;
+          if (applied2.generation === void 0) {
+            return yield* Effect.fail(
+              new import_SyncError.SyncError({
+                code: "protocol_violation",
+                message: "Compaction refusal names no generation for a receipt that omits one"
+              })
+            );
+          }
+          yield* commit(applied2.runId, applied2.afterSeq, applied2.generation, true);
+          return resynced();
+        })
+      ));
+    });
+    return resynced();
+  }));
+  return SyncClient.of({ snapshot, subscribe, progress });
+});
+const layer = Layer.effect(
+  SyncClient,
+  Effect.flatMap(RpcClient.make(import_SyncRpcs.SyncRpcs), (client) => make({ client }))
+);
+const layerWith = (options) => Layer.effect(SyncClient, Effect.flatMap(RpcClient.make(import_SyncRpcs.SyncRpcs), (client) => makeWith({ ...options, client })));
+//# sourceMappingURL=SyncClient.js.map

package/dist/cjs/SyncClient.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/SyncClient.ts"],
+  "sourcesContent": ["/**\n * Browser-safe client for replaying and following journal entries.\n *\n * @since 0.1.0\n */\n\nimport type * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport * as Cause from \"effect/Cause\"\nimport * as Context from \"effect/Context\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as Ref from \"effect/Ref\"\nimport * as Schedule from \"effect/Schedule\"\nimport * as Schema from \"effect/Schema\"\nimport * as Stream from \"effect/Stream\"\nimport * as RpcClient from \"effect/unstable/rpc/RpcClient\"\nimport * as RpcClientError from \"effect/unstable/rpc/RpcClientError\"\nimport type * as RpcGroup from \"effect/unstable/rpc/RpcGroup\"\nimport type { ShareCapability } from \"./BranchProtocol.ts\"\nimport * as Admission from \"./internal/Admission.ts\"\nimport { boundedText, causeCode, causeText } from \"./internal/CauseText.ts\"\nimport { boundedInt, positiveInt } from \"./internal/PolicyOptions.ts\"\nimport * as SnapshotBoundary from \"./internal/SnapshotBoundary.ts\"\nimport { SyncError, SyncGapError } from \"./SyncError.ts\"\nimport {\n  covers,\n  defaultMaxFrameBytes,\n  duplicateCursorRunId,\n  encodedByteLength,\n  type EntriesFrame,\n  Frame,\n  maxReadLimit,\n  maxSubscribeCredit,\n  type Progress,\n  protocolVersion,\n  ReadResponse,\n  RequestEnvelope,\n  type Resync,\n  RunCursor,\n  type Scope,\n  type Snapshot,\n  type SnapshotRequest,\n  type WorkspaceCursor\n} from \"./SyncProtocol.ts\"\nimport { SyncRpcs } from \"./SyncRpcs.ts\"\n\n/**\n * Frames one subscription round may carry before the follow replenishes it.\n *\n * A subscription's `credit` is a hard frame limit the server enforces with\n * `Stream.take`, so the number the client sends is the size of its window, not\n * a hint. At `credit: 1` the window closed after every single entry and the\n * follow resubscribed: following a run that emits a hundred entries cost a\n * hundred subscribe round trips, each of them a fresh cursor snapshot and a\n * fresh server-side fan-out. Replenishing 256 frames at a time makes the\n * round-trip cost proportional to the window rather than to the traffic, and\n * keeps it bounded \u2014 an unbounded window would hand the server one\n * never-closing subscription per follower.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const defaultCredit = 256\n\n/**\n * Entries one catch-up page asks for.\n *\n * Bootstrap is the replay half of replay-then-follow, so the page size is the\n * memory one catch-up costs and the granularity at which its cursor advances.\n * It matches {@link defaultCredit} and stays under\n * `SyncProtocol.maxReadLimit`, which is the ceiling the server enforces.\n *\n * @category constants\n * @since 1.0.0-rc.0\n */\nexport const defaultBootstrapLimit = 256\n\n/**\n * The policy one sync client runs every operation under.\n *\n * Both fields are validated by {@link makeWith} and {@link layerWith}, so a\n * value that is not a positive safe integer fails the constructor rather than\n * disabling the bound it configures.\n *\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Options {\n  /**\n   * Largest summed encoded-entry size one frame or bootstrap page may carry,\n   * in bytes. Defaults to {@link defaultMaxFrameBytes}.\n   */\n  readonly maxFrameBytes?: number | undefined\n  /**\n   * Entries one catch-up page asks for. Defaults to\n   * {@link defaultBootstrapLimit}, and may not exceed\n   * `SyncProtocol.maxReadLimit`.\n   */\n  readonly bootstrapLimit?: number | undefined\n}\n\n/** The resolved, already-validated client policy. */\ninterface Resolved {\n  readonly maxFrameBytes: number\n  readonly bootstrapLimit: number\n}\n\nconst defaults: Resolved = {\n  maxFrameBytes: defaultMaxFrameBytes,\n  bootstrapLimit: defaultBootstrapLimit\n}\n\n/**\n * Input accepted by a sync subscription.\n *\n * `capability` authorizes branch reads: following a shared branch's run\n * requires a capability that verifies for that branch on the server.\n *\n * `EApply` and `EResync` are the consumer's own failure types for `apply` and\n * `onResync`. The subscription fails with them unchanged, so an application\n * failure is never dressed as a transport or protocol {@link SyncError}.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface SubscribeOptions<EApply = never, EResync = never> {\n  readonly scope: Scope\n  /**\n   * Where this subscription starts, per run. The effective position is the\n   * LATER of this and the client's matching progress map (applied when an\n   * apply callback is present, delivered otherwise), so a caller\n   * ahead of the shared view keeps its place and a caller behind it is\n   * fast-forwarded. Rebuild from an earlier position with a fresh client.\n   */\n  readonly cursors: WorkspaceCursor\n  readonly capability?: ShareCapability\n  /**\n   * Frames one subscription round may carry before the follow replenishes the\n   * window. Defaults to {@link defaultCredit}, and must be a positive integer\n   * no greater than `SyncProtocol.maxSubscribeCredit`.\n   */\n  readonly credit?: number | undefined\n  /**\n   * Applies one entry, and DEFINES what this subscription's cursor means.\n   *\n   * Without it the cursor advances as each entry is handed to the consumer,\n   * so a consumer whose own application then fails has a cursor naming an\n   * entry it never materialized. With it the cursor advances only after this\n   * effect succeeds, and records it in `Progress.applied`. A failure here\n   * fails the subscription with the entry unacknowledged, so the\n   * next applying subscription delivers it again; the effect must\n   * therefore be idempotent, because a redelivery is exactly what a retry is.\n   */\n  readonly apply?: ((entry: JournalEvent.Entry) => Effect.Effect<void, EApply>) | undefined\n  /**\n   * Restores state when the server refuses a cursor below a compaction floor.\n   * Return the exact run and sequence actually restored, after applying it.\n   *\n   * The entries under the floor are deleted. Fetch an explicitly public\n   * projection through `snapshot` or an authorized local source; a\n   * projection has a real hole to fill. The returned sequence must cover the\n   * requested floor; a newer snapshot resumes at its own sequence, not the\n   * older floor. Missing handlers, failures, interruption, and invalid receipts\n   * leave the cursor unmoved. There is no implicit skip of deleted history.\n   *\n   * Durable consumers must commit their restored state and durable cursor in\n   * their own transaction and seed a fresh client from that cursor on restart.\n   * This client's cursor is in memory, not an atomic cross-store transaction.\n   * Recovery must be idempotent, including when a newer compaction requires\n   * another restoration before the suffix can be read.\n   */\n  readonly onResync?: ((resync: Resync) => Effect.Effect<RunCursor, EResync>) | undefined\n}\n\n/**\n * Replicated journal subscription operations.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Service {\n  /** Fetches a public snapshot without applying state or advancing a cursor. */\n  readonly snapshot: (request: SnapshotRequest) => Effect.Effect<Snapshot, SyncError>\n  /** Replays then follows `options.scope`, also failing with the callbacks' own errors. */\n  readonly subscribe: <EApply = never, EResync = never>(\n    options: SubscribeOptions<EApply, EResync>\n  ) => Stream.Stream<JournalEvent.Entry, SyncError | SyncGapError | EApply | EResync>\n  /**\n   * Delivery and application positions. `delivered` is a transport bookmark\n   * only; `applied` is what the `apply` and `onResync` callbacks acknowledged.\n   */\n  readonly progress: Effect.Effect<Progress>\n}\n\n/**\n * The browser-safe journal replication client.\n *\n * @category services\n * @since 1.0.0-rc.0\n */\nexport class SyncClient extends Context.Service<SyncClient, Service>()(\"@smthrs/sync/SyncClient\") {}\n\n/**\n * The client tag's former name, kept for one release.\n *\n * @deprecated Use {@link SyncClient}.\n * @category services\n * @since 0.1.0\n */\nexport const Sync = SyncClient\n\n/**\n * The client tag's former name, kept for one release.\n *\n * @deprecated Use {@link SyncClient}.\n * @category services\n * @since 0.1.0\n */\nexport type Sync = SyncClient\n\n/**\n * Constructs a closed sync stub, optionally overriding individual operations.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makeNoop = (overrides: Partial<Service> = {}): Service =>\n  SyncClient.of({\n    snapshot: () => Effect.fail(new SyncError({ code: \"closed\", message: \"Sync client is closed\" })),\n    subscribe: () => Stream.fail(new SyncError({ code: \"closed\", message: \"Sync client is closed\" })),\n    progress: Effect.succeed({ delivered: [], applied: [] }),\n    ...overrides\n  })\n\n/**\n * Provides a closed sync stub.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop = (overrides: Partial<Service> = {}): Layer.Layer<SyncClient> =>\n  Layer.succeed(SyncClient, makeNoop(overrides))\n\ntype Client = RpcClient.RpcClient<RpcGroup.Rpcs<typeof SyncRpcs>, RpcClientError.RpcClientError>\n\nconst transportError = (cause: unknown): SyncError =>\n  cause instanceof SyncError\n    ? cause\n    : cause instanceof RpcClientError.RpcClientError && cause.reason._tag === \"RpcClientDefect\"\n    ? new SyncError({ code: \"protocol_violation\", message: \"Sync RPC protocol failed\", cause: causeCode(cause.reason) })\n    : new SyncError({\n      code: \"transport_failed\",\n      // Bounded like `cause`. `message` is `Schema.String` and it is the\n      // declared error schema of every RPC, so a host's own sentence must not\n      // be able to be the largest thing this error carries.\n      message: cause instanceof Error ? boundedText(cause.message) : \"Sync RPC transport failed\",\n      cause: causeText(cause)\n    })\n\n/** Effect RPC decodes malformed peer values with orDie. Restore the sync\n * boundary's typed refusal without swallowing unrelated defects or interruption.\n */\nconst rpcCause = (cause: Cause.Cause<unknown>): Cause.Cause<SyncError> =>\n  Cause.fromReasons(\n    Cause.map(cause, transportError).reasons.map((reason) =>\n      Cause.isDieReason(reason) && Schema.isSchemaError(reason.defect)\n        ? Cause.makeFailReason(\n          new SyncError({ code: \"decode_failed\", message: \"Invalid sync RPC response\", cause: \"SchemaError\" })\n        )\n          .annotate(Context.makeUnsafe(reason.annotations))\n        : reason\n    )\n  )\n\ntype Cursors = Map<JournalEvent.RunId, RunCursor>\n\nconst cursorMap = (cursors: WorkspaceCursor): Cursors => new Map(cursors.map((cursor) => [cursor.runId, { ...cursor }]))\n\nconst canonicalCursors = (cursors: ReadonlyMap<JournalEvent.RunId, RunCursor>): WorkspaceCursor =>\n  Array.from(cursors.values(), (cursor) => ({ ...cursor })).sort((left, right) =>\n    // A Map has one value per key, so this comparator never receives equal\n    // run IDs. `cursorMap` and the acknowledged cursor state both establish\n    // that invariant before reaching this boundary.\n    left.runId > right.runId ? 1 : -1\n  )\n\n/**\n * Advances the shared acknowledged view monotonically. A lagging subscription\n * commits what it just consumed, but it must never move the shared cursor\n * backward past another subscription's progress.\n */\nconst advance = (\n  cursors: ReadonlyMap<JournalEvent.RunId, RunCursor>,\n  runId: JournalEvent.RunId,\n  throughSeq: JournalEvent.Seq,\n  generation: number\n): ReadonlyMap<JournalEvent.RunId, RunCursor> => {\n  const current = cursors.get(runId)\n  if (current !== undefined && current.afterSeq >= throughSeq) return cursors\n  const next = new Map(cursors)\n  next.set(runId, { runId, afterSeq: throughSeq, generation })\n  return next\n}\n\n/**\n * Live-follow reconnect policy: exponential backoff capped at five seconds,\n * the same shape as `RpcClient`'s own transport retry policy, and only for\n * transport failures \u2014 gaps, authorization refusals, server closes, and the\n * consumer's own callback failures propagate to the consumer.\n */\nconst reconnectPolicy = Schedule.min([\n  Schedule.exponential(500, 1.5),\n  Schedule.spaced(5000)\n]).pipe(\n  Schedule.while(({ input }: { readonly input: Cause.Cause<unknown> }) => isTransportCause(input))\n)\n\nconst isTransportCause = (cause: Cause.Cause<unknown>): boolean => {\n  const reason = cause.reasons[0]!\n  return cause.reasons.length === 1 && Cause.isFailReason(reason) &&\n    SyncError.is(reason.error) && reason.error.code === \"transport_failed\"\n}\n\nconst lineageChanged = (runId: JournalEvent.RunId): SyncError =>\n  new SyncError({\n    code: \"lineage_changed\",\n    message: `Run ${runId} was rewound; rebuild from its archive boundary with a fresh sync client`\n  })\n\nconst entriesByteLength = (entries: ReadonlyArray<JournalEvent.Entry>): number =>\n  entries.reduce((bytes, entry) => bytes + encodedByteLength(entry), 0)\n\nconst oversized = (bytes: number, maxFrameBytes: number): SyncError =>\n  new SyncError({\n    code: \"frame_too_large\",\n    message: `Encoded entries of ${bytes} bytes exceed the ${maxFrameBytes}-byte frame ceiling`\n  })\n\n/**\n * The first internal inconsistency of a server frame, or `undefined` for a\n * consistent one.\n *\n * A schema-valid frame can still contradict itself: carry another run's\n * entry, repeat or reorder sequences, or carry an entry outside its own\n * declared covered interval. Applying one would corrupt the client's cursor\n * bookkeeping, so an inconsistent frame is refused as a protocol violation\n * before any entry is admitted or any cursor moves.\n */\nconst frameViolation = (frame: EntriesFrame): SyncError | undefined => {\n  let previous = -1\n  for (const entry of frame.entries) {\n    if (entry.runId !== frame.runId) {\n      return new SyncError({\n        code: \"protocol_violation\",\n        cause: \"foreign_run\",\n        message: `Frame for run ${frame.runId} carried an entry for run ${entry.runId}`\n      })\n    }\n    if (entry.seq <= previous) {\n      return new SyncError({\n        code: \"protocol_violation\",\n        cause: \"non_monotonic_sequence\",\n        message: `Frame entries must ascend strictly: sequence ${entry.seq} arrived after ${previous}`\n      })\n    }\n    if (entry.seq < frame.fromSeq || frame.toSeq < entry.seq) {\n      return new SyncError({\n        code: \"protocol_violation\",\n        cause: \"invalid_frame_interval\",\n        message: `Entry ${entry.seq} lies outside the frame's covered interval ${frame.fromSeq}..${frame.toSeq}`\n      })\n    }\n    previous = entry.seq\n  }\n  return undefined\n}\n\n/**\n * The first semantic inconsistency of a catch-up page, or `undefined` for a\n * consistent one.\n *\n * Every entry must belong to the requested scope, ascend strictly within its\n * run, and lie above the requested cursor. Every entry-bearing run must have\n * exactly one response cursor with an explicit generation matching the request.\n *\n * Strictly-above-the-cursor is also what makes an incomplete page CONVERGE: a\n * page that carries entries but moves no cursor would be re-read forever.\n */\nconst pageViolation = (\n  scope: Scope,\n  requested: ReadonlyMap<JournalEvent.RunId, RunCursor>,\n  response: ReadResponse\n): SyncError | undefined => {\n  const violation = (message: string): SyncError =>\n    new SyncError({ code: \"protocol_violation\", message, cause: \"invalid_read_page\" })\n  const generations = new Set<JournalEvent.RunId>()\n  for (const cursor of response.cursors) {\n    generations.add(cursor.runId)\n    if (cursor.generation === undefined) return violation(\"Read response lacks a generation\")\n    const previous = requested.get(cursor.runId)\n    if (previous !== undefined && (previous.generation ?? 0) !== cursor.generation) {\n      return lineageChanged(cursor.runId)\n    }\n  }\n  const highest = new Map<JournalEvent.RunId, JournalEvent.Seq>()\n  for (const entry of response.entries) {\n    if (!covers(scope, entry.runId)) {\n      return violation(`Read page carried an entry for run ${entry.runId}, which the request's scope excludes`)\n    }\n    const floor = requested.get(entry.runId)?.afterSeq\n    if (floor !== undefined && entry.seq <= floor) {\n      return violation(\n        `Read page carried sequence ${entry.seq} for run ${entry.runId}, at or below the requested cursor ${floor}`\n      )\n    }\n    const previous = highest.get(entry.runId)\n    if (previous !== undefined && entry.seq <= previous) {\n      return violation(\n        `Read page entries for run ${entry.runId} must ascend strictly: sequence ${entry.seq} arrived after ${previous}`\n      )\n    }\n    highest.set(entry.runId, entry.seq)\n  }\n  for (const runId of highest.keys()) {\n    if (!generations.has(runId)) return violation(`Read page lacks a generation cursor for run ${runId}`)\n  }\n  const duplicate = duplicateCursorRunId(response.cursors)\n  return duplicate === undefined ? undefined : violation(`Read page echoed run ${duplicate} more than once`)\n}\n\n/**\n * Projects a Sync RPC client into the local replication service.\n *\n * Delivered and applied cursors are separate per-service `Ref` maps: concurrent\n * subscriptions for one materialization share them, and each commit advances\n * its matching map monotonically. A\n * cursor advances in the same stream pull that admits each entry to the\n * consumer, or \u2014 when the caller supplies `SubscribeOptions.apply` \u2014 only\n * after that callback has applied the entry. Interrupted partial pages\n * therefore retain the last admitted entry rather than incorrectly\n * acknowledging the server's whole page.\n *\n * A frame or bootstrap page whose encoded entries exceed `maxFrameBytes` is\n * refused with `frame_too_large`. Out-of-scope entries, repeated or reordered\n * sequences, and missing response generations fail with `protocol_violation`\n * before delivery. Each entry-bearing run in a Read page must have exactly one\n * explicit generation cursor, and every entry must be above the requested\n * cursor. Live frames instead drop already-covered entries and deliver only\n * the suffix above the cursor. An incomplete bootstrap page with no entries\n * or a completed subscription window with no frames fails with\n * `protocol_violation` instead of reopening immediately.\n *\n * A live follow that loses its transport reconnects under\n * {@link reconnectPolicy}, resuming from the acknowledged cursors; the failure\n * cause is logged before the retry folds it. The follow spends a credit window\n * of {@link defaultCredit} frames per subscription round and replenishes it by\n * resubscribing from the cursors it has acknowledged. Already-covered entries\n * are not delivered again; the round-trip cost scales with credit windows.\n *\n * A `compacted` refusal fails closed unless `SubscribeOptions.onResync`\n * restores the missing prefix and returns its exact cursor. Snapshot fetching\n * never applies state or advances cursors. Only a validated receipt for the requested run at or\n * above its compaction floor advances the cursor before reading the suffix.\n *\n * A subscription's effective cursor per run is the LATER of the caller's and\n * the matching progress map: a caller that restored its own progress is never\n * regressed, and a caller asking for history this client already acknowledged\n * is fast-forwarded. Rebuild a projection from an earlier position with a\n * fresh client, whose acknowledged map is empty.\n *\n * This constructor carries the default policy, which is valid by\n * construction and so cannot fail. {@link makeWith} takes an explicit\n * {@link Options} and validates it.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const make = ({ client }: { readonly client: Client }): Effect.Effect<Service> => service(client, defaults)\n\n/**\n * Constructs the sync client under an explicit policy.\n *\n * Every option is validated here, once, so a client either exists under a\n * policy it can serve or never exists at all. Validating on each `subscribe`\n * and each `snapshot` instead accepted a `maxFrameBytes` of `NaN` at\n * construction and then refused every operation under it, which reported a\n * composition's mistake as a run-time failure of the follow. This mirrors\n * `SyncServer.makeLiveWith` and `BranchCommands.makeLiveWith`.\n *\n * `SubscribeOptions.credit` is a REQUEST count rather than a client policy, so\n * it is still checked where the request is built.\n *\n * @category constructors\n * @since 1.0.0-rc.0\n */\nexport const makeWith = ({\n  bootstrapLimit,\n  client,\n  maxFrameBytes\n}: Options & { readonly client: Client }): Effect.Effect<Service, SyncError> =>\n  Effect.flatMap(\n    Effect.all({\n      maxFrameBytes: positiveInt(\"SyncClient.Options.maxFrameBytes\", maxFrameBytes, defaults.maxFrameBytes),\n      bootstrapLimit: boundedInt(\n        \"SyncClient.Options.bootstrapLimit\",\n        bootstrapLimit,\n        defaults.bootstrapLimit,\n        maxReadLimit\n      )\n    }),\n    (policy) => service(client, policy)\n  )\n\nconst service = (client: Client, { bootstrapLimit, maxFrameBytes }: Resolved): Effect.Effect<Service> =>\n  Effect.sync(() => {\n    const delivered = Ref.makeUnsafe<ReadonlyMap<JournalEvent.RunId, RunCursor>>(new Map())\n    const applied = Ref.makeUnsafe<ReadonlyMap<JournalEvent.RunId, RunCursor>>(new Map())\n\n    const progress: Effect.Effect<Progress> = Effect.gen(function*() {\n      return {\n        delivered: canonicalCursors(yield* Ref.get(delivered)),\n        applied: canonicalCursors(yield* Ref.get(applied))\n      }\n    })\n\n    const snapshot = (input: SnapshotRequest): Effect.Effect<Snapshot, SyncError> =>\n      Effect.gen(function*() {\n        const request = yield* SnapshotBoundary.request(input)\n        const supplied = yield* client[\"Sync.Snapshot\"]({ ...request }).pipe(\n          Effect.catchCause((cause) => Effect.failCause(rpcCause(cause)))\n        )\n        return yield* SnapshotBoundary.response(request, supplied, maxFrameBytes)\n      })\n\n    const subscribe = <EApply = never, EResync = never>(\n      input: SubscribeOptions<EApply, EResync>\n    ): Stream.Stream<JournalEvent.Entry, SyncError | SyncGapError | EApply | EResync> =>\n      Stream.unwrap(Effect.gen(function*() {\n        /** Every way this subscription fails: the wire's refusals and the consumer's own callback errors. */\n        type Failure = SyncError | SyncGapError | EApply | EResync\n\n        const options = {\n          ...input,\n          ...yield* Admission.decode(RequestEnvelope, input, \"invalid_request\")\n        }\n        // The client's own policy was checked once, by the constructor. What\n        // is left is the count this REQUEST carries: the declared type says\n        // `number`, and `NaN` disabled each comparison it appears in rather\n        // than tightening it.\n        const credit = yield* boundedInt(\n          \"SyncClient.SubscribeOptions.credit\",\n          options.credit,\n          defaultCredit,\n          maxSubscribeCredit\n        )\n        const cursor = cursorMap(options.cursors)\n        // A previous delivery-only subscriber cannot skip work for an applying subscriber.\n        // Rebuilding an independent projection requires a fresh client.\n        for (const [runId, position] of yield* Ref.get(options.apply === undefined ? delivered : applied)) {\n          const supplied = cursor.get(runId)\n          if (supplied !== undefined && (supplied.generation ?? 0) !== position.generation) {\n            return yield* Effect.fail(lineageChanged(runId))\n          }\n          if (supplied === undefined || supplied.afterSeq < position.afterSeq) cursor.set(runId, position)\n        }\n\n        const snapshot = (): WorkspaceCursor => canonicalCursors(cursor)\n\n        const commit = (\n          runId: JournalEvent.RunId,\n          throughSeq: JournalEvent.Seq,\n          generation: number,\n          wasApplied: boolean\n        ) =>\n          Effect.gen(function*() {\n            // Delivery and application have distinct cursors, but both are bound\n            // to the same journal generation and advance without an interrupt gap.\n            for (const view of wasApplied ? [delivered, applied] : [delivered]) {\n              const previous = (yield* Ref.get(view)).get(runId)\n              if (previous !== undefined && previous.generation !== generation) {\n                return yield* Effect.fail(lineageChanged(runId))\n              }\n            }\n            yield* Ref.update(delivered, (shared) => advance(shared, runId, throughSeq, generation))\n            if (wasApplied) yield* Ref.update(applied, (shared) => advance(shared, runId, throughSeq, generation))\n            cursor.set(runId, { runId, afterSeq: throughSeq, generation })\n          }).pipe(Effect.uninterruptible)\n\n        const applyEntry = options.apply\n\n        /**\n         * Hands one entry to the consumer and moves its cursor.\n         *\n         * With an `apply` callback the cursor moves only after the callback\n         * succeeds, so a cursor names what the consumer materialized. Without\n         * one it moves as the entry is admitted, which is the weaker promise\n         * this client has always made and the one `RunCursor`'s JSDoc now\n         * states.\n         *\n         * The position committed is SNAPSHOTTED before the callback runs.\n         * `Entry` is a `Schema.Class`, and instances are not frozen, so\n         * reading `entry.seq` again afterwards let the consumer's own callback\n         * choose the cursor it was being handed an entry for.\n         */\n        const deliver = (\n          runId: JournalEvent.RunId,\n          entry: JournalEvent.Entry,\n          generation: number\n        ): Stream.Stream<JournalEvent.Entry, Failure> => {\n          const through = entry.seq\n          return Stream.concat(\n            Stream.drain(Stream.fromEffect(\n              applyEntry === undefined\n                ? commit(runId, through, generation, false)\n                : Effect.uninterruptibleMask((restore) =>\n                  Effect.andThen(restore(applyEntry(entry)), commit(runId, through, generation, true))\n                )\n            )),\n            Stream.succeed(entry)\n          )\n        }\n\n        const batch = (frame: EntriesFrame): Stream.Stream<JournalEvent.Entry, Failure> => {\n          if (frame.generation === undefined) {\n            return Stream.fail(\n              new SyncError({ code: \"protocol_violation\", message: \"Entries frame lacks a generation\" })\n            )\n          }\n          if (!covers(options.scope, frame.runId)) {\n            return Stream.fail(\n              new SyncError({\n                code: \"protocol_violation\",\n                message: \"Live frame is outside the subscription scope\",\n                cause: \"foreign_run\"\n              })\n            )\n          }\n          const frameBytes = entriesByteLength(frame.entries)\n          if (frameBytes > maxFrameBytes) return Stream.fail(oversized(frameBytes, maxFrameBytes))\n          const violation = frameViolation(frame)\n          if (violation !== undefined) return Stream.fail(violation)\n          const position = cursor.get(frame.runId)\n          const generation = frame.generation\n          if (position !== undefined && (position.generation ?? 0) !== generation) {\n            return Stream.fail(lineageChanged(frame.runId))\n          }\n          const afterSeq: number = position?.afterSeq ?? -1\n          // `fromSeq` is the start of the server-declared covered interval. It is\n          // intentionally compared to the cursor, not to the first entry's seq:\n          // dropped journal admissions legitimately leave holes inside that range.\n          if (frame.fromSeq > afterSeq + 1) {\n            return Stream.fail(\n              new SyncGapError({\n                runId: frame.runId,\n                expectedFrom: (afterSeq + 1) as JournalEvent.Seq,\n                receivedFrom: frame.fromSeq\n              })\n            )\n          }\n          if (frame.toSeq <= afterSeq) return Stream.empty\n\n          const entries = frame.entries.filter((entry) => entry.seq > afterSeq)\n          return Stream.flatMap(Stream.fromIterable(entries), (entry) => deliver(frame.runId, entry, generation))\n        }\n\n        const livePage = (onFrame: () => void): Stream.Stream<JournalEvent.Entry, Failure> =>\n          Stream.unwrap(\n            Effect.sync(() =>\n              client[\"Sync.Subscribe\"]({\n                protocolVersion,\n                scope: options.scope,\n                cursors: snapshot(),\n                credit,\n                ...(options.capability === undefined ? {} : { capability: options.capability })\n              })\n            )\n          ).pipe(\n            Stream.catchCause((cause) => Stream.failCause(rpcCause(cause))),\n            Stream.mapEffect((frame) => Admission.decode(Frame, frame)),\n            Stream.mapEffect((frame): Effect.Effect<Frame, SyncError> =>\n              frame._tag === \"Entries\"\n                ? Effect.map(Admission.records(frame.entries), (entries) => ({ ...frame, entries }))\n                : Effect.succeed(frame)\n            ),\n            Stream.flatMap((frame) => {\n              onFrame()\n              switch (frame._tag) {\n                case \"Entries\":\n                  return batch(frame)\n                case \"Closed\":\n                  return Stream.fail(new SyncError({ code: \"closed\", message: \"Sync subscription closed\" }))\n                default:\n                  return Stream.empty\n              }\n            })\n          )\n\n        const live = (): Stream.Stream<JournalEvent.Entry, Failure> =>\n          Stream.unwrap(Effect.sync(() => {\n            let receivedFrame = false\n            return Stream.concat(\n              livePage(() => {\n                receivedFrame = true\n              }),\n              Stream.unwrap(Effect.sync(() =>\n                receivedFrame ? live() : Stream.fail(\n                  new SyncError({\n                    code: \"protocol_violation\",\n                    message: \"Subscription window closed without frames\"\n                  })\n                )\n              ))\n            )\n          }))\n\n        // The retry re-runs the whole follow from the acknowledged cursors,\n        // and its schedule resets once entries flow again, so a long-lived\n        // subscription pays the backoff only across consecutive failures.\n        const follow = (): Stream.Stream<JournalEvent.Entry, Failure> =>\n          live().pipe(\n            Stream.tapCause((cause) =>\n              isTransportCause(cause)\n                ? Effect.logWarning(\"sync live follow transport failed; reconnecting with backoff\", cause)\n                : Effect.void\n            ),\n            // Schedule the complete cause so retry refusal cannot discard an\n            // accompanying defect, interruption, or tracing annotation.\n            Stream.catchCause((cause) => Stream.fail(cause)),\n            Stream.retry(reconnectPolicy),\n            Stream.catch((cause) => Stream.failCause(cause))\n          )\n\n        const bootstrap = (): Stream.Stream<JournalEvent.Entry, Failure> =>\n          Stream.unwrap(\n            // SUSPENDED, exactly as `livePage` is. Building the payload where\n            // the recursive call is written snapshotted the cursors as page N\n            // was mapped, before a single one of its entries had reached\n            // `commit` \u2014 so read N+1 carried read N's request cursors and the\n            // server correctly re-served the page it had just served. Every\n            // catch-up page past the first arrived twice.\n            Effect.suspend(() => {\n              const requested = snapshot()\n              return client[\"Sync.Read\"]({\n                protocolVersion,\n                scope: options.scope,\n                cursors: requested,\n                limit: bootstrapLimit,\n                ...(options.capability === undefined ? {} : { capability: options.capability })\n              }).pipe(\n                Effect.catchCause((cause) => Effect.failCause(rpcCause(cause))),\n                Effect.flatMap((response) => Admission.decode(ReadResponse, response)),\n                Effect.flatMap((response) =>\n                  Effect.map(Admission.records(response.entries), (entries) => ({ ...response, entries }))\n                ),\n                Effect.map((response) => {\n                  const pageBytes = entriesByteLength(response.entries)\n                  if (pageBytes > maxFrameBytes) return Stream.fail(oversized(pageBytes, maxFrameBytes))\n                  const violation = pageViolation(options.scope, cursorMap(requested), response)\n                  if (violation !== undefined) return Stream.fail(violation)\n                  const generations = new Map(response.cursors.map((cursor) => [cursor.runId, cursor.generation!]))\n                  const page = Stream.flatMap(\n                    Stream.fromIterable(response.entries),\n                    (entry) =>\n                      deliver(\n                        entry.runId,\n                        entry,\n                        generations.get(entry.runId)!\n                      )\n                  )\n                  if (response.done) return Stream.concat(page, follow())\n                  if (response.entries.length === 0) {\n                    // An incomplete page with no entries can never converge:\n                    // the next read would carry the same cursors and receive\n                    // the same page. Fail typed instead of spinning.\n                    return Stream.fail(\n                      new SyncError({\n                        code: \"protocol_violation\",\n                        message: \"Bootstrap read reported more durable entries but returned an empty page\"\n                      })\n                    )\n                  }\n                  return Stream.concat(page, bootstrap())\n                })\n              )\n            })\n          )\n\n        /**\n         * The checkpoint one failure says to resume from, or `undefined` when\n         * the failure is not a recoverable compaction.\n         *\n         * A compaction whose checkpoint is at or below what this subscription\n         * already covers cannot move it forward, so retrying would re-read the\n         * same refusal forever. That is the same non-convergence rule the\n         * empty incomplete bootstrap page is refused under, and it is why a\n         * `compacted` failure carrying no {@link Resync} stays a failure\n         * rather than becoming a silent stall.\n         */\n        const resyncTarget = (failure: Failure): Resync | undefined => {\n          if (!SyncError.is(failure) || failure.code !== \"compacted\" || failure.resync === undefined) {\n            return undefined\n          }\n          const covered: number = cursor.get(failure.resync.runId)?.afterSeq ?? -1\n          return covered >= failure.resync.checkpointSeq ? undefined : failure.resync\n        }\n\n        const onResync = options.onResync\n\n        const resynced = (): Stream.Stream<JournalEvent.Entry, Failure> =>\n          Stream.catchCause(bootstrap(), (cause) => {\n            const reason = cause.reasons[0]!\n            if (cause.reasons.length !== 1 || !Cause.isFailReason(reason)) return Stream.failCause(cause)\n            const failure = reason.error\n            const resync = resyncTarget(failure)\n            if (resync === undefined) return Stream.failCause(cause)\n            if (!covers(options.scope, resync.runId)) {\n              return Stream.fail(\n                new SyncError({\n                  code: \"protocol_violation\",\n                  message: \"Compaction target is outside the subscription scope\"\n                })\n              )\n            }\n            if (onResync === undefined) return Stream.failCause(cause)\n            // Snapshotted before the hook runs, for the reason `deliver`\n            // snapshots: the hook is handed the value the commit is read from,\n            // and re-reading it afterwards let a consumer move its own cursor\n            // arbitrarily far forward from inside the callback.\n            const runId = resync.runId\n            const checkpointSeq = resync.checkpointSeq\n            const refusedGeneration = resync.generation\n            return Stream.unwrap(Effect.uninterruptibleMask((restore) =>\n              Effect.gen(function*() {\n                // Application remains interruptible. Once it returns success,\n                // validation and the in-memory commit finish without an async\n                // cancellation gap. Durable state/cursor atomicity belongs to\n                // the consumer's own transaction, not to this mask.\n                const receipt = yield* restore(onResync(resync))\n                const restoredCursor = () =>\n                  new SyncError({\n                    code: \"invalid_request\",\n                    message: \"Recovery must return the restored run cursor at or above its compaction floor\"\n                  })\n                // A receipt that omits its generation restored the floor's\n                // history, which the refusal names. The previous cursor's\n                // generation is no substitute: a fresh client has none,\n                // and a rewind since then has replaced it.\n                const captured = yield* Effect.try({\n                  try: () => ({\n                    runId: receipt.runId,\n                    afterSeq: receipt.afterSeq,\n                    generation: receipt.generation ?? refusedGeneration\n                  }),\n                  catch: restoredCursor\n                })\n                if (\n                  !Schema.is(RunCursor)(captured) || captured.runId !== runId || captured.afterSeq < checkpointSeq\n                ) {\n                  return yield* Effect.fail(restoredCursor())\n                }\n                const applied = captured\n                if (applied.generation === undefined) {\n                  return yield* Effect.fail(\n                    new SyncError({\n                      code: \"protocol_violation\",\n                      message: \"Compaction refusal names no generation for a receipt that omits one\"\n                    })\n                  )\n                }\n                yield* commit(applied.runId, applied.afterSeq, applied.generation, true)\n                return resynced()\n              })\n            ))\n          })\n\n        return resynced()\n      }))\n\n    return SyncClient.of({ snapshot, subscribe, progress })\n  })\n\n/**\n * Provides the sync client from the active RPC protocol.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<SyncClient, never, RpcClient.Protocol> = Layer.effect(\n  SyncClient,\n  Effect.flatMap(RpcClient.make(SyncRpcs), (client) => make({ client }))\n)\n\n/**\n * Provides the sync client under an explicit policy. Fails with\n * `invalid_request` when an option is not a positive safe integer, so a bad\n * policy fails the composition rather than every operation under it.\n *\n * @category layers\n * @since 1.0.0-rc.0\n */\nexport const layerWith = (options: Options): Layer.Layer<SyncClient, SyncError, RpcClient.Protocol> =>\n  Layer.effect(SyncClient, Effect.flatMap(RpcClient.make(SyncRpcs), (client) => makeWith({ ...options, client })))\n"],
+  "mappings": "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",
+  "names": ["snapshot", "cursor", "applied"]
+}