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

package/dist/cjs/index.js

@@ -0,0 +1,67 @@
+"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 index_exports = {};
+__export(index_exports, {
+  BranchCommands: () => BranchCommands,
+  BranchIds: () => BranchIds,
+  BranchPresence: () => BranchPresence,
+  BranchProjection: () => BranchProjection,
+  BranchProtocol: () => BranchProtocol,
+  BranchRpcs: () => BranchRpcs,
+  BranchServer: () => BranchServer,
+  BranchShare: () => BranchShare,
+  RunCatalog: () => RunCatalog,
+  SyncAuth: () => SyncAuth,
+  SyncClient: () => SyncClient,
+  SyncError: () => SyncError,
+  SyncPrincipal: () => SyncPrincipal,
+  SyncProtocol: () => SyncProtocol,
+  SyncRpcs: () => SyncRpcs,
+  SyncServer: () => SyncServer,
+  WorkspaceShare: () => WorkspaceShare
+});
+module.exports = __toCommonJS(index_exports);
+var SyncError = __toESM(require("./SyncError.js"), 1);
+var SyncProtocol = __toESM(require("./SyncProtocol.js"), 1);
+var BranchProtocol = __toESM(require("./BranchProtocol.js"), 1);
+var BranchProjection = __toESM(require("./BranchProjection.js"), 1);
+var SyncRpcs = __toESM(require("./SyncRpcs.js"), 1);
+var BranchRpcs = __toESM(require("./BranchRpcs.js"), 1);
+var RunCatalog = __toESM(require("./RunCatalog.js"), 1);
+var SyncServer = __toESM(require("./SyncServer.js"), 1);
+var SyncClient = __toESM(require("./SyncClient.js"), 1);
+var BranchShare = __toESM(require("./BranchShare.js"), 1);
+var WorkspaceShare = __toESM(require("./WorkspaceShare.js"), 1);
+var SyncPrincipal = __toESM(require("./SyncPrincipal.js"), 1);
+var SyncAuth = __toESM(require("./SyncAuth.js"), 1);
+var BranchPresence = __toESM(require("./BranchPresence.js"), 1);
+var BranchCommands = __toESM(require("./BranchCommands.js"), 1);
+var BranchServer = __toESM(require("./BranchServer.js"), 1);
+var BranchIds = __toESM(require("./BranchIds.js"), 1);
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": ["/**\n * Read-only journal synchronization services for flows.\n *\n * @since 0.1.0\n */\n\n/**\n * @category errors\n * @since 0.1.0\n */\nexport * as SyncError from \"./SyncError.ts\"\n\n/**\n * @category protocol\n * @since 0.1.0\n */\nexport * as SyncProtocol from \"./SyncProtocol.ts\"\n\n/**\n * @category protocol\n * @since 0.1.0\n */\nexport * as BranchProtocol from \"./BranchProtocol.ts\"\n\n/**\n * @category projections\n * @since 0.1.0\n */\nexport * as BranchProjection from \"./BranchProjection.ts\"\n\n/**\n * @category rpc\n * @since 0.1.0\n */\nexport * as SyncRpcs from \"./SyncRpcs.ts\"\n\n/**\n * @category rpc\n * @since 0.1.0\n */\nexport * as BranchRpcs from \"./BranchRpcs.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as RunCatalog from \"./RunCatalog.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as SyncServer from \"./SyncServer.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as SyncClient from \"./SyncClient.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as BranchShare from \"./BranchShare.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as WorkspaceShare from \"./WorkspaceShare.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as SyncPrincipal from \"./SyncPrincipal.ts\"\n\n/**\n * @category rpc\n * @since 0.1.0\n */\nexport * as SyncAuth from \"./SyncAuth.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as BranchPresence from \"./BranchPresence.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as BranchCommands from \"./BranchCommands.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as BranchServer from \"./BranchServer.ts\"\n\n/**\n * @category services\n * @since 0.1.0\n */\nexport * as BranchIds from \"./BranchIds.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,gBAA2B;AAM3B,mBAA8B;AAM9B,qBAAgC;AAMhC,uBAAkC;AAMlC,eAA0B;AAM1B,iBAA4B;AAM5B,iBAA4B;AAM5B,iBAA4B;AAM5B,iBAA4B;AAM5B,kBAA6B;AAM7B,qBAAgC;AAMhC,oBAA+B;AAM/B,eAA0B;AAM1B,qBAAgC;AAMhC,qBAAgC;AAMhC,mBAA8B;AAM9B,gBAA2B;",
+  "names": []
+}

package/dist/cjs/internal/Admission.d.ts

