@941design/marmot 0.0.0-stage → 0.2.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (192) hide show
  1. package/CHANGELOG.md +709 -0
  2. package/LICENSE +21 -0
  3. package/README.md +33 -2
  4. package/dist/account/admin.d.ts +72 -0
  5. package/dist/account/admin.js +209 -0
  6. package/dist/account/device-deps.d.ts +379 -0
  7. package/dist/account/device-deps.js +36 -0
  8. package/dist/account/device-lineage.d.ts +199 -0
  9. package/dist/account/device-lineage.js +390 -0
  10. package/dist/account/device-registry.d.ts +93 -0
  11. package/dist/account/device-registry.js +1290 -0
  12. package/dist/account/device-rotation.d.ts +61 -0
  13. package/dist/account/device-rotation.js +827 -0
  14. package/dist/account/enrolment.d.ts +339 -0
  15. package/dist/account/enrolment.js +1247 -0
  16. package/dist/account/identity-proof.d.ts +79 -0
  17. package/dist/account/identity-proof.js +264 -0
  18. package/dist/account/index.d.ts +17 -0
  19. package/dist/account/index.js +16 -0
  20. package/dist/account/restore-rotation.d.ts +21 -0
  21. package/dist/account/restore-rotation.js +22 -0
  22. package/dist/account/same-account-authorization.d.ts +86 -0
  23. package/dist/account/same-account-authorization.js +180 -0
  24. package/dist/account/teardown.d.ts +127 -0
  25. package/dist/account/teardown.js +856 -0
  26. package/dist/client/before-create-group.d.ts +18 -0
  27. package/dist/client/before-create-group.js +65 -0
  28. package/dist/client/before-publish-hooks.d.ts +121 -0
  29. package/dist/client/before-publish-hooks.js +180 -0
  30. package/dist/client/client-config.d.ts +42 -0
  31. package/dist/client/client-config.js +13 -0
  32. package/dist/client/commit-redrive.d.ts +68 -0
  33. package/dist/client/commit-redrive.js +221 -0
  34. package/dist/client/component-update.d.ts +43 -0
  35. package/dist/client/component-update.js +53 -0
  36. package/dist/client/confirm-hooks.d.ts +50 -0
  37. package/dist/client/confirm-hooks.js +59 -0
  38. package/dist/client/create-client.d.ts +1022 -0
  39. package/dist/client/create-client.js +1125 -0
  40. package/dist/client/group-disband.d.ts +28 -0
  41. package/dist/client/group-disband.js +64 -0
  42. package/dist/client/group-history.d.ts +435 -0
  43. package/dist/client/group-history.js +1295 -0
  44. package/dist/client/group-profile.d.ts +31 -0
  45. package/dist/client/group-profile.js +62 -0
  46. package/dist/client/group-records.d.ts +485 -0
  47. package/dist/client/group-records.js +1034 -0
  48. package/dist/client/group-removal.d.ts +36 -0
  49. package/dist/client/group-removal.js +127 -0
  50. package/dist/client/group-remove-member.d.ts +49 -0
  51. package/dist/client/group-remove-member.js +163 -0
  52. package/dist/client/group-runtime.d.ts +388 -0
  53. package/dist/client/group-runtime.js +2701 -0
  54. package/dist/client/group-snapshot.d.ts +98 -0
  55. package/dist/client/group-snapshot.js +453 -0
  56. package/dist/client/history-pages.d.ts +107 -0
  57. package/dist/client/history-pages.js +194 -0
  58. package/dist/client/inbox-send.d.ts +19 -0
  59. package/dist/client/inbox-send.js +71 -0
  60. package/dist/client/index.d.ts +21 -0
  61. package/dist/client/index.js +13 -0
  62. package/dist/client/ingest.d.ts +82 -0
  63. package/dist/client/ingest.js +1550 -0
  64. package/dist/client/lifecycle-events.d.ts +63 -0
  65. package/dist/client/lifecycle-events.js +35 -0
  66. package/dist/client/opaque-candidates.d.ts +81 -0
  67. package/dist/client/opaque-candidates.js +169 -0
  68. package/dist/client/own-change-outbox.d.ts +66 -0
  69. package/dist/client/own-change-outbox.js +156 -0
  70. package/dist/client/pending-leaf.d.ts +116 -0
  71. package/dist/client/pending-leaf.js +378 -0
  72. package/dist/client/permissions.d.ts +9 -0
  73. package/dist/client/permissions.js +12 -0
  74. package/dist/client/pipeline.d.ts +554 -0
  75. package/dist/client/pipeline.js +3545 -0
  76. package/dist/client/reentrancy-guard.d.ts +96 -0
  77. package/dist/client/reentrancy-guard.js +153 -0
  78. package/dist/client/rekey.d.ts +58 -0
  79. package/dist/client/rekey.js +149 -0
  80. package/dist/client/transport-policy.d.ts +181 -0
  81. package/dist/client/transport-policy.js +214 -0
  82. package/dist/history/equivocation.d.ts +55 -0
  83. package/dist/history/equivocation.js +113 -0
  84. package/dist/history/fencing.d.ts +25 -0
  85. package/dist/history/fencing.js +61 -0
  86. package/dist/history/hex.d.ts +3 -0
  87. package/dist/history/hex.js +10 -0
  88. package/dist/history/index.d.ts +73 -0
  89. package/dist/history/index.js +31 -0
  90. package/dist/history/notifications.d.ts +270 -0
  91. package/dist/history/notifications.js +264 -0
  92. package/dist/history/ordering-key.d.ts +24 -0
  93. package/dist/history/ordering-key.js +101 -0
  94. package/dist/history/own-change-fork.d.ts +112 -0
  95. package/dist/history/own-change-fork.js +196 -0
  96. package/dist/history/own-change.d.ts +106 -0
  97. package/dist/history/own-change.js +146 -0
  98. package/dist/history/policy.d.ts +48 -0
  99. package/dist/history/policy.js +52 -0
  100. package/dist/history/retained-window.d.ts +215 -0
  101. package/dist/history/retained-window.js +565 -0
  102. package/dist/inbox/demux.d.ts +90 -0
  103. package/dist/inbox/demux.js +78 -0
  104. package/dist/inbox/handler-registry.d.ts +42 -0
  105. package/dist/inbox/handler-registry.js +37 -0
  106. package/dist/inbox/index.d.ts +11 -0
  107. package/dist/inbox/index.js +10 -0
  108. package/dist/inbox/seen-set.d.ts +82 -0
  109. package/dist/inbox/seen-set.js +202 -0
  110. package/dist/inbox/subscription.d.ts +236 -0
  111. package/dist/inbox/subscription.js +644 -0
  112. package/dist/index.d.ts +10 -0
  113. package/dist/index.js +9 -0
  114. package/dist/invitations/competing-welcome.d.ts +223 -0
  115. package/dist/invitations/competing-welcome.js +128 -0
  116. package/dist/invitations/decline.d.ts +61 -0
  117. package/dist/invitations/decline.js +143 -0
  118. package/dist/invitations/expect-welcome.d.ts +66 -0
  119. package/dist/invitations/expect-welcome.js +138 -0
  120. package/dist/invitations/index.d.ts +16 -0
  121. package/dist/invitations/index.js +16 -0
  122. package/dist/invitations/invite.d.ts +303 -0
  123. package/dist/invitations/invite.js +966 -0
  124. package/dist/invitations/offers.d.ts +79 -0
  125. package/dist/invitations/offers.js +115 -0
  126. package/dist/invitations/on-proposal.d.ts +47 -0
  127. package/dist/invitations/on-proposal.js +40 -0
  128. package/dist/invitations/pending-proposal-policy.d.ts +52 -0
  129. package/dist/invitations/pending-proposal-policy.js +139 -0
  130. package/dist/invitations/proposal-deadline.d.ts +133 -0
  131. package/dist/invitations/proposal-deadline.js +164 -0
  132. package/dist/invitations/relay-planes.d.ts +43 -0
  133. package/dist/invitations/relay-planes.js +70 -0
  134. package/dist/invitations/welcome-processor.d.ts +253 -0
  135. package/dist/invitations/welcome-processor.js +1180 -0
  136. package/dist/key-packages/device-key.d.ts +131 -0
  137. package/dist/key-packages/device-key.js +272 -0
  138. package/dist/key-packages/device-rotation-records.d.ts +83 -0
  139. package/dist/key-packages/device-rotation-records.js +173 -0
  140. package/dist/key-packages/group-refs.d.ts +40 -0
  141. package/dist/key-packages/group-refs.js +79 -0
  142. package/dist/key-packages/index.d.ts +18 -0
  143. package/dist/key-packages/index.js +18 -0
  144. package/dist/key-packages/key-package-ref.d.ts +16 -0
  145. package/dist/key-packages/key-package-ref.js +21 -0
  146. package/dist/key-packages/observation-stream.d.ts +4 -0
  147. package/dist/key-packages/observation-stream.js +120 -0
  148. package/dist/key-packages/offer-rumor.d.ts +26 -0
  149. package/dist/key-packages/offer-rumor.js +69 -0
  150. package/dist/key-packages/publisher.d.ts +174 -0
  151. package/dist/key-packages/publisher.js +1247 -0
  152. package/dist/key-packages/select-key-package.d.ts +24 -0
  153. package/dist/key-packages/select-key-package.js +90 -0
  154. package/dist/key-packages/slot-manager.d.ts +167 -0
  155. package/dist/key-packages/slot-manager.js +327 -0
  156. package/dist/key-packages/validate-key-package-event.d.ts +3 -0
  157. package/dist/key-packages/validate-key-package-event.js +49 -0
  158. package/dist/media/cache.d.ts +14 -0
  159. package/dist/media/cache.js +10 -0
  160. package/dist/media/index.d.ts +52 -0
  161. package/dist/media/index.js +71 -0
  162. package/dist/mls.d.ts +15 -0
  163. package/dist/mls.js +15 -0
  164. package/dist/shared/account-pubkey.d.ts +4 -0
  165. package/dist/shared/account-pubkey.js +10 -0
  166. package/dist/shared/errors.d.ts +21 -0
  167. package/dist/shared/errors.js +85 -0
  168. package/dist/shared/hex.d.ts +4 -0
  169. package/dist/shared/hex.js +13 -0
  170. package/dist/shared/index.d.ts +14 -0
  171. package/dist/shared/index.js +14 -0
  172. package/dist/shared/kinds.d.ts +8 -0
  173. package/dist/shared/kinds.js +28 -0
  174. package/dist/shared/publish-classification.d.ts +26 -0
  175. package/dist/shared/publish-classification.js +31 -0
  176. package/dist/storage/envelope.d.ts +39 -0
  177. package/dist/storage/envelope.js +201 -0
  178. package/dist/storage/index.d.ts +227 -0
  179. package/dist/storage/index.js +459 -0
  180. package/dist/storage/indexeddb/idb-types.d.ts +68 -0
  181. package/dist/storage/indexeddb/idb-types.js +1 -0
  182. package/dist/storage/indexeddb/index.d.ts +17 -0
  183. package/dist/storage/indexeddb/index.js +141 -0
  184. package/dist/storage/lease.d.ts +41 -0
  185. package/dist/storage/lease.js +117 -0
  186. package/dist/storage/memory/deterministic-signer.d.ts +27 -0
  187. package/dist/storage/memory/deterministic-signer.js +65 -0
  188. package/dist/storage/memory/index.d.ts +32 -0
  189. package/dist/storage/memory/index.js +87 -0
  190. package/dist/storage/memory/lock-manager.d.ts +8 -0
  191. package/dist/storage/memory/lock-manager.js +71 -0
  192. package/package.json +66 -3
