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

package/dist/cjs/BranchProtocol.d.ts

@@ -0,0 +1,415 @@
+/**
+ * The branch collaboration contract: a branch is one shared live document.
+ *
+ * A branch has no store of its own. Its durable state is exactly one journal
+ * run — `branchRunId` is the only mapping — so every replication guarantee the
+ * rest of this package already provides (canonical per-run `seq`, exclusive
+ * cursors, gap detection, resumable follow) carries over unchanged, and
+ * multiplayer never introduces a second source of truth.
+ *
+ * Ephemeral collaboration state (presence, cursors) deliberately has no
+ * representation here beyond the wire shapes: it is leased, never journalled.
+ *
+ * @since 0.1.0
+ */
+import * as JournalEvent from "@smthrs/journal/JournalEvent";
+import * as Schema from "effect/Schema";
+/**
+ * Schema for the identifier of one collaboratively edited branch.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const BranchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+/**
+ * Identifier of one collaboratively edited branch.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type BranchId = typeof BranchId.Type;
+/**
+ * Schema for the identifier of one connected client.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const ParticipantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+/**
+ * Identifier of one connected client.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ParticipantId = typeof ParticipantId.Type;
+/**
+ * Schema for a client-minted command identifier.
+ *
+ * The identifier is minted once per user intent and reused across optimistic
+ * application, retransmission, and concurrent submission, which is what makes
+ * it the idempotency key rather than a correlation id.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const CommandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+/**
+ * Client-minted command identifier used as the idempotency key.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type CommandId = typeof CommandId.Type;
+/**
+ * Schema for the access a share capability grants.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Access: Schema.Literals<readonly ["read", "write"]>;
+/**
+ * The access a share capability grants.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Access = typeof Access.Type;
+/**
+ * The journal run backing a branch document.
+ *
+ * The prefix keeps branch runs from colliding with engine runs in the same
+ * workspace journal, and makes the mapping reversible for tooling.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const branchRunId: (branchId: BranchId) => JournalEvent.RunId;
+/**
+ * The branch a journal run belongs to, or `null` for a non-branch run.
+ *
+ * The bare prefix is a non-branch run, not a branch with an empty id.
+ * `BranchId` is a branded `NonEmptyString`, so branding `""` would produce a
+ * value the brand forbids and hand it to `share.verify` as the branch under
+ * authorization. Refusing it here keeps the brand's promise true everywhere
+ * downstream of this function.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const branchOfRunId: (runId: JournalEvent.RunId) => BranchId | null;
+/**
+ * The journal producer identity of one admitted command.
+ *
+ * `(runId, sourceId, sourceSeq)` is the journal's own durable idempotency
+ * key. Deriving the source from the client-minted `commandId` — with the
+ * fixed {@link commandSourceSeq} — turns that key into the branch's
+ * exactly-once admission constraint: two server instances racing the same
+ * command collide inside the journal's own transaction, so one appends and
+ * the other reads back the canonical sequence, instead of both appending
+ * (audit finding F-14). The branch run id already scopes the key, so equal
+ * command ids on different branches never collide.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const commandSourceId: (commandId: CommandId) => JournalEvent.SourceId;
+/**
+ * The fixed producer sequence of an admitted command.
+ *
+ * A command's identity lives entirely in {@link commandSourceId}, so its
+ * producer sequence is always 0. It must be supplied explicitly: letting the
+ * journal allocate would hand a resubmission after a lost response sequence 1,
+ * a fresh identity, and therefore a second durable append.
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const commandSourceSeq: JournalEvent.SourceSeq;
+/**
+ * The single durable event type a branch document is built from.
+ *
+ * Chat, edits, and flow launches are all commands, so the branch journal has
+ * exactly one event shape and the projection has exactly one decoder.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const CommandEvent = "flows/branch/command";
+declare const ShareClaims_base: Schema.Class<ShareClaims, Schema.Struct<{
+    readonly kid: Schema.NonEmptyString;
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly capabilityId: Schema.NonEmptyString;
+    readonly access: Schema.Literals<readonly ["read", "write"]>;
+    readonly issuedAtMs: Schema.Int;
+    readonly expiresAtMs: Schema.Int;
+}>, {}>;
+/**
+ * Schema for the claims a share capability carries.
+ *
+ * `kid` names the key that signed the claims and is itself signed, so a
+ * verifier both selects the right key out of a rotating keyring and refuses a
+ * capability whose key name was swapped after minting. It matches
+ * `WorkspaceShare.WorkspaceClaims`: the two authorities are one scheme, and a
+ * branch link that could not survive a secret rotation was the only place they
+ * differed.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class ShareClaims extends ShareClaims_base {
+}
+declare const ShareCapability_base: Schema.Class<ShareCapability, Schema.Struct<{
+    readonly claims: typeof ShareClaims;
+    readonly signature: Schema.String;
+}>, {}>;
+/**
+ * Schema for a signed, expiring, branch-scoped share capability.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class ShareCapability extends ShareCapability_base {
+}
+declare const Cursor_base: Schema.Class<Cursor, Schema.Struct<{
+    readonly cardId: Schema.NonEmptyString;
+    readonly offset: Schema.Int;
+}>, {}>;
+/**
+ * Schema for a participant's caret inside one embedded card.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class Cursor extends Cursor_base {
+}
+/**
+ * BranchCard-compatible display coordinates; paths are metadata only.
+ *
+ * @category schemas
+ * @since 1.0.0-rc.1
+ */
+export declare const PresenceWhere: 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">;
+}>]>;
+declare const Participant_base: Schema.Class<Participant, Schema.Struct<{
+    readonly leaseExpiresAtMs: Schema.Int;
+    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>;
+    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 Cursor>;
+}>, {}>;
+/**
+ * Schema for one live participant on a branch.
+ *
+ * `leaseExpiresAtMs` is the whole lifetime contract: presence is a lease, so a
+ * client that disconnects without saying so disappears on its own.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class Participant extends Participant_base {
+}
+/**
+ * Schema for a capability-bearing request for one branch's roster.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const RosterRequest: Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    /** Only the authenticated host adapter consumes this readiness assertion. */
+    readonly sourcesReady: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * A capability-bearing request for one branch's roster.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type RosterRequest = typeof RosterRequest.Type;
+/**
+ * Schema for a capability-bearing request to drop one participant.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const LeaveRequest: 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">;
+    /** Only the authenticated host adapter consumes this readiness assertion. */
+    readonly sourcesReady: Schema.optionalKey<Schema.Boolean>;
+}>;
+/**
+ * A capability-bearing request to drop one participant.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type LeaveRequest = typeof LeaveRequest.Type;
+/**
+ * Schema for one participant's announcement of itself on a branch.
+ *
+ * The same shape serves join, heartbeat, and cursor movement: an announcement
+ * is idempotent, so a client that reconnects simply announces again.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const Announcement: 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 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>;
+}>;
+/**
+ * One participant's announcement of itself on a branch.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Announcement = typeof Announcement.Type;
+declare const CommandSubmission_base: Schema.Class<CommandSubmission, Schema.Struct<{
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    readonly name: Schema.NonEmptyString;
+    readonly args: Schema.String;
+    readonly target: Schema.String;
+}>, {}>;
+/**
+ * Schema for one submitted command or flow invocation.
+ *
+ * Every user action on a shared branch arrives here first — chat messages are
+ * the `branch.say` command, renames are `branch.rename`, and a flow launch is
+ * that flow's own name. `target` names the shared field a command durably
+ * edits and is `""` for commands that only append.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class CommandSubmission extends CommandSubmission_base {
+}
+/**
+ * Schema for a capability-bearing command submission.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare const SubmitRequest: Schema.Struct<{
+    readonly capability: typeof ShareCapability;
+    readonly submission: typeof CommandSubmission;
+}>;
+/**
+ * A capability-bearing command submission.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type SubmitRequest = typeof SubmitRequest.Type;
+declare const CommandEventPayload_base: Schema.Class<CommandEventPayload, Schema.Struct<{
+    readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    readonly name: Schema.NonEmptyString;
+    readonly args: Schema.withDecodingDefaultKey<Schema.String, never>;
+    readonly target: Schema.withDecodingDefaultKey<Schema.String, never>;
+    readonly capabilityId: Schema.withDecodingDefaultKey<Schema.String, never>;
+}>, {}>;
+/**
+ * The durable payload stored for an admitted command.
+ *
+ * Distinct from the wire request: `args` and `target` carry decoding defaults,
+ * so a row written before those fields existed still decodes rather than
+ * failing the whole ledger rebuild.
+ *
+ * `capabilityId` is the verified id of the share capability that submitted the
+ * command, stamped by `BranchCommands.submit` and never read from the client.
+ * `participantId` is whatever the client claimed, so attribute a command to
+ * its `capabilityId`. A row admitted before the field existed decodes with
+ * `""`, which no capability can carry.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class CommandEventPayload extends CommandEventPayload_base {
+}
+/**
+ * The command that appends a collaborative chat message.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const SayCommand = "branch.say";
+declare const CommandReceipt_base: Schema.Class<CommandReceipt, Schema.Struct<{
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+    readonly status: Schema.Literals<readonly ["admitted", "duplicate"]>;
+    readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+}>, {}>;
+/**
+ * Schema for the outcome of admitting a command.
+ *
+ * `duplicate` is a success, not a failure: it reports the canonical sequence
+ * the original submission already occupies so a retransmitting client can
+ * settle its optimistic row instead of executing the command twice.
+ *
+ * @category schemas
+ * @since 0.1.0
+ */
+export declare class CommandReceipt extends CommandReceipt_base {
+}
+export {};
+//# sourceMappingURL=BranchProtocol.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BranchProtocol.d.ts","sourceRoot":"","sources":["../../src/BranchProtocol.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,YAAY,MAAM,8BAA8B,CAAA;AAE5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,6EAAmF,CAAA;AAExG;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC,IAAI,CAAA;AAE3C;;;;;GAKG;AACH,eAAO,MAAM,aAAa,kFAAwF,CAAA;AAElH;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,8EAAoF,CAAA;AAE1G;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,OAAO,SAAS,CAAC,IAAI,CAAA;AAE7C;;;;;GAKG;AACH,eAAO,MAAM,MAAM,6CAAqC,CAAA;AAExD;;;;;GAKG;AACH,MAAM,MAAM,MAAM,GAAG,OAAO,MAAM,CAAC,IAAI,CAAA;AAEvC;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,GAAI,UAAU,QAAQ,KAAG,YAAY,CAAC,KACP,CAAA;AAKvD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,YAAY,CAAC,KAAK,KAAG,QAAQ,GAAG,IAIpE,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,GAAI,WAAW,SAAS,KAAG,YAAY,CAAC,QACN,CAAA;AAE9D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,YAAY,CAAC,SAAuC,CAAA;AAEnF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,yBAAyB,CAAA;;;;;;;;;AAElD;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAY,SAAQ,gBAO/B;CAAG;;;;;AAEL;;;;;GAKG;AACH,qBAAa,eAAgB,SAAQ,oBAGnC;CAAG;;;;;AAEL;;;;;GAKG;AACH,qBAAa,MAAO,SAAQ,WAG1B;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;IASxB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgBF;;;;;;;;GAQG;AACH,qBAAa,WAAY,SAAQ,gBAO/B;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;IAGxB,6EAA6E;;EAE7E,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;AAErD;;;;;GAKG;AACH,eAAO,MAAM,YAAY;;;;;IAlBvB,6EAA6E;;EAsB7E,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;AAEnD;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;EAOvB,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC,IAAI,CAAA;;;;;;;;;AAEnD;;;;;;;;;;GAUG;AACH,qBAAa,iBAAkB,SAAQ,sBASrC;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,aAAa;;;EAAgF,CAAA;AAE1G;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,OAAO,aAAa,CAAC,IAAI,CAAA;;;;;;;;;AAErD;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,mBAAoB,SAAQ,wBASvC;CAAG;AAEL;;;;;GAKG;AACH,eAAO,MAAM,UAAU,eAAe,CAAA;;;;;;;AAEtC;;;;;;;;;GASG;AACH,qBAAa,cAAe,SAAQ,mBAKlC;CAAG"}