@@ -0,0 +1,43 @@
+/** Admission of host and transport values before any progress is committed.
+ * @since 1.0.0-rc.0
+ */
+import * as JournalEvent from "@smthrs/journal/JournalEvent";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import { CommandEventPayload } from "../BranchProtocol.ts";
+import { SyncError } from "../SyncError.ts";
+/** Decode a boundary value while retaining a safe cause classification.
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const decode: <S extends Schema.Top & {
+    readonly DecodingServices: never;
+}>(schema: S, value: unknown, code?: "decode_failed" | "invalid_request") => Effect.Effect<S["Type"], SyncError>;
+/** One admitted entry beside the command payload admission decoded from it.
+ * `command` is `undefined` for every event type other than `CommandEvent`.
+ * @category models
+ * @since 1.0.0-rc.0
+ */
+export interface Admitted {
+    readonly entry: JournalEvent.Entry;
+    readonly command: CommandEventPayload | undefined;
+}
+/** Known branch records fail closed; unknown namespaces remain open JSON envelopes.
+ * Defaults on persisted command args/target keep their existing additive schema meaning.
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const records: (values: ReadonlyArray<JournalEvent.Entry>) => Effect.Effect<ReadonlyArray<JournalEvent.Entry>, SyncError>;
+/** Admit an entire run batch before its caller publishes or updates a cursor,
+ * handing back each command beside the payload admission decoded, so a caller
+ * that needs a command field reads it instead of decoding the payload again.
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const withCommands: (values: ReadonlyArray<JournalEvent.Entry>, runId: JournalEvent.RunId, after: number) => Effect.Effect<ReadonlyArray<Admitted>, SyncError>;
+/** Admit an entire run batch before its caller publishes or updates a cursor.
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const entries: (values: ReadonlyArray<JournalEvent.Entry>, runId: JournalEvent.RunId, after: number) => Effect.Effect<ReadonlyArray<JournalEvent.Entry>, SyncError>;
+//# sourceMappingURL=Admission.d.ts.map

package/dist/cjs/internal/Admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Admission.d.ts","sourceRoot":"","sources":["../../../src/internal/Admission.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,YAAY,MAAM,8BAA8B,CAAA;AAC5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAyC,mBAAmB,EAAE,MAAM,sBAAsB,CAAA;AACjG,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAG3C;;;GAGG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,SAAS,MAAM,CAAC,GAAG,GAAG;IAAE,QAAQ,CAAC,gBAAgB,EAAE,KAAK,CAAA;CAAE,EAChF,QAAQ,CAAC,EACT,OAAO,OAAO,EACd,OAAM,eAAe,GAAG,iBAAmC,KAC1D,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,SAAS,CAIjC,CAAA;AAOJ;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC,KAAK,CAAA;IAClC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,GAAG,SAAS,CAAA;CAClD;AAiCD;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAClB,QAAQ,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,KACxC,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,SAAS,CAAyC,CAAA;AAEtG;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GACvB,QAAQ,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,EACzC,OAAO,YAAY,CAAC,KAAK,EACzB,OAAO,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,EAAE,SAAS,CAiB/C,CAAA;AAEJ;;;GAGG;AACH,eAAO,MAAM,OAAO,GAClB,QAAQ,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,EACzC,OAAO,YAAY,CAAC,KAAK,EACzB,OAAO,MAAM,KACZ,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,SAAS,CACF,CAAA"}

package/dist/cjs/internal/Admission.js

@@ -0,0 +1,90 @@
+"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 Admission_exports = {};
+__export(Admission_exports, {
+  decode: () => decode,
+  entries: () => entries,
+  records: () => records,
+  withCommands: () => withCommands
+});
+module.exports = __toCommonJS(Admission_exports);
+var JournalEvent = __toESM(require("@smthrs/journal/JournalEvent"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_BranchProtocol = require("../BranchProtocol.js");
+var import_SyncError = require("../SyncError.js");
+var import_CauseText = require("./CauseText.js");
+const decode = (schema, value, code = "decode_failed") => Effect.try({
+  try: () => Schema.decodeUnknownSync(schema)(value),
+  catch: (cause) => new import_SyncError.SyncError({ code, message: "Invalid sync envelope", cause: (0, import_CauseText.causeCode)(cause) })
+});
+const decodeEntries = Schema.decodeUnknownSync(Schema.Array(JournalEvent.Entry));
+const decodeJson = Schema.decodeUnknownSync(Schema.Struct({ payload: Schema.Json, meta: Schema.Json }));
+const decodeCommand = Schema.decodeUnknownSync(import_BranchProtocol.CommandEventPayload);
+const decodeBranch = Schema.decodeUnknownSync(Schema.Struct({ branchId: Schema.optional(import_BranchProtocol.BranchId) }));
+const admit = (values) => Effect.try({
+  // Capture getters once and detach nested payloads before any application
+  // callback can mutate the producer's next entry after admission.
+  try: () => decodeEntries(structuredClone(values)).map((entry) => {
+    decodeJson(entry);
+    if (entry.eventType !== import_BranchProtocol.CommandEvent) return { entry, command: void 0 };
+    const command = decodeCommand(entry.payload);
+    const identity = decodeBranch(entry.payload);
+    if (identity.branchId !== void 0 && identity.branchId !== (0, import_BranchProtocol.branchOfRunId)(entry.runId)) {
+      throw new import_SyncError.SyncError({
+        code: "protocol_violation",
+        message: "Command belongs to another branch",
+        cause: "foreign_branch"
+      });
+    }
+    return { entry, command };
+  }),
+  catch: (cause) => cause instanceof import_SyncError.SyncError ? cause : new import_SyncError.SyncError({ code: "decode_failed", message: "Invalid sync record", cause: (0, import_CauseText.causeCode)(cause) })
+});
+const entriesOf = (admitted) => admitted.map(({ entry }) => entry);
+const records = (values) => Effect.map(admit(values), entriesOf);
+const withCommands = (values, runId, after) => Effect.gen(function* () {
+  const admitted = yield* admit(values);
+  let previous = after;
+  for (const { entry } of admitted) {
+    if (entry.runId !== runId || entry.seq <= previous) {
+      return yield* Effect.fail(
+        new import_SyncError.SyncError({
+          code: "protocol_violation",
+          message: "Journal batch must belong to the requested run and ascend strictly above its cursor",
+          cause: entry.runId !== runId ? "foreign_run" : "non_monotonic_sequence"
+        })
+      );
+    }
+    previous = entry.seq;
+  }
+  return admitted;
+});
+const entries = (values, runId, after) => Effect.map(withCommands(values, runId, after), entriesOf);
+//# sourceMappingURL=Admission.js.map

package/dist/cjs/internal/Admission.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/Admission.ts"],
+  "sourcesContent": ["/** Admission of host and transport values before any progress is committed.\n * @since 1.0.0-rc.0\n */\n\nimport * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\nimport { BranchId, branchOfRunId, CommandEvent, CommandEventPayload } from \"../BranchProtocol.ts\"\nimport { SyncError } from \"../SyncError.ts\"\nimport { causeCode } from \"./CauseText.ts\"\n\n/** Decode a boundary value while retaining a safe cause classification.\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const decode = <S extends Schema.Top & { readonly DecodingServices: never }>(\n  schema: S,\n  value: unknown,\n  code: \"decode_failed\" | \"invalid_request\" = \"decode_failed\"\n): Effect.Effect<S[\"Type\"], SyncError> =>\n  Effect.try({\n    try: () => Schema.decodeUnknownSync(schema)(value),\n    catch: (cause) => new SyncError({ code, message: \"Invalid sync envelope\", cause: causeCode(cause) })\n  })\n\nconst decodeEntries = Schema.decodeUnknownSync(Schema.Array(JournalEvent.Entry))\nconst decodeJson = Schema.decodeUnknownSync(Schema.Struct({ payload: Schema.Json, meta: Schema.Json }))\nconst decodeCommand = Schema.decodeUnknownSync(CommandEventPayload)\nconst decodeBranch = Schema.decodeUnknownSync(Schema.Struct({ branchId: Schema.optional(BranchId) }))\n\n/** One admitted entry beside the command payload admission decoded from it.\n * `command` is `undefined` for every event type other than `CommandEvent`.\n * @category models\n * @since 1.0.0-rc.0\n */\nexport interface Admitted {\n  readonly entry: JournalEvent.Entry\n  readonly command: CommandEventPayload | undefined\n}\n\n/** The one validation `records`, `withCommands`, and `entries` share. It keeps\n * each command's decoded payload beside its entry rather than discarding it.\n */\nconst admit = (values: ReadonlyArray<JournalEvent.Entry>): Effect.Effect<ReadonlyArray<Admitted>, SyncError> =>\n  Effect.try({\n    // Capture getters once and detach nested payloads before any application\n    // callback can mutate the producer's next entry after admission.\n    try: () =>\n      decodeEntries(structuredClone(values)).map((entry): Admitted => {\n        decodeJson(entry)\n        if (entry.eventType !== CommandEvent) return { entry, command: undefined }\n        const command = decodeCommand(entry.payload)\n        const identity = decodeBranch(entry.payload)\n        if (identity.branchId !== undefined && identity.branchId !== branchOfRunId(entry.runId)) {\n          throw new SyncError({\n            code: \"protocol_violation\",\n            message: \"Command belongs to another branch\",\n            cause: \"foreign_branch\"\n          })\n        }\n        return { entry, command }\n      }),\n    catch: (cause) =>\n      cause instanceof SyncError\n        ? cause\n        : new SyncError({ code: \"decode_failed\", message: \"Invalid sync record\", cause: causeCode(cause) })\n  })\n\nconst entriesOf = (admitted: ReadonlyArray<Admitted>): ReadonlyArray<JournalEvent.Entry> =>\n  admitted.map(({ entry }) => entry)\n\n/** Known branch records fail closed; unknown namespaces remain open JSON envelopes.\n * Defaults on persisted command args/target keep their existing additive schema meaning.\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const records = (\n  values: ReadonlyArray<JournalEvent.Entry>\n): Effect.Effect<ReadonlyArray<JournalEvent.Entry>, SyncError> => Effect.map(admit(values), entriesOf)\n\n/** Admit an entire run batch before its caller publishes or updates a cursor,\n * handing back each command beside the payload admission decoded, so a caller\n * that needs a command field reads it instead of decoding the payload again.\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const withCommands = (\n  values: ReadonlyArray<JournalEvent.Entry>,\n  runId: JournalEvent.RunId,\n  after: number\n): Effect.Effect<ReadonlyArray<Admitted>, SyncError> =>\n  Effect.gen(function*() {\n    const admitted = yield* admit(values)\n    let previous = after\n    for (const { entry } of admitted) {\n      if (entry.runId !== runId || entry.seq <= previous) {\n        return yield* Effect.fail(\n          new SyncError({\n            code: \"protocol_violation\",\n            message: \"Journal batch must belong to the requested run and ascend strictly above its cursor\",\n            cause: entry.runId !== runId ? \"foreign_run\" : \"non_monotonic_sequence\"\n          })\n        )\n      }\n      previous = entry.seq\n    }\n    return admitted\n  })\n\n/** Admit an entire run batch before its caller publishes or updates a cursor.\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const entries = (\n  values: ReadonlyArray<JournalEvent.Entry>,\n  runId: JournalEvent.RunId,\n  after: number\n): Effect.Effect<ReadonlyArray<JournalEvent.Entry>, SyncError> =>\n  Effect.map(withCommands(values, runId, after), entriesOf)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAA8B;AAC9B,aAAwB;AACxB,aAAwB;AACxB,4BAA2E;AAC3E,uBAA0B;AAC1B,uBAA0B;AAMnB,MAAM,SAAS,CACpB,QACA,OACA,OAA4C,oBAE5C,OAAO,IAAI;AAAA,EACT,KAAK,MAAM,OAAO,kBAAkB,MAAM,EAAE,KAAK;AAAA,EACjD,OAAO,CAAC,UAAU,IAAI,2BAAU,EAAE,MAAM,SAAS,yBAAyB,WAAO,4BAAU,KAAK,EAAE,CAAC;AACrG,CAAC;AAEH,MAAM,gBAAgB,OAAO,kBAAkB,OAAO,MAAM,aAAa,KAAK,CAAC;AAC/E,MAAM,aAAa,OAAO,kBAAkB,OAAO,OAAO,EAAE,SAAS,OAAO,MAAM,MAAM,OAAO,KAAK,CAAC,CAAC;AACtG,MAAM,gBAAgB,OAAO,kBAAkB,yCAAmB;AAClE,MAAM,eAAe,OAAO,kBAAkB,OAAO,OAAO,EAAE,UAAU,OAAO,SAAS,8BAAQ,EAAE,CAAC,CAAC;AAepG,MAAM,QAAQ,CAAC,WACb,OAAO,IAAI;AAAA;AAAA;AAAA,EAGT,KAAK,MACH,cAAc,gBAAgB,MAAM,CAAC,EAAE,IAAI,CAAC,UAAoB;AAC9D,eAAW,KAAK;AAChB,QAAI,MAAM,cAAc,mCAAc,QAAO,EAAE,OAAO,SAAS,OAAU;AACzE,UAAM,UAAU,cAAc,MAAM,OAAO;AAC3C,UAAM,WAAW,aAAa,MAAM,OAAO;AAC3C,QAAI,SAAS,aAAa,UAAa,SAAS,iBAAa,qCAAc,MAAM,KAAK,GAAG;AACvF,YAAM,IAAI,2BAAU;AAAA,QAClB,MAAM;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,MACT,CAAC;AAAA,IACH;AACA,WAAO,EAAE,OAAO,QAAQ;AAAA,EAC1B,CAAC;AAAA,EACH,OAAO,CAAC,UACN,iBAAiB,6BACb,QACA,IAAI,2BAAU,EAAE,MAAM,iBAAiB,SAAS,uBAAuB,WAAO,4BAAU,KAAK,EAAE,CAAC;AACxG,CAAC;AAEH,MAAM,YAAY,CAAC,aACjB,SAAS,IAAI,CAAC,EAAE,MAAM,MAAM,KAAK;AAO5B,MAAM,UAAU,CACrB,WACgE,OAAO,IAAI,MAAM,MAAM,GAAG,SAAS;AAQ9F,MAAM,eAAe,CAC1B,QACA,OACA,UAEA,OAAO,IAAI,aAAY;AACrB,QAAM,WAAW,OAAO,MAAM,MAAM;AACpC,MAAI,WAAW;AACf,aAAW,EAAE,MAAM,KAAK,UAAU;AAChC,QAAI,MAAM,UAAU,SAAS,MAAM,OAAO,UAAU;AAClD,aAAO,OAAO,OAAO;AAAA,QACnB,IAAI,2BAAU;AAAA,UACZ,MAAM;AAAA,UACN,SAAS;AAAA,UACT,OAAO,MAAM,UAAU,QAAQ,gBAAgB;AAAA,QACjD,CAAC;AAAA,MACH;AAAA,IACF;AACA,eAAW,MAAM;AAAA,EACnB;AACA,SAAO;AACT,CAAC;AAMI,MAAM,UAAU,CACrB,QACA,OACA,UAEA,OAAO,IAAI,aAAa,QAAQ,OAAO,KAAK,GAAG,SAAS;",
+  "names": []
+}