package/CHANGELOG.md ADDED
@@ -0,0 +1,709 @@
1
+ # @941design/marmot
2
+
3
+ ## 0.2.0-alpha.0
4
+
5
+ ### Minor Changes
6
+
7
+ - c425a58: The engine stamp stored envelopes are compared against is now a stored-state format, `ENGINE_VERSION = "state.<N>"`
8
+ (`ENGINE_STATE_FORMAT`), instead of a digest of the engine code; the code identity moves to the new `ENGINE_BUILD`.
9
+ Engine changes that leave stored state reading the same (a comment, a read-only accessor) no longer refuse every store;
10
+ `state-format-ledger.json` and a test force a recorded decision on each code change.
11
+ This change itself moves the stamp once: stores written by earlier builds are refused with `storeIncompatible`.
12
+ - c538b1a: Generic client extension points for `account-sync`:
13
+
14
+ - `ConfirmContext` gains `snapshot: GroupSnapshot` — an opaque, branded `Storable` in marmot's versioned
15
+ envelope holding what `groups.restore` needs to resume as that leaf (state, retained rewind window, index
16
+ `createdAt`, cursor floor; restorable only by the same engine + ts-mls build). It is built lazily on first
17
+ read and readable only while the hook runs (`transaction-closed` afterwards) — and `kind` becomes the new
18
+ `ConfirmKind` (`GroupIntent['type'] | 'create' | 'join'`). `onConfirm` hooks now also run inside
19
+ `groups.create`'s persisting transaction (`kind: 'create'`) and inside a Welcome adoption's
20
+ (`kind: 'join'`), with `intentId` = group id and no notifications; a hook throw aborts the creation or
21
+ adoption like a confirmation. **Behaviour change:** a hook registered before `groups.create` now runs for
22
+ the creation too.
23
+ - `groups.restore(groupId, snapshot)`: adopts a snapshot, replays the group's commits from its relays,
24
+ commits a self-update and resolves the handle once that self-update is confirmed; a fence, teardown or
25
+ dispose ends it at once and removes the adopted group. After a dispose or crash mid-restore the next client
26
+ over the same stores resumes the unfinished adoption (marked by the group extension `marmot.restorePending`)
27
+ on its own — a startup scan, or any access — re-publishing a recorded self-update byte-identically and
28
+ confirming it, or committing a fresh one; the group is discarded only when that self-update goes terminal for
29
+ good or the group is fenced. `groups.list()` skips a group being restored, and a
30
+ Welcome for it is deferred (`inboxDisposition` `pending`, invitation kept `joining`, never blocking the inbox)
31
+ and completed by the inbox pass the restore's settling runs. A second `groups.restore` while a failed one is still
32
+ being taken back rejects `commit-pending` (`reason: 'restore-ending'`, retryable). New error code `already-member`.
33
+ A snapshot whose rewind window carries, as a link, anything but a framed MLS Commit (e.g. a genuine application
34
+ message with its true digest) is refused `envelope-mismatch` (`reason: 'malformed'`) before anything is written.
35
+ - `groups.restore` and `extensions.sendInboxRumor` reject `reentrant` from inside a group's `onConfirm` hook.
36
+ - `extensions.sendInboxRumor({ to, rumor })`: one gift-wrapped rumor to a recipient's inbox relays through
37
+ the budgeted signer, `{ status: 'delivered' | 'retryable' | 'failed', reason?, relays? }`; refuses
38
+ `RUMOR_KINDS` with `reserved-kind`; persists nothing.
39
+ - New public types `GroupSnapshot`, `ConfirmKind`, `InboxRumorDelivery`.
40
+ - 74bc747: The branch-aware own-leaf fence's hidden-credit policy defaults to anchored-zero: a clone of this
41
+ device's own leaf can no longer fence the real device by publishing a burst it cannot read, as long as canonical
42
+ carries another member's commit after the fork. The residual — members who followed the clone — is reported by the
43
+ device's `leaf-equivocation` record. No wire or stored-format change.
44
+ - e77d367: `extensions.onBeforePublish(hook)` — a pre-publish extension point for an own `commit` / `self-update`:
45
+
46
+ - The hook runs between the commit's staging and its first publish, once per staged envelope, in its own
47
+ group-store transaction (a throw rolls back only that hook's writes), handed a `BeforePublishContext`
48
+ (`{ groupId, intentId, kind, epoch, commit: { eventId, digest, parentTag, tag }, tx, snapshot, forgetting?,
49
+ resumed }`). After a crash between staging and the publish the resume path runs it again (`resumed: true`);
50
+ hooks must be idempotent per `commit.digest`. It never runs for application messages, proposals,
51
+ `groups.create`, a Welcome adoption, a foreign commit's ingest or the `groups.restore` adoption itself.
52
+ - `ctx.snapshot` is a **pending-tagged `GroupSnapshot`** of the state the commit produces (payload kind
53
+ `marmot.groupSnapshot.pending`, carrying `pending: { digest, parentTag }`; its window's tip edge is the commit
54
+ from its parent). A build that predates it refuses such a snapshot (`envelope-mismatch`), and
55
+ `groups.restore` rejects an inconsistent pending payload before anything is written. `ConfirmContext.snapshot`
56
+ is unchanged (today's kind, never pending-tagged). `groups.restore` resolves the marker (see the
57
+ `groups.restore` pending-snapshot entry).
58
+ - A hook may return a `PublishBarrier` — the commit's first publish waits for it, best-effort and bounded: all
59
+ barriers run concurrently under one deadline `options.beforePublishTimeoutMs` (new, integer >= 1, default
60
+ 10 000 ms); a rejection or the deadline abandons a barrier (its `AbortSignal` fires) and the commit is
61
+ published anyway, reported by the new `beforePublishSkipped` client event
62
+ (`reason: 'hook-error' | 'barrier-failed' | 'barrier-timeout'`).
63
+ - `onBeforePublish` is a guarded consumer surface: from inside the hook or the barrier, mutating group
64
+ operations, `groups.restore`, `devices.*` and `extensions.sendInboxRumor` reject `reentrant`.
65
+
66
+ With no hook registered, behaviour is unchanged.
67
+ - 5ee090c: Branch-aware own-leaf fence: the own-leaf fence of
68
+ `groups.restore` and of every sync is now branch-aware — the group is fenced only whenever the opaque branch could win.
69
+
70
+ `@941design/marmot` opts in to the engine seam (`branchAwareFence`, a single literal beside `equivocationCredit` in
71
+ `group-runtime.ts`). A device whose state predates a commit of its own leaf that it cannot open used to be fenced the
72
+ moment it met one; it is now fenced only if the best case of that unreadable branch could still be the canonical one.
73
+ A snapshot taken before an own commit that lost a same-epoch race — canonical won it, deeper or by the tiebreak,
74
+ and holds no own-leaf commit after the snapshot — is restored unfenced onto the canonical tip, with `U = 0` and
75
+ mutual decryption, whichever of the two competing commits the history batch lists first (a restore whose own commit
76
+ won the race, or that a later own commit of the leaf followed — e.g. a re-driven self-update — stays `fenced`, as does
77
+ a sole member's). The `groups.restore` documentation says so: `fenced` reads "whenever the opaque branch
78
+ could win".
79
+
80
+ - **Conservative default policy, pending a decision.** The hidden-credit policy is one constant,
81
+ `MARMOT_HIDDEN_CREDIT_POLICY = 'conservative'` (`history/policy.ts`); it is not a public client option. Under it
82
+ the goal — the real device staying unfenced after a cloned-leaf burst — is not met against a
83
+ deliberate attacker (the device is fenced and still records the `leaf-equivocation`); the `anchored-zero` policy
84
+ would meet it, and flipping the default after that decision is that one constant.
85
+ - **New persisted group extension `marmot.opaque`.** The engine's held candidates and the group's undecryptable
86
+ count `U` are persisted in the batch transaction that ledgers the provisional `skipped`, restored on load and on
87
+ reload and handed to every rebuilt engine (gate and fence rollbacks included). A fence deletes the record in its
88
+ own transaction; with the engine seam off nothing is ever written. The record is unbounded in `U` and rewritten
89
+ whole on a change.
90
+ - **Fail closed.** A stored `marmot.opaque` record that fails validation, or that the engine refuses, FENCES the group
91
+ on load and on reload — reading it as "nothing held" would forget a candidate that may still win, handing it on
92
+ would brick the load.
93
+ - **Pre-join history and batches.** Groups whose history fetch carries envelopes the device can never open —
94
+ the pre-join history of a late joiner, junk — carry a high `U` and fall back to today's fence, even for a lost race
95
+ with no re-drive. The verdict is taken on the whole call: `group.ingest(events)` and a sync pass's history window
96
+ hand the engine their events one at a time and settle once at the end (batch settle), so the order of the events in
97
+ one call does not matter. Residuals: live delivery is one event per call, so a lone own-leaf commit that arrives
98
+ alone is fenced on arrival (sound for what the device has received; a fence is terminal), and a history walk that
99
+ spans several windows decides each window as its own batch.
100
+
101
+ - **A fence decided by a call is taken at its end.** `group.ingest(events)` and a sync window settle once, after
102
+ every event of the call was stepped: the call's earlier events stay applied (application messages are delivered),
103
+ its other events keep their own dispositions, and every later call is `fenced`. Before the batch settle a fence
104
+ rolled back what the same drain had applied.
105
+
106
+ A new engine patch set changes `ENGINE_VERSION`: every store written by an earlier build is refused with
107
+ `storeIncompatible` (`envelope-mismatch`) and can be recovered by a wipe. See the `@941design/marmot-engine` changeset
108
+ for the engine side.
109
+ - 3182df9: `ConfirmContext` gains an optional `forgetting: { leafKeys }`. It is
110
+ set only on the confirmation of the Remove commit `devices.forget` issues in a
111
+ group — the signature keys of the leaves it removes — and omitted on every
112
+ other confirmation. `deviceForgotten` fires only once every group of the forget
113
+ settled, after this confirmation's hooks ran (and scheduled their publishes), so
114
+ the flag lets an `onConfirm` hook act on the forget before anything of that
115
+ confirmation leaves the device.
116
+ - cf51538: A second Welcome for a group the device holds is classified and decided. The
117
+ decision is the members' own rule, `compareBranchScores` over (epoch, committer, commit digest), where the competing
118
+ side's digest is the Welcome's `commit` tag; nothing switches a group yet (the group runtime implements the ports in
119
+ a later change), so a client without the ports keeps the earlier `already-member` answer.
120
+
121
+ - New pure `decideCompetingWelcome` / `judgeCompetingWelcome(held, competing)` answering `keep`, `switch` or
122
+ `undecidable` (with the reason a Welcome is kept: `same-branch`, `lower-epoch`, `same-lineage`,
123
+ `sponsor-not-a-member`, `beyond-horizon`, `lower-ranked`; `switch-failed` and `expired` end a record). A missing digest or committer at the step that needs it is
124
+ `undecidable`, never `switch`.
125
+ - `WelcomeServiceDeps.graceWindowMs` and `WelcomeServiceDeps.competing` (optional `CompetingWelcomePorts`: `competingGate`, `heldBranch`, `rebaseToWelcome`,
126
+ `onBranchSwitched`) and an optional fourth argument `joinEvidence` on `adoptJoinedGroup`.
127
+ - New `InvitationStatus` `competing`: a Welcome that could not be decided (its group's gate is closed, or the
128
+ comparison is undecidable) is held durably with its rumor and consumed key, re-decided on every inbox pass,
129
+ expires when the held tip passes its epoch or at the matching manifest's deadline, is not listed by
130
+ `invitations.pending()`, is rejected by `accept`, is removed with its group and counts as live for the consumed
131
+ key's retention. A kept Welcome is a terminal `joined` record carrying a `reason`.
132
+ - New `RumorDisposition` kind `branch-switched` (`invitationId`, `groupId`, `from`, `to`).
133
+ - `accept`, a late manifest and a stuck join of a held group run the same classification and decision.
134
+ - 5141e1a: Device key rotation. `client.devices.rotateKey()` replaces this device's MLS leaf
135
+ signature key (the device signing key) in every group and retires the KeyPackages signed with the old one. A device used
136
+ to keep one leaf key for the life of the install; it now has one key at a time and is a **lineage** of keys. Nothing
137
+ rotates unless the application calls `rotateKey()`: there is no automatic or scheduled rotation. Requires the
138
+ `@941design/marmot-engine` release with device key rotation support (its `selfUpdate` leaf-patch seam and `leafKeySuccessions`).
139
+
140
+ **API**
141
+
142
+ - **`devices.rotateKey()` / `devices.rotation()`.** `rotateKey()` resolves with `DeviceKeyRotationOutcome` `{ rotationId,
143
+ from, to, perGroupOutcome, settled, status }` once the new key is the device key and one pass drove every held group;
144
+ the rest continues in the background and after a restart. `perGroupOutcome` values are `rekeyed`, `satisfied`,
145
+ `removed`, `timed-out`, `cancelled` or `pending`; `status` is `rotating`, `rotated`, or `gave-up` (settled with a
146
+ `timed-out` group, which keeps its previous key and stays fully operable). `rotation()` returns the open rotation, else
147
+ the one that made the current device key, else the newest (`undefined` when the device never rotated). A call while a
148
+ rotation is open returns it. It rejects `invalid-options` with `details.reason` `no-device-key` (no key minted and no
149
+ group held), `device-forgetting` (see Precedence) or `rotation-unavailable` (a device service built without the group re-key
150
+ port or the KeyPackage retirement port; `createMarmotClient` wires both).
151
+ - **Events and unions (additive; an exhaustive `switch` needs the new cases or a default branch).** `deviceKeyRotated`
152
+ `{ rotationId, from, to, groups }` after the prepare committed and `deviceKeyRotationSettled` `{ rotationId,
153
+ perGroupOutcome }` when every group is terminal; each fires AT MOST ONCE per rotation, also across a crash (a crash
154
+ between the commit and the emit loses the event; read `devices.rotation()` for the durable state). `MarmotClientEvents`
155
+ gains both, `DeviceMaintenanceKind` gains `'device-rotation'` (a pass that keeps failing, or a KeyPackage retirement that
156
+ stays blocked, is given up after ten counted failures), and `GroupNotification` gains `leaf-key-rotated { account,
157
+ leafIndex, fromLeafKey, toLeafKey, commitDigest }`, `leaf-key-rotation-withdrawn` (same fields, when a rewind removes the
158
+ commit; `leaf-key-rotated` is delivered again if it rejoins the path) and `retired-key-readded { account, leafIndex,
159
+ leafKey, commitDigest }` (detection only: a commit added a leaf of the local account under a retired, non-head key of its
160
+ lineage; nothing is refused). New exports: `rotatedLeaves(parent, child)`, `successionsInWindow(window, tipState)` and the
161
+ types `LeafKeyRotatedNotification`, `LeafKeyRotationWithdrawnNotification`, `RetiredKeyReaddedNotification`,
162
+ `RotatedLeaf`, `WindowSuccession`, `DeviceKeyRotationOutcome`, `DeviceKeyRotationOutcomeStatus`.
163
+ - **`DeviceInfo` gains `previousLeafKeys` and `self`** (additive; an exact-keys assertion needs the two new members).
164
+ `devices.list()` returns one entry per DEVICE, under its lineage head (`leafKey` = the newest key, `previousLeafKeys` =
165
+ the older keys, oldest first, `self` = the local device), even while its groups hold different keys.
166
+ `devices.label(k, text)` takes any key of a chain and binds the label to the head. `devices.forget(k)` acts on the whole
167
+ chain (a group is `removed` only when no chain key is left in it, so a rotation landing between the Remove's build and
168
+ its read-back is never read as the leaf leaving; the kind-5 covers every chain key's KeyPackages; the tombstone follows
169
+ the lineage and is on the head; forgetting the own device leaves every group holding one of its keys).
170
+
171
+ **How it runs**
172
+
173
+ - **Prepare.** The account signer signs the new key's account identity proof ONCE; one account transaction then flips
174
+ `deviceRegistry/self` (the proof is stored with the key, the retired private half is dropped), records a durable
175
+ `rotation:<id>` intent with every held group, writes a `rotated:<oldKey>` link per replaced key and moves the registry
176
+ entry (label, enrolment time, tombstone) to the new key. The signer cost is that one proof plus the KeyPackage slot events (at most two
177
+ calls per replaced slot), independent of the number of groups.
178
+ - **Per group.** The device service re-keys each group's own leaf with a self-update whose UpdatePath leaf carries the new
179
+ key and the stored proof (no signer call per group), bounded concurrency of 4, and reads each group back from its state.
180
+ Three counted failed attempts, a fenced group, a refused proof or ten minutes undecided are `timed-out` (the ten minutes run per service instance, so a restart or a clock moving back restarts them, and never for a group whose own re-key commit is in flight). A group still on
181
+ an older key is an operable state, so a crash anywhere is resumed by the next `resumeInBackground` pass.
182
+ - **KeyPackage step.** Every slot whose KeyPackage carries a retired key is replaced by one on the device key (replacement
183
+ published first, kind-5 deletion of the old event only on relays that accepted it, so a slot is never without an
184
+ advertised KeyPackage and a Welcome built against the old one still joins within the grace window). A slot whose relays
185
+ refuse even the re-publish is blocked as `relay-unreachable` (a block reason, not a `status`): the rotation settles anyway and
186
+ the slot is retried once per service lifetime, at the first resume pass with no open rotation (up to three failed rechecks at
187
+ least 30 s apart); other blocks keep the rotation open on the capped backoff. After a crash that left a KeyPackage publish
188
+ pending the step can wait up to 30 s (`RESUME_BACKOFF_MS`) before it retries. A step given up after ten counted blocks
189
+ fires `maintenanceFailed` (`device-rotation`) while the rotation's `status` stays `rotated`.
190
+ - **Precedence.** Leaving beats re-keying. `rotateKey()` rejects `device-forgetting` while ANY record of a `devices.forget`
191
+ of the own device exists, open, settled or given up (a given-up forget, `gaveUp` set and never resumed, leaves its record
192
+ in place); the resume sweep is off under the same rule. The record is deleted when an enrolment approval for that
193
+ key finalizes in the store holding it (the approving sibling's) and, on the forgotten install itself, when a Welcome is
194
+ adopted (or switched to) under an enrolment request the device made at or after the forget started (settled or given-up
195
+ records and their tombstone; an open forget and a later forget are never cleared; a record whose kind-5 deletion is
196
+ still unsettled is marked superseded, ignored here and deleted once the deletion settles). `requestEnrolment()` rejects
197
+ `invalid-options` / `device-forgetting` while an own forget is open. An open rotation cancels its not-yet-terminal groups and its KeyPackage step when an
198
+ own forget is open or starts after it.
199
+ - **Resume sweep.** Independently of any rotation record, every resume pass of a device that holds retired keys re-keys each
200
+ held group whose own leaf carries a retired key of this device (a group created or joined on the old key across a prepare,
201
+ a group a rotation timed out in) toward the current key, with no new key and no signer call; once per pass, never re-armed,
202
+ with a per-group back-off after a refusal. A device that never rotated pays one registry read. A late Welcome join, a
203
+ competing-Welcome switch or a restore that lands a retired-key leaf records the same re-key. After `groups.restore` onto a replaced device, call
204
+ `rotateKey()` once: it re-keys the restored leaves and retires the lost key in the lineage only (the lost install's
205
+ KeyPackages are not deleted and stay advertised until they expire; a peer adding one raises `retired-key-readded`).
206
+ - **Dropped and refused re-keys.** A re-key with nothing left to do is dropped without a commit: `send-rejected` with
207
+ `details.reason` `already-rekeyed` (the leaf already carries the target) or `superseded` (the device key moved on), or,
208
+ when no caller is waiting, reported once through `intentFailed`, so an `intentFailed` listener can see failures for
209
+ self-updates it never sent. A re-key whose stored proof is absent or binds another key is refused `proof-invalid` before
210
+ anything is published. A re-key over staged Adds commits the Adds first and carries the re-key into a second commit; one
211
+ withdrawn by a fork rewind is re-enqueued toward the same target. The pending-intent record names only the public target
212
+ key; the private key and proof are read from the account store when the commit is built.
213
+
214
+ **Behaviour changes**
215
+
216
+ - **A rotation is no removal.** `leaf-removed` is no longer withheld for "the same account at the same index" but only for a
217
+ leaf that replaced its key in place, so a Remove plus an Add of the same account at one index (the new leaf from a
218
+ KeyPackage) is now announced as the `leaf-removed` it is. A duplicate-leaf repair commit announces one `leaf-key-rotated`
219
+ and no `leaf-removed`.
220
+ - **Duplicate-leaf repair and Add refusal.** When the target key is already in the tree at another index with the local
221
+ account's credential (an invite or a fork added the new-key KeyPackage), the re-key Removes that leaf in the same commit as
222
+ the path rotation (no admin right needed). `group.invite` and the enrolment Add refuse, sender-side only, a KeyPackage
223
+ of the device's own key chain when a chain key is already in the tree (`send-rejected`, `details.reason:
224
+ 'device-already-member'`).
225
+ - **`removeMember` survives a rotation of its target.** A recorded `removeMember` is bounded by the leaf keys the account held
226
+ when it was called; a leaf now also counts when the target replaced that key in place since (a succession on the canonical
227
+ path of the retained window, or on an abandoned branch the window still shows), so the record is no longer dropped as
228
+ `absent` while the account still has that leaf. A re-add with a fresh KeyPackage stays "added later". A rotation older than
229
+ the retained rewind horizon is not visible to the bound.
230
+ - **Enrolment compares by lineage.** An approval recorded for a key whose device rotated is not reopened by a rewind and
231
+ causes no second Add; `enrolmentApproved.leafKey` is the key the joined leaf actually carries.
232
+ - **Successions are ingested** (a commit by the leaf itself, or a committed Update proposal of it) from the held groups' canonical-path windows at the first resume pass and on each
233
+ `leaf-key-rotated` notification (the local account only; a withdrawn rotation never un-records a link). A second, different
234
+ successor recorded for a key (a rotation withdrawn by a fork, then another) is kept as alternate evidence; two installations
235
+ that share an origin key stay two devices.
236
+ - **Stored proof.** `DeviceSigningKey` carries an optional 64-byte `proof` (strict decode; additive). A key that carries it
237
+ mints KeyPackages, enrolment KeyPackages and the creator leaf of `groups.create()` with no kind-450 signer call.
238
+
239
+ **Residuals.** A device restored past the retained rewind window loses the successions it never saw and shows a rotated
240
+ sibling as a new, unlabelled device until it observes another succession or a label is applied again; a peer on a build
241
+ without lineage support does the same. The retired private key remains inside retained rewind-window snapshots, in a group
242
+ not yet re-keyed and in superseded KeyPackage private material until its grace expiry. The account-signed proof of a retired
243
+ key is never revoked. Rotation ends the old key's signing identity; it is not protection against theft of a full device store.
244
+ - **Late Welcome on a retired own key is already-member.** The joiner's `same-lineage` check of a competing Welcome (`inboxDisposition` `already-member`) now also matches a retired key of the SAME device: the held branch view carries an optional `ownLeafChain` (the device's directed ancestry through the recorded rotation links, filled from the account store when the Welcome is judged), so a Welcome built on a KeyPackage minted before a rotation is kept out without a branch switch. A live sibling installation sharing an origin key is not the same device and is still judged normally; an unreadable lineage degrades to the held key alone and never blocks the Welcome path.
245
+ - **Re-enrolled device rotates again.** `enrolmentManifests` records written by `requestEnrolment` carry an optional `recordedAt` (ms), removed from every waiting manifest when an own forget starts; the Welcome service's new optional dep `onManifestFulfilled(tx, manifest)` runs in the account transaction that marks a manifest fulfilled (join or confirmed switch) and the client wires it to `supersedeOwnForget`, which ends the device's own settled forget record and tombstone when it is admitted again, so `rotateKey()` and the resume sweep work after a forget plus re-enrolment. `devices.requestEnrolment()` rejects `invalid-options` (`device-forgetting`) while an own forget is open.
246
+ - 6e8c963: A peer's disband that the convergence settlement selected is now persisted and
247
+ surfaced instead of living only in the engine's memory. The group store gets a
248
+ durable `marmot.disband` marker, `MarmotGroup.disbanded` (new `GroupDisbanded`
249
+ type: `{ actor, epoch, nodeTag, commitDigest, at }`) names the selected
250
+ disband, and a new `group-disbanded` notification
251
+ (`GroupDisbandedNotification`) is dispatched once. From then on, also after a
252
+ reload, the group no longer syncs, `ingest` rejects every event (reason
253
+ `group-disbanded`), and `send`, the other own-intent operations and `synced()`
254
+ reject `not-a-member` with `details.reason: 'disbanded'`. Previously a reload
255
+ rebuilt the group from its pre-disband state and treated it as live.
256
+ - 4f0f9d9: New `ClientOptions.maxGiftWrapBytes` (default 65 536): the relay event-size budget of the gift wrap an own
257
+ enrolment request is sent in. `devices.requestEnrolment` now also refuses, before anything is minted, stored or
258
+ published, a request whose wrap's event JSON could exceed it — `invalid-options`, `details.reason:
259
+ 'request-too-large'`, with `wrapBytes` and `maxGiftWrapBytes`. Before, a request within NIP-44's bounds (up to
260
+ ~25 groups) could produce a ~74 KB wrap that 64 KiB relay caps refuse; it was persisted and re-published until it
261
+ expired, never delivered.
262
+ - 73baee0: Close the rewind takeover via a stale leaf snapshot: other-leaf credited depth at equivocation nodes.
263
+
264
+ `@941design/marmot` opts in: a holder of a leaf snapshot within `maxRewindCommits` who hides the post-snapshot
265
+ history and outgrows canonical no longer pulls honest members off the real device's branch once another member has
266
+ committed on canonical after the real device's first commit past the snapshot, however the holder frames its commits
267
+ on the wire. Other members' commits before that one do not suffice: the holder can advance its snapshot through them
268
+ and fork just below the real device's commit, where it still wins with a deeper branch (the engine reports that
269
+ equivocation). The persisted rewind window stores each node's commit
270
+ sender (optional; a window written before it restores the framing's). `groups.restore` does not trust the sender a
271
+ snapshot's window stores: it re-derives each link's sender from the commit at its parent, refuses a snapshot whose
272
+ stored sender disagrees (`envelope-mismatch`, `details.reason: 'malformed'`) and adopts only derived senders, so a
273
+ backup written by another holder of the sync key cannot move equivocation credit. Residuals (pure single-leaf equivocation, a snapshot of a leaf with no post-snapshot commit, the
274
+ real device fencing on its cloned leaf's commits, private-framed edges persisted before senders were, a takeover
275
+ defeated through cross-subtree evidence being corrected without being reported, an equal-depth honest race whose
276
+ loser re-drove onto the winner while others built on the abandoned commit selecting differently from MDK) remain known limitations.
277
+
278
+ `@941design/marmot` surfaces the engine's report as a new `GroupNotification` variant, `leaf-equivocation`
279
+ (`LeafEquivocationNotification`: `leafIndex`, `account`, `leafKey`, `epoch` as a `bigint`, `nodeTag`,
280
+ `commitDigests`), delivered through `onNotification` at most once per group and `(nodeTag, leafIndex)`: the evidence is
281
+ recorded in the group store (extension `marmot.equivocation`) in the ingest batch's transaction (or, when found outside a batch, in a transaction of its own)
282
+ and announced only after that commit, never again for the same evidence — including after a reload. The stored
283
+ record is the source of truth — the notification is a live hint, lost if no listener is attached or the process ends
284
+ before dispatch — and the new `MarmotGroup.equivocations()` returns every recorded equivocation (ordered by `(epoch,
285
+ nodeTag, leafIndex)`, `[]` when none), also after a reload. Informational
286
+ only: nothing is removed automatically. An exhaustive `switch` over `GroupNotification['type']` needs a case for it.
287
+ - 3e09d54: `MarmotGroup.removeMember(account)`.
288
+
289
+ - **One commit, account-scoped.** ONE durable admin commit removes every leaf the account holds when the commit is
290
+ built. The stored commit intent has a new `removeAccounts` field (the account, never leaf indexes). An admin may remove
291
+ another admin in the same commit, with no demotion first: the engine's coupling splice drops the removed admin's entry
292
+ (needs this release's receive-side fix, so the removed admin's devices accept their own removal and end as tombstones).
293
+ `onConfirm` hooks see `kind: 'commit'`.
294
+ - **Bounded re-parenting.** The record also snapshots the signature keys of the account's leaves at call time in
295
+ `removeAccountLeafKeys`, a new strictly decoded intent field. A record whose parent epoch moved is re-parented onto the
296
+ current tree only if one of those leaves is still in the tree (then ALL the account's current leaves are removed, also
297
+ one added meanwhile); a caller demoted meanwhile is refused `send-rejected` by the engine. A member who was removed and
298
+ re-added meanwhile no longer matches, so the record drops as `absent` (a waiting caller resolves; an unattended record
299
+ reports `intentFailed`, `details.reason: 'absent'`). Residual: the snapshot identifies a device key, not a membership
300
+ incarnation, so another admin's remove-and-re-add of the same device makes a resumed record remove the account again.
301
+ - **Refusals** (nothing recorded, epoch unchanged): `invalid-options` with `details.reason` `'malformed-account'`,
302
+ `'self'` (use `departAsAdmin()` / `leave()`) or `'not-admin'`; `commit-pending` while an own commit is pending. An
303
+ account holding no leaf resolves as a no-op.
304
+ - **Staged proposals.** Leaves a staged Remove or SelfRemove already targets are skipped (carried by reference).
305
+ `send-rejected`, nothing recorded, when a staged Add admits a leaf of the account (`details.reason:
306
+ 'staged-add-of-removed-account'`), when a staged Update names the account's leaf, or when a staged admin-list change
307
+ still names a removed admin (`'staged-admin-policy-update'`): commit the staged proposal first
308
+ (`send({ type: 'commit' })`) and retry. A staged admin-list change is committed together with the removal.
309
+ - devices.forget: refused send-rejected (details.reason staged-add-of-removed-leaf) while a staged Add re-admits the
310
+ forgotten leaf key; commit it first.
311
+ - **Removed side.** Unchanged (Q1 option a): a tombstoned group; that device's own group emits no `leaf-removed`
312
+ notification (the remaining members' groups do).
313
+ - **Stores.** The new intent fields are additive; a stored commit record without them decodes as before. A record with
314
+ `removeAccounts` but no `removeAccountLeafKeys` (or the reverse), or either not a non-empty array of 64-lowercase-hex
315
+ strings, is refused as a malformed intent. No engine change.
316
+ - 57ff027: New client event `groupRemoved` `{ groupId, actor? }`: a peer removed this device from the group and the removal settled
317
+ (no longer revisable, after `removalSettleMs`); `actor` is the hex account identity of the admin whose removing commit
318
+ was selected, absent when the committer cannot be resolved. The group and its history stay held, read-only; the application decides
319
+ whether to `abandon()` it. Not fired for a removal this device asked for (`leave()`, an own-leaf `devices.forget`, or an
320
+ `abandon()`/`destroy()` in progress). At most once: a crash between the settle and the emit loses it.
321
+ `MarmotClientEvents` and `MarmotClientEventName` gain the member, so an exhaustive `switch` over event names needs the
322
+ new case.
323
+ - cf99252: `MarmotGroup.rename(name, { description? })`, the read-only `MarmotGroup.description` and the exported
324
+ `groupProfileProposal({ name, description })` builder.
325
+
326
+ - **`rename`.** ONE durable admin commit that replaces the group profile (`marmot.group.profile.v1`: name and
327
+ description). It is a stored commit intent with a new `profile: { name, description }` field, so a record resumed
328
+ after a reload drives to the same committed profile, and the `onConfirm` hooks see `kind: 'commit'`. An omitted
329
+ `description` keeps the current one, resolved when the call is made and stored by value; `description: ''` clears
330
+ it. A non-admin caller is refused `invalid-options` with `details.reason: 'not-admin'` before anything is recorded.
331
+ Gate order: not a member, send gate closed, malformed argument, not-admin, `commit-pending`, proposal policy. While
332
+ a `0x8001` proposal is staged on the group, `rename` rejects `send-rejected`
333
+ (`details.reason: 'staged-profile-update'`) with nothing recorded: a commit that carried both would hold two
334
+ profile updates.
335
+ - **Two updates of one component.** A commit carries staged proposals by reference first and the committer's own
336
+ update by value after them, and receivers resolve a component to its last update, the committer's own. `setAdmins`
337
+ and the demotion of `departAsAdmin` therefore stay allowed while a foreign admin-policy proposal is staged (a
338
+ refusal would block teardown for good, since teardown never commits it); only `rename` refuses. A record that goes
339
+ terminal at build time keeps the cause's `details.reason` on its `send-rejected`.
340
+ - **Limits.** `name` is a non-empty string of at most 256 UTF-8 bytes and `description` a string of at most 4096
341
+ UTF-8 bytes (byte limits, not character counts, the component's own); a violation is `invalid-options` before
342
+ anything is recorded.
343
+ - **`groupProfileProposal`.** Returns the ts-mls `Proposal` (`appDataUpdate`, component `0x8001`) for the remaining
344
+ route, where a non-admin sends `{ type: 'proposal', proposal }` and an admin sends `{ type: 'commit' }`, with no
345
+ hand-encoded bytes; it wraps the engine's one encoder and `rename` builds from the same function. Exported from the
346
+ package root (with the `GroupProfile` type), not from `@941design/marmot/mls`.
347
+ - **Stores.** The new intent field is additive: a stored commit record without `profile` decodes as before, and a
348
+ record whose `profile` is not a pair of strings within the component's limits is refused as a malformed intent.
349
+ No engine change, so `PATCHSET_DIGEST` does not move.
350
+ - 3182df9: New `ClientOptions.inboxHandlerBudgetMs` (default 30 000 client-clock ms,
351
+ `0` never reports) and `handlerSlow` client event: an inbox consumer callback
352
+ (an `extensions.registerInboxHandler` handler or `onApplicationRumor`) still
353
+ running after the budget is reported once with `{ surface, rumorKind, wrapId,
354
+ budgetMs }`. It is a diagnostic only. The handler is not detached or
355
+ redelivered, and the inbox queue still waits for it, so the "handlers must
356
+ not await long work" contract is unchanged.
357
+ - dead108: A joined group's first sync fetches from its join floor — the Welcome's `created_at` (clamped to [arrival − grace
358
+ window, arrival]) minus the 300 s clock-skew allowance — instead of the group's whole history, so pre-join history is no
359
+ longer downloaded and no longer saturates the branch-aware fence's undecryptable set. Events below
360
+ the floor that a relay delivers anyway are still processed; restores and created groups are unchanged.
361
+ - 897a824: New root export `keyPackageRefOf(event)`: the hex KeyPackageRef of a kind-30443 KeyPackage event — what
362
+ `invitations.expectWelcome()` takes as `keyPackageRef` (and `group.invite()` reports as `inviteeRef`) — for the
363
+ event `keyPackages.create()` / `.offer()` returned or one fetched from a relay. Rejects `invalid-options` for an
364
+ event that is not a KeyPackage. Replaces the `@941design/marmot/mls` derivation recipe docs/migration.md gave.
365
+ - 3182df9: New `GroupNotification` variants `leaf-removed` and `leaf-removal-withdrawn`
366
+ (types `LeafRemovedNotification`, `LeafRemovalWithdrawnNotification`):
367
+ a commit on the canonical path that removes leaves is announced once per removed
368
+ leaf as `{ type: 'leaf-removed', commitDigest, account, leafIndex, leafKey }`
369
+ (account and index as of the commit's parent state), dispatched with that
370
+ commit's `applied` notifications — also when the account keeps other leaves,
371
+ where the engine's `memberRemoved` does not fire, so a same-account device
372
+ removal is visible as such. A rewind that supersedes the commit emits
373
+ `leaf-removal-withdrawn` with the same fields. A leaf that replaced its own key
374
+ at the same index is not a removal.
375
+ - 3751eec: Export the types that already appear in public signatures, so consumers can name them (type-only exports):
376
+ `RumorDisposition` (what `InboxDisposition` extends), `InboxRumorHandler` (the type `InboxHandler` aliases),
377
+ `MaintenanceKind` and `DeviceMaintenanceKind` (the `maintenanceFailed` event's `kind`) from the package root, and
378
+ the structural IndexedDB types `IDBFactoryLike.open` reaches — `IDBOpenDBRequestLike`, `IDBRequestLike`,
379
+ `IDBDatabaseLike`, `IDBTransactionLike`, `IDBObjectStoreLike`, `IDBValidKeyLike` — from
380
+ `@941design/marmot/storage/indexeddb`. No runtime change.
381
+ - f2b9617: A device that joined a group on one branch of a same-epoch race is moved onto the branch of a competing Welcome the
382
+ members' rule ranks higher. The group runtime implements the ports the Welcome
383
+ service decides through, and `WelcomeServiceDeps.competing` is now required.
384
+
385
+ - New client event `groupBranchSwitched` (`invitationId`, `groupId`, `from`, `to`: the confirmation tags of the
386
+ abandoned tip and of the Welcome's state). It fires once per switch, also when the switch was decided in an inbox
387
+ pass with no wrap in hand; `groupJoined` does not fire again and the abandoned Welcome's invitation stays `joined`.
388
+ The inbox disposition `branch-switched` is reported when the switch ran inside the Welcome's dispatch. A crash between
389
+ the report and the invitation's confirmation reports the switch once more on the next pass: deduplicate by
390
+ `invitationId`.
391
+ - The switch is one group transaction: the Welcome's state, a tip-only window carrying the join evidence, the per-state
392
+ group extensions (`marmot.opaque`, `marmot.removal`, `marmot.pendingLeaf`, the restore marker) cleared, everything the
393
+ abandoned branch applied that its retained window holds withdrawn (`withdrawn`, `message-withdrawn`; messages the
394
+ application sent on it are not re-sent), a settlement-recheck marker (`DeviceGroupPort.onRewind` fires), the
395
+ `onConfirm` hooks with `kind: 'join'` (an account's leaf backup follows the new branch; a throwing hook rolls the whole
396
+ switch back), and the group's pre-join ingest floor and cursor lowered to the Welcome so what was sent on the new
397
+ branch before the switch is fetched again. A crash at any step is completed by the next inbox pass.
398
+ - The decision waits (durably, as a `competing` invitation) while the group is not loaded, fenced, restoring, purging,
399
+ abandoned, syncing (its first sync since the load, or the engine's quiescence window) or has an own commit,
400
+ self-update or proposal pending; the end of each of those asks for an inbox pass.
401
+ - `adoptJoinedGroup` persists the join evidence of a tagged Welcome on the window root; an imported snapshot never
402
+ supplies it.
403
+ - `CompetingWelcomePorts.competingGate` may answer asynchronously; `HeldBranch` gains `joinedAtMs`, which lets an
404
+ interrupted join of the very Welcome be recognised after the join root left the retained window.
405
+ - A switch also withdraws own application messages minted on the abandoned branch that were not yet confirmed
406
+ (`message-withdrawn`; they never read as sent on the new branch), and re-enqueues withdrawn own self-updates. An
407
+ `onConfirm` hook that refuses a switch is retried every inbox pass without counting toward the give-up. The
408
+ Welcome's `created_at` lowers the pre-join floor only within the grace window.
409
+ - `CompetingWelcomePorts.switchState` and `WelcomeServiceDeps.passNow` are new ports; a switch leaves a durable proof row
410
+ in the group extension `marmot.branchSwitch`, so a recovery after the group moved on (or the join root left the
411
+ window) still finds the switch written, and a group that merely carries the Welcome's branch keeps it out as its own
412
+ lineage.
413
+ - 2c11e4b: Removal finality: `@941design/marmot` opts in to the engine's
414
+ `removalFinality` (a single literal beside `equivocationCredit` and `branchAwareFence` in `group-runtime.ts`).
415
+
416
+ - **A removed member cannot rewind back in.** A member removed at epoch E that, not having seen the removal, keeps
417
+ committing from E no longer wins its leaf back by depth: its own commits past the removal earn nothing, and the
418
+ removal is preferred on an equal-finality race. This holds for dead chains up to `maxRewindCommits - 1` commits past
419
+ the removal's parent (4 with the shipped horizon of 5) (counting the removed leaf's self-updates after its first commit off `P`; the guard is `tipEpoch − epoch(P) ≤ maxRewindCommits`, so a chain of exactly `maxRewindCommits` commits past `P` is still decided); a longer chain is followed by today's ordering and the
420
+ remover's withdrawn `removeMember` is re-driven on top of it, within the shared re-drive budget (`maxPublishAttempts`).
421
+ - **Behaviour changes visible to applications.** An equal-depth race between a removal and a commit of another member
422
+ now goes to the removal; a removal is withdrawn (`leaf-removal-withdrawn`, then re-driven) only when members other
423
+ than the remover and the removed leaf out-commit it. A forget's or `removeMember`'s race with the target device's own
424
+ rotation is won by the removal unless another member backs the rotation. A settled device forget is reopened by a
425
+ fork rewind only under the same condition.
426
+ - **The removed device decides `removed` by itself** in the same interleavings as the members, and settles through
427
+ the existing `removalSettleMs` path, except when the removal is extended by work it cannot read while its own branch
428
+ carries two commits by other members, or past the rule's guard.
429
+ - **Joiners.** A joiner's competing-Welcome ranking ignores removal finality; a joiner stranded on a
430
+ demoted branch is healed by the re-driven invite.
431
+
432
+ The engine patch set changes `ENGINE_VERSION`: every store written by an earlier build is refused with
433
+ `storeIncompatible` (`envelope-mismatch`) and can be recovered by a wipe. See the `@941design/marmot-engine` changeset
434
+ for the engine side.
435
+ - a4dcb1f: `groups.restore` resolves a pending-tagged `GroupSnapshot`:
436
+
437
+ - The snapshot is adopted at its tip S_C (the state of an own commit C that no relay was known to hold when the
438
+ snapshot was taken). Once the restore's first sync is over, a resolution step runs once, on the persisted tip:
439
+ if the sync delivered C (matched by commit digest only) or moved the group off S_C in any way, the adopted tip
440
+ stands and a competing branch is followed by the ordinary fork rules; if no relay delivered C (a silent or
441
+ truncated relay counts as not having it) the group is rewound to C's parent P in ONE transaction — state, rewind
442
+ window, the parked node and the marker's clearing — and the restore's self-update is made on P. A backup of a
443
+ commit that never reached a relay therefore no longer puts the device on a branch no member holds, and a backup
444
+ of a published commit no longer fences the device.
445
+ - The rewound-away S_C is parked in a side record (group extension `marmot.pendingLeaf`), outside the rewind
446
+ window and the engine's history tree, so it competes in no selection and feeds no equivocation report. If C
447
+ is delivered later (any ingest path), ingest checks its digest before the engine sees it, reinstates the node
448
+ as an ordinary own-leaf fork node, rebuilds the engine and re-offers what the lost pool held. The record is
449
+ dropped when its parent leaves the rewind window, and cleared by any restore or Welcome adoption of the group.
450
+ - Any envelope that opens under S_C's own epoch key (a peer's message, proposal or commit built on it) counts as C
451
+ seen. The rewind runs as an ordinary transition (what was delivered under S_C is withdrawn, the rewind is announced)
452
+ and fails closed under an own operation recorded on the adopted tip; a fork leaf S_C that no peer holds is parked
453
+ too. The consumer `verifier` decides before any of this, and a re-encrypted copy of a reinstated C is ledgered.
454
+ - Recognising C is durable (the ingest transaction that sees it clears the restore's marker beside its cursor and
455
+ ledger write) and the resolution is idempotent, so a client disposed or crashed anywhere between the adoption and
456
+ the self-update's confirmation resolves it identically on the next client over the same stores.
457
+ - Restoring a confirmed (unmarked) snapshot is unchanged. No vendored `marmot-engine` change.
458
+ - 0a5de38: A successful `groups.restore` now starts a device-key rotation: a lost or stolen device still holding
459
+ the backed-up key no longer keeps reading the restored groups. Restoring a batch of groups costs one rotation (one
460
+ `deviceKeyRotated`); it is best-effort, survives a restart (durable marker), and never fails the restore. Signer cost:
461
+ the rotation's prepare signature and its KeyPackage republishes.
462
+ - 3182df9: marmot now has a transport (re)connect signal. Wire the transport adapter's
463
+ (re)connect callback into the new `client.transportEvents.connected(relayUrl)`
464
+ sink, beside `authFailed`. It is re-emitted as the `transportConnected`
465
+ client event `{ relayUrl }`, with the relay string exactly as reported. It
466
+ ignores a non-string relay and is a no-op after `dispose()`.
467
+
468
+ `attachAccountSync` listens for `transportConnected`. Each event marks the
469
+ sync-key ring stale and runs the retry round (ring sync, refresh pass,
470
+ carrier pull + flush), so an application wired to marmot no longer has to
471
+ call `handle.transportEvents.connected()` as well. That sink still works for
472
+ adapters wired to the handle directly. The listener is registered and
473
+ removed with the attachment's other registrations.
474
+ - b27f674: Welcome rumors carry the digest of the commit they belong to. Every Welcome
475
+ rumor an invite commit stages now has a `['commit', <64 lowercase hex>]` tag after the `relays` (and `e`) tags: the
476
+ `commitDigest` (SHA-256) of the encoded MLS message the commit is published and confirmed with, so a joiner holding
477
+ two Welcomes for one group can later rank the two branches by (epoch, committer account, digest) the way the members
478
+ do. The rumor id is recomputed over the tagged draft; `e`, `relays` and the MLS Welcome content are unchanged, so the
479
+ engine's `getWelcome` and every Marmot reader that validates only those tags keeps decoding it.
480
+
481
+ - Welcomes staged before this release stay untagged: `decodeStoredWelcomes` reads them unchanged and `retryWelcome`
482
+ re-wraps a stored rumor byte for byte (tagged or not, same rumor id).
483
+ - Internal API of the `invitations` module: `buildWelcomeRumors` takes the encoded commit bytes (`commit`, required);
484
+ new `welcomeCommitTagOf(rumor)` reads the tag totally (`undefined` for no tag, a repeated tag, or a value that is not
485
+ 64 lowercase hex; it never throws) and `WELCOME_COMMIT_TAG` names it.
486
+ - Interop residual: other Marmot implementations must tolerate the extra tag (MIP-02 forbids only `encoding`); the
487
+ client does not yet act on it.
488
+ - 0aec8e1: The retained rewind window can carry join evidence. A window root gains an
489
+ optional `joinEvidence { digest, committer }` (hex): the commit digest from the Welcome's `commit` tag and the account
490
+ of the member that signed the Welcome's GroupInfo, recorded when a device joined. Nothing writes it yet; the joined
491
+ node's own record of its commit is what a later competing Welcome is ranked against.
492
+
493
+ - `tipOnlyWindow(state, evidence?)` puts it on the root (evidence that is not two 64-lowercase-hex strings throws); it survives `writeWindow`/`readWindow` (stored as `j`
494
+ `{ d, c }`; a window written before this release reads without it, and a malformed value is dropped, never
495
+ guessed), `extendWindow` for any number of own commits while the join node is inside `REWIND_HORIZON`, `bounded`
496
+ (`withForkNode`, `rewoundToParent`), `windowFor` and `sameNode`, and leaves the window only with its node.
497
+ - `captureWindow(tree, tip, horizon, prior)` takes the window it replaces as a REQUIRED fourth argument (`undefined` for a deliberate fresh capture, so omitting it is a compile error) and carries
498
+ the evidence of `prior` over by node tag (the engine's tree knows nothing of a join). The client's three
499
+ `captureWindow` sites (ingest) pass the window they replace, and the own-commit path (`windowAfterOwnCommit`) builds
500
+ its base with `windowFor`, so evidence survives ingest batches, own commits and reloads.
501
+ - New `heldBranchScore(window, tip)` returns `{ complete: true, score }` or `{ complete: false, missing }`: the held
502
+ side of `compareBranchScores` (depth = tip epoch for both depths, no witnesses, the tip's own link digest and its
503
+ committer from `tipCommitterOf`, else the join evidence). A digest or committer the window cannot supply gives the
504
+ second form, which carries no score, so an incomplete score cannot be compared.
505
+ - An imported snapshot never supplies evidence: its window rows are read field by field, so a claim in the payload is
506
+ not read.
507
+
508
+ ### Patch Changes
509
+
510
+ - 1b6789d: First npm pre-release (alpha) of all four packages.
511
+ - 0f720da: Group history paging keeps, for an event id delivered by several relays, the first copy whose signature verifies (the
512
+ first delivered when none does), as `requestWithDeadline` does: a faster relay returning a tampered body under an honest
513
+ id no longer hides the valid copy.
514
+ - 4f0f9d9: Enrolment approvals: the retry of a group whose earlier Add may have landed (its commit was still in the pipeline
515
+ when the pass that issued it ended) is now checked like a reopened re-drive: it carries
516
+ the device's leaf key and the recorded approval epoch, so an Add that landed and was removed by a sibling before
517
+ any pass observed it is never re-added — the group concludes `failed`. Such a retry never advances the approval's
518
+ epoch bound, and the marking (`retried` on the approval group record) survives a crash between counting the
519
+ earlier attempt and the retry.
520
+ - 85dfd19: A leaf equivocation that only the engine's scheduled disband settlement detects is now recorded and announced once,
521
+ as a `leaf-equivocation` notification. `equivocations()` returns it too. The convergence continuation records a
522
+ drive that returns only that report, then stops without rolling the engine back, as it does for a drive that
523
+ returns nothing. A peer's disband of a multi-admin group is no longer rejected as `admin-leaf-coupling` either.
524
+
525
+ The bundled `@941design/marmot-engine` moves `ENGINE_VERSION`, so stores written by earlier builds are refused
526
+ (`storeIncompatible`); wipe the store by marker to recover.
527
+ - 2829d73: `MarmotClient.dispose()` now finishes every service's teardown when a
528
+ consumer-supplied `options.timers.clear` throws. Before this fix, a throwing
529
+ clear stopped that service's dispose at the first timer. The inbox's and the
530
+ groups' live subscriptions stayed open, and a sleeping `leave()` was never
531
+ rejected. The client now wraps the consumer's timers once. A `clear` that
532
+ throws is recorded and returns, and `dispose()` lists the recorded errors in
533
+ its `AggregateError`. A clear that throws during normal operation (for example
534
+ in `inbox.stop()`) no longer escapes into that operation. It is reported at
535
+ `dispose()` instead.
536
+ - cf2115a: Application messages are decoded as strictly as MDK decodes them: a message whose bytes start with U+FEFF, that
537
+ holds malformed UTF-8, or whose strings hold an unpaired surrogate escape, is refused (before, it was accepted here while MDK peers refused it, so members on different
538
+ implementations saw different histories). Avatar `dim`/`thumbhash` hints keep a leading U+FEFF. New conformance
539
+ patches move the engine stamp, so stores written by the previous build are refused with `storeIncompatible`.
540
+ - 2ab78c6: Marmot text fields keep a leading U+FEFF: `decodeUtf8` no longer strips it as a byte-order mark, so a group name or
541
+ description starting with it reads back exactly (a name of just U+FEFF no longer decodes as empty), as other
542
+ implementations read it. A new local patch moves the engine stamp, so
543
+ stores written by the previous build are refused with `storeIncompatible`.
544
+ - c538b1a: `groups.restore` is now fenced (`fenced`) when the snapshot predates an own commit that won a same-epoch race but
545
+ reached the first sync after the competing commit — previously the restore resolved on a forked branch. The client's
546
+ fencing predicate (`isFencingError`) now delegates to the engine's `isNoOverlapError`, so it fences on exactly what
547
+ every engine replay path surfaces.
548
+ - 3182df9: A throwing inbox handler no longer costs a signer unwrap on every retry. The
549
+ counted `handler-failed` deferral now stores the unwrapped rumor with the
550
+ wrap (the same at-rest posture as a pending invitation's Welcome), and later
551
+ passes redispatch it without asking the account signer to decrypt again, so
552
+ a remote signer that prompts per decrypt is asked once per wrap. The stored
553
+ rumor is bounded by the processing-failure cap and cleared when the wrap is
554
+ delivered or dropped; a stored rumor that does not decode is ignored and the
555
+ wrap is unwrapped as before.
556
+ - abbee6d: A group's history sync no longer walks its backlog twice when the live
557
+ subscription opens while a deep backlog walk is still running. The history
558
+ pass is now single-flight per group. A resync requested while a pass runs (the
559
+ catch-up after the subscribe, a retry firing, a failed live event) is folded
560
+ into one follow-up pass that starts from the lowered catch-up floor once the
561
+ walk ends. On a relay serving one event per request, a 218-event backlog
562
+ needed about twice the requests after the subscribe. A routing change still
563
+ restarts the sync at once on the new relays.
564
+ - 4f0f9d9: Inbox: the "live covers it" shortcut — a continued backfill walk resumed inside the live session that saved it
565
+ skips re-walking the newer window — is now trusted for at most 10 minutes since
566
+ a pass last walked that window. A transport that silently re-establishes a dropped socket (an `autoReconnect`
567
+ adapter re-issuing the `limit: 0` filter without telling the observer) left wraps published during the outage
568
+ undelivered until the next restart; they now arrive with the next pass past the cap.
569
+ - 6e8c963: `EnrolmentPrompt.relays` (and the `enrolmentRequested` prompt) now names the
570
+ inbox relay(s) the request's wrap actually arrived from, using the transport's
571
+ relay provenance: every inbox relay whose history walk returned the wrap, or
572
+ the relay a live subscription delivered it on (`DeliveryMeta`). Previously it
573
+ was the whole inbox relay set the request was read over. That set is still
574
+ reported for a delivery that carries no provenance (a transport that passes no
575
+ `DeliveryMeta`, or a deferred wrap retried from the store).
576
+ - 55fee37: A device that joined a group by Welcome now applies the members' own rewind bound when it decides a competing Welcome: it switches only while `tipEpoch - (joinEpoch - 1) <= REWIND_HORIZON`, measured
577
+ from the fork's parent as `isBranchEligible` does, instead of from its join root. Before, at exactly `REWIND_HORIZON`
578
+ followed commits the joiner switched to a branch the members could no longer converge on.
579
+
580
+ The joiner only has an upper bound on the fork epoch (it holds nothing below its join root): parity at the horizon holds
581
+ when the sponsor of its Welcome had no commits the joiner did not see, otherwise the joiner may switch up to that many
582
+ epochs past the members' bound.
583
+ - 3182df9: A late fork flip in a quiet group no longer skips withdrawal detection. The
584
+ terminal ledger's age-based retention (seven days below the ingest cursor)
585
+ now keeps every entry whose delivery state is still a node of the stored
586
+ rewind window, so a group with few commits over more than a week of traffic
587
+ still reports `message-withdrawn` and still re-enqueues (or cancels the
588
+ re-enqueue of) an own self-update when a sibling commit flips the branch.
589
+ - d8f82b1: A lost store lease is now remembered by the group runtime (`leaseLost`), not only signalled. Before, a lease lost while
590
+ an `onBeforePublish` barrier ran stopped that pass, but the envelope stayed marked as handled, so a later resume pass in
591
+ the same runtime published it without its hooks. Now a pass whose hooks did not complete leaves the envelope unhandled,
592
+ and every later pass sees the ended runtime and publishes nothing; the durable record waits for the next holder of the
593
+ stores.
594
+ - 4f0f9d9: Every record codec's decode/validation failure (`store-failed`) now carries `details.malformed: true` — enrolment
595
+ sessions, the device registry and device signing key, KeyPackage slots, invite and decline records, enrolment
596
+ manifests, and a stored group state naming an unknown ciphersuite or carrying no Marmot group view. The inbox
597
+ classifies such a failure as a non-transient `malformed-record` (a poison wrap is rejected after its counted
598
+ deferrals) by the flag, whatever the message says; before, two of these sites were classified transient because
599
+ their message did not contain the word "malformed".
600
+ - 3182df9: An own commit whose every publish acknowledgement was lost no longer goes
601
+ terminal at `maxPublishAttempts` when a relay stored it. The max-attempts path
602
+ now probes the group's relays for the envelope first: a stored commit is
603
+ confirmed as the group's next epoch (the send settles instead of firing
604
+ `intentFailed` with `send-rejected`), so the device no longer commits a second
605
+ time at the same epoch and its peers no longer flag an honest client with
606
+ `leaf-equivocation`. An absent envelope, or a probe that times out or fails,
607
+ keeps the previous drop.
608
+ - 6e8c963: The post-load ratchet skip now re-arms when the group's first post-load sync
609
+ shows its record is stale. If a load does not skip because the stored skip
610
+ record (`marmot.ratchetSkip`) is undelivered, which happens with a backup taken
611
+ while the first message after a restart was refused everywhere, and that sync
612
+ then reads back an own application message at or after the skipped generation
613
+ on the same epoch state, the record is marked delivered and the first post-gate
614
+ message skips again. That message no longer re-mints the generation of an own
615
+ message held only by a relay the sync excluded as silent. The `ratchetSkipMargin`
616
+ documentation now also states the existing relay-derived floor: own messages
617
+ the first sync reads are ingested, which moves the own sender ratchet past them,
618
+ so a second restore of one snapshot skips past what the first restore sent when
619
+ a relay holds it. The remaining carve-outs are limited to messages held only by
620
+ silence-excluded relays.
621
+ - 59224af: A Welcome-race branch switch now also lowers the in-memory catch-up floor, so a live event processed before the
622
+ resync can no longer drop the lowered fetch start and miss what was sent on the new branch before the switch.
623
+ - 74a8892: A removed admin's client now tombstones the group when another admin removes it, instead of staying active on a rejected
624
+ `admin-leaf-coupling` commit (engine fix in `@941design/marmot-engine`).
625
+ - 3182df9: `groups.restore` now refuses a snapshot whose rewind window carries a state
626
+ with a forged `privatePath`. Every window state must hold the private key of
627
+ its own leaf's encryption key in that state's ratchet tree. A path whose leaf
628
+ index was redirected to another member's leaf, or whose leaf key was
629
+ replaced, is refused `envelope-mismatch` (`reason: 'malformed'`) before
630
+ anything is written, so it can no longer redirect the sender attribution of
631
+ a fenced PrivateMessage commit. Honest snapshots restore as before.
632
+ - 6e8c963: A resumed own intent whose relay probe throws (rather than timing out) no
633
+ longer keeps the group's background resume retrying forever. The throwing
634
+ probe is now handled like a timed-out one: the record goes to its publish
635
+ retry, which spends `maxPublishAttempts` and, once they are exhausted, drops
636
+ the intent as before (`intentFailed` with `send-rejected`, reason
637
+ `max-attempts`), or confirms it when a publish is accepted. Other records of
638
+ the group are no longer held back behind the failing probe.
639
+ - 74a8892: `marmot.opaque` stores and restores the engine's `undecryptableSaturated` flag, so the bounded, fail-closed undecryptable
640
+ set survives a restart. A stored flag that is not exactly `true` is treated as corrupt and fences the group.
641
+ - 8904e31: A Welcome whose invite commit was abandoned by a rewind (it lost a same-epoch race) is no longer published. The delivery of every invitee still `pending` or `retryable` goes `failed` with
642
+ reason `commit-withdrawn` and the `welcomeFailed` event fires, so the application can re-invite (`retryWelcome` still
643
+ re-sends one on request; that, not a re-invite, is the remedy); the invitee no longer consumes and rotates its KeyPackage for a branch the group left. A
644
+ Welcome already being published when the rewind lands is not recalled: if a relay accepts it the delivery reads
645
+ `delivered`, and the invitee decides it like any competing Welcome. Invite records now store the confirmation tag of the
646
+ commit (`commitTag`); a record written before this change is never withdrawn automatically.
647
+
648
+ If the commit returns to the canonical path later (equivocation credit, a longer branch), its failed deliveries go back to
649
+ `pending` and are delivered, announced by the new client event `welcomeRestored` (`groupId`, `inviteeRef`). A load
650
+ reconciles the group's open and withdrawn invite commits against the stored window first, so a withdrawal a crash lost
651
+ is made up; a reconciliation that cannot be written is reported as the new event `welcomeReconcileFailed` (`groupId`,
652
+ `error`) and leaves the deliveries as they were.
653
+ - 996fc10: Export the types that public signatures already referenced, so the API docs build cleanly:
654
+
655
+ - `@941design/nostr-events/signer/nostr-connect`: `NostrConnectTransport` (the `transport` option of
656
+ `createNostrConnectSigner` and `listenForNostrConnect`; a `NostrNetworkInterface` or `TransportContract` satisfies it).
657
+ - `@941design/marmot`: `DeviceKeyRotationGroupOutcome` (`DeviceKeyRotationOutcome.perGroupOutcome`) and `JoinEvidence`
658
+ (`WindowNode.joinEvidence`). `OwnChangeLostReason` is now spelled out as a literal union (same members).
659
+ - Updated dependencies [c425a58]
660
+ - Updated dependencies [36e5299]
661
+ - Updated dependencies [05c888c]
662
+ - Updated dependencies [1b6789d]
663
+ - Updated dependencies [5794a86]
664
+ - Updated dependencies [09a3c7f]
665
+ - Updated dependencies [5ee090c]
666
+ - Updated dependencies [c9a0364]
667
+ - Updated dependencies [5141e1a]
668
+ - Updated dependencies [85dfd19]
669
+ - Updated dependencies [c538b1a]
670
+ - Updated dependencies [13a56b8]
671
+ - Updated dependencies [fb40ae1]
672
+ - Updated dependencies [c8cda86]
673
+ - Updated dependencies [76eeb86]
674
+ - Updated dependencies [0aa122f]
675
+ - Updated dependencies [72e42b4]
676
+ - Updated dependencies [2c11e4b]
677
+ - Updated dependencies [8858e61]
678
+ - Updated dependencies [05e238d]
679
+ - Updated dependencies [cf2115a]
680
+ - Updated dependencies [780e176]
681
+ - Updated dependencies [3294d70]
682
+ - Updated dependencies [16ed6ac]
683
+ - Updated dependencies [f7a682f]
684
+ - Updated dependencies [2ab78c6]
685
+ - Updated dependencies [372aaba]
686
+ - Updated dependencies [73baee0]
687
+ - Updated dependencies [b20aa59]
688
+ - Updated dependencies [f63fac7]
689
+ - Updated dependencies [f63fac7]
690
+ - Updated dependencies [a7d0158]
691
+ - Updated dependencies [cb9952f]
692
+ - Updated dependencies [74f30dd]
693
+ - Updated dependencies [05c888c]
694
+ - Updated dependencies [18a1138]
695
+ - Updated dependencies [c32d11d]
696
+ - Updated dependencies [ff32d79]
697
+ - Updated dependencies [a805f9c]
698
+ - Updated dependencies [05cadf6]
699
+ - Updated dependencies [996fc10]
700
+ - Updated dependencies [1b19215]
701
+ - Updated dependencies [8eb3026]
702
+ - Updated dependencies [a805f9c]
703
+ - Updated dependencies [7701c6a]
704
+ - Updated dependencies [f78d148]
705
+ - Updated dependencies [b637b3b]
706
+ - Updated dependencies [a805f9c]
707
+ - Updated dependencies [996fc10]
708
+ - @941design/marmot-engine@0.2.0-alpha.0
709
+ - @941design/nostr-events@0.2.0-alpha.0