package/dist/cjs/BranchProtocol.js

@@ -0,0 +1,172 @@
+"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 BranchProtocol_exports = {};
+__export(BranchProtocol_exports, {
+  Access: () => Access,
+  Announcement: () => Announcement,
+  BranchId: () => BranchId,
+  CommandEvent: () => CommandEvent,
+  CommandEventPayload: () => CommandEventPayload,
+  CommandId: () => CommandId,
+  CommandReceipt: () => CommandReceipt,
+  CommandSubmission: () => CommandSubmission,
+  Cursor: () => Cursor,
+  LeaveRequest: () => LeaveRequest,
+  Participant: () => Participant,
+  ParticipantId: () => ParticipantId,
+  PresenceWhere: () => PresenceWhere,
+  RosterRequest: () => RosterRequest,
+  SayCommand: () => SayCommand,
+  ShareCapability: () => ShareCapability,
+  ShareClaims: () => ShareClaims,
+  SubmitRequest: () => SubmitRequest,
+  branchOfRunId: () => branchOfRunId,
+  branchRunId: () => branchRunId,
+  commandSourceId: () => commandSourceId,
+  commandSourceSeq: () => commandSourceSeq
+});
+module.exports = __toCommonJS(BranchProtocol_exports);
+var JournalEvent = __toESM(require("@smthrs/journal/JournalEvent"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+const BranchId = Schema.NonEmptyString.pipe(Schema.brand("@smthrs/sync/BranchProtocol/BranchId"));
+const ParticipantId = Schema.NonEmptyString.pipe(Schema.brand("@smthrs/sync/BranchProtocol/ParticipantId"));
+const CommandId = Schema.NonEmptyString.pipe(Schema.brand("@smthrs/sync/BranchProtocol/CommandId"));
+const Access = Schema.Literals(["read", "write"]);
+const branchRunId = (branchId) => `${branchRunPrefix}${branchId}`;
+const branchRunPrefix = "flows/branch/";
+const branchOfRunId = (runId) => {
+  if (!runId.startsWith(branchRunPrefix)) return null;
+  const rest = runId.slice(branchRunPrefix.length);
+  return rest.length === 0 ? null : rest;
+};
+const commandSourceId = (commandId) => `flows/branch-command/${commandId}`;
+const commandSourceSeq = 0;
+const CommandEvent = "flows/branch/command";
+class ShareClaims extends Schema.Class("@smthrs/sync/BranchProtocol/ShareClaims")({
+  kid: Schema.NonEmptyString,
+  branchId: BranchId,
+  capabilityId: Schema.NonEmptyString,
+  access: Access,
+  issuedAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),
+  expiresAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {
+}
+class ShareCapability extends Schema.Class("@smthrs/sync/BranchProtocol/ShareCapability")({
+  claims: ShareClaims,
+  signature: Schema.String
+}) {
+}
+class Cursor extends Schema.Class("@smthrs/sync/BranchProtocol/Cursor")({
+  cardId: Schema.NonEmptyString,
+  offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {
+}
+const PresenceWhere = Schema.Union([
+  Schema.Struct({
+    kind: Schema.Literal("file"),
+    path: Schema.NonEmptyString,
+    line: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))
+  }),
+  Schema.Struct({ kind: Schema.Literal("terminal"), id: Schema.NonEmptyString }),
+  Schema.Struct({ kind: Schema.Literal("step"), label: Schema.NonEmptyString }),
+  Schema.Struct({ kind: Schema.Literal("branch") })
+]);
+const presenceFields = {
+  sessionId: Schema.optionalKey(Schema.NonEmptyString),
+  kind: Schema.optionalKey(Schema.Literals(["person", "agent"])),
+  where: Schema.optionalKey(PresenceWhere),
+  watching: Schema.optionalKey(Schema.NonEmptyString),
+  for_member: Schema.optionalKey(Schema.NonEmptyString),
+  agentKind: Schema.optionalKey(
+    Schema.Literals(["smithers", "coding", "reviewer", "claude-code", "codex", "external"])
+  ),
+  via: Schema.optionalKey(Schema.Literals(["ssh", "terminal", "cli"])),
+  runId: Schema.optionalKey(Schema.NonEmptyString)
+};
+class Participant extends Schema.Class("@smthrs/sync/BranchProtocol/Participant")({
+  branchId: BranchId,
+  participantId: ParticipantId,
+  displayName: Schema.NonEmptyString,
+  cursor: Schema.NullOr(Cursor),
+  ...presenceFields,
+  leaseExpiresAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))
+}) {
+}
+const RosterRequest = Schema.Struct({
+  capability: ShareCapability,
+  branchId: BranchId,
+  /** Only the authenticated host adapter consumes this readiness assertion. */
+  sourcesReady: Schema.optionalKey(Schema.Boolean)
+});
+const LeaveRequest = Schema.Struct({
+  ...RosterRequest.fields,
+  participantId: ParticipantId,
+  sessionId: Schema.optionalKey(Schema.NonEmptyString)
+});
+const Announcement = Schema.Struct({
+  ...presenceFields,
+  capability: ShareCapability,
+  branchId: BranchId,
+  participantId: ParticipantId,
+  displayName: Schema.NonEmptyString,
+  cursor: Schema.NullOr(Cursor)
+});
+class CommandSubmission extends Schema.Class(
+  "@smthrs/sync/BranchProtocol/CommandSubmission"
+)({
+  branchId: BranchId,
+  commandId: CommandId,
+  participantId: ParticipantId,
+  name: Schema.NonEmptyString,
+  args: Schema.String,
+  target: Schema.String
+}) {
+}
+const SubmitRequest = Schema.Struct({ capability: ShareCapability, submission: CommandSubmission });
+class CommandEventPayload extends Schema.Class(
+  "@smthrs/sync/BranchProtocol/CommandEventPayload"
+)({
+  commandId: CommandId,
+  participantId: ParticipantId,
+  name: Schema.NonEmptyString,
+  args: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(""))),
+  target: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(""))),
+  capabilityId: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed("")))
+}) {
+}
+const SayCommand = "branch.say";
+class CommandReceipt extends Schema.Class("@smthrs/sync/BranchProtocol/CommandReceipt")({
+  branchId: BranchId,
+  commandId: CommandId,
+  status: Schema.Literals(["admitted", "duplicate"]),
+  seq: JournalEvent.Seq
+}) {
+}
+//# sourceMappingURL=BranchProtocol.js.map