package/dist/cjs/internal/CauseText.d.ts

@@ -0,0 +1,55 @@
+/**
+ * How a host failure crosses the sync boundary: what a follower is told about
+ * it, and what it is not.
+ *
+ * `SyncError.cause` crosses the wire to a follower that may hold nothing but a
+ * branch share link, so it carries a short string rather than the host object
+ * that failed. An arbitrary `unknown` had three problems at once: it counted
+ * against no ceiling, a class instance or a cyclic value has no defined wire
+ * form, and whatever the host threw — a driver message with SQL text, a
+ * rejected credential — went out verbatim.
+ *
+ * @since 1.0.0-rc.0
+ */
+/**
+ * Clamps one rendering to {@link maxCauseTextLength}.
+ *
+ * Every string this module produces leaves through here, and so does every
+ * other string a `SyncError` carries out of a host failure: `message` is
+ * `Schema.String` and is as unbounded as `cause` was.
+ *
+ * @category encoding
+ * @since 1.0.0-rc.0
+ */
+export declare const boundedText: (text: string) => string;
+/**
+ * Renders one host failure as a bounded string.
+ *
+ * An `Error` renders as `name: message`; anything else renders as its type
+ * alone, because a non-`Error` value is arbitrary host data and its contents
+ * are not this boundary's to publish. Nothing is retained beyond the returned
+ * string, so an oversized input does not keep its subject alive.
+ *
+ * @category encoding
+ * @since 1.0.0-rc.0
+ */
+export declare const causeText: (cause: unknown) => string;
+/**
+ * Renders one failure as its TYPE alone, with no message.
+ *
+ * The journal's message is the SQLite driver's, and it routinely carries SQL
+ * text, table and column names, and constraint identifiers. A follower may
+ * hold nothing but a branch share link, so what it learns about a storage
+ * fault is the stable code the journal enumerates, never the sentence the
+ * driver wrote. `decodeCapability` already refuses to be a parsing oracle;
+ * this is the same rule for the read and write paths.
+ *
+ * The result is bounded like {@link causeText}: a `Journal` is a host seam, so
+ * the `name` and `code` this reads are as much the host's to choose as the
+ * message it refuses to publish.
+ *
+ * @category encoding
+ * @since 1.0.0-rc.0
+ */
+export declare const causeCode: (cause: unknown) => string;
+//# sourceMappingURL=CauseText.d.ts.map

