@smthrs/sync 1.0.0-rc.4 → 1.0.0-rc.6

package/README.md

@@ -2,9 +2,9 @@
 
 Release candidate scope, host requirements and compatibility review are defined in the [library support policy](https://github.com/smithersai/smithers/blob/main/RELEASE_SUPPORT.md).
 
-This package declares `effect` as an exact
-`4.0.0-rc.115` peer dependency. Keep the application on that version so
-all Smithers packages share one Effect runtime.
+This package declares `effect` as a `^4.0.4` peer dependency. Install one
+`effect` release in that range so all Smithers packages share one Effect
+runtime.
 
 **Documentation:** https://smithers-sync.smithers.sh
 
@@ -22,7 +22,7 @@ commands to a branch's journal run after verifying a write-scoped
 
 Not on npm yet; see [Installation](https://github.com/smithersai/smithers/blob/main/packages/smithers/flows/flow/docs/installation.md#use-the-libraries).
 
-`effect` is a peer dependency at exactly `4.0.0-rc.115`. Two copies of `effect`
+`effect` is a peer dependency in the range `^4.0.4`. Two copies of `effect`
 in one program are two sets of service tags, so a client built against one copy
 cannot be provided to a program holding the other.
 
@@ -39,9 +39,9 @@ import type { JournalEvent } from "@smthrs/journal"
 import * as SyncClient from "@smthrs/sync/SyncClient"
 import * as Effect from "effect/Effect"
 import * as Layer from "effect/Layer"
+import * as RpcClient from "effect/rpc/RpcClient"
+import * as RpcSerialization from "effect/rpc/RpcSerialization"
 import * as Stream from "effect/Stream"
-import * as RpcClient from "effect/unstable/rpc/RpcClient"
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization"
 
 const runId = "build-42" as JournalEvent.RunId
 

package/dist/cjs/BranchRpcs.d.ts

@@ -14,8 +14,8 @@
  *
  * @since 0.1.0
  */
+import { Rpc, RpcGroup } from "effect/rpc";
 import * as Schema from "effect/Schema";
-import { Rpc, RpcGroup } from "effect/unstable/rpc";
 import { CommandReceipt, Participant, ShareCapability } from "./BranchProtocol.ts";
 import { SyncError } from "./SyncError.ts";
 import { SyncAuth } from "./SyncRpcs.ts";
@@ -171,7 +171,7 @@ export declare const BranchRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Branch.CreateBranch"
     readonly capability: typeof ShareCapability;
     readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
     readonly sourcesReady: Schema.optionalKey<Schema.Boolean>;
-}>, import("effect/unstable/rpc/RpcSchema").Stream<Schema.Struct<{
+}>, import("effect/rpc/RpcSchema").Stream<Schema.Struct<{
     readonly participants: Schema.$Array<typeof Participant>;
 }>, typeof SyncError>, Schema.Never, typeof SyncAuth, never>>;
 //# sourceMappingURL=BranchRpcs.d.ts.map

package/dist/cjs/BranchRpcs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BranchRpcs.d.ts","sourceRoot":"","sources":["../../src/BranchRpcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AACnD,OAAO,EAIL,cAAc,EAEd,WAAW,EAEX,eAAe,EAEhB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAsB,CAAA;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;EAK9B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;EAG/B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;EAI3B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;EAEtB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6DAqBD,CAAA"}
+{"version":3,"file":"BranchRpcs.d.ts","sourceRoot":"","sources":["../../src/BranchRpcs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EAIL,cAAc,EAEd,WAAW,EAEX,eAAe,EAEhB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,QAAsB,CAAA;AAErD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;EAK9B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAA;AAEjE;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;EAG/B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAA;AAEnE;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB;;;;EAI3B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC,IAAI,CAAA;AAE3D;;;;;GAKG;AACH,eAAO,MAAM,WAAW;;EAEtB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC,IAAI,CAAA;AAEjD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6DAqBD,CAAA"}

package/dist/cjs/BranchRpcs.js

@@ -36,8 +36,8 @@ __export(BranchRpcs_exports, {
   maximumBranchTtlMs: () => maximumBranchTtlMs
 });
 module.exports = __toCommonJS(BranchRpcs_exports);
+var import_rpc = require("effect/rpc");
 var Schema = __toESM(require("effect/Schema"), 1);
-var import_rpc = require("effect/unstable/rpc");
 var import_BranchProtocol = require("./BranchProtocol.js");
 var import_SyncError = require("./SyncError.js");
 var import_SyncRpcs = require("./SyncRpcs.js");

package/dist/cjs/BranchRpcs.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/BranchRpcs.ts"],
-  "sourcesContent": ["/**\n * The branch collaboration wire contract: the RPC projection of the write\n * and presence paths that complement the read-only {@link SyncRpcs}.\n *\n * Authorization has two stages. Opening a branch is the bootstrap: no\n * capability can exist yet, so `CreateBranch` requires an authenticated\n * workspace principal supplied by the group's {@link SyncAuth} middleware,\n * and its handler refuses any other principal.\n *\n * Every later procedure carries its own share capability and authorizes\n * through {@link BranchShare}: past the bootstrap the capability IS the\n * credential, and cross-branch or expired capabilities are refused by the\n * same service boundary the in-process callers use.\n *\n * @since 0.1.0\n */\n\nimport * as Schema from \"effect/Schema\"\nimport { Rpc, RpcGroup } from \"effect/unstable/rpc\"\nimport {\n  Access,\n  Announcement,\n  BranchId,\n  CommandReceipt,\n  LeaveRequest,\n  Participant,\n  RosterRequest,\n  ShareCapability,\n  SubmitRequest\n} from \"./BranchProtocol.ts\"\nimport { SyncError } from \"./SyncError.ts\"\nimport { SyncAuth } from \"./SyncRpcs.ts\"\n\n/**\n * Maximum lifetime the branch bootstrap may mint.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const maximumBranchTtlMs = 24 * 60 * 60 * 1000\n\n/**\n * Schema for a request to open a new shared branch.\n *\n * The RPC authentication middleware must establish the workspace principal\n * before the handler mints the first write capability.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CreateBranchPayload = Schema.Struct({\n  ttlMs: Schema.Int.check(\n    Schema.isGreaterThan(0),\n    Schema.isLessThanOrEqualTo(maximumBranchTtlMs)\n  )\n})\n\n/**\n * A request to open a new shared branch.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CreateBranchPayload = typeof CreateBranchPayload.Type\n\n/**\n * Schema for the freshly opened branch and its owner capability.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CreateBranchResponse = Schema.Struct({\n  branchId: BranchId,\n  capability: ShareCapability\n})\n\n/**\n * The freshly opened branch and its owner capability.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CreateBranchResponse = typeof CreateBranchResponse.Type\n\n/**\n * Schema for a request to mint a share link for a branch.\n *\n * The presenting capability must hold write access to the branch \u2014 only a\n * collaborator can invite one \u2014 and the minted link never outlives the\n * capability it was minted from.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const MintSharePayload = Schema.Struct({\n  capability: ShareCapability,\n  access: Access,\n  ttlMs: Schema.Int.check(Schema.isGreaterThan(0))\n})\n\n/**\n * A request to mint a share link for a branch.\n *\n * @category models\n * @since 0.1.0\n */\nexport type MintSharePayload = typeof MintSharePayload.Type\n\n/**\n * Schema for one roster emission on a branch watch stream.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const RosterFrame = Schema.Struct({\n  participants: Schema.Array(Participant)\n})\n\n/**\n * One roster emission on a branch watch stream.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RosterFrame = typeof RosterFrame.Type\n\n/**\n * The remote procedures of branch collaboration.\n *\n * The capability-bearing payloads ARE the `BranchProtocol` request schemas the\n * branch services take, not copies of them. Four wire payloads used to\n * re-declare the message their service already owned, and the announce copy\n * had already drifted: it accepted `displayName: \"\"` where the service\n * requires a non-empty name, so a wire-legal announce reached a `Participant`\n * constructor and threw a defect outside the declared `SyncError` channel.\n * Naming one schema on both sides makes that drift impossible rather than\n * fixed once, and keeps this group free of the services themselves.\n *\n * @category groups\n * @since 0.1.0\n */\nexport const BranchRpcs = RpcGroup.make(\n  Rpc.make(\"Branch.CreateBranch\", {\n    payload: CreateBranchPayload,\n    success: CreateBranchResponse,\n    error: SyncError\n  }),\n  Rpc.make(\"Branch.MintShare\", { payload: MintSharePayload, success: ShareCapability, error: SyncError }),\n  Rpc.make(\"Branch.Submit\", { payload: SubmitRequest, success: CommandReceipt, error: SyncError }),\n  Rpc.make(\"Branch.Announce\", { payload: Announcement, success: Participant, error: SyncError }),\n  Rpc.make(\"Branch.Leave\", { payload: LeaveRequest, success: Schema.Null, error: SyncError }),\n  Rpc.make(\"Branch.Roster\", {\n    payload: RosterRequest,\n    success: Schema.Array(Participant),\n    error: SyncError\n  }),\n  Rpc.make(\"Branch.PresenceOn\", {\n    payload: RosterRequest,\n    success: Schema.Literals([\"unknown\", \"present\", \"empty\"]),\n    error: SyncError\n  }),\n  Rpc.make(\"Branch.WatchRoster\", { payload: RosterRequest, success: RosterFrame, error: SyncError, stream: true })\n).middleware(SyncAuth)\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,aAAwB;AACxB,iBAA8B;AAC9B,4BAUO;AACP,uBAA0B;AAC1B,sBAAyB;AAQlB,MAAM,qBAAqB,KAAK,KAAK,KAAK;AAW1C,MAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C,OAAO,OAAO,IAAI;AAAA,IAChB,OAAO,cAAc,CAAC;AAAA,IACtB,OAAO,oBAAoB,kBAAkB;AAAA,EAC/C;AACF,CAAC;AAgBM,MAAM,uBAAuB,OAAO,OAAO;AAAA,EAChD,UAAU;AAAA,EACV,YAAY;AACd,CAAC;AAoBM,MAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,YAAY;AAAA,EACZ,QAAQ;AAAA,EACR,OAAO,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;AACjD,CAAC;AAgBM,MAAM,cAAc,OAAO,OAAO;AAAA,EACvC,cAAc,OAAO,MAAM,iCAAW;AACxC,CAAC;AAyBM,MAAM,aAAa,oBAAS;AAAA,EACjC,eAAI,KAAK,uBAAuB;AAAA,IAC9B,SAAS;AAAA,IACT,SAAS;AAAA,IACT,OAAO;AAAA,EACT,CAAC;AAAA,EACD,eAAI,KAAK,oBAAoB,EAAE,SAAS,kBAAkB,SAAS,uCAAiB,OAAO,2BAAU,CAAC;AAAA,EACtG,eAAI,KAAK,iBAAiB,EAAE,SAAS,qCAAe,SAAS,sCAAgB,OAAO,2BAAU,CAAC;AAAA,EAC/F,eAAI,KAAK,mBAAmB,EAAE,SAAS,oCAAc,SAAS,mCAAa,OAAO,2BAAU,CAAC;AAAA,EAC7F,eAAI,KAAK,gBAAgB,EAAE,SAAS,oCAAc,SAAS,OAAO,MAAM,OAAO,2BAAU,CAAC;AAAA,EAC1F,eAAI,KAAK,iBAAiB;AAAA,IACxB,SAAS;AAAA,IACT,SAAS,OAAO,MAAM,iCAAW;AAAA,IACjC,OAAO;AAAA,EACT,CAAC;AAAA,EACD,eAAI,KAAK,qBAAqB;AAAA,IAC5B,SAAS;AAAA,IACT,SAAS,OAAO,SAAS,CAAC,WAAW,WAAW,OAAO,CAAC;AAAA,IACxD,OAAO;AAAA,EACT,CAAC;AAAA,EACD,eAAI,KAAK,sBAAsB,EAAE,SAAS,qCAAe,SAAS,aAAa,OAAO,4BAAW,QAAQ,KAAK,CAAC;AACjH,EAAE,WAAW,wBAAQ;",
+  "sourcesContent": ["/**\n * The branch collaboration wire contract: the RPC projection of the write\n * and presence paths that complement the read-only {@link SyncRpcs}.\n *\n * Authorization has two stages. Opening a branch is the bootstrap: no\n * capability can exist yet, so `CreateBranch` requires an authenticated\n * workspace principal supplied by the group's {@link SyncAuth} middleware,\n * and its handler refuses any other principal.\n *\n * Every later procedure carries its own share capability and authorizes\n * through {@link BranchShare}: past the bootstrap the capability IS the\n * credential, and cross-branch or expired capabilities are refused by the\n * same service boundary the in-process callers use.\n *\n * @since 0.1.0\n */\n\nimport { Rpc, RpcGroup } from \"effect/rpc\"\nimport * as Schema from \"effect/Schema\"\nimport {\n  Access,\n  Announcement,\n  BranchId,\n  CommandReceipt,\n  LeaveRequest,\n  Participant,\n  RosterRequest,\n  ShareCapability,\n  SubmitRequest\n} from \"./BranchProtocol.ts\"\nimport { SyncError } from \"./SyncError.ts\"\nimport { SyncAuth } from \"./SyncRpcs.ts\"\n\n/**\n * Maximum lifetime the branch bootstrap may mint.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const maximumBranchTtlMs = 24 * 60 * 60 * 1000\n\n/**\n * Schema for a request to open a new shared branch.\n *\n * The RPC authentication middleware must establish the workspace principal\n * before the handler mints the first write capability.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CreateBranchPayload = Schema.Struct({\n  ttlMs: Schema.Int.check(\n    Schema.isGreaterThan(0),\n    Schema.isLessThanOrEqualTo(maximumBranchTtlMs)\n  )\n})\n\n/**\n * A request to open a new shared branch.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CreateBranchPayload = typeof CreateBranchPayload.Type\n\n/**\n * Schema for the freshly opened branch and its owner capability.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CreateBranchResponse = Schema.Struct({\n  branchId: BranchId,\n  capability: ShareCapability\n})\n\n/**\n * The freshly opened branch and its owner capability.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CreateBranchResponse = typeof CreateBranchResponse.Type\n\n/**\n * Schema for a request to mint a share link for a branch.\n *\n * The presenting capability must hold write access to the branch \u2014 only a\n * collaborator can invite one \u2014 and the minted link never outlives the\n * capability it was minted from.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const MintSharePayload = Schema.Struct({\n  capability: ShareCapability,\n  access: Access,\n  ttlMs: Schema.Int.check(Schema.isGreaterThan(0))\n})\n\n/**\n * A request to mint a share link for a branch.\n *\n * @category models\n * @since 0.1.0\n */\nexport type MintSharePayload = typeof MintSharePayload.Type\n\n/**\n * Schema for one roster emission on a branch watch stream.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const RosterFrame = Schema.Struct({\n  participants: Schema.Array(Participant)\n})\n\n/**\n * One roster emission on a branch watch stream.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RosterFrame = typeof RosterFrame.Type\n\n/**\n * The remote procedures of branch collaboration.\n *\n * The capability-bearing payloads ARE the `BranchProtocol` request schemas the\n * branch services take, not copies of them. Four wire payloads used to\n * re-declare the message their service already owned, and the announce copy\n * had already drifted: it accepted `displayName: \"\"` where the service\n * requires a non-empty name, so a wire-legal announce reached a `Participant`\n * constructor and threw a defect outside the declared `SyncError` channel.\n * Naming one schema on both sides makes that drift impossible rather than\n * fixed once, and keeps this group free of the services themselves.\n *\n * @category groups\n * @since 0.1.0\n */\nexport const BranchRpcs = RpcGroup.make(\n  Rpc.make(\"Branch.CreateBranch\", {\n    payload: CreateBranchPayload,\n    success: CreateBranchResponse,\n    error: SyncError\n  }),\n  Rpc.make(\"Branch.MintShare\", { payload: MintSharePayload, success: ShareCapability, error: SyncError }),\n  Rpc.make(\"Branch.Submit\", { payload: SubmitRequest, success: CommandReceipt, error: SyncError }),\n  Rpc.make(\"Branch.Announce\", { payload: Announcement, success: Participant, error: SyncError }),\n  Rpc.make(\"Branch.Leave\", { payload: LeaveRequest, success: Schema.Null, error: SyncError }),\n  Rpc.make(\"Branch.Roster\", {\n    payload: RosterRequest,\n    success: Schema.Array(Participant),\n    error: SyncError\n  }),\n  Rpc.make(\"Branch.PresenceOn\", {\n    payload: RosterRequest,\n    success: Schema.Literals([\"unknown\", \"present\", \"empty\"]),\n    error: SyncError\n  }),\n  Rpc.make(\"Branch.WatchRoster\", { payload: RosterRequest, success: RosterFrame, error: SyncError, stream: true })\n).middleware(SyncAuth)\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,iBAA8B;AAC9B,aAAwB;AACxB,4BAUO;AACP,uBAA0B;AAC1B,sBAAyB;AAQlB,MAAM,qBAAqB,KAAK,KAAK,KAAK;AAW1C,MAAM,sBAAsB,OAAO,OAAO;AAAA,EAC/C,OAAO,OAAO,IAAI;AAAA,IAChB,OAAO,cAAc,CAAC;AAAA,IACtB,OAAO,oBAAoB,kBAAkB;AAAA,EAC/C;AACF,CAAC;AAgBM,MAAM,uBAAuB,OAAO,OAAO;AAAA,EAChD,UAAU;AAAA,EACV,YAAY;AACd,CAAC;AAoBM,MAAM,mBAAmB,OAAO,OAAO;AAAA,EAC5C,YAAY;AAAA,EACZ,QAAQ;AAAA,EACR,OAAO,OAAO,IAAI,MAAM,OAAO,cAAc,CAAC,CAAC;AACjD,CAAC;AAgBM,MAAM,cAAc,OAAO,OAAO;AAAA,EACvC,cAAc,OAAO,MAAM,iCAAW;AACxC,CAAC;AAyBM,MAAM,aAAa,oBAAS;AAAA,EACjC,eAAI,KAAK,uBAAuB;AAAA,IAC9B,SAAS;AAAA,IACT,SAAS;AAAA,IACT,OAAO;AAAA,EACT,CAAC;AAAA,EACD,eAAI,KAAK,oBAAoB,EAAE,SAAS,kBAAkB,SAAS,uCAAiB,OAAO,2BAAU,CAAC;AAAA,EACtG,eAAI,KAAK,iBAAiB,EAAE,SAAS,qCAAe,SAAS,sCAAgB,OAAO,2BAAU,CAAC;AAAA,EAC/F,eAAI,KAAK,mBAAmB,EAAE,SAAS,oCAAc,SAAS,mCAAa,OAAO,2BAAU,CAAC;AAAA,EAC7F,eAAI,KAAK,gBAAgB,EAAE,SAAS,oCAAc,SAAS,OAAO,MAAM,OAAO,2BAAU,CAAC;AAAA,EAC1F,eAAI,KAAK,iBAAiB;AAAA,IACxB,SAAS;AAAA,IACT,SAAS,OAAO,MAAM,iCAAW;AAAA,IACjC,OAAO;AAAA,EACT,CAAC;AAAA,EACD,eAAI,KAAK,qBAAqB;AAAA,IAC5B,SAAS;AAAA,IACT,SAAS,OAAO,SAAS,CAAC,WAAW,WAAW,OAAO,CAAC;AAAA,IACxD,OAAO;AAAA,EACT,CAAC;AAAA,EACD,eAAI,KAAK,sBAAsB,EAAE,SAAS,qCAAe,SAAS,aAAa,OAAO,4BAAW,QAAQ,KAAK,CAAC;AACjH,EAAE,WAAW,wBAAQ;",
   "names": []
 }

package/dist/cjs/BranchServer.d.ts

@@ -16,8 +16,8 @@
  * @since 0.1.0
  */
 import type * as Layer from "effect/Layer";
-import type * as Rpc from "effect/unstable/rpc/Rpc";
-import type * as RpcGroup from "effect/unstable/rpc/RpcGroup";
+import type * as Rpc from "effect/rpc/Rpc";
+import type * as RpcGroup from "effect/rpc/RpcGroup";
 import * as BranchCommands from "./BranchCommands.ts";
 import * as BranchIds from "./BranchIds.ts";
 import * as BranchPresence from "./BranchPresence.ts";

package/dist/cjs/BranchServer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BranchServer.d.ts","sourceRoot":"","sources":["../../src/BranchServer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAE1C,OAAO,KAAK,KAAK,GAAG,MAAM,yBAAyB,CAAA;AACnD,OAAO,KAAK,KAAK,QAAQ,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAwC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,KAAK,CACrC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC,EAC/C,KAAK,EACH,WAAW,CAAC,WAAW,GACvB,cAAc,CAAC,cAAc,GAC7B,cAAc,CAAC,cAAc,GAC7B,SAAS,CAAC,SAAS,CAkGtB,CAAA"}
+{"version":3,"file":"BranchServer.d.ts","sourceRoot":"","sources":["../../src/BranchServer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,KAAK,GAAG,MAAM,gBAAgB,CAAA;AAC1C,OAAO,KAAK,KAAK,QAAQ,MAAM,qBAAqB,CAAA;AAEpD,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AACrD,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,KAAK,WAAW,MAAM,kBAAkB,CAAA;AAwC/C;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,KAAK,CACrC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,UAAU,CAAC,CAAC,EAC/C,KAAK,EACH,WAAW,CAAC,WAAW,GACvB,cAAc,CAAC,cAAc,GAC7B,cAAc,CAAC,cAAc,GAC7B,SAAS,CAAC,SAAS,CAkGtB,CAAA"}

package/dist/cjs/BranchServer.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/BranchServer.ts"],
-  "sourcesContent": ["/**\n * The server-side handlers of {@link BranchRpcs}: a thin projection of the\n * branch services onto the wire.\n *\n * Five procedures forward to the service that owns their boundary and add\n * nothing: `Branch.Submit` to {@link BranchCommands}, and `Branch.Announce`,\n * `Branch.Leave`, `Branch.Roster`, and `Branch.WatchRoster` to\n * {@link BranchPresence}. Two enforce policy here, on top of what\n * {@link BranchShare} checks: `Branch.CreateBranch` refuses any principal that\n * is not an authenticated workspace, and `Branch.MintShare` verifies write\n * access, refuses an expired parent, and caps the child at the parent's\n * expiry. `BranchShare.mint` performs none of those checks, so an in-process\n * host that mints through the service directly must gate the principal and\n * the parent capability itself.\n *\n * @since 0.1.0\n */\n\nimport * as Clock from \"effect/Clock\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport * as Stream from \"effect/Stream\"\nimport type * as Rpc from \"effect/unstable/rpc/Rpc\"\nimport type * as RpcGroup from \"effect/unstable/rpc/RpcGroup\"\nimport * as BranchCommands from \"./BranchCommands.ts\"\nimport * as BranchIds from \"./BranchIds.ts\"\nimport * as BranchPresence from \"./BranchPresence.ts\"\nimport { BranchId, type Participant } from \"./BranchProtocol.ts\"\nimport { BranchRpcs } from \"./BranchRpcs.ts\"\nimport * as BranchShare from \"./BranchShare.ts\"\nimport * as Admission from \"./internal/Admission.ts\"\nimport { SyncError } from \"./SyncError.ts\"\nimport * as SyncPrincipal from \"./SyncPrincipal.ts\"\n\n/**\n * Whether two roster emissions say the same thing.\n *\n * `list` returns participants sorted by id, so the comparison is positional.\n * The lease itself is part of the key: a heartbeat that only extends a lease\n * IS a change the watcher wants, because it is the evidence the participant is\n * still there.\n *\n * The rendering is JSON rather than delimiter-joined fields. Participant ids\n * and display names are `NonEmptyString` with no charset constraint, so every\n * separator is a character they may carry, including the control bytes this\n * used to join on. Two rosters differing only in where a field boundary falls\n * then rendered identically and a watcher never observed the change. JSON\n * quotes and escapes each field, so distinct rosters render distinctly.\n */\nconst rosterKey = (participants: ReadonlyArray<Participant>): string =>\n  JSON.stringify(\n    participants.map((participant) => [\n      participant.participantId,\n      participant.displayName,\n      participant.sessionId,\n      participant.kind,\n      participant.where,\n      participant.watching,\n      participant.for_member,\n      participant.leaseExpiresAtMs,\n      participant.cursor === null ? null : [participant.cursor.cardId, participant.cursor.offset]\n    ])\n  )\n\nconst sameRoster = (\n  left: ReadonlyArray<Participant>,\n  right: ReadonlyArray<Participant>\n): boolean => rosterKey(left) === rosterKey(right)\n\n/**\n * Provides the branch RPC handlers over the branch services.\n *\n * With {@link BranchPresence.layerNoop}, roster reads and watches fail with\n * `unsupported`: unavailable presence cannot establish an empty roster.\n *\n * A roster watch emits the roster as of subscription, then re-lists on every\n * presence change for the branch AND at least once per second, emitting\n * only when the roster it read differs from the one it last sent.\n *\n * All three of those are triggers into ONE sequential reader. The roster is\n * mutable state behind an effect, so concurrent readers can complete out of\n * order, and a watcher that receives an older roster after a newer one keeps\n * the older one: `changesWith` compares against the previous emission, not\n * against the freshest state. Serializing the reads is what makes the last\n * value a watcher holds the most recent one that was read.\n *\n * The periodic re-list is what makes expiry observable. A lapsed lease\n * publishes nothing \u2014 the roster drops it the next time somebody lists \u2014 so a\n * watch driven by change events alone never saw the LAST participant leave,\n * and a burst of announcements on unrelated branches could slide the one\n * notification this watch needed out of the shared feed. Both are bounded by\n * one second: a departure is visible within 1 s of lease expiry,\n * whether or not a survivor reports it.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerHandlers: Layer.Layer<\n  Rpc.ToHandler<RpcGroup.Rpcs<typeof BranchRpcs>>,\n  never,\n  | BranchShare.BranchShare\n  | BranchPresence.BranchPresence\n  | BranchCommands.BranchCommands\n  | BranchIds.BranchIds\n> = BranchRpcs.toLayer(\n  Effect.gen(function*() {\n    const share = yield* BranchShare.BranchShare\n    const presence = yield* BranchPresence.BranchPresence\n    const commands = yield* BranchCommands.BranchCommands\n    const ids = yield* BranchIds.BranchIds\n\n    return BranchRpcs.of({\n      \"Branch.CreateBranch\": ({ ttlMs }) =>\n        Effect.gen(function*() {\n          const principal = yield* SyncPrincipal.SyncPrincipal\n          if (!SyncPrincipal.isWorkspace(principal)) {\n            return yield* new SyncError({\n              code: \"unauthorized\",\n              message: \"Creating a branch requires an authenticated workspace principal\"\n            })\n          }\n          // Decoded, not branded: `BranchIds` is a host port whose `fresh` is\n          // typed `Effect<string>`, so a host id source yielding \"\" turned an\n          // asserted `BranchId` into a schema defect inside `mint` rather than\n          // the `SyncError` this handler declares.\n          const branchId = yield* Admission.decode(BranchId, yield* ids.fresh, \"invalid_request\")\n          const capability = yield* share.mint({\n            branchId,\n            capabilityId: yield* ids.fresh,\n            access: \"write\",\n            ttlMs\n          })\n          return { branchId: capability.claims.branchId, capability }\n        }),\n      \"Branch.MintShare\": ({ capability, access, ttlMs }) =>\n        Effect.gen(function*() {\n          const claims = yield* share.verify(capability, {\n            branchId: capability.claims.branchId,\n            access: \"write\"\n          })\n          const capabilityId = yield* ids.fresh\n          const nowMs = yield* Clock.currentTimeMillis\n          // ID generation may outlast the parent. Refuse before minting, and\n          // pass the absolute ceiling so the signing clock cannot extend it.\n          if (nowMs >= claims.expiresAtMs) {\n            return yield* new SyncError({\n              code: \"unauthorized\",\n              message: \"The share capability has expired\"\n            })\n          }\n          // A link never outlives the capability it was minted from.\n          return yield* share.mint({\n            branchId: claims.branchId,\n            capabilityId,\n            access,\n            ttlMs,\n            maxExpiresAtMs: claims.expiresAtMs\n          })\n        }),\n      \"Branch.Submit\": (payload) => commands.submit(payload),\n      \"Branch.Announce\": (payload) => presence.announce(payload),\n      \"Branch.Leave\": (payload) => Effect.as(presence.leave(payload), null),\n      \"Branch.Roster\": (payload) => presence.list(payload),\n      \"Branch.PresenceOn\": (payload) => presence.presenceOn(payload),\n      \"Branch.WatchRoster\": (payload) =>\n        Stream.merge(\n          // The subscription's own snapshot is a TRIGGER like the other two,\n          // not a fourth reader. Reading it here concurrently with them let\n          // the roster a change produced overtake it: `presence.list` is an\n          // effect against mutable state, three of them ran at once, and the\n          // slowest one won the merge. `changesWith` compares an emission only\n          // against the one before it, so the older roster passed the filter\n          // and the watcher's LAST value said a participant who had already\n          // left was still present, until the next change or lease tick.\n          Stream.succeed(undefined),\n          Stream.merge(\n            presence.changes.pipe(\n              Stream.filter((branchId) => branchId === payload.branchId),\n              Stream.map(() => undefined)\n            ),\n            // A lapsed lease publishes nothing, so a watch driven only by\n            // change events never observes the LAST participant leaving, and\n            // an unrelated branch's burst can slide the one notification this\n            // watch needed out of the shared feed. Re-listing at least once per second\n            // bounds both: a departure is visible within 1 s of expiry, whether or not anyone reports it.\n            Stream.fromEffectRepeat(Effect.sleep(Math.min(presence.leaseMs, 1_000))).pipe(Stream.map(() => undefined))\n          )\n        ).pipe(\n          // ONE reader, sequential by default, so a roster is read in the\n          // order its trigger arrived and every emission is at least as fresh\n          // as the one before it.\n          Stream.mapEffect(() => presence.list(payload)),\n          // Deduplicated over the WHOLE stream, initial emission included.\n          // Applied to the change half alone, its first value always passed,\n          // so a change that left the roster identical still sent the watcher\n          // a second copy of what it had just been given.\n          Stream.changesWith(sameRoster),\n          Stream.map((participants) => ({ participants }))\n        )\n    })\n  })\n)\n"],
-  "mappings": "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",
+  "sourcesContent": ["/**\n * The server-side handlers of {@link BranchRpcs}: a thin projection of the\n * branch services onto the wire.\n *\n * Five procedures forward to the service that owns their boundary and add\n * nothing: `Branch.Submit` to {@link BranchCommands}, and `Branch.Announce`,\n * `Branch.Leave`, `Branch.Roster`, and `Branch.WatchRoster` to\n * {@link BranchPresence}. Two enforce policy here, on top of what\n * {@link BranchShare} checks: `Branch.CreateBranch` refuses any principal that\n * is not an authenticated workspace, and `Branch.MintShare` verifies write\n * access, refuses an expired parent, and caps the child at the parent's\n * expiry. `BranchShare.mint` performs none of those checks, so an in-process\n * host that mints through the service directly must gate the principal and\n * the parent capability itself.\n *\n * @since 0.1.0\n */\n\nimport * as Clock from \"effect/Clock\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Layer from \"effect/Layer\"\nimport type * as Rpc from \"effect/rpc/Rpc\"\nimport type * as RpcGroup from \"effect/rpc/RpcGroup\"\nimport * as Stream from \"effect/Stream\"\nimport * as BranchCommands from \"./BranchCommands.ts\"\nimport * as BranchIds from \"./BranchIds.ts\"\nimport * as BranchPresence from \"./BranchPresence.ts\"\nimport { BranchId, type Participant } from \"./BranchProtocol.ts\"\nimport { BranchRpcs } from \"./BranchRpcs.ts\"\nimport * as BranchShare from \"./BranchShare.ts\"\nimport * as Admission from \"./internal/Admission.ts\"\nimport { SyncError } from \"./SyncError.ts\"\nimport * as SyncPrincipal from \"./SyncPrincipal.ts\"\n\n/**\n * Whether two roster emissions say the same thing.\n *\n * `list` returns participants sorted by id, so the comparison is positional.\n * The lease itself is part of the key: a heartbeat that only extends a lease\n * IS a change the watcher wants, because it is the evidence the participant is\n * still there.\n *\n * The rendering is JSON rather than delimiter-joined fields. Participant ids\n * and display names are `NonEmptyString` with no charset constraint, so every\n * separator is a character they may carry, including the control bytes this\n * used to join on. Two rosters differing only in where a field boundary falls\n * then rendered identically and a watcher never observed the change. JSON\n * quotes and escapes each field, so distinct rosters render distinctly.\n */\nconst rosterKey = (participants: ReadonlyArray<Participant>): string =>\n  JSON.stringify(\n    participants.map((participant) => [\n      participant.participantId,\n      participant.displayName,\n      participant.sessionId,\n      participant.kind,\n      participant.where,\n      participant.watching,\n      participant.for_member,\n      participant.leaseExpiresAtMs,\n      participant.cursor === null ? null : [participant.cursor.cardId, participant.cursor.offset]\n    ])\n  )\n\nconst sameRoster = (\n  left: ReadonlyArray<Participant>,\n  right: ReadonlyArray<Participant>\n): boolean => rosterKey(left) === rosterKey(right)\n\n/**\n * Provides the branch RPC handlers over the branch services.\n *\n * With {@link BranchPresence.layerNoop}, roster reads and watches fail with\n * `unsupported`: unavailable presence cannot establish an empty roster.\n *\n * A roster watch emits the roster as of subscription, then re-lists on every\n * presence change for the branch AND at least once per second, emitting\n * only when the roster it read differs from the one it last sent.\n *\n * All three of those are triggers into ONE sequential reader. The roster is\n * mutable state behind an effect, so concurrent readers can complete out of\n * order, and a watcher that receives an older roster after a newer one keeps\n * the older one: `changesWith` compares against the previous emission, not\n * against the freshest state. Serializing the reads is what makes the last\n * value a watcher holds the most recent one that was read.\n *\n * The periodic re-list is what makes expiry observable. A lapsed lease\n * publishes nothing \u2014 the roster drops it the next time somebody lists \u2014 so a\n * watch driven by change events alone never saw the LAST participant leave,\n * and a burst of announcements on unrelated branches could slide the one\n * notification this watch needed out of the shared feed. Both are bounded by\n * one second: a departure is visible within 1 s of lease expiry,\n * whether or not a survivor reports it.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerHandlers: Layer.Layer<\n  Rpc.ToHandler<RpcGroup.Rpcs<typeof BranchRpcs>>,\n  never,\n  | BranchShare.BranchShare\n  | BranchPresence.BranchPresence\n  | BranchCommands.BranchCommands\n  | BranchIds.BranchIds\n> = BranchRpcs.toLayer(\n  Effect.gen(function*() {\n    const share = yield* BranchShare.BranchShare\n    const presence = yield* BranchPresence.BranchPresence\n    const commands = yield* BranchCommands.BranchCommands\n    const ids = yield* BranchIds.BranchIds\n\n    return BranchRpcs.of({\n      \"Branch.CreateBranch\": ({ ttlMs }) =>\n        Effect.gen(function*() {\n          const principal = yield* SyncPrincipal.SyncPrincipal\n          if (!SyncPrincipal.isWorkspace(principal)) {\n            return yield* new SyncError({\n              code: \"unauthorized\",\n              message: \"Creating a branch requires an authenticated workspace principal\"\n            })\n          }\n          // Decoded, not branded: `BranchIds` is a host port whose `fresh` is\n          // typed `Effect<string>`, so a host id source yielding \"\" turned an\n          // asserted `BranchId` into a schema defect inside `mint` rather than\n          // the `SyncError` this handler declares.\n          const branchId = yield* Admission.decode(BranchId, yield* ids.fresh, \"invalid_request\")\n          const capability = yield* share.mint({\n            branchId,\n            capabilityId: yield* ids.fresh,\n            access: \"write\",\n            ttlMs\n          })\n          return { branchId: capability.claims.branchId, capability }\n        }),\n      \"Branch.MintShare\": ({ capability, access, ttlMs }) =>\n        Effect.gen(function*() {\n          const claims = yield* share.verify(capability, {\n            branchId: capability.claims.branchId,\n            access: \"write\"\n          })\n          const capabilityId = yield* ids.fresh\n          const nowMs = yield* Clock.currentTimeMillis\n          // ID generation may outlast the parent. Refuse before minting, and\n          // pass the absolute ceiling so the signing clock cannot extend it.\n          if (nowMs >= claims.expiresAtMs) {\n            return yield* new SyncError({\n              code: \"unauthorized\",\n              message: \"The share capability has expired\"\n            })\n          }\n          // A link never outlives the capability it was minted from.\n          return yield* share.mint({\n            branchId: claims.branchId,\n            capabilityId,\n            access,\n            ttlMs,\n            maxExpiresAtMs: claims.expiresAtMs\n          })\n        }),\n      \"Branch.Submit\": (payload) => commands.submit(payload),\n      \"Branch.Announce\": (payload) => presence.announce(payload),\n      \"Branch.Leave\": (payload) => Effect.as(presence.leave(payload), null),\n      \"Branch.Roster\": (payload) => presence.list(payload),\n      \"Branch.PresenceOn\": (payload) => presence.presenceOn(payload),\n      \"Branch.WatchRoster\": (payload) =>\n        Stream.merge(\n          // The subscription's own snapshot is a TRIGGER like the other two,\n          // not a fourth reader. Reading it here concurrently with them let\n          // the roster a change produced overtake it: `presence.list` is an\n          // effect against mutable state, three of them ran at once, and the\n          // slowest one won the merge. `changesWith` compares an emission only\n          // against the one before it, so the older roster passed the filter\n          // and the watcher's LAST value said a participant who had already\n          // left was still present, until the next change or lease tick.\n          Stream.succeed(undefined),\n          Stream.merge(\n            presence.changes.pipe(\n              Stream.filter((branchId) => branchId === payload.branchId),\n              Stream.map(() => undefined)\n            ),\n            // A lapsed lease publishes nothing, so a watch driven only by\n            // change events never observes the LAST participant leaving, and\n            // an unrelated branch's burst can slide the one notification this\n            // watch needed out of the shared feed. Re-listing at least once per second\n            // bounds both: a departure is visible within 1 s of expiry, whether or not anyone reports it.\n            Stream.fromEffectRepeat(Effect.sleep(Math.min(presence.leaseMs, 1_000))).pipe(Stream.map(() => undefined))\n          )\n        ).pipe(\n          // ONE reader, sequential by default, so a roster is read in the\n          // order its trigger arrived and every emission is at least as fresh\n          // as the one before it.\n          Stream.mapEffect(() => presence.list(payload)),\n          // Deduplicated over the WHOLE stream, initial emission included.\n          // Applied to the change half alone, its first value always passed,\n          // so a change that left the roster identical still sent the watcher\n          // a second copy of what it had just been given.\n          Stream.changesWith(sameRoster),\n          Stream.map((participants) => ({ participants }))\n        )\n    })\n  })\n)\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/cjs/SyncAuth.d.ts

@@ -21,7 +21,7 @@
  */
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as RpcMiddleware from "effect/unstable/rpc/RpcMiddleware";
+import * as RpcMiddleware from "effect/rpc/RpcMiddleware";
 import { SyncError } from "./SyncError.ts";
 import { SyncAuth } from "./SyncRpcs.ts";
 import * as WorkspaceShare from "./WorkspaceShare.ts";

package/dist/cjs/SyncAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SyncAuth.d.ts","sourceRoot":"","sources":["../../src/SyncAuth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAIrC,OAAO,KAAK,aAAa,MAAM,mCAAmC,CAAA;AAGlE,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,yBAAyB,CAAA;AAItD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,cAAc,CAAC,mBAAmB,KAC7C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAajC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,mBAAmB,EAAE,SAAS,CAe3G,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,cAAc,CAyB7E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,YAAY,cAAc,CAAC,mBAAmB,KAC7C,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAKxD,CAAA"}
+{"version":3,"file":"SyncAuth.d.ts","sourceRoot":"","sources":["../../src/SyncAuth.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAGvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AAErC,OAAO,KAAK,aAAa,MAAM,0BAA0B,CAAA;AAIzD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAE1C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,OAAO,KAAK,cAAc,MAAM,qBAAqB,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,yBAAyB,CAAA;AAItD;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAC3B,YAAY,cAAc,CAAC,mBAAmB,KAC7C,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAajC,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,mBAAmB,EAAE,SAAS,CAe3G,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,cAAc,CAyB7E,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,YAAY,cAAc,CAAC,mBAAmB,KAC7C,KAAK,CAAC,KAAK,CAAC,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,EAAE,SAAS,CAKxD,CAAA"}

package/dist/cjs/SyncAuth.js

@@ -36,12 +36,12 @@ __export(SyncAuth_exports, {
 });
 module.exports = __toCommonJS(SyncAuth_exports);
 var Effect = __toESM(require("effect/Effect"), 1);
-var Encoding = __toESM(require("effect/Encoding"), 1);
+var Base64Url = __toESM(require("effect/encoding/Base64Url"), 1);
+var Headers = __toESM(require("effect/http/Headers"), 1);
 var Layer = __toESM(require("effect/Layer"), 1);
 var Result = __toESM(require("effect/Result"), 1);
+var RpcMiddleware = __toESM(require("effect/rpc/RpcMiddleware"), 1);
 var Schema = __toESM(require("effect/Schema"), 1);
-var Headers = __toESM(require("effect/unstable/http/Headers"), 1);
-var RpcMiddleware = __toESM(require("effect/unstable/rpc/RpcMiddleware"), 1);
 var import_CauseText = require("./internal/CauseText.js");
 var shareSigner = __toESM(require("./internal/ShareSigner.js"), 1);
 var import_SyncError = require("./SyncError.js");
@@ -60,10 +60,10 @@ const encodeCapability = (capability) => {
       // carries the value it rejected, and the value here is a credential.
       cause: (0, import_CauseText.causeText)(encoded.failure)
     })
-  ) : Effect.succeed(Encoding.encodeBase64Url(JSON.stringify(encoded.success)));
+  ) : Effect.succeed(Base64Url.encode(JSON.stringify(encoded.success)));
 };
 const decodeCapability = (value) => {
-  const text = Encoding.decodeBase64UrlString(value);
+  const text = Base64Url.decodeString(value);
   if (Result.isFailure(text)) {
     return Effect.fail(denied("The workspace capability header is not a capability"));
   }

package/dist/cjs/SyncAuth.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/SyncAuth.ts"],
-  "sourcesContent": ["/**\n * The sync read path's connection authentication: implementations of the\n * `SyncRpcs.SyncAuth` RPC middleware.\n *\n * A connection presents a {@link WorkspaceShare.WorkspaceCapability} in the\n * {@link capabilityHeader} request header. {@link layer} verifies it against\n * the workspace's {@link WorkspaceShare.WorkspaceShare} authority and runs\n * the handler as the workspace principal. A request with no header runs as\n * the anonymous principal \u2014 branch share capabilities carried in request\n * payloads still authorize branch reads \u2014 and the server refuses anonymous\n * access to every non-branch run. A request whose header is present but\n * malformed, forged, expired, or signed by an unknown key is refused\n * outright: presence of a credential is a claim, and a false claim is never\n * downgraded to anonymity.\n *\n * There is deliberately no trusted pass-through implementation here: the only\n * sanctioned bypass is an in-process caller providing `SyncPrincipal` itself,\n * never a transport.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Encoding from \"effect/Encoding\"\nimport * as Layer from \"effect/Layer\"\nimport * as Result from \"effect/Result\"\nimport * as Schema from \"effect/Schema\"\nimport * as Headers from \"effect/unstable/http/Headers\"\nimport * as RpcMiddleware from \"effect/unstable/rpc/RpcMiddleware\"\nimport { causeText } from \"./internal/CauseText.ts\"\nimport * as shareSigner from \"./internal/ShareSigner.ts\"\nimport { SyncError } from \"./SyncError.ts\"\nimport * as SyncPrincipal from \"./SyncPrincipal.ts\"\nimport { SyncAuth } from \"./SyncRpcs.ts\"\nimport * as WorkspaceShare from \"./WorkspaceShare.ts\"\n\n/**\n * The request header a connection presents its workspace capability in.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const capabilityHeader = \"flows-sync-workspace\"\n\nconst denied = shareSigner.unauthorized\n\n/**\n * Renders a workspace capability as its header value: unpadded base64url of\n * the schema-encoded capability JSON.\n *\n * @category encoding\n * @since 0.1.0\n */\nexport const encodeCapability = (\n  capability: WorkspaceShare.WorkspaceCapability\n): Effect.Effect<string, SyncError> => {\n  const encoded = Schema.encodeUnknownResult(WorkspaceShare.WorkspaceCapability)(capability)\n  return Result.isFailure(encoded)\n    ? Effect.fail(\n      new SyncError({\n        code: \"invalid_request\",\n        message: \"The workspace capability does not encode\",\n        // The rendering, never the parse failure itself: a schema issue\n        // carries the value it rejected, and the value here is a credential.\n        cause: causeText(encoded.failure)\n      })\n    )\n    : Effect.succeed(Encoding.encodeBase64Url(JSON.stringify(encoded.success)))\n}\n\n/**\n * Decodes a capability header value. Every malformation folds to the same\n * `unauthorized` refusal so the header is not a parsing oracle.\n *\n * @category encoding\n * @since 0.1.0\n */\nexport const decodeCapability = (value: string): Effect.Effect<WorkspaceShare.WorkspaceCapability, SyncError> => {\n  const text = Encoding.decodeBase64UrlString(value)\n  if (Result.isFailure(text)) {\n    return Effect.fail(denied(\"The workspace capability header is not a capability\"))\n  }\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(text.success)\n  } catch {\n    return Effect.fail(denied(\"The workspace capability header is not a capability\"))\n  }\n  const decoded = Schema.decodeUnknownResult(WorkspaceShare.WorkspaceCapability)(parsed)\n  return Result.isFailure(decoded)\n    ? Effect.fail(denied(\"The workspace capability header is not a capability\"))\n    : Effect.succeed(decoded.success)\n}\n\n/**\n * Provides the workspace-capability authentication middleware: no header\n * runs the handler as anonymous, a verified header runs it as the workspace\n * principal, and anything else refuses the request. Verification faults\n * (Web Crypto failing) propagate as their own error rather than as a\n * refusal.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<SyncAuth, never, WorkspaceShare.WorkspaceShare> = Layer.effect(\n  SyncAuth,\n  Effect.gen(function*() {\n    const share = yield* WorkspaceShare.WorkspaceShare\n    const middleware: RpcMiddleware.RpcMiddleware<never, SyncError, never> = (effect, options) => {\n      const header = Headers.get(options.headers, capabilityHeader)\n      if (header._tag === \"None\") {\n        return Effect.provideService(effect, SyncPrincipal.SyncPrincipal, SyncPrincipal.anonymous)\n      }\n      return decodeCapability(header.value).pipe(\n        Effect.flatMap((capability) => share.verify(capability, { access: \"read\" })),\n        Effect.flatMap((claims) =>\n          Effect.provideService(\n            effect,\n            SyncPrincipal.SyncPrincipal,\n            // The signed expiry travels WITH the identity. A handler that\n            // opens a stream authorizes once; reducing the verified claims to\n            // a capability id here left the stream with nothing to expire on.\n            SyncPrincipal.workspace(claims.capabilityId, claims.expiresAtMs)\n          )\n        )\n      )\n    }\n    return middleware\n  })\n)\n\n/**\n * Stamps every outgoing request from a generated RPC client with the given\n * workspace capability.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerClient = (\n  capability: WorkspaceShare.WorkspaceCapability\n): Layer.Layer<RpcMiddleware.ForClient<SyncAuth>, SyncError> =>\n  RpcMiddleware.layerClient(\n    SyncAuth,\n    Effect.map(encodeCapability(capability), (header) => ({ next, request }) =>\n      next({ ...request, headers: Headers.set(request.headers, capabilityHeader, header) }))\n  )\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,aAAwB;AACxB,eAA0B;AAC1B,YAAuB;AACvB,aAAwB;AACxB,aAAwB;AACxB,cAAyB;AACzB,oBAA+B;AAC/B,uBAA0B;AAC1B,kBAA6B;AAC7B,uBAA0B;AAC1B,oBAA+B;AAC/B,sBAAyB;AACzB,qBAAgC;AAQzB,MAAM,mBAAmB;AAEhC,MAAM,SAAS,YAAY;AASpB,MAAM,mBAAmB,CAC9B,eACqC;AACrC,QAAM,UAAU,OAAO,oBAAoB,eAAe,mBAAmB,EAAE,UAAU;AACzF,SAAO,OAAO,UAAU,OAAO,IAC3B,OAAO;AAAA,IACP,IAAI,2BAAU;AAAA,MACZ,MAAM;AAAA,MACN,SAAS;AAAA;AAAA;AAAA,MAGT,WAAO,4BAAU,QAAQ,OAAO;AAAA,IAClC,CAAC;AAAA,EACH,IACE,OAAO,QAAQ,SAAS,gBAAgB,KAAK,UAAU,QAAQ,OAAO,CAAC,CAAC;AAC9E;AASO,MAAM,mBAAmB,CAAC,UAAgF;AAC/G,QAAM,OAAO,SAAS,sBAAsB,KAAK;AACjD,MAAI,OAAO,UAAU,IAAI,GAAG;AAC1B,WAAO,OAAO,KAAK,OAAO,qDAAqD,CAAC;AAAA,EAClF;AACA,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,KAAK,OAAO;AAAA,EAClC,QAAQ;AACN,WAAO,OAAO,KAAK,OAAO,qDAAqD,CAAC;AAAA,EAClF;AACA,QAAM,UAAU,OAAO,oBAAoB,eAAe,mBAAmB,EAAE,MAAM;AACrF,SAAO,OAAO,UAAU,OAAO,IAC3B,OAAO,KAAK,OAAO,qDAAqD,CAAC,IACzE,OAAO,QAAQ,QAAQ,OAAO;AACpC;AAYO,MAAM,QAAqE,MAAM;AAAA,EACtF;AAAA,EACA,OAAO,IAAI,aAAY;AACrB,UAAM,QAAQ,OAAO,eAAe;AACpC,UAAM,aAAmE,CAAC,QAAQ,YAAY;AAC5F,YAAM,SAAS,QAAQ,IAAI,QAAQ,SAAS,gBAAgB;AAC5D,UAAI,OAAO,SAAS,QAAQ;AAC1B,eAAO,OAAO,eAAe,QAAQ,cAAc,eAAe,cAAc,SAAS;AAAA,MAC3F;AACA,aAAO,iBAAiB,OAAO,KAAK,EAAE;AAAA,QACpC,OAAO,QAAQ,CAAC,eAAe,MAAM,OAAO,YAAY,EAAE,QAAQ,OAAO,CAAC,CAAC;AAAA,QAC3E,OAAO;AAAA,UAAQ,CAAC,WACd,OAAO;AAAA,YACL;AAAA,YACA,cAAc;AAAA;AAAA;AAAA;AAAA,YAId,cAAc,UAAU,OAAO,cAAc,OAAO,WAAW;AAAA,UACjE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AACH;AASO,MAAM,cAAc,CACzB,eAEA,cAAc;AAAA,EACZ;AAAA,EACA,OAAO,IAAI,iBAAiB,UAAU,GAAG,CAAC,WAAW,CAAC,EAAE,MAAM,QAAQ,MACpE,KAAK,EAAE,GAAG,SAAS,SAAS,QAAQ,IAAI,QAAQ,SAAS,kBAAkB,MAAM,EAAE,CAAC,CAAC;AACzF;",
+  "sourcesContent": ["/**\n * The sync read path's connection authentication: implementations of the\n * `SyncRpcs.SyncAuth` RPC middleware.\n *\n * A connection presents a {@link WorkspaceShare.WorkspaceCapability} in the\n * {@link capabilityHeader} request header. {@link layer} verifies it against\n * the workspace's {@link WorkspaceShare.WorkspaceShare} authority and runs\n * the handler as the workspace principal. A request with no header runs as\n * the anonymous principal \u2014 branch share capabilities carried in request\n * payloads still authorize branch reads \u2014 and the server refuses anonymous\n * access to every non-branch run. A request whose header is present but\n * malformed, forged, expired, or signed by an unknown key is refused\n * outright: presence of a credential is a claim, and a false claim is never\n * downgraded to anonymity.\n *\n * There is deliberately no trusted pass-through implementation here: the only\n * sanctioned bypass is an in-process caller providing `SyncPrincipal` itself,\n * never a transport.\n *\n * @since 0.1.0\n */\n\nimport * as Effect from \"effect/Effect\"\nimport * as Base64Url from \"effect/encoding/Base64Url\"\nimport * as Headers from \"effect/http/Headers\"\nimport * as Layer from \"effect/Layer\"\nimport * as Result from \"effect/Result\"\nimport * as RpcMiddleware from \"effect/rpc/RpcMiddleware\"\nimport * as Schema from \"effect/Schema\"\nimport { causeText } from \"./internal/CauseText.ts\"\nimport * as shareSigner from \"./internal/ShareSigner.ts\"\nimport { SyncError } from \"./SyncError.ts\"\nimport * as SyncPrincipal from \"./SyncPrincipal.ts\"\nimport { SyncAuth } from \"./SyncRpcs.ts\"\nimport * as WorkspaceShare from \"./WorkspaceShare.ts\"\n\n/**\n * The request header a connection presents its workspace capability in.\n *\n * @category constants\n * @since 0.1.0\n */\nexport const capabilityHeader = \"flows-sync-workspace\"\n\nconst denied = shareSigner.unauthorized\n\n/**\n * Renders a workspace capability as its header value: unpadded base64url of\n * the schema-encoded capability JSON.\n *\n * @category encoding\n * @since 0.1.0\n */\nexport const encodeCapability = (\n  capability: WorkspaceShare.WorkspaceCapability\n): Effect.Effect<string, SyncError> => {\n  const encoded = Schema.encodeUnknownResult(WorkspaceShare.WorkspaceCapability)(capability)\n  return Result.isFailure(encoded)\n    ? Effect.fail(\n      new SyncError({\n        code: \"invalid_request\",\n        message: \"The workspace capability does not encode\",\n        // The rendering, never the parse failure itself: a schema issue\n        // carries the value it rejected, and the value here is a credential.\n        cause: causeText(encoded.failure)\n      })\n    )\n    : Effect.succeed(Base64Url.encode(JSON.stringify(encoded.success)))\n}\n\n/**\n * Decodes a capability header value. Every malformation folds to the same\n * `unauthorized` refusal so the header is not a parsing oracle.\n *\n * @category encoding\n * @since 0.1.0\n */\nexport const decodeCapability = (value: string): Effect.Effect<WorkspaceShare.WorkspaceCapability, SyncError> => {\n  const text = Base64Url.decodeString(value)\n  if (Result.isFailure(text)) {\n    return Effect.fail(denied(\"The workspace capability header is not a capability\"))\n  }\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(text.success)\n  } catch {\n    return Effect.fail(denied(\"The workspace capability header is not a capability\"))\n  }\n  const decoded = Schema.decodeUnknownResult(WorkspaceShare.WorkspaceCapability)(parsed)\n  return Result.isFailure(decoded)\n    ? Effect.fail(denied(\"The workspace capability header is not a capability\"))\n    : Effect.succeed(decoded.success)\n}\n\n/**\n * Provides the workspace-capability authentication middleware: no header\n * runs the handler as anonymous, a verified header runs it as the workspace\n * principal, and anything else refuses the request. Verification faults\n * (Web Crypto failing) propagate as their own error rather than as a\n * refusal.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layer: Layer.Layer<SyncAuth, never, WorkspaceShare.WorkspaceShare> = Layer.effect(\n  SyncAuth,\n  Effect.gen(function*() {\n    const share = yield* WorkspaceShare.WorkspaceShare\n    const middleware: RpcMiddleware.RpcMiddleware<never, SyncError, never> = (effect, options) => {\n      const header = Headers.get(options.headers, capabilityHeader)\n      if (header._tag === \"None\") {\n        return Effect.provideService(effect, SyncPrincipal.SyncPrincipal, SyncPrincipal.anonymous)\n      }\n      return decodeCapability(header.value).pipe(\n        Effect.flatMap((capability) => share.verify(capability, { access: \"read\" })),\n        Effect.flatMap((claims) =>\n          Effect.provideService(\n            effect,\n            SyncPrincipal.SyncPrincipal,\n            // The signed expiry travels WITH the identity. A handler that\n            // opens a stream authorizes once; reducing the verified claims to\n            // a capability id here left the stream with nothing to expire on.\n            SyncPrincipal.workspace(claims.capabilityId, claims.expiresAtMs)\n          )\n        )\n      )\n    }\n    return middleware\n  })\n)\n\n/**\n * Stamps every outgoing request from a generated RPC client with the given\n * workspace capability.\n *\n * @category layers\n * @since 0.1.0\n */\nexport const layerClient = (\n  capability: WorkspaceShare.WorkspaceCapability\n): Layer.Layer<RpcMiddleware.ForClient<SyncAuth>, SyncError> =>\n  RpcMiddleware.layerClient(\n    SyncAuth,\n    Effect.map(encodeCapability(capability), (header) => ({ next, request }) =>\n      next({ ...request, headers: Headers.set(request.headers, capabilityHeader, header) }))\n  )\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBA,aAAwB;AACxB,gBAA2B;AAC3B,cAAyB;AACzB,YAAuB;AACvB,aAAwB;AACxB,oBAA+B;AAC/B,aAAwB;AACxB,uBAA0B;AAC1B,kBAA6B;AAC7B,uBAA0B;AAC1B,oBAA+B;AAC/B,sBAAyB;AACzB,qBAAgC;AAQzB,MAAM,mBAAmB;AAEhC,MAAM,SAAS,YAAY;AASpB,MAAM,mBAAmB,CAC9B,eACqC;AACrC,QAAM,UAAU,OAAO,oBAAoB,eAAe,mBAAmB,EAAE,UAAU;AACzF,SAAO,OAAO,UAAU,OAAO,IAC3B,OAAO;AAAA,IACP,IAAI,2BAAU;AAAA,MACZ,MAAM;AAAA,MACN,SAAS;AAAA;AAAA;AAAA,MAGT,WAAO,4BAAU,QAAQ,OAAO;AAAA,IAClC,CAAC;AAAA,EACH,IACE,OAAO,QAAQ,UAAU,OAAO,KAAK,UAAU,QAAQ,OAAO,CAAC,CAAC;AACtE;AASO,MAAM,mBAAmB,CAAC,UAAgF;AAC/G,QAAM,OAAO,UAAU,aAAa,KAAK;AACzC,MAAI,OAAO,UAAU,IAAI,GAAG;AAC1B,WAAO,OAAO,KAAK,OAAO,qDAAqD,CAAC;AAAA,EAClF;AACA,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,KAAK,OAAO;AAAA,EAClC,QAAQ;AACN,WAAO,OAAO,KAAK,OAAO,qDAAqD,CAAC;AAAA,EAClF;AACA,QAAM,UAAU,OAAO,oBAAoB,eAAe,mBAAmB,EAAE,MAAM;AACrF,SAAO,OAAO,UAAU,OAAO,IAC3B,OAAO,KAAK,OAAO,qDAAqD,CAAC,IACzE,OAAO,QAAQ,QAAQ,OAAO;AACpC;AAYO,MAAM,QAAqE,MAAM;AAAA,EACtF;AAAA,EACA,OAAO,IAAI,aAAY;AACrB,UAAM,QAAQ,OAAO,eAAe;AACpC,UAAM,aAAmE,CAAC,QAAQ,YAAY;AAC5F,YAAM,SAAS,QAAQ,IAAI,QAAQ,SAAS,gBAAgB;AAC5D,UAAI,OAAO,SAAS,QAAQ;AAC1B,eAAO,OAAO,eAAe,QAAQ,cAAc,eAAe,cAAc,SAAS;AAAA,MAC3F;AACA,aAAO,iBAAiB,OAAO,KAAK,EAAE;AAAA,QACpC,OAAO,QAAQ,CAAC,eAAe,MAAM,OAAO,YAAY,EAAE,QAAQ,OAAO,CAAC,CAAC;AAAA,QAC3E,OAAO;AAAA,UAAQ,CAAC,WACd,OAAO;AAAA,YACL;AAAA,YACA,cAAc;AAAA;AAAA;AAAA;AAAA,YAId,cAAc,UAAU,OAAO,cAAc,OAAO,WAAW;AAAA,UACjE;AAAA,QACF;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT,CAAC;AACH;AASO,MAAM,cAAc,CACzB,eAEA,cAAc;AAAA,EACZ;AAAA,EACA,OAAO,IAAI,iBAAiB,UAAU,GAAG,CAAC,WAAW,CAAC,EAAE,MAAM,QAAQ,MACpE,KAAK,EAAE,GAAG,SAAS,SAAS,QAAQ,IAAI,QAAQ,SAAS,kBAAkB,MAAM,EAAE,CAAC,CAAC;AACzF;",
   "names": []
 }

package/dist/cjs/SyncClient.d.ts

@@ -7,10 +7,10 @@ import type * as JournalEvent from "@smthrs/journal/JournalEvent";
 import * as Context from "effect/Context";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as RpcClientError from "effect/rpc/RpcClientError";
+import type * as RpcGroup from "effect/rpc/RpcGroup";
 import * as Stream from "effect/Stream";
-import * as RpcClient from "effect/unstable/rpc/RpcClient";
-import * as RpcClientError from "effect/unstable/rpc/RpcClientError";
-import type * as RpcGroup from "effect/unstable/rpc/RpcGroup";
 import type { ShareCapability } from "./BranchProtocol.ts";
 import { SyncError, SyncGapError } from "./SyncError.ts";
 import { type Progress, type Resync, RunCursor, type Scope, type Snapshot, type SnapshotRequest, type WorkspaceCursor } from "./SyncProtocol.ts";

package/dist/cjs/SyncClient.d.ts.map

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

package/dist/cjs/SyncClient.js

@@ -45,11 +45,11 @@ var Context = __toESM(require("effect/Context"), 1);
 var Effect = __toESM(require("effect/Effect"), 1);
 var Layer = __toESM(require("effect/Layer"), 1);
 var Ref = __toESM(require("effect/Ref"), 1);
+var RpcClient = __toESM(require("effect/rpc/RpcClient"), 1);
+var RpcClientError = __toESM(require("effect/rpc/RpcClientError"), 1);
 var Schedule = __toESM(require("effect/Schedule"), 1);
 var Schema = __toESM(require("effect/Schema"), 1);
 var Stream = __toESM(require("effect/Stream"), 1);
-var RpcClient = __toESM(require("effect/unstable/rpc/RpcClient"), 1);
-var RpcClientError = __toESM(require("effect/unstable/rpc/RpcClientError"), 1);
 var Admission = __toESM(require("./internal/Admission.js"), 1);
 var import_CauseText = require("./internal/CauseText.js");
 var import_PolicyOptions = require("./internal/PolicyOptions.js");