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

package/dist/esm/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Read-only journal synchronization services for flows.
+ *
+ * @since 0.1.0
+ */
+/**
+ * @category errors
+ * @since 0.1.0
+ */
+export * as SyncError from "./SyncError.ts";
+/**
+ * @category protocol
+ * @since 0.1.0
+ */
+export * as SyncProtocol from "./SyncProtocol.ts";
+/**
+ * @category protocol
+ * @since 0.1.0
+ */
+export * as BranchProtocol from "./BranchProtocol.ts";
+/**
+ * @category projections
+ * @since 0.1.0
+ */
+export * as BranchProjection from "./BranchProjection.ts";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as SyncRpcs from "./SyncRpcs.ts";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as BranchRpcs from "./BranchRpcs.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as RunCatalog from "./RunCatalog.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as SyncServer from "./SyncServer.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as SyncClient from "./SyncClient.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchShare from "./BranchShare.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as WorkspaceShare from "./WorkspaceShare.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as SyncPrincipal from "./SyncPrincipal.ts";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as SyncAuth from "./SyncAuth.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchPresence from "./BranchPresence.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchCommands from "./BranchCommands.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchServer from "./BranchServer.ts";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchIds from "./BranchIds.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA"}

package/dist/esm/index.js

@@ -0,0 +1,91 @@
+/**
+ * Read-only journal synchronization services for flows.
+ *
+ * @since 0.1.0
+ */
+/**
+ * @category errors
+ * @since 0.1.0
+ */
+export * as SyncError from "./SyncError.js";
+/**
+ * @category protocol
+ * @since 0.1.0
+ */
+export * as SyncProtocol from "./SyncProtocol.js";
+/**
+ * @category protocol
+ * @since 0.1.0
+ */
+export * as BranchProtocol from "./BranchProtocol.js";
+/**
+ * @category projections
+ * @since 0.1.0
+ */
+export * as BranchProjection from "./BranchProjection.js";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as SyncRpcs from "./SyncRpcs.js";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as BranchRpcs from "./BranchRpcs.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as RunCatalog from "./RunCatalog.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as SyncServer from "./SyncServer.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as SyncClient from "./SyncClient.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchShare from "./BranchShare.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as WorkspaceShare from "./WorkspaceShare.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as SyncPrincipal from "./SyncPrincipal.js";
+/**
+ * @category rpc
+ * @since 0.1.0
+ */
+export * as SyncAuth from "./SyncAuth.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchPresence from "./BranchPresence.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchCommands from "./BranchCommands.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchServer from "./BranchServer.js";
+/**
+ * @category services
+ * @since 0.1.0
+ */
+export * as BranchIds from "./BranchIds.js";
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAE3C;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,gBAAgB,MAAM,uBAAuB,CAAA;AAEzD;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,UAAU,MAAM,iBAAiB,CAAA;AAE7C;;;GAGG;AACH,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAE/C;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,aAAa,MAAM,oBAAoB,CAAA;AAEnD;;;GAGG;AACH,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAA;AAEzC;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;GAGG;AACH,OAAO,KAAK,YAAY,MAAM,mBAAmB,CAAA;AAEjD;;;GAGG;AACH,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA","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"]}

package/dist/esm/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/esm/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/esm/internal/Admission.js

@@ -0,0 +1,80 @@
+/** 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 { BranchId, branchOfRunId, CommandEvent, CommandEventPayload } from "../BranchProtocol.js";
+import { SyncError } from "../SyncError.js";
+import { causeCode } from "./CauseText.js";
+/** Decode a boundary value while retaining a safe cause classification.
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export const decode = (schema, value, code = "decode_failed") => Effect.try({
+    try: () => Schema.decodeUnknownSync(schema)(value),
+    catch: (cause) => new SyncError({ code, message: "Invalid sync envelope", cause: 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(CommandEventPayload);
+const decodeBranch = Schema.decodeUnknownSync(Schema.Struct({ branchId: Schema.optional(BranchId) }));
+/** The one validation `records`, `withCommands`, and `entries` share. It keeps
+ * each command's decoded payload beside its entry rather than discarding it.
+ */
+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 !== CommandEvent)
+            return { entry, command: undefined };
+        const command = decodeCommand(entry.payload);
+        const identity = decodeBranch(entry.payload);
+        if (identity.branchId !== undefined && identity.branchId !== branchOfRunId(entry.runId)) {
+            throw new SyncError({
+                code: "protocol_violation",
+                message: "Command belongs to another branch",
+                cause: "foreign_branch"
+            });
+        }
+        return { entry, command };
+    }),
+    catch: (cause) => cause instanceof SyncError
+        ? cause
+        : new SyncError({ code: "decode_failed", message: "Invalid sync record", cause: causeCode(cause) })
+});
+const entriesOf = (admitted) => admitted.map(({ entry }) => entry);
+/** 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 const records = (values) => Effect.map(admit(values), entriesOf);
+/** 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 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 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;
+});
+/** Admit an entire run batch before its caller publishes or updates a cursor.
+ * @category validation
+ * @since 1.0.0-rc.0
+ */
+export const entries = (values, runId, after) => Effect.map(withCommands(values, runId, after), entriesOf);
+//# sourceMappingURL=Admission.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Admission.js","sourceRoot":"","sources":["../../../src/internal/Admission.ts"],"names":[],"mappings":"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","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"]}