package/dist/cjs/internal/CauseText.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CauseText.d.ts","sourceRoot":"","sources":["../../../src/internal/CauseText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AASH;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,MACoD,CAAA;AAE/F;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAGxC,CAAA;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAM1C,CAAA"}

package/dist/cjs/internal/CauseText.js

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CauseText_exports = {};
+__export(CauseText_exports, {
+  boundedText: () => boundedText,
+  causeCode: () => causeCode,
+  causeText: () => causeText
+});
+module.exports = __toCommonJS(CauseText_exports);
+const maxCauseTextLength = 512;
+const boundedText = (text) => text.length <= maxCauseTextLength ? text : `${text.slice(0, maxCauseTextLength)} (truncated)`;
+const causeText = (cause) => boundedText(
+  cause instanceof Error ? `${cause.name}: ${cause.message}` : Object.prototype.toString.call(cause)
+);
+const causeCode = (cause) => {
+  if (cause instanceof Error) {
+    const code = cause.code;
+    return boundedText(typeof code === "string" ? `${cause.name}(${code})` : cause.name);
+  }
+  return boundedText(Object.prototype.toString.call(cause));
+};
+//# sourceMappingURL=CauseText.js.map

package/dist/cjs/internal/CauseText.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/CauseText.ts"],
+  "sourcesContent": ["/**\n * How a host failure crosses the sync boundary: what a follower is told about\n * it, and what it is not.\n *\n * `SyncError.cause` crosses the wire to a follower that may hold nothing but a\n * branch share link, so it carries a short string rather than the host object\n * that failed. An arbitrary `unknown` had three problems at once: it counted\n * against no ceiling, a class instance or a cyclic value has no defined wire\n * form, and whatever the host threw \u2014 a driver message with SQL text, a\n * rejected credential \u2014 went out verbatim.\n *\n * @since 1.0.0-rc.0\n */\n\n/**\n * Longest cause rendering that crosses the wire. Long enough to name a failure\n * and short enough that an error can never be the largest thing a follower\n * receives.\n */\nconst maxCauseTextLength = 512\n\n/**\n * Clamps one rendering to {@link maxCauseTextLength}.\n *\n * Every string this module produces leaves through here, and so does every\n * other string a `SyncError` carries out of a host failure: `message` is\n * `Schema.String` and is as unbounded as `cause` was.\n *\n * @category encoding\n * @since 1.0.0-rc.0\n */\nexport const boundedText = (text: string): string =>\n  text.length <= maxCauseTextLength ? text : `${text.slice(0, maxCauseTextLength)} (truncated)`\n\n/**\n * Renders one host failure as a bounded string.\n *\n * An `Error` renders as `name: message`; anything else renders as its type\n * alone, because a non-`Error` value is arbitrary host data and its contents\n * are not this boundary's to publish. Nothing is retained beyond the returned\n * string, so an oversized input does not keep its subject alive.\n *\n * @category encoding\n * @since 1.0.0-rc.0\n */\nexport const causeText = (cause: unknown): string =>\n  boundedText(\n    cause instanceof Error ? `${cause.name}: ${cause.message}` : Object.prototype.toString.call(cause)\n  )\n\n/**\n * Renders one failure as its TYPE alone, with no message.\n *\n * The journal's message is the SQLite driver's, and it routinely carries SQL\n * text, table and column names, and constraint identifiers. A follower may\n * hold nothing but a branch share link, so what it learns about a storage\n * fault is the stable code the journal enumerates, never the sentence the\n * driver wrote. `decodeCapability` already refuses to be a parsing oracle;\n * this is the same rule for the read and write paths.\n *\n * The result is bounded like {@link causeText}: a `Journal` is a host seam, so\n * the `name` and `code` this reads are as much the host's to choose as the\n * message it refuses to publish.\n *\n * @category encoding\n * @since 1.0.0-rc.0\n */\nexport const causeCode = (cause: unknown): string => {\n  if (cause instanceof Error) {\n    const code = (cause as { readonly code?: unknown }).code\n    return boundedText(typeof code === \"string\" ? `${cause.name}(${code})` : cause.name)\n  }\n  return boundedText(Object.prototype.toString.call(cause))\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAmBA,MAAM,qBAAqB;AAYpB,MAAM,cAAc,CAAC,SAC1B,KAAK,UAAU,qBAAqB,OAAO,GAAG,KAAK,MAAM,GAAG,kBAAkB,CAAC;AAa1E,MAAM,YAAY,CAAC,UACxB;AAAA,EACE,iBAAiB,QAAQ,GAAG,MAAM,IAAI,KAAK,MAAM,OAAO,KAAK,OAAO,UAAU,SAAS,KAAK,KAAK;AACnG;AAmBK,MAAM,YAAY,CAAC,UAA2B;AACnD,MAAI,iBAAiB,OAAO;AAC1B,UAAM,OAAQ,MAAsC;AACpD,WAAO,YAAY,OAAO,SAAS,WAAW,GAAG,MAAM,IAAI,IAAI,IAAI,MAAM,MAAM,IAAI;AAAA,EACrF;AACA,SAAO,YAAY,OAAO,UAAU,SAAS,KAAK,KAAK,CAAC;AAC1D;",
+  "names": []
+}

