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

package/dist/cjs/BranchProjection.d.ts

@@ -0,0 +1,179 @@
+/**
+ * The branch document projection: journal entries folded into what two people
+ * looking at the same branch must agree on.
+ *
+ * The fold is order-independent over the canonical entry set, which is what
+ * makes convergence a property rather than a hope: any two clients that have
+ * applied the same set of entries hold the same state, regardless of the
+ * order their transports delivered frames in or how many times a frame
+ * arrived.
+ *
+ * Three guards do all the work, and each is a production invariant:
+ *
+ * - entries from another branch's run are ignored, so a mis-routed frame can
+ *   never leak into a projection;
+ * - an entry already folded — the cursor tip redelivered, or a command id
+ *   already applied — is ignored, so an at-least-once transport cannot
+ *   double-apply a user action and a reconnect replays no side effects;
+ * - an entry below the cursor whose command was never applied is folded into
+ *   its canonical `seq` position, so out-of-order delivery converges on the
+ *   same document instead of permanently dropping the late entry.
+ *
+ * @since 0.1.0
+ */
+import * as JournalEvent from "@smthrs/journal/JournalEvent";
+import * as Schema from "effect/Schema";
+import { BranchId } from "./BranchProtocol.ts";
+/**
+ * One collaborative chat message in the branch timeline.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Message: Schema.Struct<{
+    readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+    readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    /** The verified share capability that submitted the message. */
+    readonly capabilityId: Schema.String;
+    readonly text: Schema.String;
+}>;
+/**
+ * The value form of {@link Message}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Message = typeof Message.Type;
+/**
+ * One command applied to the branch document.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const AppliedCommand: Schema.Struct<{
+    readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+    readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    /** The verified share capability that submitted the command. */
+    readonly capabilityId: Schema.String;
+    readonly name: Schema.NonEmptyString;
+    readonly args: Schema.String;
+    readonly target: Schema.String;
+}>;
+/**
+ * The value form of {@link AppliedCommand}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type AppliedCommand = typeof AppliedCommand.Type;
+/**
+ * The current winning value of one durably edited shared field.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const Field: Schema.Struct<{
+    readonly target: Schema.NonEmptyString;
+    readonly value: Schema.String;
+    readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+    readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+    /** The verified share capability that wrote the winning value. */
+    readonly capabilityId: Schema.String;
+}>;
+/**
+ * The value form of {@link Field}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type Field = typeof Field.Type;
+/**
+ * The projected state of one branch document.
+ *
+ * `seq` is the highest journal sequence folded in and is exactly the cursor a
+ * client resumes from.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export declare const State: Schema.Struct<{
+    readonly branchId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/BranchId">;
+    readonly seq: Schema.Int;
+    readonly messages: Schema.$Array<Schema.Struct<{
+        readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+        readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+        readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+        /** The verified share capability that submitted the message. */
+        readonly capabilityId: Schema.String;
+        readonly text: Schema.String;
+    }>>;
+    readonly commands: Schema.$Array<Schema.Struct<{
+        readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+        readonly commandId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/CommandId">;
+        readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+        /** The verified share capability that submitted the command. */
+        readonly capabilityId: Schema.String;
+        readonly name: Schema.NonEmptyString;
+        readonly args: Schema.String;
+        readonly target: Schema.String;
+    }>>;
+    readonly fields: Schema.$Array<Schema.Struct<{
+        readonly target: Schema.NonEmptyString;
+        readonly value: Schema.String;
+        readonly seq: Schema.brand<Schema.Int, "@smthrs/journal/JournalEvent/Seq">;
+        readonly participantId: Schema.brand<Schema.NonEmptyString, "@smthrs/sync/BranchProtocol/ParticipantId">;
+        /** The verified share capability that wrote the winning value. */
+        readonly capabilityId: Schema.String;
+    }>>;
+}>;
+/**
+ * The value form of {@link State}.
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type State = typeof State.Type;
+/**
+ * The empty projection of a branch, whose cursor is "nothing applied".
+ *
+ * @category constructors
+ * @since 0.1.0
+ */
+export declare const empty: (branchId: BranchId) => State;
+/**
+ * The conflict policy for two durable edits of the same field.
+ *
+ * Highest canonical sequence wins. Within a branch the sequence is a total
+ * order assigned by the journal, so this is already decisive; the
+ * lexicographic `participantId` tie-break exists so the policy stays total if
+ * a future deployment ever merges two sequence domains. It is deliberately not
+ * wall-clock based — client clocks disagree, and a merge rule that depends on
+ * them is not deterministic.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const resolveField: (existing: Field | undefined, candidate: Field) => Field;
+/**
+ * Folds one journal entry into a branch projection.
+ *
+ * Redelivery and out-of-order delivery are told apart by identity, not by
+ * position: the cursor tip redelivered and a command id already applied are
+ * no-ops, while a below-cursor entry never applied is folded into canonical
+ * order. Non-command entries only raise the cursor, so re-applying one is
+ * idempotent by construction.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const apply: (state: State, entry: JournalEvent.Entry) => State;
+/**
+ * Folds a whole entry stream into a branch projection.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const project: (branchId: BranchId, entries: Iterable<JournalEvent.Entry>) => State;
+//# sourceMappingURL=BranchProjection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"BranchProjection.d.ts","sourceRoot":"","sources":["../../src/BranchProjection.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,YAAY,MAAM,8BAA8B,CAAA;AAG5D,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,EACL,QAAQ,EAOT,MAAM,qBAAqB,CAAA;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,OAAO;;;;IAIlB,gEAAgE;;;EAGhE,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,OAAO,GAAG,OAAO,OAAO,CAAC,IAAI,CAAA;AAEzC;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;IAIzB,gEAAgE;;;;;EAKhE,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC,IAAI,CAAA;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;IAKhB,kEAAkE;;EAElE,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK;;;;;;;QAnEhB,gEAAgE;;;;;;;;QAsBhE,gEAAgE;;;;;;;;;;;QAyBhE,kEAAkE;;;EA0BlE,CAAA;AACF;;;;;GAKG;AACH,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAC,IAAI,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,UAAU,QAAQ,KAAG,KAMzC,CAAA;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,UAAU,KAAK,GAAG,SAAS,EAAE,WAAW,KAAK,KAAG,KAI5E,CAAA;AAwCD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,KAAK,EAAE,OAAO,YAAY,CAAC,KAAK,KAAG,KAuC/D,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,UAAU,QAAQ,EAAE,SAAS,QAAQ,CAAC,YAAY,CAAC,KAAK,CAAC,KAAG,KA+CnF,CAAA"}

package/dist/cjs/BranchProjection.js

@@ -0,0 +1,197 @@
+"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 BranchProjection_exports = {};
+__export(BranchProjection_exports, {
+  AppliedCommand: () => AppliedCommand,
+  Field: () => Field,
+  Message: () => Message,
+  State: () => State,
+  apply: () => apply,
+  empty: () => empty,
+  project: () => project,
+  resolveField: () => resolveField
+});
+module.exports = __toCommonJS(BranchProjection_exports);
+var JournalEvent = __toESM(require("@smthrs/journal/JournalEvent"), 1);
+var HashSet = __toESM(require("effect/HashSet"), 1);
+var Option = __toESM(require("effect/Option"), 1);
+var Schema = __toESM(require("effect/Schema"), 1);
+var import_BranchProtocol = require("./BranchProtocol.js");
+const Message = Schema.Struct({
+  seq: JournalEvent.Seq,
+  commandId: import_BranchProtocol.CommandId,
+  participantId: import_BranchProtocol.ParticipantId,
+  /** The verified share capability that submitted the message. */
+  capabilityId: Schema.String,
+  text: Schema.String
+});
+const AppliedCommand = Schema.Struct({
+  seq: JournalEvent.Seq,
+  commandId: import_BranchProtocol.CommandId,
+  participantId: import_BranchProtocol.ParticipantId,
+  /** The verified share capability that submitted the command. */
+  capabilityId: Schema.String,
+  name: Schema.NonEmptyString,
+  args: Schema.String,
+  target: Schema.String
+});
+const Field = Schema.Struct({
+  target: Schema.NonEmptyString,
+  value: Schema.String,
+  seq: JournalEvent.Seq,
+  participantId: import_BranchProtocol.ParticipantId,
+  /** The verified share capability that wrote the winning value. */
+  capabilityId: Schema.String
+});
+const State = Schema.Struct({
+  branchId: import_BranchProtocol.BranchId,
+  seq: Schema.Int.check(Schema.isGreaterThanOrEqualTo(-1)),
+  messages: Schema.Array(Message),
+  commands: Schema.Array(AppliedCommand),
+  fields: Schema.Array(Field)
+});
+const empty = (branchId) => ({
+  branchId,
+  seq: -1,
+  messages: [],
+  commands: [],
+  fields: []
+});
+const resolveField = (existing, candidate) => {
+  if (existing === void 0) return candidate;
+  if (candidate.seq !== existing.seq) return candidate.seq > existing.seq ? candidate : existing;
+  return candidate.participantId > existing.participantId ? candidate : existing;
+};
+const insertBySeq = (items, item) => {
+  const last = items[items.length - 1];
+  if (last === void 0 || last.seq <= item.seq) return [...items, item];
+  let low = 0;
+  let high = items.length;
+  while (low < high) {
+    const middle = Math.floor((low + high) / 2);
+    if (items[middle].seq <= item.seq) low = middle + 1;
+    else high = middle;
+  }
+  const result = items.slice();
+  result.splice(low, 0, item);
+  return result;
+};
+const commandIds = /* @__PURE__ */ new WeakMap();
+const indexCommands = (commands) => {
+  const cached = commandIds.get(commands);
+  if (cached !== void 0) return cached;
+  const index = HashSet.fromIterable(commands.map((command) => command.commandId));
+  commandIds.set(commands, index);
+  return index;
+};
+const decodeCommand = Schema.decodeUnknownOption(import_BranchProtocol.CommandEventPayload);
+const apply = (state, entry) => {
+  if (entry.runId !== (0, import_BranchProtocol.branchRunId)(state.branchId) || entry.seq === state.seq) return state;
+  const advanced = entry.seq < state.seq ? state : { ...state, seq: entry.seq };
+  if (entry.eventType !== import_BranchProtocol.CommandEvent) return advanced;
+  const decoded = decodeCommand(entry.payload);
+  if (Option.isNone(decoded)) return advanced;
+  const commandSubmission = decoded.value;
+  const ids = indexCommands(state.commands);
+  if (HashSet.has(ids, commandSubmission.commandId)) return advanced;
+  const command = { ...commandSubmission, seq: entry.seq };
+  const messages = commandSubmission.name === import_BranchProtocol.SayCommand ? insertBySeq(state.messages, {
+    seq: entry.seq,
+    commandId: commandSubmission.commandId,
+    participantId: commandSubmission.participantId,
+    capabilityId: commandSubmission.capabilityId,
+    text: commandSubmission.args
+  }) : state.messages;
+  const fields = commandSubmission.target === "" ? state.fields : (() => {
+    const candidate = {
+      target: commandSubmission.target,
+      value: commandSubmission.args,
+      seq: entry.seq,
+      participantId: commandSubmission.participantId,
+      capabilityId: commandSubmission.capabilityId
+    };
+    const winner = resolveField(
+      state.fields.find((field) => field.target === commandSubmission.target),
+      candidate
+    );
+    return [...state.fields.filter((field) => field.target !== commandSubmission.target), winner].sort((left, right) => left.target < right.target ? -1 : 1);
+  })();
+  const commands = insertBySeq(state.commands, command);
+  commandIds.set(commands, HashSet.add(ids, command.commandId));
+  return { ...advanced, messages, commands, fields };
+};
+const project = (branchId, entries) => {
+  const runId = (0, import_BranchProtocol.branchRunId)(branchId);
+  let seq = -1;
+  const ids = /* @__PURE__ */ new Set();
+  const commands = [];
+  const messages = [];
+  const fields = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.runId !== runId || entry.seq === seq) continue;
+    seq = Math.max(seq, entry.seq);
+    if (entry.eventType !== import_BranchProtocol.CommandEvent) continue;
+    const decoded = decodeCommand(entry.payload);
+    if (Option.isNone(decoded)) continue;
+    const submission = decoded.value;
+    if (ids.has(submission.commandId)) continue;
+    ids.add(submission.commandId);
+    commands.push({ ...submission, seq: entry.seq });
+    if (submission.name === import_BranchProtocol.SayCommand) {
+      messages.push({
+        seq: entry.seq,
+        commandId: submission.commandId,
+        participantId: submission.participantId,
+        capabilityId: submission.capabilityId,
+        text: submission.args
+      });
+    }
+    if (submission.target !== "") {
+      const candidate = {
+        target: submission.target,
+        value: submission.args,
+        seq: entry.seq,
+        participantId: submission.participantId,
+        capabilityId: submission.capabilityId
+      };
+      fields.set(submission.target, resolveField(fields.get(submission.target), candidate));
+    }
+  }
+  commands.sort((left, right) => left.seq - right.seq);
+  messages.sort((left, right) => left.seq - right.seq);
+  commandIds.set(commands, HashSet.fromIterable(ids));
+  return {
+    branchId,
+    seq,
+    commands,
+    messages,
+    fields: Array.from(fields.values()).sort((left, right) => left.target < right.target ? -1 : 1)
+  };
+};
+//# sourceMappingURL=BranchProjection.js.map