package/dist/esm/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/esm/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/esm/internal/CauseText.js

@@ -0,0 +1,67 @@
+/**
+ * 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
+ */
+/**
+ * Longest cause rendering that crosses the wire. Long enough to name a failure
+ * and short enough that an error can never be the largest thing a follower
+ * receives.
+ */
+const maxCauseTextLength = 512;
+/**
+ * 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 const boundedText = (text) => text.length <= maxCauseTextLength ? text : `${text.slice(0, maxCauseTextLength)} (truncated)`;
+/**
+ * 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 const causeText = (cause) => boundedText(cause instanceof Error ? `${cause.name}: ${cause.message}` : Object.prototype.toString.call(cause));
+/**
+ * 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 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/esm/internal/CauseText.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CauseText.js","sourceRoot":"","sources":["../../../src/internal/CauseText.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH,MAAM,kBAAkB,GAAG,GAAG,CAAA;AAE9B;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,IAAY,EAAU,EAAE,CAClD,IAAI,CAAC,MAAM,IAAI,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,cAAc,CAAA;AAE/F;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAc,EAAU,EAAE,CAClD,WAAW,CACT,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CACnG,CAAA;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,KAAc,EAAU,EAAE;IAClD,IAAI,KAAK,YAAY,KAAK,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAI,KAAqC,CAAC,IAAI,CAAA;QACxD,OAAO,WAAW,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,IAAI,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACtF,CAAC;IACD,OAAO,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;AAC3D,CAAC,CAAA","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 — a driver message with SQL text, a\n * rejected credential — 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"]}

package/dist/esm/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/esm/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/esm/internal/JournalErrorCode.js

@@ -0,0 +1,44 @@
+/**
+ * How a journal failure's stable code maps onto the sync boundary's error
+ * vocabulary.
+ *
+ * @since 1.0.0-rc.0
+ */
+/**
+ * The journal codes this boundary can state in its own vocabulary.
+ *
+ * Only codes whose meaning is identical on both sides are here. A journal that
+ * is shut down and a sync boundary that is closed are the same fact; an
+ * admission queue that overflowed and backpressure are the same fact; a
+ * payload the journal could not decode and one this boundary could not decode
+ * are the same fact. Everything else — a fence lost, a sequence conflict, a
+ * projection fault — is a storage-layer distinction a follower cannot act on,
+ * and inventing a sync code for it would say more than is known.
+ */
+const journalCodes = {
+    decode_failed: "decode_failed",
+    journal_closed: "closed",
+    queue_overflow: "backpressure"
+};
+/**
+ * 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 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/esm/internal/JournalErrorCode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"JournalErrorCode.js","sourceRoot":"","sources":["../../../src/internal/JournalErrorCode.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,YAAY,GAA0E;IAC1F,aAAa,EAAE,eAAe;IAC9B,cAAc,EAAE,QAAQ;IACxB,cAAc,EAAE,cAAc;CAC/B,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,KAAc,EAC2C,EAAE;IAC3D,IAAI,CAAC,CAAC,KAAK,YAAY,KAAK,CAAC;QAAE,OAAO,SAAS,CAAA;IAC/C,MAAM,IAAI,GAAI,KAAqC,CAAC,IAAI,CAAA;IACxD,OAAO,OAAO,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,SAAS,CAAA;AAC/E,CAAC,CAAA","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 — a fence lost, a sequence conflict, a\n * projection fault — 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"]}

package/dist/esm/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/esm/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"}