package/dist/cjs/internal/JournalErrorCode.d.ts

@@ -0,0 +1,23 @@
+/**
+ * How a journal failure's stable code maps onto the sync boundary's error
+ * vocabulary.
+ *
+ * @since 1.0.0-rc.0
+ */
+/**
+ * Projects one journal failure's stable code onto this boundary's vocabulary,
+ * or `unknown` when it has no counterpart.
+ *
+ * `SyncError.ErrorCode` already declares `closed`, `backpressure`, and
+ * `decode_failed`, so collapsing every journal failure but `compacted` into
+ * `unknown` threw away a classification the wire could already carry, and left
+ * a follower unable to tell a shut-down journal from an unexplained fault.
+ * Nothing here widens what a follower learns: `causeCode` already publishes
+ * the journal's own enumerated code, and the journal's MESSAGE stays refused
+ * on every path.
+ *
+ * @category encoding
+ * @since 1.0.0-rc.0
+ */
+export declare const journalErrorCode: (cause: unknown) => "backpressure" | "closed" | "decode_failed" | "unknown";
+//# sourceMappingURL=JournalErrorCode.d.ts.map

package/dist/cjs/internal/JournalErrorCode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalErrorCode.d.ts","sourceRoot":"","sources":["../../../src/internal/JournalErrorCode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAmBH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,OAAO,KACb,cAAc,GAAG,QAAQ,GAAG,eAAe,GAAG,SAIhD,CAAA"}

