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

package/dist/cjs/BranchRpcs.d.ts

@@ -0,0 +1,177 @@
+/**
+ * The branch collaboration wire contract: the RPC projection of the write
+ * and presence paths that complement the read-only {@link SyncRpcs}.
+ *
+ * Authorization has two stages. Opening a branch is the bootstrap: no
+ * capability can exist yet, so `CreateBranch` requires an authenticated
+ * workspace principal supplied by the group's {@link SyncAuth} middleware,
+ * and its handler refuses any other principal.
+ *
+ * Every later procedure carries its own share capability and authorizes
+ * through {@link BranchShare}: past the bootstrap the capability IS the
+ * credential, and cross-branch or expired capabilities are refused by the
+ * same service boundary the in-process callers use.
+ *
+ * @since 0.1.0
+ */
+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";
+/**
+ * Maximum lifetime the branch bootstrap may mint.
+ *
+ * @category constants
+ * @since 0.1.0
+ */
+export declare const maximumBranchTtlMs: number;
+/**
+ * Schema for a request to open a new shared branch.
+ *
+ * The RPC authentication middleware must establish the workspace principal
+ * before the handler mints the first write capability.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const CreateBranchPayload: Schema.Struct<{
+    readonly ttlMs: Schema.Int;
+}>;
+/**
+ * A request to open a new shared branch.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type CreateBranchPayload = typeof CreateBranchPayload.Type;
+/**
+ * Schema for the freshly opened branch and its owner capability.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const CreateBranchResponse: Schema.Struct<{
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly capability: typeof ShareCapability;
+}>;
+/**
+ * The freshly opened branch and its owner capability.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type CreateBranchResponse = typeof CreateBranchResponse.Type;
+/**
+ * Schema for a request to mint a share link for a branch.
+ *
+ * The presenting capability must hold write access to the branch — only a
+ * collaborator can invite one — and the minted link never outlives the
+ * capability it was minted from.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const MintSharePayload: Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly access: Schema.Literals<readonly ["read", "write"]>;
+    readonly ttlMs: Schema.Int;
+}>;
+/**
+ * A request to mint a share link for a branch.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type MintSharePayload = typeof MintSharePayload.Type;
+/**
+ * Schema for one roster emission on a branch watch stream.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const RosterFrame: Schema.Struct<{
+    readonly participants: Schema.$Array<typeof Participant>;
+}>;
+/**
+ * One roster emission on a branch watch stream.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RosterFrame = typeof RosterFrame.Type;
+/**
+ * The remote procedures of branch collaboration.
+ *
+ * The capability-bearing payloads ARE the `BranchProtocol` request schemas the
+ * branch services take, not copies of them. Four wire payloads used to
+ * re-declare the message their service already owned, and the announce copy
+ * had already drifted: it accepted `displayName: ""` where the service
+ * requires a non-empty name, so a wire-legal announce reached a `Participant`
+ * constructor and threw a defect outside the declared `SyncError` channel.
+ * Naming one schema on both sides makes that drift impossible rather than
+ * fixed once, and keeps this group free of the services themselves.
+ *
+ * @category groups
+ * @since 0.1.0
+ */
+export declare const BranchRpcs: RpcGroup.RpcGroup<Rpc.Rpc<"Branch.CreateBranch", Schema.Struct<{
+    readonly ttlMs: Schema.Int;
+}>, Schema.Struct<{
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly capability: typeof ShareCapability;
+}>, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.MintShare", Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly access: Schema.Literals<readonly ["read", "write"]>;
+    readonly ttlMs: Schema.Int;
+}>, typeof ShareCapability, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.Submit", Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly submission: typeof import("./BranchProtocol.ts").CommandSubmission;
+}>, typeof CommandReceipt, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.Announce", Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    readonly displayName: Schema.NonEmptyString;
+    readonly cursor: Schema.NullOr<typeof import("./BranchProtocol.ts").Cursor>;
+    readonly sessionId: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly kind: Schema.optionalKey<Schema.Literals<readonly ["person", "agent"]>>;
+    readonly where: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"file">;
+        readonly path: Schema.NonEmptyString;
+        readonly line: Schema.optionalKey<Schema.Int>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"terminal">;
+        readonly id: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"step">;
+        readonly label: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"branch">;
+    }>]>>;
+    readonly watching: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly for_member: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly agentKind: Schema.optionalKey<Schema.Literals<readonly ["smithers", "coding", "reviewer", "claude-code", "codex", "external"]>>;
+    readonly via: Schema.optionalKey<Schema.Literals<readonly ["ssh", "terminal", "cli"]>>;
+    readonly runId: Schema.optionalKey<Schema.NonEmptyString>;
+}>, typeof Participant, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.Leave", Schema.Struct<{
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    readonly sessionId: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly capability: typeof ShareCapability;
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly sourcesReady: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.Null, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.Roster", Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly sourcesReady: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.$Array<typeof Participant>, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.PresenceOn", Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly sourcesReady: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.Literals<readonly ["unknown", "present", "empty"]>, typeof SyncError, typeof SyncAuth, never> | Rpc.Rpc<"Branch.WatchRoster", Schema.Struct<{
+    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<{
+    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

@@ -0,0 +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"}

package/dist/cjs/BranchRpcs.js

@@ -0,0 +1,85 @@
+"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 BranchRpcs_exports = {};
+__export(BranchRpcs_exports, {
+  BranchRpcs: () => BranchRpcs,
+  CreateBranchPayload: () => CreateBranchPayload,
+  CreateBranchResponse: () => CreateBranchResponse,
+  MintSharePayload: () => MintSharePayload,
+  RosterFrame: () => RosterFrame,
+  maximumBranchTtlMs: () => maximumBranchTtlMs
+});
+module.exports = __toCommonJS(BranchRpcs_exports);
+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");
+const maximumBranchTtlMs = 24 * 60 * 60 * 1e3;
+const CreateBranchPayload = Schema.Struct({
+  ttlMs: Schema.Int.check(
+    Schema.isGreaterThan(0),
+    Schema.isLessThanOrEqualTo(maximumBranchTtlMs)
+  )
+});
+const CreateBranchResponse = Schema.Struct({
+  branchId: import_BranchProtocol.BranchId,
+  capability: import_BranchProtocol.ShareCapability
+});
+const MintSharePayload = Schema.Struct({
+  capability: import_BranchProtocol.ShareCapability,
+  access: import_BranchProtocol.Access,
+  ttlMs: Schema.Int.check(Schema.isGreaterThan(0))
+});
+const RosterFrame = Schema.Struct({
+  participants: Schema.Array(import_BranchProtocol.Participant)
+});
+const BranchRpcs = import_rpc.RpcGroup.make(
+  import_rpc.Rpc.make("Branch.CreateBranch", {
+    payload: CreateBranchPayload,
+    success: CreateBranchResponse,
+    error: import_SyncError.SyncError
+  }),
+  import_rpc.Rpc.make("Branch.MintShare", { payload: MintSharePayload, success: import_BranchProtocol.ShareCapability, error: import_SyncError.SyncError }),
+  import_rpc.Rpc.make("Branch.Submit", { payload: import_BranchProtocol.SubmitRequest, success: import_BranchProtocol.CommandReceipt, error: import_SyncError.SyncError }),
+  import_rpc.Rpc.make("Branch.Announce", { payload: import_BranchProtocol.Announcement, success: import_BranchProtocol.Participant, error: import_SyncError.SyncError }),
+  import_rpc.Rpc.make("Branch.Leave", { payload: import_BranchProtocol.LeaveRequest, success: Schema.Null, error: import_SyncError.SyncError }),
+  import_rpc.Rpc.make("Branch.Roster", {
+    payload: import_BranchProtocol.RosterRequest,
+    success: Schema.Array(import_BranchProtocol.Participant),
+    error: import_SyncError.SyncError
+  }),
+  import_rpc.Rpc.make("Branch.PresenceOn", {
+    payload: import_BranchProtocol.RosterRequest,
+    success: Schema.Literals(["unknown", "present", "empty"]),
+    error: import_SyncError.SyncError
+  }),
+  import_rpc.Rpc.make("Branch.WatchRoster", { payload: import_BranchProtocol.RosterRequest, success: RosterFrame, error: import_SyncError.SyncError, stream: true })
+).middleware(import_SyncRpcs.SyncAuth);
+//# sourceMappingURL=BranchRpcs.js.map

package/dist/cjs/BranchRpcs.js.map

@@ -0,0 +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;",
+  "names": []
+}

package/dist/cjs/BranchServer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The server-side handlers of {@link BranchRpcs}: a thin projection of the
+ * branch services onto the wire.
+ *
+ * Five procedures forward to the service that owns their boundary and add
+ * nothing: `Branch.Submit` to {@link BranchCommands}, and `Branch.Announce`,
+ * `Branch.Leave`, `Branch.Roster`, and `Branch.WatchRoster` to
+ * {@link BranchPresence}. Two enforce policy here, on top of what
+ * {@link BranchShare} checks: `Branch.CreateBranch` refuses any principal that
+ * is not an authenticated workspace, and `Branch.MintShare` verifies write
+ * access, refuses an expired parent, and caps the child at the parent's
+ * expiry. `BranchShare.mint` performs none of those checks, so an in-process
+ * host that mints through the service directly must gate the principal and
+ * the parent capability itself.
+ *
+ * @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 * as BranchCommands from "./BranchCommands.ts";
+import * as BranchIds from "./BranchIds.ts";
+import * as BranchPresence from "./BranchPresence.ts";
+import { BranchRpcs } from "./BranchRpcs.ts";
+import * as BranchShare from "./BranchShare.ts";
+/**
+ * Provides the branch RPC handlers over the branch services.
+ *
+ * With {@link BranchPresence.layerNoop}, roster reads and watches fail with
+ * `unsupported`: unavailable presence cannot establish an empty roster.
+ *
+ * A roster watch emits the roster as of subscription, then re-lists on every
+ * presence change for the branch AND at least once per second, emitting
+ * only when the roster it read differs from the one it last sent.
+ *
+ * All three of those are triggers into ONE sequential reader. The roster is
+ * mutable state behind an effect, so concurrent readers can complete out of
+ * order, and a watcher that receives an older roster after a newer one keeps
+ * the older one: `changesWith` compares against the previous emission, not
+ * against the freshest state. Serializing the reads is what makes the last
+ * value a watcher holds the most recent one that was read.
+ *
+ * The periodic re-list is what makes expiry observable. A lapsed lease
+ * publishes nothing — the roster drops it the next time somebody lists — so a
+ * watch driven by change events alone never saw the LAST participant leave,
+ * and a burst of announcements on unrelated branches could slide the one
+ * notification this watch needed out of the shared feed. Both are bounded by
+ * one second: a departure is visible within 1 s of lease expiry,
+ * whether or not a survivor reports it.
+ *
+ * @category layers
+ * @since 0.1.0
+ */
+export declare const layerHandlers: Layer.Layer<Rpc.ToHandler<RpcGroup.Rpcs<typeof BranchRpcs>>, never, BranchShare.BranchShare | BranchPresence.BranchPresence | BranchCommands.BranchCommands | BranchIds.BranchIds>;
+//# sourceMappingURL=BranchServer.d.ts.map

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

@@ -0,0 +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"}

package/dist/cjs/BranchServer.js

@@ -0,0 +1,147 @@
+"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 BranchServer_exports = {};
+__export(BranchServer_exports, {
+  layerHandlers: () => layerHandlers
+});
+module.exports = __toCommonJS(BranchServer_exports);
+var Clock = __toESM(require("effect/Clock"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Stream = __toESM(require("effect/Stream"), 1);
+var BranchCommands = __toESM(require("./BranchCommands.js"), 1);
+var BranchIds = __toESM(require("./BranchIds.js"), 1);
+var BranchPresence = __toESM(require("./BranchPresence.js"), 1);
+var import_BranchProtocol = require("./BranchProtocol.js");
+var import_BranchRpcs = require("./BranchRpcs.js");
+var BranchShare = __toESM(require("./BranchShare.js"), 1);
+var Admission = __toESM(require("./internal/Admission.js"), 1);
+var import_SyncError = require("./SyncError.js");
+var SyncPrincipal = __toESM(require("./SyncPrincipal.js"), 1);
+const rosterKey = (participants) => JSON.stringify(
+  participants.map((participant) => [
+    participant.participantId,
+    participant.displayName,
+    participant.sessionId,
+    participant.kind,
+    participant.where,
+    participant.watching,
+    participant.for_member,
+    participant.leaseExpiresAtMs,
+    participant.cursor === null ? null : [participant.cursor.cardId, participant.cursor.offset]
+  ])
+);
+const sameRoster = (left, right) => rosterKey(left) === rosterKey(right);
+const layerHandlers = import_BranchRpcs.BranchRpcs.toLayer(
+  Effect.gen(function* () {
+    const share = yield* BranchShare.BranchShare;
+    const presence = yield* BranchPresence.BranchPresence;
+    const commands = yield* BranchCommands.BranchCommands;
+    const ids = yield* BranchIds.BranchIds;
+    return import_BranchRpcs.BranchRpcs.of({
+      "Branch.CreateBranch": ({ ttlMs }) => Effect.gen(function* () {
+        const principal = yield* SyncPrincipal.SyncPrincipal;
+        if (!SyncPrincipal.isWorkspace(principal)) {
+          return yield* new import_SyncError.SyncError({
+            code: "unauthorized",
+            message: "Creating a branch requires an authenticated workspace principal"
+          });
+        }
+        const branchId = yield* Admission.decode(import_BranchProtocol.BranchId, yield* ids.fresh, "invalid_request");
+        const capability = yield* share.mint({
+          branchId,
+          capabilityId: yield* ids.fresh,
+          access: "write",
+          ttlMs
+        });
+        return { branchId: capability.claims.branchId, capability };
+      }),
+      "Branch.MintShare": ({ capability, access, ttlMs }) => Effect.gen(function* () {
+        const claims = yield* share.verify(capability, {
+          branchId: capability.claims.branchId,
+          access: "write"
+        });
+        const capabilityId = yield* ids.fresh;
+        const nowMs = yield* Clock.currentTimeMillis;
+        if (nowMs >= claims.expiresAtMs) {
+          return yield* new import_SyncError.SyncError({
+            code: "unauthorized",
+            message: "The share capability has expired"
+          });
+        }
+        return yield* share.mint({
+          branchId: claims.branchId,
+          capabilityId,
+          access,
+          ttlMs,
+          maxExpiresAtMs: claims.expiresAtMs
+        });
+      }),
+      "Branch.Submit": (payload) => commands.submit(payload),
+      "Branch.Announce": (payload) => presence.announce(payload),
+      "Branch.Leave": (payload) => Effect.as(presence.leave(payload), null),
+      "Branch.Roster": (payload) => presence.list(payload),
+      "Branch.PresenceOn": (payload) => presence.presenceOn(payload),
+      "Branch.WatchRoster": (payload) => Stream.merge(
+        // The subscription's own snapshot is a TRIGGER like the other two,
+        // not a fourth reader. Reading it here concurrently with them let
+        // the roster a change produced overtake it: `presence.list` is an
+        // effect against mutable state, three of them ran at once, and the
+        // slowest one won the merge. `changesWith` compares an emission only
+        // against the one before it, so the older roster passed the filter
+        // and the watcher's LAST value said a participant who had already
+        // left was still present, until the next change or lease tick.
+        Stream.succeed(void 0),
+        Stream.merge(
+          presence.changes.pipe(
+            Stream.filter((branchId) => branchId === payload.branchId),
+            Stream.map(() => void 0)
+          ),
+          // A lapsed lease publishes nothing, so a watch driven only by
+          // change events never observes the LAST participant leaving, and
+          // an unrelated branch's burst can slide the one notification this
+          // watch needed out of the shared feed. Re-listing at least once per second
+          // bounds both: a departure is visible within 1 s of expiry, whether or not anyone reports it.
+          Stream.fromEffectRepeat(Effect.sleep(Math.min(presence.leaseMs, 1e3))).pipe(Stream.map(() => void 0))
+        )
+      ).pipe(
+        // ONE reader, sequential by default, so a roster is read in the
+        // order its trigger arrived and every emission is at least as fresh
+        // as the one before it.
+        Stream.mapEffect(() => presence.list(payload)),
+        // Deduplicated over the WHOLE stream, initial emission included.
+        // Applied to the change half alone, its first value always passed,
+        // so a change that left the roster identical still sent the watcher
+        // a second copy of what it had just been given.
+        Stream.changesWith(sameRoster),
+        Stream.map((participants) => ({ participants }))
+      )
+    });
+  })
+);
+//# sourceMappingURL=BranchServer.js.map

package/dist/cjs/BranchServer.js.map

@@ -0,0 +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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",
+  "names": []
+}