package/dist/cjs/BranchProjection.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/BranchProjection.ts"],
+  "sourcesContent": ["/**\n * The branch document projection: journal entries folded into what two people\n * looking at the same branch must agree on.\n *\n * The fold is order-independent over the canonical entry set, which is what\n * makes convergence a property rather than a hope: any two clients that have\n * applied the same set of entries hold the same state, regardless of the\n * order their transports delivered frames in or how many times a frame\n * arrived.\n *\n * Three guards do all the work, and each is a production invariant:\n *\n * - entries from another branch's run are ignored, so a mis-routed frame can\n *   never leak into a projection;\n * - an entry already folded \u2014 the cursor tip redelivered, or a command id\n *   already applied \u2014 is ignored, so an at-least-once transport cannot\n *   double-apply a user action and a reconnect replays no side effects;\n * - an entry below the cursor whose command was never applied is folded into\n *   its canonical `seq` position, so out-of-order delivery converges on the\n *   same document instead of permanently dropping the late entry.\n *\n * @since 0.1.0\n */\n\nimport * as JournalEvent from \"@smthrs/journal/JournalEvent\"\nimport * as HashSet from \"effect/HashSet\"\nimport * as Option from \"effect/Option\"\nimport * as Schema from \"effect/Schema\"\nimport {\n  BranchId,\n  branchRunId,\n  CommandEvent,\n  CommandEventPayload,\n  CommandId,\n  ParticipantId,\n  SayCommand\n} from \"./BranchProtocol.ts\"\n\n/**\n * One collaborative chat message in the branch timeline.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Message = Schema.Struct({\n  seq: JournalEvent.Seq,\n  commandId: CommandId,\n  participantId: ParticipantId,\n  /** The verified share capability that submitted the message. */\n  capabilityId: Schema.String,\n  text: Schema.String\n})\n/**\n * The value form of {@link Message}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Message = typeof Message.Type\n\n/**\n * One command applied to the branch document.\n *\n * @category models\n * @since 0.1.0\n */\nexport const AppliedCommand = Schema.Struct({\n  seq: JournalEvent.Seq,\n  commandId: CommandId,\n  participantId: ParticipantId,\n  /** The verified share capability that submitted the command. */\n  capabilityId: Schema.String,\n  name: Schema.NonEmptyString,\n  args: Schema.String,\n  target: Schema.String\n})\n/**\n * The value form of {@link AppliedCommand}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type AppliedCommand = typeof AppliedCommand.Type\n\n/**\n * The current winning value of one durably edited shared field.\n *\n * @category models\n * @since 0.1.0\n */\nexport const Field = Schema.Struct({\n  target: Schema.NonEmptyString,\n  value: Schema.String,\n  seq: JournalEvent.Seq,\n  participantId: ParticipantId,\n  /** The verified share capability that wrote the winning value. */\n  capabilityId: Schema.String\n})\n/**\n * The value form of {@link Field}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type Field = typeof Field.Type\n\n/**\n * The projected state of one branch document.\n *\n * `seq` is the highest journal sequence folded in and is exactly the cursor a\n * client resumes from.\n *\n * @category models\n * @since 0.1.0\n */\nexport const State = Schema.Struct({\n  branchId: BranchId,\n  seq: Schema.Int.check(Schema.isGreaterThanOrEqualTo(-1)),\n  messages: Schema.Array(Message),\n  commands: Schema.Array(AppliedCommand),\n  fields: Schema.Array(Field)\n})\n/**\n * The value form of {@link State}.\n *\n * @category models\n * @since 0.1.0\n */\nexport type State = typeof State.Type\n\n/**\n * The empty projection of a branch, whose cursor is \"nothing applied\".\n *\n * @category constructors\n * @since 0.1.0\n */\nexport const empty = (branchId: BranchId): State => ({\n  branchId,\n  seq: -1,\n  messages: [],\n  commands: [],\n  fields: []\n})\n\n/**\n * The conflict policy for two durable edits of the same field.\n *\n * Highest canonical sequence wins. Within a branch the sequence is a total\n * order assigned by the journal, so this is already decisive; the\n * lexicographic `participantId` tie-break exists so the policy stays total if\n * a future deployment ever merges two sequence domains. It is deliberately not\n * wall-clock based \u2014 client clocks disagree, and a merge rule that depends on\n * them is not deterministic.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const resolveField = (existing: Field | undefined, candidate: Field): Field => {\n  if (existing === undefined) return candidate\n  if (candidate.seq !== existing.seq) return candidate.seq > existing.seq ? candidate : existing\n  return candidate.participantId > existing.participantId ? candidate : existing\n}\n\n/**\n * Inserts one item into a sequence-ordered array at its canonical position.\n *\n * Canonical sequences are unique within a run, so an equal-sequence collision\n * is unrepresentable here: dedup happens before insertion.\n */\nconst insertBySeq = <Item extends { readonly seq: JournalEvent.Seq }>(\n  items: ReadonlyArray<Item>,\n  item: Item\n): Array<Item> => {\n  const last = items[items.length - 1]\n  if (last === undefined || last.seq <= item.seq) return [...items, item]\n  let low = 0\n  let high = items.length\n  while (low < high) {\n    const middle = Math.floor((low + high) / 2)\n    if (items[middle]!.seq <= item.seq) low = middle + 1\n    else high = middle\n  }\n  const result = items.slice()\n  result.splice(low, 0, item)\n  return result\n}\n\n// Cache by the immutable command array so cursor-only updates share the index.\n// Persistent sets let independent continuations share history without changing\n// an older state's deduplication. Restored states build their index on first use.\nconst commandIds = new WeakMap<ReadonlyArray<AppliedCommand>, HashSet.HashSet<CommandId>>()\nconst indexCommands = (commands: ReadonlyArray<AppliedCommand>): HashSet.HashSet<CommandId> => {\n  const cached = commandIds.get(commands)\n  if (cached !== undefined) return cached\n  const index = HashSet.fromIterable(commands.map((command) => command.commandId))\n  commandIds.set(commands, index)\n  return index\n}\n\nconst decodeCommand = Schema.decodeUnknownOption(CommandEventPayload)\n\n/**\n * Folds one journal entry into a branch projection.\n *\n * Redelivery and out-of-order delivery are told apart by identity, not by\n * position: the cursor tip redelivered and a command id already applied are\n * no-ops, while a below-cursor entry never applied is folded into canonical\n * order. Non-command entries only raise the cursor, so re-applying one is\n * idempotent by construction.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const apply = (state: State, entry: JournalEvent.Entry): State => {\n  if (entry.runId !== branchRunId(state.branchId) || entry.seq === state.seq) return state\n  const advanced = entry.seq < state.seq ? state : { ...state, seq: entry.seq }\n  if (entry.eventType !== CommandEvent) return advanced\n  const decoded = decodeCommand(entry.payload)\n  if (Option.isNone(decoded)) return advanced\n  const commandSubmission = decoded.value\n  const ids = indexCommands(state.commands)\n  if (HashSet.has(ids, commandSubmission.commandId)) return advanced\n  const command: AppliedCommand = { ...commandSubmission, seq: entry.seq }\n  const messages = commandSubmission.name === SayCommand\n    ? insertBySeq(state.messages, {\n      seq: entry.seq,\n      commandId: commandSubmission.commandId,\n      participantId: commandSubmission.participantId,\n      capabilityId: commandSubmission.capabilityId,\n      text: commandSubmission.args\n    })\n    : state.messages\n  const fields = commandSubmission.target === \"\"\n    ? state.fields\n    : (() => {\n      const candidate: Field = {\n        target: commandSubmission.target,\n        value: commandSubmission.args,\n        seq: entry.seq,\n        participantId: commandSubmission.participantId,\n        capabilityId: commandSubmission.capabilityId\n      }\n      const winner = resolveField(\n        state.fields.find((field) => field.target === commandSubmission.target),\n        candidate\n      )\n      return [...state.fields.filter((field) => field.target !== commandSubmission.target), winner]\n        .sort((left, right) => left.target < right.target ? -1 : 1)\n    })()\n  const commands = insertBySeq(state.commands, command)\n  commandIds.set(commands, HashSet.add(ids, command.commandId))\n  return { ...advanced, messages, commands, fields }\n}\n\n/**\n * Folds a whole entry stream into a branch projection.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const project = (branchId: BranchId, entries: Iterable<JournalEvent.Entry>): State => {\n  const runId = branchRunId(branchId)\n  let seq = -1\n  const ids = new Set<CommandId>()\n  const commands: Array<AppliedCommand> = []\n  const messages: Array<Message> = []\n  const fields = new Map<string, Field>()\n  for (const entry of entries) {\n    if (entry.runId !== runId || entry.seq === seq) continue\n    seq = Math.max(seq, entry.seq)\n    if (entry.eventType !== CommandEvent) continue\n    const decoded = decodeCommand(entry.payload)\n    if (Option.isNone(decoded)) continue\n    const submission = decoded.value\n    if (ids.has(submission.commandId)) continue\n    ids.add(submission.commandId)\n    commands.push({ ...submission, seq: entry.seq })\n    if (submission.name === SayCommand) {\n      messages.push({\n        seq: entry.seq,\n        commandId: submission.commandId,\n        participantId: submission.participantId,\n        capabilityId: submission.capabilityId,\n        text: submission.args\n      })\n    }\n    if (submission.target !== \"\") {\n      const candidate: Field = {\n        target: submission.target,\n        value: submission.args,\n        seq: entry.seq,\n        participantId: submission.participantId,\n        capabilityId: submission.capabilityId\n      }\n      fields.set(submission.target, resolveField(fields.get(submission.target), candidate))\n    }\n  }\n  commands.sort((left, right) => left.seq - right.seq)\n  messages.sort((left, right) => left.seq - right.seq)\n  commandIds.set(commands, HashSet.fromIterable(ids))\n  return {\n    branchId,\n    seq,\n    commands,\n    messages,\n    fields: Array.from(fields.values()).sort((left, right) => left.target < right.target ? -1 : 1)\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}