package/dist/cjs/internal/JournalErrorCode.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var JournalErrorCode_exports = {};
+__export(JournalErrorCode_exports, {
+  journalErrorCode: () => journalErrorCode
+});
+module.exports = __toCommonJS(JournalErrorCode_exports);
+const journalCodes = {
+  decode_failed: "decode_failed",
+  journal_closed: "closed",
+  queue_overflow: "backpressure"
+};
+const journalErrorCode = (cause) => {
+  if (!(cause instanceof Error)) return "unknown";
+  const code = cause.code;
+  return typeof code === "string" ? journalCodes[code] ?? "unknown" : "unknown";
+};
+//# sourceMappingURL=JournalErrorCode.js.map

package/dist/cjs/internal/JournalErrorCode.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/JournalErrorCode.ts"],
+  "sourcesContent": ["/**\n * How a journal failure's stable code maps onto the sync boundary's error\n * vocabulary.\n *\n * @since 1.0.0-rc.0\n */\n\n/**\n * The journal codes this boundary can state in its own vocabulary.\n *\n * Only codes whose meaning is identical on both sides are here. A journal that\n * is shut down and a sync boundary that is closed are the same fact; an\n * admission queue that overflowed and backpressure are the same fact; a\n * payload the journal could not decode and one this boundary could not decode\n * are the same fact. Everything else \u2014 a fence lost, a sequence conflict, a\n * projection fault \u2014 is a storage-layer distinction a follower cannot act on,\n * and inventing a sync code for it would say more than is known.\n */\nconst journalCodes: Readonly<Record<string, \"backpressure\" | \"closed\" | \"decode_failed\">> = {\n  decode_failed: \"decode_failed\",\n  journal_closed: \"closed\",\n  queue_overflow: \"backpressure\"\n}\n\n/**\n * Projects one journal failure's stable code onto this boundary's vocabulary,\n * or `unknown` when it has no counterpart.\n *\n * `SyncError.ErrorCode` already declares `closed`, `backpressure`, and\n * `decode_failed`, so collapsing every journal failure but `compacted` into\n * `unknown` threw away a classification the wire could already carry, and left\n * a follower unable to tell a shut-down journal from an unexplained fault.\n * Nothing here widens what a follower learns: `causeCode` already publishes\n * the journal's own enumerated code, and the journal's MESSAGE stays refused\n * on every path.\n *\n * @category encoding\n * @since 1.0.0-rc.0\n */\nexport const journalErrorCode = (\n  cause: unknown\n): \"backpressure\" | \"closed\" | \"decode_failed\" | \"unknown\" => {\n  if (!(cause instanceof Error)) return \"unknown\"\n  const code = (cause as { readonly code?: unknown }).code\n  return typeof code === \"string\" ? journalCodes[code] ?? \"unknown\" : \"unknown\"\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,MAAM,eAAsF;AAAA,EAC1F,eAAe;AAAA,EACf,gBAAgB;AAAA,EAChB,gBAAgB;AAClB;AAiBO,MAAM,mBAAmB,CAC9B,UAC4D;AAC5D,MAAI,EAAE,iBAAiB,OAAQ,QAAO;AACtC,QAAM,OAAQ,MAAsC;AACpD,SAAO,OAAO,SAAS,WAAW,aAAa,IAAI,KAAK,YAAY;AACtE;",
+  "names": []
+}