package/dist/cjs/BranchProtocol.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/BranchProtocol.ts"],
+  "sourcesContent": ["/**\n * The branch collaboration contract: a branch is one shared live document.\n *\n * A branch has no store of its own. Its durable state is exactly one journal\n * run \u2014 `branchRunId` is the only mapping \u2014 so every replication guarantee the\n * rest of this package already provides (canonical per-run `seq`, exclusive\n * cursors, gap detection, resumable follow) carries over unchanged, and\n * multiplayer never introduces a second source of truth.\n *\n * Ephemeral collaboration state (presence, cursors) deliberately has no\n * representation here beyond the wire shapes: it is leased, never journalled.\n *\n * @since 0.1.0\n */\n\nimport * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport * as Effect from \"effect/Effect\"\nimport * as Schema from \"effect/Schema\"\n\n/**\n * Schema for the identifier of one collaboratively edited branch.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const BranchId = Schema.NonEmptyString.pipe(Schema.brand(\"@smthrs/sync/BranchProtocol/BranchId\"))\n\n/**\n * Identifier of one collaboratively edited branch.\n *\n * @category models\n * @since 0.1.0\n */\nexport type BranchId = typeof BranchId.Type\n\n/**\n * Schema for the identifier of one connected client.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const ParticipantId = Schema.NonEmptyString.pipe(Schema.brand(\"@smthrs/sync/BranchProtocol/ParticipantId\"))\n\n/**\n * Identifier of one connected client.\n *\n * @category models\n * @since 0.1.0\n */\nexport type ParticipantId = typeof ParticipantId.Type\n\n/**\n * Schema for a client-minted command identifier.\n *\n * The identifier is minted once per user intent and reused across optimistic\n * application, retransmission, and concurrent submission, which is what makes\n * it the idempotency key rather than a correlation id.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const CommandId = Schema.NonEmptyString.pipe(Schema.brand(\"@smthrs/sync/BranchProtocol/CommandId\"))\n\n/**\n * Client-minted command identifier used as the idempotency key.\n *\n * @category models\n * @since 0.1.0\n */\nexport type CommandId = typeof CommandId.Type\n\n/**\n * Schema for the access a share capability grants.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Access = Schema.Literals([\"read\", \"write\"])\n\n/**\n * The access a share capability grants.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Access = typeof Access.Type\n\n/**\n * The journal run backing a branch document.\n *\n * The prefix keeps branch runs from colliding with engine runs in the same\n * workspace journal, and makes the mapping reversible for tooling.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const branchRunId = (branchId: BranchId): JournalEvent.RunId =>\n  `${branchRunPrefix}${branchId}` as JournalEvent.RunId\n\n/** The one prefix {@link branchRunId} writes and {@link branchOfRunId} reads. */\nconst branchRunPrefix = \"flows/branch/\"\n\n/**\n * The branch a journal run belongs to, or `null` for a non-branch run.\n *\n * The bare prefix is a non-branch run, not a branch with an empty id.\n * `BranchId` is a branded `NonEmptyString`, so branding `\"\"` would produce a\n * value the brand forbids and hand it to `share.verify` as the branch under\n * authorization. Refusing it here keeps the brand's promise true everywhere\n * downstream of this function.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const branchOfRunId = (runId: JournalEvent.RunId): BranchId | null => {\n  if (!runId.startsWith(branchRunPrefix)) return null\n  const rest = runId.slice(branchRunPrefix.length)\n  return rest.length === 0 ? null : rest as BranchId\n}\n\n/**\n * The journal producer identity of one admitted command.\n *\n * `(runId, sourceId, sourceSeq)` is the journal's own durable idempotency\n * key. Deriving the source from the client-minted `commandId` \u2014 with the\n * fixed {@link commandSourceSeq} \u2014 turns that key into the branch's\n * exactly-once admission constraint: two server instances racing the same\n * command collide inside the journal's own transaction, so one appends and\n * the other reads back the canonical sequence, instead of both appending\n * (audit finding F-14). The branch run id already scopes the key, so equal\n * command ids on different branches never collide.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const commandSourceId = (commandId: CommandId): JournalEvent.SourceId =>\n  `flows/branch-command/${commandId}` as JournalEvent.SourceId\n\n/**\n * The fixed producer sequence of an admitted command.\n *\n * A command's identity lives entirely in {@link commandSourceId}, so its\n * producer sequence is always 0. It must be supplied explicitly: letting the\n * journal allocate would hand a resubmission after a lost response sequence 1,\n * a fresh identity, and therefore a second durable append.\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const commandSourceSeq: JournalEvent.SourceSeq = 0 as JournalEvent.SourceSeq\n\n/**\n * The single durable event type a branch document is built from.\n *\n * Chat, edits, and flow launches are all commands, so the branch journal has\n * exactly one event shape and the projection has exactly one decoder.\n *\n * @category models\n * @since 0.1.0\n */\nexport const CommandEvent = \"flows/branch/command\"\n\n/**\n * Schema for the claims a share capability carries.\n *\n * `kid` names the key that signed the claims and is itself signed, so a\n * verifier both selects the right key out of a rotating keyring and refuses a\n * capability whose key name was swapped after minting. It matches\n * `WorkspaceShare.WorkspaceClaims`: the two authorities are one scheme, and a\n * branch link that could not survive a secret rotation was the only place they\n * differed.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class ShareClaims extends Schema.Class<ShareClaims>(\"@smthrs/sync/BranchProtocol/ShareClaims\")({\n  kid: Schema.NonEmptyString,\n  branchId: BranchId,\n  capabilityId: Schema.NonEmptyString,\n  access: Access,\n  issuedAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)),\n  expiresAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n}) {}\n\n/**\n * Schema for a signed, expiring, branch-scoped share capability.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class ShareCapability extends Schema.Class<ShareCapability>(\"@smthrs/sync/BranchProtocol/ShareCapability\")({\n  claims: ShareClaims,\n  signature: Schema.String\n}) {}\n\n/**\n * Schema for a participant's caret inside one embedded card.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class Cursor extends Schema.Class<Cursor>(\"@smthrs/sync/BranchProtocol/Cursor\")({\n  cardId: Schema.NonEmptyString,\n  offset: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n}) {}\n\n/**\n * BranchCard-compatible display coordinates; paths are metadata only.\n *\n * @category schemas\n * @since 1.0.0-rc.1\n */\nexport const PresenceWhere = Schema.Union([\n  Schema.Struct({\n    kind: Schema.Literal(\"file\"),\n    path: Schema.NonEmptyString,\n    line: Schema.optionalKey(Schema.Int.check(Schema.isGreaterThan(0)))\n  }),\n  Schema.Struct({ kind: Schema.Literal(\"terminal\"), id: Schema.NonEmptyString }),\n  Schema.Struct({ kind: Schema.Literal(\"step\"), label: Schema.NonEmptyString }),\n  Schema.Struct({ kind: Schema.Literal(\"branch\") })\n])\n\n// Optional fields preserve decoding of recorded branch-protocol frames.\nconst presenceFields = {\n  sessionId: Schema.optionalKey(Schema.NonEmptyString),\n  kind: Schema.optionalKey(Schema.Literals([\"person\", \"agent\"])),\n  where: Schema.optionalKey(PresenceWhere),\n  watching: Schema.optionalKey(Schema.NonEmptyString),\n  for_member: Schema.optionalKey(Schema.NonEmptyString),\n  agentKind: Schema.optionalKey(\n    Schema.Literals([\"smithers\", \"coding\", \"reviewer\", \"claude-code\", \"codex\", \"external\"])\n  ),\n  via: Schema.optionalKey(Schema.Literals([\"ssh\", \"terminal\", \"cli\"])),\n  runId: Schema.optionalKey(Schema.NonEmptyString)\n}\n\n/**\n * Schema for one live participant on a branch.\n *\n * `leaseExpiresAtMs` is the whole lifetime contract: presence is a lease, so a\n * client that disconnects without saying so disappears on its own.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class Participant extends Schema.Class<Participant>(\"@smthrs/sync/BranchProtocol/Participant\")({\n  branchId: BranchId,\n  participantId: ParticipantId,\n  displayName: Schema.NonEmptyString,\n  cursor: Schema.NullOr(Cursor),\n  ...presenceFields,\n  leaseExpiresAtMs: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0))\n}) {}\n\n/**\n * Schema for a capability-bearing request for one branch's roster.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const RosterRequest = Schema.Struct({\n  capability: ShareCapability,\n  branchId: BranchId,\n  /** Only the authenticated host adapter consumes this readiness assertion. */\n  sourcesReady: Schema.optionalKey(Schema.Boolean)\n})\n\n/**\n * A capability-bearing request for one branch's roster.\n *\n * @category models\n * @since 0.1.0\n */\nexport type RosterRequest = typeof RosterRequest.Type\n\n/**\n * Schema for a capability-bearing request to drop one participant.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const LeaveRequest = Schema.Struct({\n  ...RosterRequest.fields,\n  participantId: ParticipantId,\n  sessionId: Schema.optionalKey(Schema.NonEmptyString)\n})\n\n/**\n * A capability-bearing request to drop one participant.\n *\n * @category models\n * @since 0.1.0\n */\nexport type LeaveRequest = typeof LeaveRequest.Type\n\n/**\n * Schema for one participant's announcement of itself on a branch.\n *\n * The same shape serves join, heartbeat, and cursor movement: an announcement\n * is idempotent, so a client that reconnects simply announces again.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const Announcement = Schema.Struct({\n  ...presenceFields,\n  capability: ShareCapability,\n  branchId: BranchId,\n  participantId: ParticipantId,\n  displayName: Schema.NonEmptyString,\n  cursor: Schema.NullOr(Cursor)\n})\n\n/**\n * One participant's announcement of itself on a branch.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Announcement = typeof Announcement.Type\n\n/**\n * Schema for one submitted command or flow invocation.\n *\n * Every user action on a shared branch arrives here first \u2014 chat messages are\n * the `branch.say` command, renames are `branch.rename`, and a flow launch is\n * that flow's own name. `target` names the shared field a command durably\n * edits and is `\"\"` for commands that only append.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class CommandSubmission extends Schema.Class<CommandSubmission>(\n  \"@smthrs/sync/BranchProtocol/CommandSubmission\"\n)({\n  branchId: BranchId,\n  commandId: CommandId,\n  participantId: ParticipantId,\n  name: Schema.NonEmptyString,\n  args: Schema.String,\n  target: Schema.String\n}) {}\n\n/**\n * Schema for a capability-bearing command submission.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport const SubmitRequest = Schema.Struct({ capability: ShareCapability, submission: CommandSubmission })\n\n/**\n * A capability-bearing command submission.\n *\n * @category models\n * @since 0.1.0\n */\nexport type SubmitRequest = typeof SubmitRequest.Type\n\n/**\n * The durable payload stored for an admitted command.\n *\n * Distinct from the wire request: `args` and `target` carry decoding defaults,\n * so a row written before those fields existed still decodes rather than\n * failing the whole ledger rebuild.\n *\n * `capabilityId` is the verified id of the share capability that submitted the\n * command, stamped by `BranchCommands.submit` and never read from the client.\n * `participantId` is whatever the client claimed, so attribute a command to\n * its `capabilityId`. A row admitted before the field existed decodes with\n * `\"\"`, which no capability can carry.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class CommandEventPayload extends Schema.Class<CommandEventPayload>(\n  \"@smthrs/sync/BranchProtocol/CommandEventPayload\"\n)({\n  commandId: CommandId,\n  participantId: ParticipantId,\n  name: Schema.NonEmptyString,\n  args: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(\"\"))),\n  target: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(\"\"))),\n  capabilityId: Schema.String.pipe(Schema.withDecodingDefaultKey(Effect.succeed(\"\")))\n}) {}\n\n/**\n * The command that appends a collaborative chat message.\n *\n * @category models\n * @since 0.1.0\n */\nexport const SayCommand = \"branch.say\"\n\n/**\n * Schema for the outcome of admitting a command.\n *\n * `duplicate` is a success, not a failure: it reports the canonical sequence\n * the original submission already occupies so a retransmitting client can\n * settle its optimistic row instead of executing the command twice.\n *\n * @category schemas\n * @since 0.1.0\n */\nexport class CommandReceipt extends Schema.Class<CommandReceipt>(\"@smthrs/sync/BranchProtocol/CommandReceipt\")({\n  branchId: BranchId,\n  commandId: CommandId,\n  status: Schema.Literals([\"admitted\", \"duplicate\"]),\n  seq: JournalEvent.Seq\n}) {}\n"],
+  "mappings": "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",
+  "names": []
+}