@interop/wallet-core 0.48.0 → 0.50.0

package/dist/clientAnnex/ladderAnchored.js

@@ -0,0 +1,631 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The ladder-anchored ceremonies on the ACCOUNT log -- everything a standing
+ * credential's ladder does to the world-readable `did.jsonl` beyond the
+ * split-posture edits (which stay in `unlock/standingWebvh.ts`):
+ *
+ * - {@link createLadderAnchoredAccountLog} / {@link ensureLadderAnchoredDidWebvh}
+ *   -- the genesis of an account with zero enrolled durable clients, anchored
+ *   on the credential's ladder alone (rung 0 signs, the ladder VM and the
+ *   credential's `keyAgreement` posture fold into the one entry).
+ * - {@link selfEnrollWebvhClient} -- the self-enrolling continuation a fresh
+ *   browser runs with nothing but the credential: two entries through the
+ *   record's delegated `did.jsonl` bridge --
+ *
+ *   1. **Reveal + commit**: ladder rung `i` joins `updateKeys` (its hash
+ *      stands committed, which is what makes the entry verify) and
+ *      `nextKeyHashes` extends with the new ordinary client's update- and
+ *      staged-key hashes plus `hash(rung i + 1)` -- the credential's next
+ *      standing commitment.
+ *   2. **Add + retire the rung**: signed by the new client's update key
+ *      (revealed from the commit), this entry publishes the new client's
+ *      verification methods and update key and drops the spent rung and its
+ *      hash. The credential's own posture -- its `keyAgreement` entry and the
+ *      freshly committed `hash(rung i + 1)` -- stands untouched, ready for
+ *      the next self-enrollment. Nothing is spent, and no replacement exists.
+ *      When the account was LADDER-ANCHORED, the same atomic entry removes
+ *      the ladder VM from the document and its relations -- the transitional
+ *      key exists only while no durable client does, and folding the removal
+ *      in leaves no window with neither.
+ *
+ * - {@link forgetWebvhClient} -- self-enrollment in reverse: one atomic
+ *   ladder-signed removal entry through the bridge takes a durable client's
+ *   whole document footprint out; the last enrolled durable client refuses
+ *   ({@link LastDurableClientForgetError}).
+ * - {@link installLadderVmWebvh} / {@link forgetLastWebvhClient} -- the two
+ *   entries of the LAST durable client's forget (decision 0004's 2026-08-19
+ *   amendment): an install entry publishing the ladder VM while the client
+ *   stands (the both-present transitional state), then -- after the
+ *   revocations the composed ceremony runs in between -- a removal entry
+ *   that takes the client out while the installed VM keeps the account
+ *   ladder-anchored. The composed ceremony is `forgetLast.ts`.
+ *
+ * Which rung is current is recovered from the log itself
+ * (`attributeLadderRung`, fail-closed); a lost compare-and-swap race re-runs,
+ * re-attributes, and climbs to the winner's committed rung -- the
+ * retry-up-the-ladder resolution. Every stage is idempotent and resumable
+ * from durable state alone, on the recovery continuation's pattern.
+ */
+import { deriveNextKeyHash, updateDID } from '@interop/did-method-webvh';
+import { assertCarryOverCommitments, concludeWithPublishedLog, createLadderAnchoredWebvhLog, didWebvhControllerTemplate, genesisNextKeyHashes, ladderVerificationMethod, markedVerificationMethodPair, pinOfLog, publishWebvhLog, putLogResource, readPublishedLog, relationIds, updateKeySigner, withLogConflictRetry } from '../webvh/didWebvh.js';
+import { accountLogPinId } from '../webvh/verifyLog.js';
+import { ladderVmIds } from '../webvh/listClients.js';
+import { clientRemovalFields, clientRemovalTarget } from '../webvh/revokeClient.js';
+import { readLogOrThrow, unlockKeyVerificationMethod } from '../unlock/standingWebvh.js';
+import { attributeLadderRung, ladderRung, ladderVmKeyMultibase } from './ladder.js';
+/**
+ * LADDER-ANCHORED GENESIS: assembles the one-entry did:webvh log of an account
+ * with zero enrolled durable clients, anchored on the minting credential's
+ * ladder alone. Everything derives from the ladder seed: rung 0 is the sole
+ * `updateKeys` member and signs the entry, `nextKeyHashes` commits rung 0's
+ * own carry-over hash plus rung 1 (the staged rung) -- the carry-over hash is
+ * what the first durable self-enrollment's reveal-and-commit entry,
+ * re-stating `updateKeys` containing rung 0, requires --
+ * and the ladder VM (the stable sibling) is published under `assertionMethod`
+ * and `capabilityDelegation` only. The credential's `keyAgreement` posture
+ * entry is FOLDED INTO GENESIS -- no enrolled client exists to run the
+ * separate bind entry ({@link publishUnlockKey}) -- so the genesis
+ * `keyAgreement` array holds only the credential's entry.
+ *
+ * The ladder-anchored window this opens is closed by the credential's first
+ * durable self-enrollment ({@link selfEnrollWebvhClient}), whose add entry
+ * atomically publishes the client, retires rung 0, and removes the ladder VM.
+ *
+ * The caller owns publication (conditional, create-only) and the pointer
+ * write that follows; this assembles and signs the log only.
+ *
+ * @param options {object}
+ * @param options.wasServerUrl {string}
+ * @param options.spaceId {string}
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}   the
+ *   credential's key-agreement publication (commitment or verbatim)
+ * @returns {Promise<{ log: DIDLog, webDoc: object, did: string }>}
+ */
+export async function createLadderAnchoredAccountLog({ wasServerUrl, spaceId, ladderSeed, keyAgreement }) {
+    const rung0 = await ladderRung({ ladderSeed, index: 0 });
+    const rung1 = await ladderRung({ ladderSeed, index: 1 });
+    const controllerTemplate = didWebvhControllerTemplate({
+        wasServerUrl,
+        spaceId
+    });
+    return createLadderAnchoredWebvhLog({
+        wasServerUrl,
+        spaceId,
+        ladderVmKeyMultibase: await ladderVmKeyMultibase({ ladderSeed }),
+        credentialKeyAgreementMethod: unlockKeyVerificationMethod({
+            did: controllerTemplate,
+            keyAgreement
+        }),
+        updateKeyPublicKeyMultibase: rung0.keyMultibase,
+        nextKeyHashes: await genesisNextKeyHashes({
+            activeKeyMultibase: rung0.keyMultibase,
+            stagedKeyMultibase: rung1.keyMultibase
+        }),
+        signer: await updateKeySigner({ seed: rung0.seed })
+    });
+}
+/**
+ * LADDER-ANCHORED GENESIS AS AN ENSURE: probe, adopt, or create-and-publish --
+ * {@link createLadderAnchoredAccountLog} with the durable-flow `ensureDidWebvh`
+ * convention wrapped around it. The convergence rule is what makes signup a
+ * ceremony rather than a bare create: `createDID` timestamps the genesis
+ * entry, so a naive re-run of a torn signup mints a DIFFERENT SCID and its
+ * create-if-absent PUT can never land. So a published log is ADOPTED instead
+ * -- iff `attributeLadderRung` attributes its update parameters to this
+ * credential's ladder (rung revealed or committed; a foreign log fails
+ * closed with `LadderAttributionError` and is never built on).
+ *
+ * The publish is a conditional create-if-absent, so a concurrent signup's
+ * winner is adopted on the conflict re-run rather than erased. On the create
+ * path a supplied `pinStore` is written from the log this run minted (the
+ * account-log trust-on-first-use convention: the creator knows the true
+ * genesis); on the probe path the read itself carries the pin check.
+ *
+ * @param options {object}
+ * @param options.idStore {WebvhIdStore}
+ * @param options.wasServerUrl {string}
+ * @param options.spaceId {string}
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed
+ * @param options.keyAgreement {UnlockKeyAgreementPublication}   the
+ *   credential's key-agreement publication (commitment or verbatim)
+ * @param [options.expectedDid] {string}   the DID the published log must
+ *   resolve to, when the caller holds the account pointer; a heal login on a
+ *   fresh terminal legitimately holds none
+ * @param [options.pinStore] {ResourceLogPinStore}   this client's chain-head
+ *   pins; the account log's slot is keyed by `accountLogPinId` over the
+ *   `spaceId` above
+ * @returns {Promise<{ did: string }>}
+ */
+export async function ensureLadderAnchoredDidWebvh(options) {
+    return withLogConflictRetry(() => ensureLadderAnchoredDidWebvhOnce(options));
+}
+/**
+ * One attempt of {@link ensureLadderAnchoredDidWebvh}, re-invoked by the
+ * conflict retry.
+ *
+ * @param options {object}   see {@link ensureLadderAnchoredDidWebvh}
+ * @returns {Promise<{ did: string }>}
+ */
+async function ensureLadderAnchoredDidWebvhOnce({ idStore, wasServerUrl, spaceId, ladderSeed, keyAgreement, expectedDid, pinStore }) {
+    const logId = accountLogPinId({ spaceId });
+    const published = await readPublishedLog({
+        idStore,
+        ...(expectedDid !== undefined ? { expectedDid } : {}),
+        ...(pinStore ? { pinStore, logId } : {})
+    });
+    if (published) {
+        // Adoption: a torn earlier signup (or a concurrent one) already published
+        // the log. Adopt it iff this credential's ladder attributes it -- the
+        // ladder-anchored analog of the durable path's "authorizes one of this
+        // client's seeds" check. The attribution accepts a revealed rung too, so
+        // an account that has since self-enrolled a durable client (retiring
+        // rung 0) still adopts here rather than hard-failing.
+        await attributeLadderRung({ ladderSeed, published });
+        // Heals a did.json left lagging by a torn earlier publish.
+        const { did } = await concludeWithPublishedLog({ idStore, published });
+        return { did };
+    }
+    const created = await createLadderAnchoredAccountLog({
+        wasServerUrl,
+        spaceId,
+        ladderSeed,
+        keyAgreement
+    });
+    await publishWebvhLog({
+        idStore,
+        log: created.log,
+        webDoc: created.webDoc,
+        // Create-if-absent: a concurrent signup that already published its own
+        // log wins, and this run re-reads and adopts (or refuses) instead of
+        // erasing it.
+        ifNoneMatch: true
+    });
+    // Trust-on-first-use, established by the creator itself: this run minted the
+    // genesis, so the pin it writes needs no served log to be believed.
+    if (pinStore) {
+        await pinStore.write({ logId, pin: pinOfLog(created.log) });
+    }
+    return { did: created.did };
+}
+/**
+ * Publishes `did.jsonl` through the narrow seam -- the log only, never
+ * `did.json` (the bridge delegation covers nothing else; the enrolled session
+ * republishes the projection once it is the controller). Conditional on the
+ * read the entry was built on; a lost race surfaces as a
+ * `WebvhLogConflictError` (the mapping lives in `putLogResource`).
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}
+ * @param options.log {DIDLog}
+ * @param [options.ifMatch] {string}   publish only if `did.jsonl` is unchanged
+ * @returns {Promise<void>}
+ */
+async function publishLogOnly({ store, log, ifMatch }) {
+    await putLogResource({ store, log, ifMatch });
+}
+/**
+ * SELF-ENROLLMENT (run by the credential-derived client through the delegated
+ * `did.jsonl` PUT): writes the standing continuation described in the module
+ * doc -- the reveal-and-commit entry signed by the attributed ladder rung,
+ * then the add entry signed by the new ordinary client's update key, which
+ * also retires the spent rung. Resumable from durable state alone: a
+ * completed continuation is detected by the new client's update key already
+ * being authorized (no-op), a torn one by the attribution finding the rung
+ * already revealed. Both entries publish conditionally on the read they were
+ * built on, and a race lost to a concurrent ceremony re-runs from the top --
+ * re-attributing, which is exactly the retry-up-the-ladder resolution.
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}   public log read + delegated PUT
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed, from
+ *   its unlock record
+ * @param options.newClientKeys {WebvhEnrollmentKeys}   the new ordinary
+ *   client's public halves
+ * @param options.newClientUpdateSeeds {ClientWebvhUpdateKeys}   the new
+ *   client's update-key seeds (minted by the self-enrolling flow, which
+ *   therefore holds them and can sign the add entry)
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, from the credential-authenticated pointer
+ * @returns {Promise<{ did: string, webDoc?: object }>}   the account DID and,
+ *   when the add entry ran here, the final `did.json` projection for the
+ *   enrolled session to republish
+ */
+export async function selfEnrollWebvhClient(options) {
+    return withLogConflictRetry(() => selfEnrollWebvhClientOnce(options));
+}
+/**
+ * One attempt of {@link selfEnrollWebvhClient}, re-invoked by the conflict
+ * retry.
+ *
+ * @param options {object}   see {@link selfEnrollWebvhClient}
+ * @returns {Promise<{ did: string, webDoc?: object }>}
+ */
+async function selfEnrollWebvhClientOnce({ store, ladderSeed, newClientKeys, newClientUpdateSeeds, expectedDid }) {
+    let published = await readLogOrThrow({
+        store,
+        ...(expectedDid !== undefined ? { expectedDid } : {})
+    });
+    // Already complete (a torn earlier run finished the add entry): the new
+    // client's update key is authorized, which only the add entry writes.
+    if (published.updateKeys.includes(newClientKeys.updateKeyMultibase)) {
+        return { did: published.did };
+    }
+    // Which rung is current, recovered from the log itself. Fails closed with
+    // `LadderAttributionError` for a revoked (or never-bound) credential and
+    // for any ambiguous history.
+    const { rung, state } = await attributeLadderRung({ ladderSeed, published });
+    const nextRung = await ladderRung({ ladderSeed, index: rung.index + 1 });
+    const rungHash = await deriveNextKeyHash(rung.keyMultibase);
+    const newUpdateHash = await deriveNextKeyHash(newClientKeys.updateKeyMultibase);
+    const newStagedHash = await deriveNextKeyHash(newClientKeys.stagedUpdateKeyMultibase);
+    const nextRungHash = await deriveNextKeyHash(nextRung.keyMultibase);
+    // The reveal-and-commit entry, skipped when a torn earlier run already
+    // published it (the rung revealed AND every needed hash committed).
+    const revealed = state === 'revealed';
+    const committed = [newUpdateHash, newStagedHash, nextRungHash].every(hash => published.nextKeyHashes.includes(hash));
+    if (!revealed || !committed) {
+        await assertCarryOverCommitments({ published });
+        const signer = await updateKeySigner({ seed: rung.seed });
+        const updated = await updateDID({
+            log: published.log,
+            signer,
+            alsoKnownAsWeb: true,
+            updateKeys: [...new Set([...published.updateKeys, rung.keyMultibase])],
+            // The spent rung's own hash is kept through this entry (so a resumed
+            // commit can re-state the revealed key); the add entry drops it, while
+            // the next rung's hash stays as the credential's standing commitment.
+            nextKeyHashes: [
+                ...new Set([
+                    ...published.nextKeyHashes,
+                    rungHash,
+                    newUpdateHash,
+                    newStagedHash,
+                    nextRungHash
+                ])
+            ]
+        });
+        await publishLogOnly({ store, log: updated.log, ifMatch: published.etag });
+        // The same account the reveal entry just extended.
+        published = await readLogOrThrow({ store, expectedDid: published.did });
+    }
+    // The add entry: the new client's verification methods and update key in;
+    // the spent rung's key and hash out. The credential's keyAgreement entry
+    // and the next rung's committed hash stand untouched. Signed by the new
+    // client's update key, whose hash the commit entry just committed.
+    const { did, doc } = published;
+    const vmId = (publicKeyMultibase) => `${did}#${publicKeyMultibase}`;
+    // When this is the FIRST durable enrollment of a ladder-anchored account, the
+    // same atomic entry ends the ladder-anchored window: every ladder VM (the
+    // relation-asymmetry recognition) leaves the document and its relations
+    // here, so no window exists where the account has neither a durable client
+    // nor the ladder VM. On an account with enrolled clients the recognition
+    // finds none and the filters are no-ops.
+    const ladderVms = ladderVmIds({ doc });
+    const addedMethods = markedVerificationMethodPair({
+        controller: did,
+        signingKeyMultibase: newClientKeys.signingKeyMultibase,
+        keyAgreementKeyMultibase: newClientKeys.keyAgreementKeyMultibase
+    });
+    const existingMethods = (doc.verificationMethod ?? []);
+    const verificationMethods = [
+        ...existingMethods.filter(method => !addedMethods.some(added => added.id === method.id) &&
+            (method.id === undefined || !ladderVms.includes(method.id))),
+        ...addedMethods
+    ];
+    const withReference = (relation, id) => [...new Set([...relationIds(relation), id])].filter(referencedId => !ladderVms.includes(referencedId));
+    const signingVmId = vmId(newClientKeys.signingKeyMultibase);
+    const signer = await updateKeySigner({
+        seed: newClientUpdateSeeds.updateSeed
+    });
+    const updated = await updateDID({
+        log: published.log,
+        signer,
+        alsoKnownAsWeb: true,
+        updateKeys: [
+            ...new Set([
+                ...published.updateKeys.filter(key => key !== rung.keyMultibase),
+                newClientKeys.updateKeyMultibase
+            ])
+        ],
+        nextKeyHashes: published.nextKeyHashes.filter(hash => hash !== rungHash),
+        verificationMethods,
+        authentication: withReference(doc.authentication, signingVmId),
+        assertionMethod: withReference(doc.assertionMethod, signingVmId),
+        keyAgreement: withReference(doc.keyAgreement, vmId(newClientKeys.keyAgreementKeyMultibase)),
+        capabilityInvocation: withReference(doc.capabilityInvocation, signingVmId),
+        capabilityDelegation: withReference(doc.capabilityDelegation, signingVmId)
+    });
+    // Conditional on the read this entry was built on: the re-read above when
+    // the commit entry ran here, the first read when it was skipped.
+    await publishLogOnly({ store, log: updated.log, ifMatch: published.etag });
+    return { did: updated.did, webDoc: updated.webDoc };
+}
+/**
+ * Thrown when the client being forgotten is the account's LAST enrolled
+ * durable client. Removing it through this entry would leave the document
+ * with no client and no ladder verification method -- an account nothing can
+ * invoke for -- so that case is its own ceremony (the two-entry
+ * ladder-VM-install shape), and this primitive refuses rather than
+ * transitioning the account by accident.
+ *
+ * **`name` is a stable contract.** It is always the string
+ * `'LastDurableClientForgetError'`, and a consumer should match on that
+ * rather than on `instanceof`: a wallet app that links this package (or holds
+ * two copies of it through a dependency tree) gets a different class object
+ * for the same error, so `instanceof` silently fails there while the name
+ * does not.
+ */
+export class LastDurableClientForgetError extends Error {
+    constructor() {
+        super('did:webvh: the client being forgotten is the last enrolled durable ' +
+            'client; forgetting it takes the ladder-anchored transition ceremony, ' +
+            'not the plain removal entry.');
+        this.name = 'LastDurableClientForgetError';
+    }
+}
+/**
+ * FORGET (run by the forgetting client itself, through the standing
+ * credential's bridge): removes THIS browser's enrolled client from the
+ * published document in ONE atomic ladder-signed entry -- self-enrollment in
+ * reverse, collapsed to a single entry because a removal reveals no new key.
+ * The signer is the credential's current ladder rung, recovered from the log
+ * itself ({@link attributeLadderRung}): its hash stands committed by the
+ * credential's posture (or the rung is already revealed), which is exactly
+ * what lets it reveal itself in the entry it signs under prerotation. The
+ * entry's members are the revocation removal's, verbatim
+ * (`clientRemovalTarget` / `clientRemovalFields`, shared with
+ * `revokeWebvhClient` so the two removal shapes cannot drift): the client's
+ * verification methods out of the document and all five relations, its update
+ * key out of `updateKeys`, and its carry-over and staged hashes out of
+ * `nextKeyHashes` -- plus the acting rung into `updateKeys` with its own hash
+ * kept committed (the carry-over convention).
+ *
+ * Atomicity is the point of the one-entry shape: no torn state exists where
+ * the rung is revealed and the client still stands. The honest residue is the
+ * acting rung itself -- no entry can remove its own signing key, so the rung
+ * stands REVEALED in `updateKeys` afterwards (the same standing state the
+ * ladder-anchored postures live in). That is credential-held authority, not
+ * the forgotten client's: only the ladder seed derives it, the credential's
+ * next self-enrollment consumes and retires it, and retiring the credential
+ * itself strikes it (`attributeLadderPosture`).
+ *
+ * Forgetting the LAST enrolled durable client is refused
+ * ({@link LastDurableClientForgetError}): that transition -- to the
+ * client-less, ladder-anchored state -- is its own two-entry ceremony.
+ *
+ * Idempotent: a client with no remaining presence is a no-op that returns the
+ * published state unchanged, so a naive re-run after a torn ceremony
+ * converges. The entry publishes conditionally on the log this call read; a
+ * lost race re-runs, re-attributes, and rebases on the winner's head.
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}   the credential's delegated
+ *   `did.jsonl` bridge store
+ * @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.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 the log must resolve
+ *   to, from the caller's stored account pointer
+ * @returns {Promise<{ did: string, doc: DIDDoc, log: DIDLog }>}   the account
+ *   DID and the document and log as the removal entry leaves them (unchanged
+ *   on the idempotent no-op path)
+ */
+export async function forgetWebvhClient(options) {
+    return withLogConflictRetry(() => clientForgetEntryOnce({ ...options, transition: false }));
+}
+/**
+ * THE LAST-CLIENT REMOVAL ENTRY (the two-entry transition ceremony's second
+ * entry): {@link forgetWebvhClient}'s removal shape with the last-client
+ * refusal inverted -- the forgotten client IS the last enrolled durable
+ * client, and the account stays invocable because the ladder VM the install
+ * entry published ({@link installLadderVmWebvh}) remains in the document. A
+ * document NOT carrying this credential's ladder VM refuses: publishing the
+ * entry would strand the account with neither a durable client nor the
+ * ladder anchor. Run only from the composed ceremony
+ * (`forgetLastDurableClient`), which sequences the install entry and the
+ * delegation revocations before it.
+ *
+ * @param options {object}   see {@link forgetWebvhClient}
+ * @returns {Promise<{ did: string, doc: DIDDoc, log: DIDLog }>}
+ */
+export async function forgetLastWebvhClient(options) {
+    return withLogConflictRetry(() => clientForgetEntryOnce({ ...options, transition: true }));
+}
+/**
+ * One attempt of {@link forgetWebvhClient} or {@link forgetLastWebvhClient},
+ * re-invoked by the conflict retry. The two share everything but the guard:
+ * the plain forget refuses the last durable client, the transition removal
+ * requires the ladder VM already installed instead.
+ *
+ * @param options {object}   see {@link forgetWebvhClient}, plus:
+ * @param options.transition {boolean}   `true` for the last-client removal
+ *   entry (require the installed ladder VM), `false` for the plain forget
+ *   (refuse the last client)
+ * @returns {Promise<{ did: string, doc: DIDDoc, log: DIDLog }>}
+ */
+async function clientForgetEntryOnce({ store, ladderSeed, forgottenClient, knownLatentHashes = [], expectedDid, transition }) {
+    const published = await readLogOrThrow({
+        store,
+        ...(expectedDid !== undefined ? { expectedDid } : {})
+    });
+    const { did, doc } = published;
+    const target = await clientRemovalTarget({
+        published,
+        client: forgottenClient
+    });
+    if (!target.present) {
+        // Already forgotten (a torn earlier run finished the entry). No did.json
+        // heal here: the bridge covers did.jsonl only.
+        return { did, doc, log: published.log };
+    }
+    if (transition) {
+        // The no-neither invariant, checked rather than assumed: the removal may
+        // only publish while the ladder VM stands in the document (the install
+        // entry ran), or the account would land with nothing that can anchor it.
+        const ladderVmId = `${did}#${await ladderVmKeyMultibase({ ladderSeed })}`;
+        if (!ladderVmIds({ doc }).includes(ladderVmId)) {
+            throw new Error('did:webvh: the ladder VM is not installed in the document; the ' +
+                'last-client removal entry would strand the account (the install ' +
+                'entry runs first).');
+        }
+    }
+    else {
+        // The last-client refusal: capabilityInvocation lists exactly the
+        // enrolled clients' signing keys (a recovery code's key is
+        // keyAgreement-only and the KMS convenience authentication-only), so the
+        // forgotten client standing alone there means removing it strands the
+        // account.
+        const invocationIds = relationIds(doc.capabilityInvocation);
+        if (invocationIds.includes(target.signingVmId) &&
+            invocationIds.every(id => id === target.signingVmId)) {
+            throw new LastDurableClientForgetError();
+        }
+    }
+    // Which rung is current, recovered from the log itself. Fails closed with
+    // `LadderAttributionError` for a revoked (or never-bound) credential and
+    // for any ambiguous history.
+    const { rung } = await attributeLadderRung({ ladderSeed, published });
+    const rungHash = await deriveNextKeyHash(rung.keyMultibase);
+    await assertCarryOverCommitments({ published });
+    // The ladder vouches for its own commitments: a self-enrolled client's
+    // staged hash was committed in the same reveal entry as the next rung's
+    // hash, so without these the staged-hash attribution cannot tell the two
+    // apart. Every hash a reveal entry can have committed is for a rung at or
+    // one past the current index.
+    const ladderHashes = [];
+    for (let index = 0; index <= rung.index + 1; index++) {
+        const laddered = await ladderRung({ ladderSeed, index });
+        ladderHashes.push(await deriveNextKeyHash(laddered.keyMultibase));
+    }
+    const fields = await clientRemovalFields({
+        published,
+        target,
+        knownLatentHashes: [...knownLatentHashes, ...ladderHashes]
+    });
+    const signer = await updateKeySigner({ seed: rung.seed });
+    const updated = await updateDID({
+        log: published.log,
+        signer,
+        alsoKnownAsWeb: true,
+        ...fields,
+        // The acting rung reveals itself in the entry it signs (its hash stands
+        // committed, or the rung is already revealed), and its own hash is kept
+        // committed so the carry-over convention holds for the next entry.
+        updateKeys: [...new Set([...fields.updateKeys, rung.keyMultibase])],
+        nextKeyHashes: [...new Set([...fields.nextKeyHashes, rungHash])]
+    });
+    await publishLogOnly({ store, log: updated.log, ifMatch: published.etag });
+    return { did: updated.did, doc: updated.doc, log: updated.log };
+}
+/**
+ * THE LADDER-VM INSTALL ENTRY (the two-entry transition ceremony's first
+ * entry): publishes the credential's ladder VM -- the stable sibling, under
+ * `assertionMethod` and `capabilityDelegation` only -- while the last durable
+ * client's whole footprint stays untouched: the both-present transitional
+ * state the no-neither invariant permits. The entry is ladder-signed by the
+ * attributed rung, which reveals itself into `updateKeys` with its own hash
+ * kept committed (the carry-over convention), exactly the removal entry's
+ * rung math -- so a torn ceremony's re-run re-attributes the now-revealed
+ * rung and carries on.
+ *
+ * This entry is what makes the transition's document version POSTURE-CHANGING
+ * under the ceremony-tail license (the ladder-VM set gains a member), so the
+ * ceremony's ONE ladder-signed roster append anchors here -- and it is what
+ * lets the delegation revocations that follow verify their ladder-signed
+ * chains against the currently resolved document while the still-standing
+ * client signs the invocations.
+ *
+ * Idempotent: a document already carrying this credential's ladder VM (by
+ * the relation-asymmetry recognition) returns unchanged with
+ * `installed: false`. The entry publishes conditionally on the log this call
+ * read; a lost race re-runs, re-attributes, and rebases on the winner's
+ * head.
+ *
+ * @param options {object}
+ * @param options.store {UnlockLogStore}   the credential's delegated
+ *   `did.jsonl` bridge store
+ * @param options.ladderSeed {Uint8Array}   the credential's ladder seed
+ * @param [options.expectedDid] {string}   the account DID the log must resolve
+ *   to, from the caller's stored account pointer
+ * @returns {Promise<{ did: string, doc: DIDDoc, log: DIDLog, installed: boolean }>}
+ *   the account DID and the document and log as the install entry leaves them
+ *   (unchanged on the idempotent no-op path); `installed` says whether the
+ *   entry ran on this call
+ */
+export async function installLadderVmWebvh(options) {
+    return withLogConflictRetry(() => installLadderVmWebvhOnce(options));
+}
+/**
+ * One attempt of {@link installLadderVmWebvh}, re-invoked by the conflict
+ * retry.
+ *
+ * @param options {object}   see {@link installLadderVmWebvh}
+ * @returns {Promise<{ did: string, doc: DIDDoc, log: DIDLog, installed: boolean }>}
+ */
+async function installLadderVmWebvhOnce({ store, ladderSeed, expectedDid }) {
+    const published = await readLogOrThrow({
+        store,
+        ...(expectedDid !== undefined ? { expectedDid } : {})
+    });
+    const { did, doc } = published;
+    const ladderVmKey = await ladderVmKeyMultibase({ ladderSeed });
+    const ladderVmId = `${did}#${ladderVmKey}`;
+    if (ladderVmIds({ doc }).includes(ladderVmId)) {
+        // Already installed (a torn earlier run published the entry, or the
+        // account is mid-transition).
+        return { did, doc, log: published.log, installed: false };
+    }
+    // Which rung is current, recovered from the log itself. Fails closed with
+    // `LadderAttributionError` for a revoked (or never-bound) credential and
+    // for any ambiguous history.
+    const { rung } = await attributeLadderRung({ ladderSeed, published });
+    const rungHash = await deriveNextKeyHash(rung.keyMultibase);
+    await assertCarryOverCommitments({ published });
+    const existingMethods = (doc.verificationMethod ?? []);
+    const verificationMethods = [
+        ...existingMethods.filter(method => method.id !== ladderVmId),
+        ladderVerificationMethod({
+            controller: did,
+            publicKeyMultibase: ladderVmKey
+        })
+    ];
+    // The ladder VM's relation asymmetry: `assertionMethod` and
+    // `capabilityDelegation` only -- no `authentication`, no
+    // `capabilityInvocation` -- which is also what keeps it out of every client
+    // listing.
+    const withVm = (relation) => [
+        ...new Set([...relationIds(relation), ladderVmId])
+    ];
+    const signer = await updateKeySigner({ seed: rung.seed });
+    const updated = await updateDID({
+        log: published.log,
+        signer,
+        alsoKnownAsWeb: true,
+        // The acting rung reveals itself in the entry it signs (its hash stands
+        // committed, or the rung is already revealed), and its own hash is kept
+        // committed so the carry-over convention holds for the next entry.
+        updateKeys: [...new Set([...published.updateKeys, rung.keyMultibase])],
+        nextKeyHashes: [...new Set([...published.nextKeyHashes, rungHash])],
+        verificationMethods,
+        authentication: relationIds(doc.authentication),
+        assertionMethod: withVm(doc.assertionMethod),
+        keyAgreement: relationIds(doc.keyAgreement),
+        capabilityInvocation: relationIds(doc.capabilityInvocation),
+        capabilityDelegation: withVm(doc.capabilityDelegation)
+    });
+    await publishLogOnly({ store, log: updated.log, ifMatch: published.etag });
+    return {
+        did: updated.did,
+        doc: updated.doc,
+        log: updated.log,
+        installed: true
+    };
+}
+//# sourceMappingURL=ladderAnchored.js.map

package/dist/clientAnnex/ladderAnchored.js.map

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