package/dist/cjs/internal/PolicyOptions.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Execution-time validation of the numeric policies this package's
+ * constructors accept.
+ *
+ * Every `Options` field is typed `number`, and TypeScript admits `NaN`,
+ * `Infinity`, zero, and a negative under that type. Each of them disables the
+ * thing it configures rather than tightening it: `maxFrameBytes: NaN` makes
+ * every `bytes > maxFrameBytes` comparison false, so the ceiling silently
+ * stops existing; `concurrency: 0` reaches a bounded `Stream.flatMap`
+ * unchecked. A policy is checked once, where it enters, and a bad one is a
+ * typed refusal rather than a bound that quietly does nothing.
+ *
+ * @since 1.0.0-rc.0
+ */
+import * as Effect from "effect/Effect";
+import { SyncError } from "../SyncError.ts";
+/**
+ * The caller's value when it is a positive safe integer, the fallback when the
+ * caller supplied none, and a typed `invalid_request` refusal otherwise. The
+ * message names the option so the offending field is identifiable without the
+ * error carrying anything but the scalar it was given.
+ *
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const positiveInt: (name: string, value: number | undefined, fallback: number) => Effect.Effect<number, SyncError>;
+/**
+ * A count carried by a REQUEST rather than by a policy: floored at one,
+ * ceilinged at what the wire schema allows, and refused otherwise.
+ *
+ * `SyncProtocol` already bounds `limit` and `credit` on both sides, so a
+ * decoded request cannot carry a bad one. An in-process caller that builds the
+ * request value directly never meets that schema, and the TypeScript type it
+ * does meet is `number`: `NaN`, zero, and a negative all satisfy it. Each of
+ * them disables the bound instead of tightening it — `Math.min(NaN, ceiling)`
+ * is `NaN`, every `length >= NaN` comparison answers false, and the value
+ * reaches the journal as a page size — so the floor is checked here, where
+ * both callers share one refusal and one sentence.
+ *
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const requestCount: (name: string, value: number, ceiling: number) => Effect.Effect<number, SyncError>;
+/**
+ * {@link positiveInt} plus a ceiling, for a policy the WIRE also bounds.
+ *
+ * A value the local schema would accept and the wire schema would refuse is
+ * not a transport failure, but that is what it looked like: the RPC client's
+ * own decode failure arrived through the same channel a dropped connection
+ * does, and the follow retried it under backoff forever. The refusal belongs
+ * here, before a request is built.
+ *
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const boundedInt: (name: string, value: number | undefined, fallback: number, maximum: number) => Effect.Effect<number, SyncError>;
+//# sourceMappingURL=PolicyOptions.d.ts.map

package/dist/cjs/internal/PolicyOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PolicyOptions.d.ts","sourceRoot":"","sources":["../../../src/internal/PolicyOptions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GACtB,MAAM,MAAM,EACZ,OAAO,MAAM,GAAG,SAAS,EACzB,UAAU,MAAM,KACf,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAQjC,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,OAAO,MAAM,EACb,SAAS,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAM/B,CAAA;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,UAAU,GACrB,MAAM,MAAM,EACZ,OAAO,MAAM,GAAG,SAAS,EACzB,UAAU,MAAM,EAChB,SAAS,MAAM,KACd,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAU/B,CAAA"}

package/dist/cjs/internal/PolicyOptions.js

@@ -0,0 +1,62 @@
+"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 PolicyOptions_exports = {};
+__export(PolicyOptions_exports, {
+  boundedInt: () => boundedInt,
+  positiveInt: () => positiveInt,
+  requestCount: () => requestCount
+});
+module.exports = __toCommonJS(PolicyOptions_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var import_SyncError = require("../SyncError.js");
+const positiveInt = (name, value, fallback) => {
+  if (value === void 0) return Effect.succeed(fallback);
+  return Number.isSafeInteger(value) && value > 0 ? Effect.succeed(value) : Effect.fail(
+    new import_SyncError.SyncError({
+      code: "invalid_request",
+      message: `${name} must be a positive safe integer, not ${value}`
+    })
+  );
+};
+const requestCount = (name, value, ceiling) => Number.isSafeInteger(value) && value > 0 ? Effect.succeed(Math.min(value, ceiling)) : Effect.fail(
+  new import_SyncError.SyncError({
+    code: "invalid_request",
+    message: `${name} must be a positive safe integer, not ${value}`
+  })
+);
+const boundedInt = (name, value, fallback, maximum) => Effect.flatMap(
+  positiveInt(name, value, fallback),
+  (accepted) => accepted <= maximum ? Effect.succeed(accepted) : Effect.fail(
+    new import_SyncError.SyncError({
+      code: "invalid_request",
+      message: `${name} must be at most ${maximum}, not ${accepted}`
+    })
+  )
+);
+//# sourceMappingURL=PolicyOptions.js.map

package/dist/cjs/internal/PolicyOptions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/internal/PolicyOptions.ts"],
+  "sourcesContent": ["/**\n * Execution-time validation of the numeric policies this package's\n * constructors accept.\n *\n * Every `Options` field is typed `number`, and TypeScript admits `NaN`,\n * `Infinity`, zero, and a negative under that type. Each of them disables the\n * thing it configures rather than tightening it: `maxFrameBytes: NaN` makes\n * every `bytes > maxFrameBytes` comparison false, so the ceiling silently\n * stops existing; `concurrency: 0` reaches a bounded `Stream.flatMap`\n * unchecked. A policy is checked once, where it enters, and a bad one is a\n * typed refusal rather than a bound that quietly does nothing.\n *\n * @since 1.0.0-rc.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport { SyncError } from \"../SyncError.ts\"\n\n/**\n * The caller's value when it is a positive safe integer, the fallback when the\n * caller supplied none, and a typed `invalid_request` refusal otherwise. The\n * message names the option so the offending field is identifiable without the\n * error carrying anything but the scalar it was given.\n *\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const positiveInt = (\n  name: string,\n  value: number | undefined,\n  fallback: number\n): Effect.Effect<number, SyncError> => {\n  if (value === undefined) return Effect.succeed(fallback)\n  return Number.isSafeInteger(value) && value > 0 ? Effect.succeed(value) : Effect.fail(\n    new SyncError({\n      code: \"invalid_request\",\n      message: `${name} must be a positive safe integer, not ${value}`\n    })\n  )\n}\n\n/**\n * A count carried by a REQUEST rather than by a policy: floored at one,\n * ceilinged at what the wire schema allows, and refused otherwise.\n *\n * `SyncProtocol` already bounds `limit` and `credit` on both sides, so a\n * decoded request cannot carry a bad one. An in-process caller that builds the\n * request value directly never meets that schema, and the TypeScript type it\n * does meet is `number`: `NaN`, zero, and a negative all satisfy it. Each of\n * them disables the bound instead of tightening it \u2014 `Math.min(NaN, ceiling)`\n * is `NaN`, every `length >= NaN` comparison answers false, and the value\n * reaches the journal as a page size \u2014 so the floor is checked here, where\n * both callers share one refusal and one sentence.\n *\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const requestCount = (\n  name: string,\n  value: number,\n  ceiling: number\n): Effect.Effect<number, SyncError> =>\n  Number.isSafeInteger(value) && value > 0 ? Effect.succeed(Math.min(value, ceiling)) : Effect.fail(\n    new SyncError({\n      code: \"invalid_request\",\n      message: `${name} must be a positive safe integer, not ${value}`\n    })\n  )\n\n/**\n * {@link positiveInt} plus a ceiling, for a policy the WIRE also bounds.\n *\n * A value the local schema would accept and the wire schema would refuse is\n * not a transport failure, but that is what it looked like: the RPC client's\n * own decode failure arrived through the same channel a dropped connection\n * does, and the follow retried it under backoff forever. The refusal belongs\n * here, before a request is built.\n *\n * @category validation\n * @since 1.0.0-rc.0\n */\nexport const boundedInt = (\n  name: string,\n  value: number | undefined,\n  fallback: number,\n  maximum: number\n): Effect.Effect<number, SyncError> =>\n  Effect.flatMap(\n    positiveInt(name, value, fallback),\n    (accepted) =>\n      accepted <= maximum ? Effect.succeed(accepted) : Effect.fail(\n        new SyncError({\n          code: \"invalid_request\",\n          message: `${name} must be at most ${maximum}, not ${accepted}`\n        })\n      )\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,aAAwB;AACxB,uBAA0B;AAWnB,MAAM,cAAc,CACzB,MACA,OACA,aACqC;AACrC,MAAI,UAAU,OAAW,QAAO,OAAO,QAAQ,QAAQ;AACvD,SAAO,OAAO,cAAc,KAAK,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,IAAI,OAAO;AAAA,IAC/E,IAAI,2BAAU;AAAA,MACZ,MAAM;AAAA,MACN,SAAS,GAAG,IAAI,yCAAyC,KAAK;AAAA,IAChE,CAAC;AAAA,EACH;AACF;AAkBO,MAAM,eAAe,CAC1B,MACA,OACA,YAEA,OAAO,cAAc,KAAK,KAAK,QAAQ,IAAI,OAAO,QAAQ,KAAK,IAAI,OAAO,OAAO,CAAC,IAAI,OAAO;AAAA,EAC3F,IAAI,2BAAU;AAAA,IACZ,MAAM;AAAA,IACN,SAAS,GAAG,IAAI,yCAAyC,KAAK;AAAA,EAChE,CAAC;AACH;AAcK,MAAM,aAAa,CACxB,MACA,OACA,UACA,YAEA,OAAO;AAAA,EACL,YAAY,MAAM,OAAO,QAAQ;AAAA,EACjC,CAAC,aACC,YAAY,UAAU,OAAO,QAAQ,QAAQ,IAAI,OAAO;AAAA,IACtD,IAAI,2BAAU;AAAA,MACZ,MAAM;AAAA,MACN,SAAS,GAAG,IAAI,oBAAoB,OAAO,SAAS,QAAQ;AAAA,IAC9D,CAAC;AAAA,EACH;AACJ;",
+  "names": []
+}

package/dist/cjs/internal/ProtocolVersion.d.ts

@@ -0,0 +1,17 @@
+/** The one protocol-version comparison every sync boundary answers with.
+ * @since 1.0.0-rc.0
+ */
+import * as Effect from "effect/Effect";
+import { SyncError } from "../SyncError.ts";
+/** Refuse a version this revision does not speak, on every path, with one code.
+ *
+ * Read, subscribe and snapshot all decode a mismatched version so the refusal
+ * is this typed `protocol_violation` rather than three different decode
+ * failures, and the accepted number is only ever
+ * {@link SyncProtocol.protocolVersion}.
+ *
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export declare const requireVersion: (version: number | undefined) => Effect.Effect<void, SyncError>;
+//# sourceMappingURL=ProtocolVersion.d.ts.map

package/dist/cjs/internal/ProtocolVersion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProtocolVersion.d.ts","sourceRoot":"","sources":["../../../src/internal/ProtocolVersion.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAG3C;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,MAAM,GAAG,SAAS,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CASrF,CAAA"}

package/dist/cjs/internal/ProtocolVersion.js

@@ -0,0 +1,44 @@
+"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 ProtocolVersion_exports = {};
+__export(ProtocolVersion_exports, {
+  requireVersion: () => requireVersion
+});
+module.exports = __toCommonJS(ProtocolVersion_exports);
+var Effect = __toESM(require("effect/Effect"), 1);
+var import_SyncError = require("../SyncError.js");
+var import_SyncProtocol = require("../SyncProtocol.js");
+const requireVersion = (version) => version === import_SyncProtocol.protocolVersion ? Effect.void : Effect.fail(
+  new import_SyncError.SyncError({
+    code: "protocol_violation",
+    message: `Expected sync protocol version ${import_SyncProtocol.protocolVersion}; received ${version}`,
+    cause: "protocol_version_mismatch"
+  })
+);
+//# sourceMappingURL=ProtocolVersion.js.map