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

package/dist/cjs/test/TestSocket.js

@@ -0,0 +1,145 @@
+"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 TestSocket_exports = {};
+__export(TestSocket_exports, {
+  makePair: () => makePair
+});
+module.exports = __toCommonJS(TestSocket_exports);
+var Deferred = __toESM(require("effect/Deferred"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Latch = __toESM(require("effect/Latch"), 1);
+var Queue = __toESM(require("effect/Queue"), 1);
+var Scope = __toESM(require("effect/Scope"), 1);
+var Socket = __toESM(require("effect/unstable/socket/Socket"), 1);
+const queueCapacity = 16;
+const transportError = () => new Socket.SocketError({
+  reason: new Socket.SocketReadError({ cause: new Error("test socket disconnected") })
+});
+const intersects = (leftFrom, leftTo, rightFrom, rightTo) => leftFrom <= rightTo && rightFrom <= leftTo;
+const entriesRange = (bytes) => {
+  try {
+    const value = JSON.parse(new TextDecoder().decode(bytes));
+    return findEntriesRange(value);
+  } catch {
+    return void 0;
+  }
+};
+const findEntriesRange = (value) => {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  if (record["_tag"] === "Entries" && typeof record["runId"] === "string" && typeof record["fromSeq"] === "number" && typeof record["toSeq"] === "number") {
+    return { runId: record["runId"], from: record["fromSeq"], to: record["toSeq"] };
+  }
+  for (const child of Object.values(record)) {
+    if (Array.isArray(child)) {
+      for (const element of child) {
+        const result = findEntriesRange(element);
+        if (result !== void 0) return result;
+      }
+    } else {
+      const result = findEntriesRange(child);
+      if (result !== void 0) return result;
+    }
+  }
+  return void 0;
+};
+const makePair = () => Effect.gen(function* () {
+  const scope = yield* Effect.scope;
+  const clientIncoming = yield* Queue.bounded(queueCapacity);
+  const serverIncoming = yield* Queue.bounded(queueCapacity);
+  yield* Scope.addFinalizer(
+    scope,
+    Effect.all([Queue.shutdown(clientIncoming), Queue.shutdown(serverIncoming)], { discard: true })
+  );
+  const delivery = Latch.makeUnsafe(true);
+  const filters = [];
+  const offer = (queue, bytes) => Effect.suspend(() => {
+    let current = bytes;
+    for (const filter of filters) {
+      const result = filter(current);
+      if (typeof result === "boolean") {
+        if (result === false) return Effect.void;
+      } else {
+        current = result;
+      }
+    }
+    return Queue.offer(queue, current).pipe(Effect.asVoid);
+  });
+  const socket = (incoming, outgoing) => {
+    const write = (chunk) => {
+      if (Socket.isCloseEvent(chunk)) return Effect.void;
+      const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+      return offer(outgoing, bytes);
+    };
+    return Socket.make({
+      reader: Effect.gen(function* () {
+        const closed = yield* Deferred.make();
+        yield* Effect.addFinalizer(() => Deferred.fail(closed, transportError()));
+        return {
+          pull: Effect.raceFirst(
+            Effect.map(delivery.whenOpen(Queue.take(incoming)), (bytes) => [bytes]),
+            Deferred.await(closed)
+          ),
+          upgrade: Socket.SocketUpgradeError.unsupported
+        };
+      }),
+      writer: Effect.succeed({
+        write,
+        writeAll: (chunks) => Effect.forEach(chunks, write, { discard: true })
+      })
+    });
+  };
+  const faults = {
+    installFilter: (filter) => {
+      filters.push(filter);
+    },
+    dropRange: (runId, from, to) => {
+      filters.push((bytes) => {
+        const range = entriesRange(bytes);
+        return range === void 0 || range.runId !== runId || !intersects(range.from, range.to, from, to);
+      });
+    },
+    stall: () => {
+      delivery.closeUnsafe();
+    },
+    resume: () => {
+      delivery.openUnsafe();
+    },
+    disconnect: () => Effect.andThen(
+      Queue.fail(clientIncoming, transportError()),
+      Queue.fail(serverIncoming, transportError())
+    ).pipe(Effect.asVoid)
+  };
+  return {
+    client: socket(clientIncoming, serverIncoming),
+    server: socket(serverIncoming, clientIncoming),
+    faults
+  };
+});
+//# sourceMappingURL=TestSocket.js.map

package/dist/cjs/test/TestSocket.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/test/TestSocket.ts"],
+  "sourcesContent": ["/**\n * Deterministic in-memory socket transport for sync tests.\n *\n * @since 0.1.0\n */\n\nimport * as Deferred from \"effect/Deferred\"\nimport * as Effect from \"effect/Effect\"\nimport * as Latch from \"effect/Latch\"\nimport * as Queue from \"effect/Queue\"\nimport * as Scope from \"effect/Scope\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\n\n/**\n * A predicate or byte transformation installed between the two socket ends.\n * Returning `false` drops the frame.\n *\n * @category models\n * @since 0.1.0\n */\nexport type FrameFilter = (bytes: Uint8Array) => boolean | Uint8Array\n\n/**\n * Deterministic transport failures that can be injected into a test socket pair.\n *\n * `dropRange` recognizes the JSON representation of an `Entries` frame without\n * importing the sync protocol. Tests using another wire representation can use\n * `installFilter` directly.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface TestFaults {\n  readonly installFilter: (filter: FrameFilter) => void\n  readonly dropRange: (runId: string, from: number, to: number) => void\n  readonly stall: () => void\n  readonly resume: () => void\n  readonly disconnect: () => Effect.Effect<void>\n}\n\n/**\n * The two endpoints and controls of an in-memory socket connection.\n *\n * @category models\n * @since 0.1.0\n */\nexport interface Pair {\n  readonly client: Socket.Socket\n  readonly server: Socket.Socket\n  readonly faults: TestFaults\n}\n\nconst queueCapacity = 16\n\nconst transportError = () =>\n  new Socket.SocketError({\n    reason: new Socket.SocketReadError({ cause: new Error(\"test socket disconnected\") })\n  })\n\nconst intersects = (leftFrom: number, leftTo: number, rightFrom: number, rightTo: number) =>\n  leftFrom <= rightTo && rightFrom <= leftTo\n\nconst entriesRange = (\n  bytes: Uint8Array\n): { readonly runId: string; readonly from: number; readonly to: number } | undefined => {\n  try {\n    const value: unknown = JSON.parse(new TextDecoder().decode(bytes))\n    return findEntriesRange(value)\n  } catch {\n    return undefined\n  }\n}\n\nconst findEntriesRange = (\n  value: unknown\n): { readonly runId: string; readonly from: number; readonly to: number } | undefined => {\n  if (typeof value !== \"object\" || value === null) return undefined\n  const record = value as Readonly<Record<string, unknown>>\n  if (\n    record[\"_tag\"] === \"Entries\" &&\n    typeof record[\"runId\"] === \"string\" &&\n    typeof record[\"fromSeq\"] === \"number\" &&\n    typeof record[\"toSeq\"] === \"number\"\n  ) {\n    return { runId: record[\"runId\"], from: record[\"fromSeq\"], to: record[\"toSeq\"] }\n  }\n  for (const child of Object.values(record)) {\n    if (Array.isArray(child)) {\n      for (const element of child) {\n        const result = findEntriesRange(element)\n        if (result !== undefined) return result\n      }\n    } else {\n      const result = findEntriesRange(child)\n      if (result !== undefined) return result\n    }\n  }\n  return undefined\n}\n\n/**\n * Creates a scoped, bounded, bidirectional in-memory socket connection.\n *\n * Socket runs wait on queue reads and are therefore interrupted with their\n * enclosing scope; no host abort signal or timer is involved.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const makePair = (): Effect.Effect<Pair, never, Scope.Scope> =>\n  Effect.gen(function*() {\n    const scope = yield* Effect.scope\n    const clientIncoming = yield* Queue.bounded<Uint8Array, Socket.SocketError>(queueCapacity)\n    const serverIncoming = yield* Queue.bounded<Uint8Array, Socket.SocketError>(queueCapacity)\n    yield* Scope.addFinalizer(\n      scope,\n      Effect.all([Queue.shutdown(clientIncoming), Queue.shutdown(serverIncoming)], { discard: true })\n    )\n    const delivery = Latch.makeUnsafe(true)\n    const filters: Array<FrameFilter> = []\n\n    const offer = (queue: Queue.Queue<Uint8Array, Socket.SocketError>, bytes: Uint8Array) =>\n      Effect.suspend(() => {\n        let current = bytes\n        for (const filter of filters) {\n          const result = filter(current)\n          if (typeof result === \"boolean\") {\n            if (result === false) return Effect.void\n          } else {\n            current = result\n          }\n        }\n        return Queue.offer(queue, current).pipe(Effect.asVoid)\n      })\n\n    const socket = (\n      incoming: Queue.Queue<Uint8Array, Socket.SocketError>,\n      outgoing: Queue.Queue<Uint8Array, Socket.SocketError>\n    ) => {\n      const write: Socket.Writer[\"write\"] = (chunk) => {\n        if (Socket.isCloseEvent(chunk)) return Effect.void\n        const bytes = typeof chunk === \"string\" ? new TextEncoder().encode(chunk) : chunk\n        return offer(outgoing, bytes)\n      }\n      return Socket.make({\n        reader: Effect.gen(function*() {\n          const closed = yield* Deferred.make<never, Socket.SocketError>()\n          yield* Effect.addFinalizer(() => Deferred.fail(closed, transportError()))\n          return {\n            pull: Effect.raceFirst(\n              Effect.map(delivery.whenOpen(Queue.take(incoming)), (bytes) => [bytes] as const),\n              Deferred.await(closed)\n            ),\n            upgrade: Socket.SocketUpgradeError.unsupported\n          }\n        }),\n        writer: Effect.succeed({\n          write,\n          writeAll: (chunks) => Effect.forEach(chunks, write, { discard: true })\n        })\n      })\n    }\n\n    const faults: TestFaults = {\n      installFilter: (filter) => {\n        filters.push(filter)\n      },\n      dropRange: (runId, from, to) => {\n        filters.push((bytes) => {\n          const range = entriesRange(bytes)\n          return range === undefined || range.runId !== runId || !intersects(range.from, range.to, from, to)\n        })\n      },\n      stall: () => {\n        delivery.closeUnsafe()\n      },\n      resume: () => {\n        delivery.openUnsafe()\n      },\n      disconnect: () =>\n        Effect.andThen(\n          Queue.fail(clientIncoming, transportError()),\n          Queue.fail(serverIncoming, transportError())\n        ).pipe(Effect.asVoid)\n    }\n\n    return {\n      client: socket(clientIncoming, serverIncoming),\n      server: socket(serverIncoming, clientIncoming),\n      faults\n    }\n  })\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/test/TestSync.d.ts

@@ -0,0 +1,54 @@
+/**
+ * In-process sync service and RPC transport wiring for tests.
+ *
+ * @since 0.1.0
+ */
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as RunCatalog from "../RunCatalog.ts";
+import * as SyncClient from "../SyncClient.ts";
+import * as SyncRpcs from "../SyncRpcs.ts";
+import * as SyncServer from "../SyncServer.ts";
+import type { Pair } from "./TestSocket.ts";
+/**
+ * An authentication middleware that trusts every connection as the workspace
+ * owner. Test-only by construction: replication-mechanics suites use it so
+ * they exercise paging and streaming without provisioning capabilities,
+ * while the authentication suites use the production `SyncAuth.layer`.
+ *
+ * Never compose it into a served transport: every network client would read
+ * every workspace run as the owner. The name says so at the call site.
+ *
+ * @category layers
+ * @since 1.0.0-rc.1
+ */
+export declare const layerTrustAllAsOwner: Layer.Layer<SyncRpcs.SyncAuth, never, never>;
+/**
+ * Provides the durable in-memory journal, a mutable empty run catalog, the
+ * owner-trusting {@link layerTrustAllAsOwner} middleware, and the production
+ * sync server.
+ *
+ * Tests that need runs in the workspace may register them through their own
+ * `RunCatalog.makeMemory` fixture before providing a more specific layer.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerTest: Layer.Layer<import("@smthrs/journal/Journal").Journal | SyncRpcs.SyncAuth | RunCatalog.RunCatalog | SyncServer.SyncServer, import("effect/unstable/sql/SqlError").SqlError | import("@smthrs/journal/Journal").JournalError | import("effect/unstable/sql/Migrator").MigrationError | import("../SyncError.ts").SyncError, never>;
+/**
+ * Provides no-op sync dependencies for consumers that only require the ports.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: Layer.Layer<SyncRpcs.SyncAuth | RunCatalog.RunCatalog | SyncClient.SyncClient | SyncServer.SyncServer, never, never>;
+/**
+ * Starts an RPC server over the pair's server endpoint and returns a sync
+ * client over the client endpoint. JSON serialization is deliberately used so
+ * frame faults can inspect test traffic without coupling to sync schemas.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const connect: (pair: Pair) => Effect.Effect<SyncClient.Service, never, import("effect/Scope").Scope | SyncRpcs.SyncAuth | SyncServer.SyncServer>;
+//# sourceMappingURL=TestSync.d.ts.map

package/dist/cjs/test/TestSync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestSync.d.ts","sourceRoot":"","sources":["../../../src/test/TestSync.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAOrC,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAA;AAE9C,OAAO,KAAK,QAAQ,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAA;AAC9C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AAI3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,8CAEhC,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,mUAQrB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sHAKrB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,IAAI,uHA8B9B,CAAA"}

package/dist/cjs/test/TestSync.js

@@ -0,0 +1,96 @@
+"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 TestSync_exports = {};
+__export(TestSync_exports, {
+  connect: () => connect,
+  layerNoop: () => layerNoop,
+  layerTest: () => layerTest,
+  layerTrustAllAsOwner: () => layerTrustAllAsOwner
+});
+module.exports = __toCommonJS(TestSync_exports);
+var TestJournal = __toESM(require("@smthrs/journal/test/TestJournal"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Layer = __toESM(require("effect/Layer"), 1);
+var NetAddress = __toESM(require("effect/unstable/net/NetAddress"), 1);
+var RpcClient = __toESM(require("effect/unstable/rpc/RpcClient"), 1);
+var RpcSerialization = __toESM(require("effect/unstable/rpc/RpcSerialization"), 1);
+var RpcServer = __toESM(require("effect/unstable/rpc/RpcServer"), 1);
+var Socket = __toESM(require("effect/unstable/socket/Socket"), 1);
+var SocketServer = __toESM(require("effect/unstable/socket/SocketServer"), 1);
+var RunCatalog = __toESM(require("../RunCatalog.js"), 1);
+var SyncClient = __toESM(require("../SyncClient.js"), 1);
+var SyncPrincipal = __toESM(require("../SyncPrincipal.js"), 1);
+var SyncRpcs = __toESM(require("../SyncRpcs.js"), 1);
+var SyncServer = __toESM(require("../SyncServer.js"), 1);
+const layerNoopAuth = Layer.succeed(SyncRpcs.SyncAuth)((effect) => effect);
+const layerTrustAllAsOwner = Layer.succeed(SyncRpcs.SyncAuth)(
+  (effect) => Effect.provideService(effect, SyncPrincipal.SyncPrincipal, SyncPrincipal.workspace("test-workspace-owner"))
+);
+const layerTest = SyncServer.layer.pipe(
+  Layer.provideMerge(
+    Layer.mergeAll(
+      TestJournal.layer(),
+      RunCatalog.layerMemory(),
+      layerTrustAllAsOwner
+    )
+  )
+);
+const layerNoop = Layer.mergeAll(
+  SyncClient.layerNoop(),
+  SyncServer.layerNoop,
+  RunCatalog.layerNoop,
+  layerNoopAuth
+);
+const connect = (pair) => Effect.gen(function* () {
+  const sync = yield* SyncServer.SyncServer;
+  const handlers = SyncServer.layerHandlers.pipe(
+    Layer.provide(Layer.succeed(SyncServer.SyncServer, sync))
+  );
+  const serverProtocol = yield* RpcServer.makeProtocolSocketServer.pipe(
+    Effect.provideService(SocketServer.SocketServer, {
+      address: NetAddress.inetAddressFromIpStringUnsafe("127.0.0.1", 0),
+      run: (handler) => handler(pair.server).pipe(Effect.orDie, Effect.andThen(Effect.never))
+    }),
+    Effect.provide(RpcSerialization.layerJson)
+  );
+  yield* RpcServer.make(SyncRpcs.SyncRpcs, { disableFatalDefects: true }).pipe(
+    Effect.provideService(RpcServer.Protocol, serverProtocol),
+    Effect.provide(handlers),
+    Effect.forkScoped
+  );
+  const protocol = yield* RpcClient.makeProtocolSocket().pipe(
+    Effect.provideService(Socket.Socket, pair.client),
+    Effect.provide(RpcSerialization.layerJson)
+  );
+  const client = yield* RpcClient.make(SyncRpcs.SyncRpcs).pipe(
+    Effect.provideService(RpcClient.Protocol, protocol)
+  );
+  return yield* SyncClient.make({ client });
+});
+//# sourceMappingURL=TestSync.js.map

package/dist/cjs/test/TestSync.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/test/TestSync.ts"],
+  "sourcesContent": ["/**\n * In-process sync service and RPC transport wiring for tests.\n *\n * @since 0.1.0\n */\n\nimport * as TestJournal from \"@smthrs/journal/test/TestJournal\"\nimport * as Effect from \"effect/Effect\"\nimport * as Layer from \"effect/Layer\"\nimport * as NetAddress from \"effect/unstable/net/NetAddress\"\nimport * as RpcClient from \"effect/unstable/rpc/RpcClient\"\nimport * as RpcSerialization from \"effect/unstable/rpc/RpcSerialization\"\nimport * as RpcServer from \"effect/unstable/rpc/RpcServer\"\nimport * as Socket from \"effect/unstable/socket/Socket\"\nimport * as SocketServer from \"effect/unstable/socket/SocketServer\"\nimport * as RunCatalog from \"../RunCatalog.ts\"\nimport * as SyncClient from \"../SyncClient.ts\"\nimport * as SyncPrincipal from \"../SyncPrincipal.ts\"\nimport * as SyncRpcs from \"../SyncRpcs.ts\"\nimport * as SyncServer from \"../SyncServer.ts\"\nimport type { Pair } from \"./TestSocket.ts\"\n\nconst layerNoopAuth = Layer.succeed(SyncRpcs.SyncAuth)((effect) => effect)\n\n/**\n * An authentication middleware that trusts every connection as the workspace\n * owner. Test-only by construction: replication-mechanics suites use it so\n * they exercise paging and streaming without provisioning capabilities,\n * while the authentication suites use the production `SyncAuth.layer`.\n *\n * Never compose it into a served transport: every network client would read\n * every workspace run as the owner. The name says so at the call site.\n *\n * @category layers\n * @since 1.0.0-rc.1\n */\nexport const layerTrustAllAsOwner = Layer.succeed(SyncRpcs.SyncAuth)((effect) =>\n  Effect.provideService(effect, SyncPrincipal.SyncPrincipal, SyncPrincipal.workspace(\"test-workspace-owner\"))\n)\n\n/**\n * Provides the durable in-memory journal, a mutable empty run catalog, the\n * owner-trusting {@link layerTrustAllAsOwner} middleware, and the production\n * sync server.\n *\n * Tests that need runs in the workspace may register them through their own\n * `RunCatalog.makeMemory` fixture before providing a more specific layer.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerTest = SyncServer.layer.pipe(\n  Layer.provideMerge(\n    Layer.mergeAll(\n      TestJournal.layer(),\n      RunCatalog.layerMemory(),\n      layerTrustAllAsOwner\n    )\n  )\n)\n\n/**\n * Provides no-op sync dependencies for consumers that only require the ports.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerNoop = Layer.mergeAll(\n  SyncClient.layerNoop(),\n  SyncServer.layerNoop,\n  RunCatalog.layerNoop,\n  layerNoopAuth\n)\n\n/**\n * Starts an RPC server over the pair's server endpoint and returns a sync\n * client over the client endpoint. JSON serialization is deliberately used so\n * frame faults can inspect test traffic without coupling to sync schemas.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const connect = (pair: Pair) =>\n  Effect.gen(function*() {\n    const sync = yield* SyncServer.SyncServer\n    const handlers = SyncServer.layerHandlers.pipe(\n      Layer.provide(Layer.succeed(SyncServer.SyncServer, sync))\n    )\n    // Use the production schema-aware protocol. JSON.stringify on the raw\n    // makeNoSerialization responses happened to encode successes, but not\n    // Effect's Cause representation: typed RPC failures never reached clients.\n    const serverProtocol = yield* RpcServer.makeProtocolSocketServer.pipe(\n      Effect.provideService(SocketServer.SocketServer, {\n        address: NetAddress.inetAddressFromIpStringUnsafe(\"127.0.0.1\", 0),\n        run: (handler) => handler(pair.server).pipe(Effect.orDie, Effect.andThen(Effect.never))\n      }),\n      Effect.provide(RpcSerialization.layerJson)\n    )\n    yield* RpcServer.make(SyncRpcs.SyncRpcs, { disableFatalDefects: true }).pipe(\n      Effect.provideService(RpcServer.Protocol, serverProtocol),\n      Effect.provide(handlers),\n      Effect.forkScoped\n    )\n\n    const protocol = yield* RpcClient.makeProtocolSocket().pipe(\n      Effect.provideService(Socket.Socket, pair.client),\n      Effect.provide(RpcSerialization.layerJson)\n    )\n    const client = yield* RpcClient.make(SyncRpcs.SyncRpcs).pipe(\n      Effect.provideService(RpcClient.Protocol, protocol)\n    )\n    return yield* SyncClient.make({ client })\n  })\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,kBAA6B;AAC7B,aAAwB;AACxB,YAAuB;AACvB,iBAA4B;AAC5B,gBAA2B;AAC3B,uBAAkC;AAClC,gBAA2B;AAC3B,aAAwB;AACxB,mBAA8B;AAC9B,iBAA4B;AAC5B,iBAA4B;AAC5B,oBAA+B;AAC/B,eAA0B;AAC1B,iBAA4B;AAG5B,MAAM,gBAAgB,MAAM,QAAQ,SAAS,QAAQ,EAAE,CAAC,WAAW,MAAM;AAclE,MAAM,uBAAuB,MAAM,QAAQ,SAAS,QAAQ;AAAA,EAAE,CAAC,WACpE,OAAO,eAAe,QAAQ,cAAc,eAAe,cAAc,UAAU,sBAAsB,CAAC;AAC5G;AAaO,MAAM,YAAY,WAAW,MAAM;AAAA,EACxC,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,YAAY,MAAM;AAAA,MAClB,WAAW,YAAY;AAAA,MACvB;AAAA,IACF;AAAA,EACF;AACF;AAQO,MAAM,YAAY,MAAM;AAAA,EAC7B,WAAW,UAAU;AAAA,EACrB,WAAW;AAAA,EACX,WAAW;AAAA,EACX;AACF;AAUO,MAAM,UAAU,CAAC,SACtB,OAAO,IAAI,aAAY;AACrB,QAAM,OAAO,OAAO,WAAW;AAC/B,QAAM,WAAW,WAAW,cAAc;AAAA,IACxC,MAAM,QAAQ,MAAM,QAAQ,WAAW,YAAY,IAAI,CAAC;AAAA,EAC1D;AAIA,QAAM,iBAAiB,OAAO,UAAU,yBAAyB;AAAA,IAC/D,OAAO,eAAe,aAAa,cAAc;AAAA,MAC/C,SAAS,WAAW,8BAA8B,aAAa,CAAC;AAAA,MAChE,KAAK,CAAC,YAAY,QAAQ,KAAK,MAAM,EAAE,KAAK,OAAO,OAAO,OAAO,QAAQ,OAAO,KAAK,CAAC;AAAA,IACxF,CAAC;AAAA,IACD,OAAO,QAAQ,iBAAiB,SAAS;AAAA,EAC3C;AACA,SAAO,UAAU,KAAK,SAAS,UAAU,EAAE,qBAAqB,KAAK,CAAC,EAAE;AAAA,IACtE,OAAO,eAAe,UAAU,UAAU,cAAc;AAAA,IACxD,OAAO,QAAQ,QAAQ;AAAA,IACvB,OAAO;AAAA,EACT;AAEA,QAAM,WAAW,OAAO,UAAU,mBAAmB,EAAE;AAAA,IACrD,OAAO,eAAe,OAAO,QAAQ,KAAK,MAAM;AAAA,IAChD,OAAO,QAAQ,iBAAiB,SAAS;AAAA,EAC3C;AACA,QAAM,SAAS,OAAO,UAAU,KAAK,SAAS,QAAQ,EAAE;AAAA,IACtD,OAAO,eAAe,UAAU,UAAU,QAAQ;AAAA,EACpD;AACA,SAAO,OAAO,WAAW,KAAK,EAAE,OAAO,CAAC;AAC1C,CAAC;",
+  "names": []
+}

package/dist/esm/BranchCommands.d.ts

@@ -0,0 +1,228 @@
+/**
+ * Idempotent admission of collaborative commands onto a branch document.
+ *
+ * Three different things look identical from the server's side — an optimistic
+ * client re-sending after a timeout, a reconnecting client flushing its
+ * outbox, and two people pressing the same button at once — and all three must
+ * produce exactly one durable command. The client-minted `commandId` is the
+ * idempotency key for all three.
+ *
+ * The exactly-once constraint is durable, not process-local: every append
+ * carries the producer identity `(branch run, commandSourceId(commandId),
+ * commandSourceSeq)`, which the journal enforces inside its own write
+ * transaction. Two independently constructed servers that race the same
+ * command therefore collide in the journal — one appends, the other receives
+ * a duplicate receipt or an idempotency conflict and resolves the canonical
+ * sequence by replaying the branch (audit finding F-14). The in-memory
+ * ledger, permit, and replay cursor are a fast path only: they answer known
+ * duplicates without a journal write and keep a restarted server from
+ * re-executing history, but correctness never depends on them.
+ *
+ * @since 0.1.0
+ */
+import { Journal } from "@smthrs/journal";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import { type BranchId, type CommandId, CommandReceipt, CommandSubmission, SubmitRequest } from "./BranchProtocol.ts";
+import * as BranchShare from "./BranchShare.ts";
+import { SyncError } from "./SyncError.ts";
+/**
+ * Branch command admission operations.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Service {
+    readonly submit: (request: SubmitRequest) => Effect.Effect<CommandReceipt, SyncError>;
+}
+declare const BranchCommands_base: Context.ServiceClass<BranchCommands, "@smthrs/sync/BranchCommands", Service>;
+/**
+ * The branch command ledger.
+ *
+ * @category services
+ * @since 0.1.0
+ */
+export declare class BranchCommands extends BranchCommands_base {
+}
+/**
+ * Constructs a command ledger that admits nothing.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeNoop: (overrides?: Partial<Service>) => Service;
+/**
+ * Provides a command ledger that admits nothing.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerNoop: Layer.Layer<BranchCommands>;
+/**
+ * Receipts one branch keeps in memory before the oldest are evicted.
+ *
+ * The ledger is a fast path: it answers a known duplicate without a journal
+ * write, and losing an entry costs a round trip, never correctness, because
+ * the journal's own producer identity is the durable exactly-once constraint
+ * and returns a `Duplicate` receipt for a command already admitted. Retaining
+ * one receipt per command forever meant a process serving a hundred branches
+ * of a hundred thousand commands held ten million of them, so the fast path
+ * is bounded and the durable path is what makes it safe to bound.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultLedgerCapacity = 4096;
+/**
+ * Inclusive UTF-8 JSON submission ceiling. The separate sync entry ceiling
+ * leaves room for the durable envelope around every admitted command.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultMaxCommandBytes: number;
+/**
+ * Milliseconds a branch may have no active submissions before its in-memory state is
+ * dropped.
+ *
+ * The receipt ledger is bounded per branch; this bounds the branches. A
+ * dropped branch re-hydrates on its next submission exactly as it does after
+ * a restart, so eviction costs a journal read, never correctness. The default
+ * is the longest lifetime a branch capability may carry, so a branch is only
+ * dropped once every capability minted at its last touch can have expired.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultBranchIdleMs: number;
+/**
+ * Entries one branch's first-touch hydration reads before it stops.
+ *
+ * Hydration is the only full history read that ever sat on the WRITE path: the
+ * first submission a process makes to a branch paged that branch's whole
+ * durable log, 256 entries at a time, while holding the branch's admission
+ * permit, before its own append was attempted. A hundred-thousand-entry branch
+ * therefore charged its next writer four hundred journal reads for a fast path
+ * that keeps four thousand receipts.
+ *
+ * The budget defaults to {@link defaultLedgerCapacity} because hydration
+ * cannot seed more receipts than the ledger holds: everything a longer walk
+ * records displaces something the same walk already recorded. What the extra
+ * reads buy is a FRESHER selection — the tail of history rather than its head
+ * — and the price is an unbounded wait on somebody's write. This trades that
+ * back: the walk stops, the cursor stays where it stopped, and a later replay
+ * continues forward from there.
+ *
+ * A branch longer than the budget starts with a partly cold fast path and
+ * nothing else. Correctness never rested on the ledger: the journal's producer
+ * identity is the durable exactly-once constraint, an exact retry receives a
+ * `Duplicate` receipt carrying the canonical sequence, and an
+ * `idempotency_conflict` is resolved by a read of the whole history that the
+ * ledger's own bound already made necessary.
+ *
+ * @category constants
+ * @since 1.0.0-rc.0
+ */
+export declare const defaultHydrationLimit = 4096;
+/**
+ * Admission policy.
+ *
+ * The default caps one encoded command submission at 1 MiB, one branch's
+ * in-memory receipt ledger at {@link defaultLedgerCapacity} commands, and one
+ * branch's first-touch hydration at {@link defaultHydrationLimit} entries.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export interface Options {
+    /**
+     * Largest encoded journal entry followers accept. Defaults to
+     * {@link SyncProtocol.defaultMaxFrameBytes}. Configure the server and client
+     * with the same or a larger ceiling. Admission reserves the full durable
+     * envelope, including generated sequence and timestamp fields, before writing.
+     */
+    readonly maxFrameBytes?: number | undefined;
+    /**
+     * Largest encoded command submission admitted, in bytes. Defaults to
+     * {@link defaultMaxCommandBytes}.
+     */
+    readonly maxCommandBytes?: number | undefined;
+    /**
+     * Receipts one branch keeps in memory before the oldest are evicted.
+     * Defaults to {@link defaultLedgerCapacity}.
+     */
+    readonly ledgerCapacity?: number | undefined;
+    /**
+     * Entries one branch's first-touch hydration reads before it stops.
+     * Defaults to {@link defaultHydrationLimit}.
+     */
+    readonly hydrationLimit?: number | undefined;
+    /**
+     * Milliseconds a branch may have no active submissions before its in-memory state is
+     * dropped. Defaults to {@link defaultBranchIdleMs}.
+     */
+    readonly branchIdleMs?: number | undefined;
+}
+/**
+ * Constructs the journal-backed branch command ledger under an explicit
+ * policy. The caller scope owns cached states and their idle-expiration timers.
+ *
+ * A submission whose encoded form exceeds the command ceiling is refused with
+ * `frame_too_large` before anything is appended, so one oversized `args`
+ * cannot enter the branch journal and poison every follower that replays it.
+ *
+ * First-touch hydration reads at most `hydrationLimit` entries, so the length
+ * of a branch's history is not charged to the next writer's latency; see
+ * {@link defaultHydrationLimit} for why the fast path may be seeded partially
+ * without any effect on what the ledger admits.
+ *
+ * Every option is validated as a positive safe integer at construction: the
+ * TypeScript type says `number`, and `NaN` silently disabled the ceiling it
+ * was compared against.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeLiveWith: (options?: Options) => Effect.Effect<Service, SyncError, Journal.Journal | BranchShare.BranchShare | Scope.Scope>;
+/**
+ * Constructs the journal-backed branch command ledger with default policy.
+ * The caller scope owns cached states and their idle-expiration timers.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const makeLive: Effect.Effect<Service, never, Journal.Journal | BranchShare.BranchShare | Scope.Scope>;
+/**
+ * Provides the journal-backed branch command ledger.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layer: Layer.Layer<BranchCommands, never, Journal.Journal | BranchShare.BranchShare>;
+/**
+ * Provides the journal-backed branch command ledger under an explicit policy.
+ * Fails with `invalid_request` when an option is not a positive safe integer.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerWith: (options: Options) => Layer.Layer<BranchCommands, SyncError, Journal.Journal | BranchShare.BranchShare>;
+/**
+ * Builds a submission, filling in the fields a plain command never sets, and
+ * refusing a field the schema forbids with a `SyncError` rather than a defect.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const submission: (fields: {
+    readonly branchId: BranchId;
+    readonly commandId: CommandId;
+    readonly participantId: CommandSubmission["participantId"];
+    readonly name: string;
+    readonly args?: string;
+    readonly target?: string;
+}) => Effect.Effect<CommandSubmission, SyncError>;
+export {};
+//# sourceMappingURL=BranchCommands.d.ts.map

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

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