@interop/wallet-core 0.49.0 → 0.51.0

package/README.md

@@ -57,8 +57,11 @@ The subpaths:
   injected), the App Connect app-key credential module (query validation,
   matching, minting, store-time refusal, legacy re-issue), the
   `WalletOnboardingQuery` transport vocabulary (compose and classification), the
-  VC-API exchange client, and VCALM `interaction:` URL handling. The VPR type
-  vocabulary lives in
+  VC-API exchange client, VCALM `interaction:` URL handling, the requester's
+  half of a server's ephemeral exchange (`createEphemeralExchange` /
+  `pollEphemeralExchange`, the poll bounded by a caller signal or its own
+  deadline), and `composeCapabilityRequest`, the zcap-only VPR a requester
+  stores on such an exchange. The VPR type vocabulary lives in
   [`@interop/data-integrity-core`](https://npm.im/@interop/data-integrity-core)
   and is re-exported here.
 

package/dist/clientAnnex/credentialAnchoredGenesis.d.ts

@@ -0,0 +1,127 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The account-genesis ceremony's CREDENTIAL-ANCHORED variant: such a
+ * signup mints no durable client, so the ceremony is anchored on the unlock
+ * credential's ladder alone. The stage order mirrors `ensureAccountGenesis`
+ * with the durable-client members swapped for their ladder analogs:
+ *
+ * 1. Space provisioning under the ladder VM's bare did:key -- the bootstrap
+ *    controller (wallet-core decision 0004, freewallet decision 0002's
+ *    resolution of the orphan-Space tear): re-derivable from the unlock
+ *    record's ladder seed, so a tab death here strands nothing a later
+ *    login cannot finish or unwind.
+ * 2. The ladder-anchored did:webvh genesis
+ *    (`ensureLadderAnchoredDidWebvh`): the entry signed by ladder rung 0, `updateKeys` = [rung 0], `nextKeyHashes`
+ *    = [hash(rung 0), hash(rung 1)], the ladder VM and the credential's
+ *    `keyAgreement` posture folded in, `portable` unchanged. There is no KMS
+ *    stage: the keystore is DEFERRED to the first durable enrollment (a
+ *    ladder-anchored account has no consumer for the convenience VM, and a
+ *    keystore under an evaporating identity would orphan).
+ * 3. The user-key roster genesis, wrapped to the CREDENTIAL's standing
+ *    key-agreement key -- the only recipient a ladder-anchored account has
+ *    -- with the entry proof signed by the ladder VM (the ceremony-tail
+ *    license's first-entry shape). The account is credential-recoverable
+ *    from the moment this lands.
+ * 4. Epoch[0] on every encrypted roster collection -- gated twice, unlike
+ *    the durable flow. The roster stage must have landed, AND the roster's
+ *    current epoch must BE the `userKey` this run was handed: the user key
+ *    here exists only in this tab's memory, so installing collection epochs
+ *    under a key the roster does not deliver would strand the collections
+ *    on a key that dies with the tab. The second gate is what a re-run over
+ *    an earlier run's roster hits: `read()` adopts a roster keyed to that
+ *    run's user key, and this run's candidate key is a throwaway nobody
+ *    holds -- installing epoch[0] under it on a collection the earlier run
+ *    never reached would key that collection to nothing, permanently, since
+ *    the install is create-if-absent and every later ensure adopts it. So
+ *    the stage is skipped whole and reported on `epochsSkipped`; the caller
+ *    that recovers the roster's real key is the one installer. With both
+ *    gates the tear heal is always clean: no roster means no epochs, and a
+ *    fresh user key re-runs both.
+ * 5. Space-controller promotion, last -- every earlier stage ran under the
+ *    bootstrap did:key the Space's stored controller authorizes.
+ *
+ * Idempotent end to end on the durable flow's convention; the did:webvh
+ * stage adopts a published log iff the ladder attributes it (a naive re-run
+ * would mint a different SCID, so adoption IS the torn-signup convergence).
+ */
+import { type RecipientPublicKey } from '@interop/was-client/edv';
+import type { WasClient } from '@interop/was-client';
+import type { EncryptionDescriptorStore } from '@interop/was-client/edv';
+import type { WebvhIdStore } from '../webvh/didWebvh.js';
+import type { UnlockKeyAgreementPublication } from '../unlock/standingWebvh.js';
+import { type UserKey } from '../keys/index.js';
+import type { ResourceLogPinStore } from '../resourceLog/index.js';
+import { type AccountGenesisResult } from '../genesis/accountGenesis.js';
+/**
+ * The key set a credential-anchored signup mints locally before anything
+ * touches the network: the data Space id and the account's user key -- nothing else.
+ * No client seed and no client update-key seeds exist (that is the point);
+ * the ladder seed is minted by the unlock layer beside the record that
+ * carries it, and every other key derives from it.
+ *
+ * @returns {Promise<{ spaceId: string, userKey: Required<UserKey> }>}
+ */
+export declare function mintCredentialAnchoredAccountKeySet(): Promise<{
+    spaceId: string;
+    userKey: Required<UserKey>;
+}>;
+/**
+ * Runs the credential-anchored account-genesis ceremony (see the module doc
+ * for the stage order and its whys). The caller has already durably written the
+ * unlock record carrying the ladder seed -- the transposed
+ * persist-before-publish rule: rung 0 must never publish before the seed
+ * that derives it is recoverable.
+ *
+ * @param options {object}
+ * @param options.was {WasClient}   signing as the ladder VM's bare did:key
+ *   (the bootstrap controller; build it over `ladderVmAgent`)
+ * @param options.wasServerUrl {string}
+ * @param options.spaceId {string}
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed,
+ *   already sealed into the durably written unlock record
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}   the
+ *   credential's key-agreement publication (commitment or verbatim), folded
+ *   into the genesis document
+ * @param options.standingRecipient {RecipientPublicKey}   the credential's
+ *   standing key-agreement key as a roster recipient (`id` its roster kid)
+ * @param options.userKey {UserKey}   the account's user key, epoch[0] of the
+ *   roster and recipient zero of every encrypted collection
+ * @param options.idStore {WebvhIdStore}   the account's `id` collection
+ *   store, signing as the same bootstrap did:key
+ * @param options.rosterStoreFor {Function}   `({ did }) =>
+ *   EncryptionDescriptorStore` -- the user-key roster's store once the DID is
+ *   known, with a LADDER-signed `ResourceLogSigner` (the first-entry shape)
+ * @param [options.expectedDid] {string}   the account DID, when the caller
+ *   holds a pointer that already names one (a heal re-run); a fresh signup
+ *   and a fresh-terminal heal legitimately hold none
+ * @param [options.accountLogPinStore] {ResourceLogPinStore}   the chain-head
+ *   pins the genesis read and create ride (a transient signup passes the
+ *   visit's in-memory store)
+ * @param [options.onDidPublished] {Function}   `({ did }) => Promise<void>`
+ * @param [options.promoteController] {boolean}   default `true`; an app whose
+ *   account pointer must durably name the DID first (freewallet's record
+ *   re-bind) passes `false` and promotes after that write
+ * @returns {Promise<AccountGenesisResult>}
+ */
+export declare function ensureCredentialAnchoredAccountGenesis({ was, wasServerUrl, spaceId, ladderSeed, keyAgreement, standingRecipient, userKey, idStore, rosterStoreFor, expectedDid, accountLogPinStore, onDidPublished, promoteController }: {
+    was: WasClient;
+    wasServerUrl: string;
+    spaceId: string;
+    ladderSeed: Uint8Array;
+    keyAgreement: UnlockKeyAgreementPublication;
+    standingRecipient: RecipientPublicKey;
+    userKey: UserKey;
+    idStore: WebvhIdStore;
+    rosterStoreFor: (options: {
+        did: string;
+    }) => EncryptionDescriptorStore;
+    expectedDid?: string;
+    accountLogPinStore?: ResourceLogPinStore;
+    onDidPublished?: (published: {
+        did: string;
+    }) => Promise<void>;
+    promoteController?: boolean;
+}): Promise<AccountGenesisResult>;
+//# sourceMappingURL=credentialAnchoredGenesis.d.ts.map

package/dist/clientAnnex/credentialAnchoredGenesis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialAnchoredGenesis.d.ts","sourceRoot":"","sources":["../../src/clientAnnex/credentialAnchoredGenesis.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAwB,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC1E,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAIxE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,4BAA4B,CAAA;AAC/E,OAAO,EAGL,KAAK,OAAO,EAEb,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,EAIL,KAAK,oBAAoB,EAC1B,MAAM,8BAA8B,CAAA;AAErC;;;;;;;;GAQG;AACH,wBAAsB,mCAAmC,IAAI,OAAO,CAAC;IACnE,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;CAC3B,CAAC,CAED;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,sCAAsC,CAAC,EAC3D,GAAG,EACH,YAAY,EACZ,OAAO,EACP,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,OAAO,EACP,OAAO,EACP,cAAc,EACd,WAAW,EACX,kBAAkB,EAClB,cAAc,EACd,iBAAwB,EACzB,EAAE;IACD,GAAG,EAAE,SAAS,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,UAAU,CAAA;IACtB,YAAY,EAAE,6BAA6B,CAAA;IAC3C,iBAAiB,EAAE,kBAAkB,CAAA;IACrC,OAAO,EAAE,OAAO,CAAA;IAChB,OAAO,EAAE,YAAY,CAAA;IACrB,cAAc,EAAE,CAAC,OAAO,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,yBAAyB,CAAA;IACvE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,kBAAkB,CAAC,EAAE,mBAAmB,CAAA;IACxC,cAAc,CAAC,EAAE,CAAC,SAAS,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC9D,iBAAiB,CAAC,EAAE,OAAO,CAAA;CAC5B,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0FhC"}

package/dist/clientAnnex/credentialAnchoredGenesis.js

@@ -0,0 +1,195 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The account-genesis ceremony's CREDENTIAL-ANCHORED variant: such a
+ * signup mints no durable client, so the ceremony is anchored on the unlock
+ * credential's ladder alone. The stage order mirrors `ensureAccountGenesis`
+ * with the durable-client members swapped for their ladder analogs:
+ *
+ * 1. Space provisioning under the ladder VM's bare did:key -- the bootstrap
+ *    controller (wallet-core decision 0004, freewallet decision 0002's
+ *    resolution of the orphan-Space tear): re-derivable from the unlock
+ *    record's ladder seed, so a tab death here strands nothing a later
+ *    login cannot finish or unwind.
+ * 2. The ladder-anchored did:webvh genesis
+ *    (`ensureLadderAnchoredDidWebvh`): the entry signed by ladder rung 0, `updateKeys` = [rung 0], `nextKeyHashes`
+ *    = [hash(rung 0), hash(rung 1)], the ladder VM and the credential's
+ *    `keyAgreement` posture folded in, `portable` unchanged. There is no KMS
+ *    stage: the keystore is DEFERRED to the first durable enrollment (a
+ *    ladder-anchored account has no consumer for the convenience VM, and a
+ *    keystore under an evaporating identity would orphan).
+ * 3. The user-key roster genesis, wrapped to the CREDENTIAL's standing
+ *    key-agreement key -- the only recipient a ladder-anchored account has
+ *    -- with the entry proof signed by the ladder VM (the ceremony-tail
+ *    license's first-entry shape). The account is credential-recoverable
+ *    from the moment this lands.
+ * 4. Epoch[0] on every encrypted roster collection -- gated twice, unlike
+ *    the durable flow. The roster stage must have landed, AND the roster's
+ *    current epoch must BE the `userKey` this run was handed: the user key
+ *    here exists only in this tab's memory, so installing collection epochs
+ *    under a key the roster does not deliver would strand the collections
+ *    on a key that dies with the tab. The second gate is what a re-run over
+ *    an earlier run's roster hits: `read()` adopts a roster keyed to that
+ *    run's user key, and this run's candidate key is a throwaway nobody
+ *    holds -- installing epoch[0] under it on a collection the earlier run
+ *    never reached would key that collection to nothing, permanently, since
+ *    the install is create-if-absent and every later ensure adopts it. So
+ *    the stage is skipped whole and reported on `epochsSkipped`; the caller
+ *    that recovers the roster's real key is the one installer. With both
+ *    gates the tear heal is always clean: no roster means no epochs, and a
+ *    fresh user key re-runs both.
+ * 5. Space-controller promotion, last -- every earlier stage ran under the
+ *    bootstrap did:key the Space's stored controller authorizes.
+ *
+ * Idempotent end to end on the durable flow's convention; the did:webvh
+ * stage adopts a published log iff the ladder attributes it (a naive re-run
+ * would mint a different SCID, so adoption IS the torn-signup convergence).
+ */
+import { initRecipients } from '@interop/was-client/edv';
+import { provisionWalletSpace } from '../space/index.js';
+import { ladderVmAgent } from './zcap.js';
+import { ensureLadderAnchoredDidWebvh } from './ladderAnchored.js';
+import { ensureWalletSpaceEpochs, mintUserKey } from '../keys/index.js';
+import { AccountGenesisSpaceError, ensurePromotedSpaceController, mintSpaceId } from '../genesis/accountGenesis.js';
+/**
+ * The key set a credential-anchored signup mints locally before anything
+ * touches the network: the data Space id and the account's user key -- nothing else.
+ * No client seed and no client update-key seeds exist (that is the point);
+ * the ladder seed is minted by the unlock layer beside the record that
+ * carries it, and every other key derives from it.
+ *
+ * @returns {Promise<{ spaceId: string, userKey: Required<UserKey> }>}
+ */
+export async function mintCredentialAnchoredAccountKeySet() {
+    return { spaceId: mintSpaceId(), userKey: await mintUserKey() };
+}
+/**
+ * Runs the credential-anchored account-genesis ceremony (see the module doc
+ * for the stage order and its whys). The caller has already durably written the
+ * unlock record carrying the ladder seed -- the transposed
+ * persist-before-publish rule: rung 0 must never publish before the seed
+ * that derives it is recoverable.
+ *
+ * @param options {object}
+ * @param options.was {WasClient}   signing as the ladder VM's bare did:key
+ *   (the bootstrap controller; build it over `ladderVmAgent`)
+ * @param options.wasServerUrl {string}
+ * @param options.spaceId {string}
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed,
+ *   already sealed into the durably written unlock record
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}   the
+ *   credential's key-agreement publication (commitment or verbatim), folded
+ *   into the genesis document
+ * @param options.standingRecipient {RecipientPublicKey}   the credential's
+ *   standing key-agreement key as a roster recipient (`id` its roster kid)
+ * @param options.userKey {UserKey}   the account's user key, epoch[0] of the
+ *   roster and recipient zero of every encrypted collection
+ * @param options.idStore {WebvhIdStore}   the account's `id` collection
+ *   store, signing as the same bootstrap did:key
+ * @param options.rosterStoreFor {Function}   `({ did }) =>
+ *   EncryptionDescriptorStore` -- the user-key roster's store once the DID is
+ *   known, with a LADDER-signed `ResourceLogSigner` (the first-entry shape)
+ * @param [options.expectedDid] {string}   the account DID, when the caller
+ *   holds a pointer that already names one (a heal re-run); a fresh signup
+ *   and a fresh-terminal heal legitimately hold none
+ * @param [options.accountLogPinStore] {ResourceLogPinStore}   the chain-head
+ *   pins the genesis read and create ride (a transient signup passes the
+ *   visit's in-memory store)
+ * @param [options.onDidPublished] {Function}   `({ did }) => Promise<void>`
+ * @param [options.promoteController] {boolean}   default `true`; an app whose
+ *   account pointer must durably name the DID first (freewallet's record
+ *   re-bind) passes `false` and promotes after that write
+ * @returns {Promise<AccountGenesisResult>}
+ */
+export async function ensureCredentialAnchoredAccountGenesis({ was, wasServerUrl, spaceId, ladderSeed, keyAgreement, standingRecipient, userKey, idStore, rosterStoreFor, expectedDid, accountLogPinStore, onDidPublished, promoteController = true }) {
+    const failed = [];
+    const bootstrap = await ladderVmAgent({ ladderSeed });
+    // 1. The Space and its collection roster, create-if-absent under the
+    // ladder VM's bare did:key. The typed refusal, exactly as on the durable
+    // flow: nothing downstream can proceed without a Space.
+    try {
+        await provisionWalletSpace({ was, spaceId, controllerDid: bootstrap.id });
+    }
+    catch (err) {
+        throw new AccountGenesisSpaceError({ spaceId, cause: err });
+    }
+    // 2. The ladder-anchored did:webvh genesis -- probe, adopt
+    // (ladder-attributed), or create-and-publish. Fatal on failure, like the durable stage.
+    const { did } = await ensureLadderAnchoredDidWebvh({
+        idStore,
+        wasServerUrl,
+        spaceId,
+        ladderSeed,
+        keyAgreement,
+        ...(expectedDid !== undefined ? { expectedDid } : {}),
+        ...(accountLogPinStore ? { pinStore: accountLogPinStore } : {})
+    });
+    await onDidPublished?.({ did });
+    // 3. The roster genesis: epoch[0] IS the user key, wrapped once, to the
+    // credential's standing key-agreement key. The store's ladder-signed
+    // genesis append is the ceremony-tail license's first-entry shape.
+    let rosterDescriptor;
+    try {
+        const store = rosterStoreFor({ did });
+        const current = await store.read();
+        rosterDescriptor =
+            current !== null
+                ? current.descriptor
+                : await initRecipients({
+                    store,
+                    recipients: [standingRecipient],
+                    epoch: { epochId: userKey.id, secret: userKey.secret }
+                });
+    }
+    catch (err) {
+        failed.push({ stage: 'roster', error: err });
+    }
+    // 4. Epoch[0] on every encrypted roster collection, only behind a landed
+    // roster whose current epoch IS this run's user key (see the module doc:
+    // the user key is memory-only here, and an adopted roster keyed to another
+    // run's key would have the collections installed under a throwaway).
+    let epochs;
+    let epochsSkipped;
+    if (rosterDescriptor) {
+        if (rosterDescriptor.currentEpoch === userKey.id) {
+            try {
+                epochs = await ensureWalletSpaceEpochs({ was, spaceId, userKey });
+            }
+            catch (err) {
+                failed.push({ stage: 'epochs', error: err });
+            }
+        }
+        else {
+            epochsSkipped =
+                rosterDescriptor.currentEpoch !== undefined
+                    ? { rosterEpochId: rosterDescriptor.currentEpoch }
+                    : {};
+        }
+    }
+    // 5. The controller promotion, last. The bootstrap client IS the bare
+    // did:key client, so it serves the heal branch too.
+    let promotion;
+    if (promoteController) {
+        try {
+            promotion = await ensurePromotedSpaceController({
+                was,
+                wasAsClient: was,
+                spaceId,
+                did
+            });
+        }
+        catch (err) {
+            failed.push({ stage: 'promotion', error: err });
+        }
+    }
+    return {
+        did,
+        ...(rosterDescriptor ? { rosterDescriptor } : {}),
+        ...(epochs ? { epochs } : {}),
+        ...(epochsSkipped ? { epochsSkipped } : {}),
+        ...(promotion ? { promotion } : {}),
+        failed
+    };
+}
+//# sourceMappingURL=credentialAnchoredGenesis.js.map

package/dist/clientAnnex/credentialAnchoredGenesis.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentialAnchoredGenesis.js","sourceRoot":"","sources":["../../src/clientAnnex/credentialAnchoredGenesis.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,OAAO,EACL,cAAc,EAEf,MAAM,yBAAyB,CAAA;AAIhC,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAEzC,OAAO,EAAE,4BAA4B,EAAE,MAAM,qBAAqB,CAAA;AAElE,OAAO,EACL,uBAAuB,EACvB,WAAW,EAGZ,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EACL,wBAAwB,EACxB,6BAA6B,EAC7B,WAAW,EAEZ,MAAM,8BAA8B,CAAA;AAErC;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,mCAAmC;IAIvD,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,EAAE,OAAO,EAAE,MAAM,WAAW,EAAE,EAAE,CAAA;AACjE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,KAAK,UAAU,sCAAsC,CAAC,EAC3D,GAAG,EACH,YAAY,EACZ,OAAO,EACP,UAAU,EACV,YAAY,EACZ,iBAAiB,EACjB,OAAO,EACP,OAAO,EACP,cAAc,EACd,WAAW,EACX,kBAAkB,EAClB,cAAc,EACd,iBAAiB,GAAG,IAAI,EAezB;IACC,MAAM,MAAM,GAAmC,EAAE,CAAA;IACjD,MAAM,SAAS,GAAG,MAAM,aAAa,CAAC,EAAE,UAAU,EAAE,CAAC,CAAA;IAErD,qEAAqE;IACrE,yEAAyE;IACzE,wDAAwD;IACxD,IAAI,CAAC;QACH,MAAM,oBAAoB,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,aAAa,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,CAAA;IAC3E,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,wBAAwB,CAAC,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IAC7D,CAAC;IAED,2DAA2D;IAC3D,wFAAwF;IACxF,MAAM,EAAE,GAAG,EAAE,GAAG,MAAM,4BAA4B,CAAC;QACjD,OAAO;QACP,YAAY;QACZ,OAAO;QACP,UAAU;QACV,YAAY;QACZ,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACrD,GAAG,CAAC,kBAAkB,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;KAChE,CAAC,CAAA;IACF,MAAM,cAAc,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,CAAA;IAE/B,wEAAwE;IACxE,qEAAqE;IACrE,mEAAmE;IACnE,IAAI,gBAAkD,CAAA;IACtD,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,cAAc,CAAC,EAAE,GAAG,EAAE,CAAC,CAAA;QACrC,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,IAAI,EAAE,CAAA;QAClC,gBAAgB;YACd,OAAO,KAAK,IAAI;gBACd,CAAC,CAAC,OAAO,CAAC,UAAU;gBACpB,CAAC,CAAC,MAAM,cAAc,CAAC;oBACnB,KAAK;oBACL,UAAU,EAAE,CAAC,iBAAiB,CAAC;oBAC/B,KAAK,EAAE,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,EAAE;iBACvD,CAAC,CAAA;IACV,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;IAC9C,CAAC;IAED,yEAAyE;IACzE,yEAAyE;IACzE,2EAA2E;IAC3E,qEAAqE;IACrE,IAAI,MAA2C,CAAA;IAC/C,IAAI,aAAoD,CAAA;IACxD,IAAI,gBAAgB,EAAE,CAAC;QACrB,IAAI,gBAAgB,CAAC,YAAY,KAAK,OAAO,CAAC,EAAE,EAAE,CAAC;YACjD,IAAI,CAAC;gBACH,MAAM,GAAG,MAAM,uBAAuB,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAA;YACnE,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;YAC9C,CAAC;QACH,CAAC;aAAM,CAAC;YACN,aAAa;gBACX,gBAAgB,CAAC,YAAY,KAAK,SAAS;oBACzC,CAAC,CAAC,EAAE,aAAa,EAAE,gBAAgB,CAAC,YAAY,EAAE;oBAClD,CAAC,CAAC,EAAE,CAAA;QACV,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,oDAAoD;IACpD,IAAI,SAA4C,CAAA;IAChD,IAAI,iBAAiB,EAAE,CAAC;QACtB,IAAI,CAAC;YACH,SAAS,GAAG,MAAM,6BAA6B,CAAC;gBAC9C,GAAG;gBACH,WAAW,EAAE,GAAG;gBAChB,OAAO;gBACP,GAAG;aACJ,CAAC,CAAA;QACJ,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAA;QACjD,CAAC;IACH,CAAC;IAED,OAAO;QACL,GAAG;QACH,GAAG,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACjD,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7B,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAC3C,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QACnC,MAAM;KACP,CAAA;AACH,CAAC"}

package/dist/clientAnnex/forget.d.ts

@@ -0,0 +1,138 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The forget ceremony: a remembered browser's durable client removes ITSELF
+ * from the account, through the standing unlock credential's bridge, before
+ * the app wipes its local state. Self-enrollment in reverse, run with what a
+ * live durable session already holds -- the credential's ladder seed and its
+ * delegated `did.jsonl` bridge -- and refused for the account's last enrolled
+ * durable client ({@link LastDurableClientForgetError}), whose forget is the
+ * ladder-anchored transition, a separate ceremony.
+ *
+ * The stage order INVERTS the revocation cascade's document-edit-first rule,
+ * and the inversion is forced twice over: once the removal entry lands, the
+ * forgetting client's key is out of `assertionMethod` at the post-edit head,
+ * so it can sign no roster append (the entry-proof rule), and its WAS
+ * invocations stop verifying (the current-key-set rule), so the collection
+ * fan-out cannot run either -- while a ladder-signed append is licensed only
+ * at a posture-changing document version, which a not-last-client removal is
+ * not. So:
+ *
+ * 1. **The roster rotation**, PRE-edit, signed by the still-enrolled
+ *    forgetting client: the user key rotates off this client's wrap, retired
+ *    by its roster kid explicitly (document convergence cannot drop a client
+ *    the document still lists). The fresh key is read back through the
+ *    CREDENTIAL's standing wrap -- the forgetting client just retired its
+ *    own -- which the rotation fan-out keeps escrowed into every epoch.
+ * 2. **The collection fan-out**, still under this client's invocation
+ *    authority: every encrypted collection re-epochs onto the fresh key, so
+ *    writes stop landing under epochs a later holder of this browser's
+ *    residue could open.
+ * 3. **The removal entry** ({@link forgetWebvhClient}): one atomic
+ *    ladder-signed entry through the bridge takes the client's whole document
+ *    footprint out. The app's local wipe runs after this ceremony returns, so
+ *    a tear anywhere before the entry reads as "not forgotten" and a re-click
+ *    resumes.
+ *
+ * Torn-state map: a run torn after stage 1 leaves the account rotated off a
+ * client the document still lists -- writes already land under the fresh key,
+ * the client-key record still stands, and the re-run's rotation no-ops (the
+ * wrap is already gone) while its later stages finish. Torn after stage 3
+ * (the removal published, the app's wipe not run) is the
+ * finish-the-wipe state the app's next login maps. What no re-run needs:
+ * the roster log's head stays anchored BEFORE the removal entry -- no signer
+ * this ceremony holds may append after it -- which is exactly the unsealed
+ * state any other enrolled client's login sweep detects and seals.
+ *
+ * There is deliberately no recovery-delegation or generation-delegation
+ * re-mint stage: the forgetting client cannot re-mint with a key that dies at
+ * stage 3 (the replacement would rot moments later), so a delegation this
+ * client had signed is left to the standing self-heals (a durable login's
+ * bridge refresh and `ensureGenerationDelegationCurrent` on the
+ * account-document axis).
+ *
+ * The honest limitation is the cascade's, as everywhere: ciphertext this
+ * browser already fetched stays forensically recoverable from its storage,
+ * and old epochs stay open to keys it already held. The rotation stops future
+ * reads; the wipe removes the local copies.
+ */
+import type { IKeyAgreementKey } from '@interop/data-integrity-core';
+import type { CollectionEncryption } from '@interop/was-client';
+import type { EncryptionDescriptorStore } from '@interop/was-client/edv';
+import type { RevokedClientKeys } from '../webvh/revokeClient.js';
+import { type CascadeCollections, type UserKey, type UserKeyCascadeResult } from '../keys/index.js';
+import type { UnlockLogStore } from '../unlock/standingWebvh.js';
+/**
+ * What a completed forget reports: whether the roster's wrap for the
+ * forgotten client was actually retired on this run (a re-run of a
+ * torn-after-rotation ceremony reports `false`), the per-collection fan-out
+ * result, the document as the removal entry left it, and -- when the account
+ * has a roster -- the rotated key with the roster descriptor it was read
+ * from.
+ */
+export interface DurableClientForgetResult {
+    rotated: boolean;
+    collections: UserKeyCascadeResult;
+    did: string;
+    document: object;
+    userKey?: UserKey;
+    rosterDescriptor?: CollectionEncryption;
+}
+/**
+ * Forgets one enrolled durable client -- this browser's own -- from its
+ * account. See the module doc for the stage order (rotation and fan-out
+ * BEFORE the removal entry, the self-forget inversion) and the torn-state
+ * map. The caller runs the local wipe only after this resolves.
+ *
+ * @param options {object}
+ * @param options.logStore {UnlockLogStore}   the credential's delegated
+ *   `did.jsonl` bridge store; also serves the ceremony's public pre-edit
+ *   read. The caller is expected to have verified the account log under its
+ *   own chain-head pins in the same session (the ceremony re-reads through
+ *   the seam and checks `expectedDid`, but carries no pin store itself)
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed
+ * @param options.forgottenClient {RevokedClientKeys}   this client's public
+ *   halves; an `updateKeyMultibase` the log does not authorize (stale, or the
+ *   staged key) is re-derived from the log
+ * @param options.forgottenKeyAgreementKeyMultibase {string}   this client's
+ *   identity key-agreement key (the X25519 twin), naming its roster wrap
+ * @param [options.knownLatentHashes] {string[]}   standing latent commitments
+ *   the caller vouches for (the recovery registry's update-key hashes),
+ *   excluded from the staged-hash attribution
+ * @param options.expectedDid {string}   the account DID from the caller's
+ *   stored account pointer
+ * @param options.rosterStore {EncryptionDescriptorStore}   the
+ *   `key-map/user-key.jsonl` roster store, signing as the forgetting client
+ * @param options.credentialKeyAgreementKey {IKeyAgreementKey}   the standing
+ *   credential's key-agreement key -- the recipient whose wrap survives the
+ *   rotation, reading the fresh key back and unwrapping the generations for
+ *   the fan-out
+ * @param [options.userKey] {UserKey}   this client's cached user key
+ * @param [options.pinnedEpochId] {string}   the locally pinned latest-seen
+ *   roster epoch
+ * @param [options.onUserKeyAdopted] {Function}   persists a rotated key:
+ *   called with `{ userKey, latestEpochId, descriptor }` after the roster
+ *   read and BEFORE the fan-out
+ * @param options.collections {CascadeCollections}   the fan-out's work
+ * @returns {Promise<DurableClientForgetResult>}
+ */
+export declare function forgetDurableClient({ logStore, ladderSeed, forgottenClient, forgottenKeyAgreementKeyMultibase, knownLatentHashes, expectedDid, rosterStore, credentialKeyAgreementKey, userKey, pinnedEpochId, onUserKeyAdopted, collections }: {
+    logStore: UnlockLogStore;
+    ladderSeed: Uint8Array;
+    forgottenClient: RevokedClientKeys;
+    forgottenKeyAgreementKeyMultibase: string;
+    knownLatentHashes?: string[];
+    expectedDid: string;
+    rosterStore: EncryptionDescriptorStore;
+    credentialKeyAgreementKey: IKeyAgreementKey;
+    userKey?: UserKey;
+    pinnedEpochId?: string | null;
+    onUserKeyAdopted?: (adopted: {
+        userKey: UserKey;
+        latestEpochId: string;
+        descriptor: CollectionEncryption;
+    }) => Promise<void>;
+    collections: CascadeCollections;
+}): Promise<DurableClientForgetResult>;
+//# sourceMappingURL=forget.d.ts.map

package/dist/clientAnnex/forget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forget.d.ts","sourceRoot":"","sources":["../../src/clientAnnex/forget.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAA;AAGxE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,OAAO,EACZ,KAAK,oBAAoB,EAC1B,MAAM,kBAAkB,CAAA;AAKzB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAA;AAEhE;;;;;;;GAOG;AACH,MAAM,WAAW,yBAAyB;IACxC,OAAO,EAAE,OAAO,CAAA;IAChB,WAAW,EAAE,oBAAoB,CAAA;IACjC,GAAG,EAAE,MAAM,CAAA;IACX,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,gBAAgB,CAAC,EAAE,oBAAoB,CAAA;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,QAAQ,EACR,UAAU,EACV,eAAe,EACf,iCAAiC,EACjC,iBAAiB,EACjB,WAAW,EACX,WAAW,EACX,yBAAyB,EACzB,OAAO,EACP,aAAa,EACb,gBAAgB,EAChB,WAAW,EACZ,EAAE;IACD,QAAQ,EAAE,cAAc,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,eAAe,EAAE,iBAAiB,CAAA;IAClC,iCAAiC,EAAE,MAAM,CAAA;IACzC,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,yBAAyB,CAAA;IACtC,yBAAyB,EAAE,gBAAgB,CAAA;IAC3C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,gBAAgB,CAAC,EAAE,CAAC,OAAO,EAAE;QAC3B,OAAO,EAAE,OAAO,CAAA;QAChB,aAAa,EAAE,MAAM,CAAA;QACrB,UAAU,EAAE,oBAAoB,CAAA;KACjC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IACnB,WAAW,EAAE,kBAAkB,CAAA;CAChC,GAAG,OAAO,CAAC,yBAAyB,CAAC,CAoGrC"}

package/dist/clientAnnex/forget.js

@@ -0,0 +1,133 @@
+import { readPublishedLog, relationIds } from '../webvh/didWebvh.js';
+import { cascadeCollectionsToUserKey, readUserKeyRoster, rosterRecipientKid, rotateUserKeyRoster } from '../keys/index.js';
+import { forgetWebvhClient, LastDurableClientForgetError } from './ladderAnchored.js';
+/**
+ * Forgets one enrolled durable client -- this browser's own -- from its
+ * account. See the module doc for the stage order (rotation and fan-out
+ * BEFORE the removal entry, the self-forget inversion) and the torn-state
+ * map. The caller runs the local wipe only after this resolves.
+ *
+ * @param options {object}
+ * @param options.logStore {UnlockLogStore}   the credential's delegated
+ *   `did.jsonl` bridge store; also serves the ceremony's public pre-edit
+ *   read. The caller is expected to have verified the account log under its
+ *   own chain-head pins in the same session (the ceremony re-reads through
+ *   the seam and checks `expectedDid`, but carries no pin store itself)
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed
+ * @param options.forgottenClient {RevokedClientKeys}   this client's public
+ *   halves; an `updateKeyMultibase` the log does not authorize (stale, or the
+ *   staged key) is re-derived from the log
+ * @param options.forgottenKeyAgreementKeyMultibase {string}   this client's
+ *   identity key-agreement key (the X25519 twin), naming its roster wrap
+ * @param [options.knownLatentHashes] {string[]}   standing latent commitments
+ *   the caller vouches for (the recovery registry's update-key hashes),
+ *   excluded from the staged-hash attribution
+ * @param options.expectedDid {string}   the account DID from the caller's
+ *   stored account pointer
+ * @param options.rosterStore {EncryptionDescriptorStore}   the
+ *   `key-map/user-key.jsonl` roster store, signing as the forgetting client
+ * @param options.credentialKeyAgreementKey {IKeyAgreementKey}   the standing
+ *   credential's key-agreement key -- the recipient whose wrap survives the
+ *   rotation, reading the fresh key back and unwrapping the generations for
+ *   the fan-out
+ * @param [options.userKey] {UserKey}   this client's cached user key
+ * @param [options.pinnedEpochId] {string}   the locally pinned latest-seen
+ *   roster epoch
+ * @param [options.onUserKeyAdopted] {Function}   persists a rotated key:
+ *   called with `{ userKey, latestEpochId, descriptor }` after the roster
+ *   read and BEFORE the fan-out
+ * @param options.collections {CascadeCollections}   the fan-out's work
+ * @returns {Promise<DurableClientForgetResult>}
+ */
+export async function forgetDurableClient({ logStore, ladderSeed, forgottenClient, forgottenKeyAgreementKeyMultibase, knownLatentHashes, expectedDid, rosterStore, credentialKeyAgreementKey, userKey, pinnedEpochId, onUserKeyAdopted, collections }) {
+    // The pre-edit read, doing double duty: the last-client refusal must fire
+    // BEFORE the rotation (or a refused forget would already have retired this
+    // client's wrap), and the rotation's recipient resolver needs the pre-edit
+    // document (which still keys every other recipient).
+    const published = await readPublishedLog({
+        // readPublishedLog only calls getIdResourceRaw, so the narrow seam is
+        // safe.
+        idStore: logStore,
+        expectedDid
+    });
+    if (!published) {
+        throw new Error('did:webvh: did.jsonl is missing; nothing to forget from.');
+    }
+    const signingVmId = `${published.did}#${forgottenClient.signingKeyMultibase}`;
+    const invocationIds = relationIds(published.doc.capabilityInvocation);
+    if (invocationIds.includes(signingVmId) &&
+        invocationIds.every(id => id === signingVmId)) {
+        throw new LastDurableClientForgetError();
+    }
+    // Stages 1 and 2: the roster rotation off this client's wrap and the
+    // collection fan-out, both under this client's still-standing authority.
+    let rotated = false;
+    let read;
+    let cascade = { outcomes: {}, failed: [] };
+    const current = await rosterStore.read();
+    if (current !== null) {
+        const forgottenKid = rosterRecipientKid({
+            signingKeyMultibase: forgottenClient.signingKeyMultibase,
+            keyAgreementKeyMultibase: forgottenKeyAgreementKeyMultibase
+        });
+        let descriptor = current.descriptor;
+        const currentEpoch = (descriptor.epochs ?? []).find(epoch => epoch.id === descriptor.currentEpoch);
+        const wrapped = currentEpoch?.recipients.some(entry => entry.header.kid === forgottenKid);
+        if (wrapped) {
+            descriptor = await rotateUserKeyRoster({
+                store: rosterStore,
+                document: published.doc,
+                retireRecipientId: forgottenKid
+            });
+            rotated = true;
+        }
+        // The fresh key comes back through the credential's standing wrap -- this
+        // client's own is gone from the current epoch -- with the continuity and
+        // possession checks still running on the threaded descriptor.
+        const adopted = await readUserKeyRoster({
+            store: rosterStore,
+            descriptor,
+            ...(userKey ? { userKey } : {}),
+            clientKeyAgreementKey: credentialKeyAgreementKey,
+            pinnedEpochId
+        });
+        if (adopted.rotated) {
+            await onUserKeyAdopted?.({
+                userKey: adopted.userKey,
+                latestEpochId: adopted.latestEpochId,
+                descriptor: adopted.descriptor
+            });
+        }
+        read = { userKey: adopted.userKey, descriptor: adopted.descriptor };
+        cascade = await cascadeCollectionsToUserKey({
+            collectionIds: typeof collections.collectionIds === 'function'
+                ? await collections.collectionIds()
+                : collections.collectionIds,
+            storeFor: collections.storeFor,
+            ...(collections.isEncrypted
+                ? { isEncrypted: collections.isEncrypted }
+                : {}),
+            rosterDescriptor: adopted.descriptor,
+            clientKeyAgreementKey: credentialKeyAgreementKey,
+            userKey: adopted.userKey
+        });
+    }
+    // Stage 3: the atomic ladder-signed removal entry, through the bridge.
+    const removed = await forgetWebvhClient({
+        store: logStore,
+        ladderSeed,
+        forgottenClient,
+        ...(knownLatentHashes ? { knownLatentHashes } : {}),
+        expectedDid
+    });
+    return {
+        rotated,
+        collections: cascade,
+        did: removed.did,
+        document: removed.doc,
+        ...(read
+            ? { userKey: read.userKey, rosterDescriptor: read.descriptor }
+            : {})
+    };
+}
+//# sourceMappingURL=forget.js.map

package/dist/clientAnnex/forget.js.map

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