@interop/wallet-core 0.9.0 → 0.11.0

package/README.md

@@ -63,13 +63,18 @@ The subpaths:
 
 - **`@interop/wallet-core/webvh`** -- the account's did:webvh identity: the
   hosted DID log, its per-client update-key rotation, the client enrollment
-  entries, and ZCap signing under the did:webvh verification-method id.
+  entries, the one-entry client-revocation edit (verification methods, update
+  key, and standing commitments out in a single entry, the staged commitment
+  recovered by log attribution), and ZCap signing under the did:webvh
+  verification-method id.
 
 - **`@interop/wallet-core/keys`** -- the per-user key (PUK) and its
   `key-map/puk.json` wrap-set roster: minting, the roster's init/read/rotate
   primitives with their client-side guards (`epochsMac`, the latest-seen epoch
-  pin, the document-backed recipient resolver), and the roster's
-  compare-and-swap descriptor store.
+  pin, the document-backed recipient resolver), the roster's compare-and-swap
+  descriptor store, and the PUK rotation cascade's per-collection op (re-epoch a
+  collection onto the roster's current PUK, staleness detected from durable
+  state alone, history escrowed -- also the completion sweep's building block).
 
 - **`@interop/wallet-core/descriptors`** -- collection encryption-descriptor
   acquisition (fetch / cache / offline fallback) and the unknown-epoch refresh

package/dist/keyring/index.d.ts

@@ -25,6 +25,6 @@ export { deriveUnlockIdentity, KEYRING_KDF, UNLOCK_HANDLE, UNLOCK_KEY_NAME, unlo
 export type { UnlockIdentity, UnlockKdf } from './kdf.js';
 export { KEYRING_RECORD_VERSION, parseRecordPointer, unwrapKeyringRecord, wrapKeyringRecord } from './record.js';
 export type { AccountPointer, KeyringRecordContents } from './record.js';
-export { deleteUnlockSpace, deleteUnlockSpaceWithCapability, ensureUnlockSpace, getUnlockKeyring, putUnlockKeyring, UNLOCK_SPACE_NAME } from './unlockSpace.js';
+export { deleteUnlockSpace, deleteUnlockSpaceWithCapability, ensureUnlockSpace, getUnlockKeyring, putUnlockKeyring, putUnlockKeyringWithCapability, UNLOCK_SPACE_NAME } from './unlockSpace.js';
 export { fetchKeyringRecord } from './fetch.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/keyring/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keyring/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,eAAe,EACf,gBAAgB,EACjB,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzD,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAExE,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keyring/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,eAAe,EACf,gBAAgB,EACjB,MAAM,UAAU,CAAA;AACjB,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEzD,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAExE,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,8BAA8B,EAC9B,iBAAiB,EAClB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA"}

package/dist/keyring/index.js

@@ -23,6 +23,6 @@
  */
 export { deriveUnlockIdentity, KEYRING_KDF, UNLOCK_HANDLE, UNLOCK_KEY_NAME, unlockSpaceIdFor } from './kdf.js';
 export { KEYRING_RECORD_VERSION, parseRecordPointer, unwrapKeyringRecord, wrapKeyringRecord } from './record.js';
-export { deleteUnlockSpace, deleteUnlockSpaceWithCapability, ensureUnlockSpace, getUnlockKeyring, putUnlockKeyring, UNLOCK_SPACE_NAME } from './unlockSpace.js';
+export { deleteUnlockSpace, deleteUnlockSpaceWithCapability, ensureUnlockSpace, getUnlockKeyring, putUnlockKeyring, putUnlockKeyringWithCapability, UNLOCK_SPACE_NAME } from './unlockSpace.js';
 export { fetchKeyringRecord } from './fetch.js';
 //# sourceMappingURL=index.js.map

package/dist/keyring/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keyring/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,eAAe,EACf,gBAAgB,EACjB,MAAM,UAAU,CAAA;AAGjB,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,iBAAiB,EAClB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keyring/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EACL,oBAAoB,EACpB,WAAW,EACX,aAAa,EACb,eAAe,EACf,gBAAgB,EACjB,MAAM,UAAU,CAAA;AAGjB,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,aAAa,CAAA;AAGpB,OAAO,EACL,iBAAiB,EACjB,+BAA+B,EAC/B,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,8BAA8B,EAC9B,iBAAiB,EAClB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA"}

package/dist/keyring/unlockSpace.d.ts

@@ -59,6 +59,33 @@ export declare function putUnlockKeyring({ storageServerUrl, zcapClient, spaceId
     spaceId: string;
     record: object;
 }): Promise<void>;
+/**
+ * Writes (upserts) the keyring record with an explicitly attached management
+ * capability, rather than by root invocation. The `zcapClient` here is an
+ * enrolled client's (not the unlock identity's); the attached `capability` --
+ * the management zcap the unlock identity delegated at bind time, provided it
+ * allows PUT -- authorizes the write against the unlock Space. This is what
+ * lets the revocation cascade re-PUT a recovery code's unlock record (a fresh
+ * `did.jsonl` delegation inside a re-wrapped record) without holding the
+ * code: the record's JWE recipient is the code's unlock KAK, whose PUBLIC
+ * half the issuing client recorded, so re-encryption needs no secret.
+ *
+ * @param options {object}
+ * @param options.storageServerUrl {string}
+ * @param options.zcapClient {ZcapClient}   an enrolled client's zcap client
+ * @param options.spaceId {string}   the unlock Space id
+ * @param options.record {object}   the keyring record
+ * @param options.capability {IZcap}   the delegated management zcap (must
+ *   allow PUT)
+ * @returns {Promise<void>}
+ */
+export declare function putUnlockKeyringWithCapability({ storageServerUrl, zcapClient, spaceId, record, capability }: {
+    storageServerUrl: string;
+    zcapClient: ZcapClient;
+    spaceId: string;
+    record: object;
+    capability: IZcap;
+}): Promise<void>;
 /**
  * Deletes the whole unlock Space (what retires an old passphrase on a
  * passphrase change). `space.delete()` is idempotent, so an already-absent

package/dist/keyring/unlockSpace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"unlockSpace.d.ts","sourceRoot":"","sources":["../../src/keyring/unlockSpace.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAA;AAoIrD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,UAAU,EACV,IAAwB,EACzB,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACR,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAQ1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,MAAM,EACP,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CAShB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACR,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,+BAA+B,CAAC,EACpD,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,UAAU,EACX,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,KAAK,CAAA;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAchB"}
+{"version":3,"file":"unlockSpace.d.ts","sourceRoot":"","sources":["../../src/keyring/unlockSpace.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,8BAA8B,CAAA;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,uBAAuB,CAAA;AAoIrD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,UAAU,EACV,IAAwB,EACzB,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,MAAM,CAAA;IAClB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACR,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC,CAQ1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,MAAM,EACP,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CAShB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAsB,8BAA8B,CAAC,EACnD,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,MAAM,EACN,UAAU,EACX,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,KAAK,CAAA;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAUhB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACR,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,OAAO,CAAC,IAAI,CAAC,CAGhB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,+BAA+B,CAAC,EACpD,gBAAgB,EAChB,UAAU,EACV,OAAO,EACP,UAAU,EACX,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,KAAK,CAAA;CAClB,GAAG,OAAO,CAAC,IAAI,CAAC,CAchB"}

package/dist/keyring/unlockSpace.js

@@ -175,6 +175,37 @@ export async function putUnlockKeyring({ storageServerUrl, zcapClient, spaceId,
         record
     });
 }
+/**
+ * Writes (upserts) the keyring record with an explicitly attached management
+ * capability, rather than by root invocation. The `zcapClient` here is an
+ * enrolled client's (not the unlock identity's); the attached `capability` --
+ * the management zcap the unlock identity delegated at bind time, provided it
+ * allows PUT -- authorizes the write against the unlock Space. This is what
+ * lets the revocation cascade re-PUT a recovery code's unlock record (a fresh
+ * `did.jsonl` delegation inside a re-wrapped record) without holding the
+ * code: the record's JWE recipient is the code's unlock KAK, whose PUBLIC
+ * half the issuing client recorded, so re-encryption needs no secret.
+ *
+ * @param options {object}
+ * @param options.storageServerUrl {string}
+ * @param options.zcapClient {ZcapClient}   an enrolled client's zcap client
+ * @param options.spaceId {string}   the unlock Space id
+ * @param options.record {object}   the keyring record
+ * @param options.capability {IZcap}   the delegated management zcap (must
+ *   allow PUT)
+ * @returns {Promise<void>}
+ */
+export async function putUnlockKeyringWithCapability({ storageServerUrl, zcapClient, spaceId, record, capability }) {
+    const was = unlockSpaceClient({ storageServerUrl, zcapClient });
+    const body = new TextEncoder().encode(JSON.stringify(record));
+    await was.request({
+        capability,
+        path: `/space/${spaceId}/${KEYRING_COLLECTION.id}/${KEYRING_RESOURCE}`,
+        method: 'PUT',
+        headers: { 'content-type': 'application/json' },
+        body
+    });
+}
 /**
  * Deletes the whole unlock Space (what retires an old passphrase on a
  * passphrase change). `space.delete()` is idempotent, so an already-absent

package/dist/keyring/unlockSpace.js.map

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

package/dist/keys/index.d.ts

@@ -16,10 +16,18 @@
  *   document).
  * - `pukRosterDescriptorStore` -- that descriptor store, built from a bare
  *   signing client for the login-time direct read.
+ * - `rotatePukRoster` / `unwrapPukGenerations` / `rotateCollectionEpochsToPuk`
+ *   / `cascadeCollectionsToPuk` / `pukAsRecipient` -- the PUK rotation
+ *   cascade: the roster rotation off a revoked recipient, the per-collection
+ *   re-epoch that brings an encrypted collection onto the roster's current
+ *   PUK, and the parallel best-effort fan-out over the collections the wallet
+ *   names (also the completion sweep's driver).
  */
 export { mintPuk, pukVaultKeys } from './puk.js';
 export type { Puk } from './puk.js';
-export { addPukRosterRecipient, ensurePukRoster, PukRosterContinuityError, PukRosterIntegrityError, PukRosterUnwrapError, pukRosterRecipientResolver, readPukRoster } from './pukRoster.js';
+export { addPukRosterRecipient, ensurePukRoster, PukRosterContinuityError, PukRosterIntegrityError, PukRosterUnwrapError, pukRosterRecipientResolver, readPukRoster, rotatePukRoster } from './pukRoster.js';
+export { cascadeCollectionsToPuk, pukAsRecipient, rotateCollectionEpochsToPuk, unwrapPukGenerations } from './pukCascade.js';
+export type { CollectionPukRotationOutcome, PukCascadeResult } from './pukCascade.js';
 export type { PukRosterReadResult, RosterRecipientDocument } from './pukRoster.js';
 export { pukRosterDescriptorStore } from './rosterStore.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/keys/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAChD,YAAY,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAEnC,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACd,MAAM,gBAAgB,CAAA;AACvB,YAAY,EACV,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAChD,YAAY,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAEnC,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACb,eAAe,EAChB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,4BAA4B,EAC5B,gBAAgB,EACjB,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,gBAAgB,CAAA;AAEvB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/keys/index.js

@@ -16,8 +16,15 @@
  *   document).
  * - `pukRosterDescriptorStore` -- that descriptor store, built from a bare
  *   signing client for the login-time direct read.
+ * - `rotatePukRoster` / `unwrapPukGenerations` / `rotateCollectionEpochsToPuk`
+ *   / `cascadeCollectionsToPuk` / `pukAsRecipient` -- the PUK rotation
+ *   cascade: the roster rotation off a revoked recipient, the per-collection
+ *   re-epoch that brings an encrypted collection onto the roster's current
+ *   PUK, and the parallel best-effort fan-out over the collections the wallet
+ *   names (also the completion sweep's driver).
  */
 export { mintPuk, pukVaultKeys } from './puk.js';
-export { addPukRosterRecipient, ensurePukRoster, PukRosterContinuityError, PukRosterIntegrityError, PukRosterUnwrapError, pukRosterRecipientResolver, readPukRoster } from './pukRoster.js';
+export { addPukRosterRecipient, ensurePukRoster, PukRosterContinuityError, PukRosterIntegrityError, PukRosterUnwrapError, pukRosterRecipientResolver, readPukRoster, rotatePukRoster } from './pukRoster.js';
+export { cascadeCollectionsToPuk, pukAsRecipient, rotateCollectionEpochsToPuk, unwrapPukGenerations } from './pukCascade.js';
 export { pukRosterDescriptorStore } from './rosterStore.js';
 //# sourceMappingURL=index.js.map

package/dist/keys/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGhD,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACd,MAAM,gBAAgB,CAAA;AAMvB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGhD,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,wBAAwB,EACxB,uBAAuB,EACvB,oBAAoB,EACpB,0BAA0B,EAC1B,aAAa,EACb,eAAe,EAChB,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,2BAA2B,EAC3B,oBAAoB,EACrB,MAAM,iBAAiB,CAAA;AAUxB,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/keys/pukCascade.d.ts

@@ -0,0 +1,157 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The per-collection half of the PUK rotation cascade: once the roster's
+ * current epoch has moved to a fresh PUK (a client revoked, a recovery code
+ * spent or revoked), every encrypted collection must take a new epoch naming
+ * the fresh PUK and retire the old one -- otherwise writes keep landing under
+ * an epoch key the revoked party still holds.
+ *
+ * The staleness rule is the one the revocation spike verified: **a collection
+ * is stale exactly when its current epoch names a PUK KAK other than the
+ * roster's current** -- detectable from durable data alone, no checkpoint
+ * resource anywhere, which is what makes a crashed cascade resumable by a
+ * naive full re-run (and what the login-time completion sweep re-checks).
+ * Which KAKs are "PUK generations" is read from the roster itself: its epochs
+ * ARE the PUK generations, each escrow-wrapped to every enrolled client, so
+ * any enrolled client can recover any generation's key
+ * ({@link unwrapPukGenerations}) -- needed both to recognize a stale epoch
+ * and to escrow the fresh PUK into a stranded collection's history.
+ *
+ * One residue, accepted: a collection with NO epochs gets the newest prior
+ * generation installed as its first epoch (pre-epoch envelopes are sealed to
+ * the era's PUK KAK, and the PUK IS the epoch construction, so they ARE
+ * epoch-of-that-generation envelopes) -- envelopes older than that
+ * generation, on a collection every prior cascade missed, stay readable only
+ * to sessions that held the older key.
+ */
+import type { IKeyAgreementKey } from '@interop/data-integrity-core';
+import type { CollectionEncryption } from '@interop/was-client';
+import { type EncryptionDescriptorStore, type RecipientPublicKey } from '@interop/was-client/edv';
+import { type Puk } from './puk.js';
+/**
+ * A PUK presented as an epoch-roster recipient: the kid is the
+ * self-describing `<did:key>#<fingerprint>` form every collection epoch names
+ * the user under, and the public key is the did:key's own multibase.
+ *
+ * @param options {object}
+ * @param options.puk {Puk}
+ * @returns {RecipientPublicKey}
+ */
+export declare function pukAsRecipient({ puk }: {
+    puk: Puk;
+}): RecipientPublicKey;
+/**
+ * Recovers every PUK generation from the roster descriptor: each roster epoch
+ * is one generation (its id the generation's did:key, its wrapped secret the
+ * generation's raw key), escrow-wrapped to every enrolled client -- so this
+ * client's key-agreement key unwraps them all, in roster (chronological)
+ * order. A generation whose wrap is missing or fails to unwrap is skipped
+ * rather than fatal (the cascade then simply cannot recognize or escrow that
+ * generation; the current epoch always unwraps or the roster read itself
+ * would have refused).
+ *
+ * @param options {object}
+ * @param options.descriptor {CollectionEncryption}   the roster descriptor
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key
+ * @returns {Promise<Puk[]>}   the generations, oldest first
+ */
+export declare function unwrapPukGenerations({ descriptor, clientKeyAgreementKey }: {
+    descriptor: CollectionEncryption;
+    clientKeyAgreementKey: IKeyAgreementKey;
+}): Promise<Puk[]>;
+/**
+ * What one collection's cascade step did: `noop` (already on the current
+ * PUK), `installed` (a pre-epoch collection on a first-generation account
+ * gained its first epoch; nothing to retire), `escrowed` (the current PUK's
+ * wrap was completed into history with no stale epoch to rotate), or
+ * `rotated` (a fresh epoch sealed to the current PUK, the stale generations
+ * retired -- the pre-epoch install falls through to this).
+ */
+export type CollectionPukRotationOutcome = 'noop' | 'installed' | 'escrowed' | 'rotated';
+/**
+ * Brings ONE encrypted collection's epoch roster onto the current PUK -- the
+ * per-collection op of the revocation cascade and of the completion sweep:
+ *
+ * - **No epochs yet**: install the newest PRIOR generation as the first epoch
+ *   (see the module doc), wrapped to that generation and the current PUK,
+ *   then fall through to the rotation. A first-generation account (nothing
+ *   prior) installs the current PUK alone and is done.
+ * - **Stale current epoch** (names a non-current generation): one
+ *   `replaceRecipient` write -- the current PUK escrowed into every epoch,
+ *   a fresh epoch minted without the stale generations. Two requests per
+ *   collection; app recipients and other readers ride through untouched (the
+ *   default did:key resolver re-wraps them).
+ * - **Current already** and fully escrowed: no write at all, so a naive
+ *   re-run after a mid-cascade crash converges with zero redundant epochs.
+ *
+ * The pull axis is deliberately a no-op here: a PUK rotation follows a
+ * document edit (client revocation, code retirement) that already killed the
+ * revoked party's server-side access everywhere under the current-key-set
+ * rule -- there is no per-collection revoke.
+ *
+ * @param options {object}
+ * @param options.store {EncryptionDescriptorStore}   the collection's
+ *   descriptor store
+ * @param options.puk {Puk}   the roster's CURRENT PUK
+ * @param options.generations {Puk[]}   every roster generation this client
+ *   could unwrap ({@link unwrapPukGenerations}), oldest first
+ * @returns {Promise<CollectionPukRotationOutcome>}
+ */
+export declare function rotateCollectionEpochsToPuk({ store, puk, generations }: {
+    store: EncryptionDescriptorStore;
+    puk: Puk;
+    generations: Puk[];
+}): Promise<CollectionPukRotationOutcome>;
+/**
+ * What the collection fan-out did, per collection id: the outcomes for every
+ * collection that needed (or took) work, and the per-collection failures the
+ * caller surfaces -- the cascade never aborts on one stuck collection.
+ */
+export interface PukCascadeResult {
+    outcomes: Record<string, CollectionPukRotationOutcome>;
+    failed: Array<{
+        collectionId: string;
+        error: unknown;
+    }>;
+}
+/**
+ * The collection fan-out of the PUK rotation cascade: re-epochs every named
+ * collection onto the roster's current PUK, in parallel, unwrapping the PUK
+ * generations from the roster once. The wallet supplies what only it knows --
+ * which collections exist (`collectionIds`) and how to reach each one's
+ * descriptor (`storeFor`); the per-collection staleness rule and re-epoch live
+ * in {@link rotateCollectionEpochsToPuk}.
+ *
+ * A collection that fails is reported in `failed` and the rest proceed; the
+ * caller decides what a failure means (the login-time completion sweep is the
+ * standing backstop, and the staleness rule makes a naive full re-run
+ * converge with zero redundant epochs).
+ *
+ * @param options {object}
+ * @param options.collectionIds {string[]}   the encrypted collections to
+ *   cover, deduplicated by the caller
+ * @param options.storeFor {Function}   `(collectionId) =>
+ *   EncryptionDescriptorStore` -- the collection's descriptor store
+ * @param [options.isEncrypted] {Function}   `(collectionId) =>
+ *   Promise<boolean>` -- optional pre-filter, checked inside each collection's
+ *   own task so a throwing check lands in that collection's `failed` entry
+ *   (e.g. a standard collection an account never provisioned server-side)
+ * @param options.rosterDescriptor {CollectionEncryption}   the freshly read
+ *   `key-map/puk.json` roster (the source of the PUK generations)
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key, unwrapping the generations
+ * @param options.puk {Puk}   the roster's current PUK
+ * @returns {Promise<PukCascadeResult>}
+ */
+export declare function cascadeCollectionsToPuk({ collectionIds, storeFor, isEncrypted, rosterDescriptor, clientKeyAgreementKey, puk }: {
+    collectionIds: string[];
+    storeFor: (collectionId: string) => EncryptionDescriptorStore;
+    isEncrypted?: (collectionId: string) => Promise<boolean>;
+    rosterDescriptor: CollectionEncryption;
+    clientKeyAgreementKey: IKeyAgreementKey;
+    puk: Puk;
+}): Promise<PukCascadeResult>;
+//# sourceMappingURL=pukCascade.d.ts.map

package/dist/keys/pukCascade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pukCascade.d.ts","sourceRoot":"","sources":["../../src/keys/pukCascade.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,EAML,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAA;AAEhC,OAAO,EAAgB,KAAK,GAAG,EAAE,MAAM,UAAU,CAAA;AAEjD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,EAAE,GAAG,EAAE,EAAE;IAAE,GAAG,EAAE,GAAG,CAAA;CAAE,GAAG,kBAAkB,CAKxE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,oBAAoB,CAAC,EACzC,UAAU,EACV,qBAAqB,EACtB,EAAE;IACD,UAAU,EAAE,oBAAoB,CAAA;IAChC,qBAAqB,EAAE,gBAAgB,CAAA;CACxC,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAkBjB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,4BAA4B,GACtC,MAAM,GAAG,WAAW,GAAG,UAAU,GAAG,SAAS,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,2BAA2B,CAAC,EAChD,KAAK,EACL,GAAG,EACH,WAAW,EACZ,EAAE;IACD,KAAK,EAAE,yBAAyB,CAAA;IAChC,GAAG,EAAE,GAAG,CAAA;IACR,WAAW,EAAE,GAAG,EAAE,CAAA;CACnB,GAAG,OAAO,CAAC,4BAA4B,CAAC,CA2HxC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAA;IACtD,MAAM,EAAE,KAAK,CAAC;QAAE,YAAY,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAA;CACxD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,uBAAuB,CAAC,EAC5C,aAAa,EACb,QAAQ,EACR,WAAW,EACX,gBAAgB,EAChB,qBAAqB,EACrB,GAAG,EACJ,EAAE;IACD,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,QAAQ,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,yBAAyB,CAAA;IAC7D,WAAW,CAAC,EAAE,CAAC,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACxD,gBAAgB,EAAE,oBAAoB,CAAA;IACtC,qBAAqB,EAAE,gBAAgB,CAAA;IACvC,GAAG,EAAE,GAAG,CAAA;CACT,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwB5B"}

package/dist/keys/pukCascade.js

@@ -0,0 +1,235 @@
+import { addRecipient, epochKeyIdFor, initRecipients, replaceRecipient, unwrapEpochSecret } from '@interop/was-client/edv';
+import { ValidationError } from '@interop/was-client';
+import { pukVaultKeys } from './puk.js';
+/**
+ * A PUK presented as an epoch-roster recipient: the kid is the
+ * self-describing `<did:key>#<fingerprint>` form every collection epoch names
+ * the user under, and the public key is the did:key's own multibase.
+ *
+ * @param options {object}
+ * @param options.puk {Puk}
+ * @returns {RecipientPublicKey}
+ */
+export function pukAsRecipient({ puk }) {
+    return {
+        id: epochKeyIdFor(puk.id),
+        publicKeyMultibase: puk.id.split(':')[2]
+    };
+}
+/**
+ * Recovers every PUK generation from the roster descriptor: each roster epoch
+ * is one generation (its id the generation's did:key, its wrapped secret the
+ * generation's raw key), escrow-wrapped to every enrolled client -- so this
+ * client's key-agreement key unwraps them all, in roster (chronological)
+ * order. A generation whose wrap is missing or fails to unwrap is skipped
+ * rather than fatal (the cascade then simply cannot recognize or escrow that
+ * generation; the current epoch always unwraps or the roster read itself
+ * would have refused).
+ *
+ * @param options {object}
+ * @param options.descriptor {CollectionEncryption}   the roster descriptor
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key
+ * @returns {Promise<Puk[]>}   the generations, oldest first
+ */
+export async function unwrapPukGenerations({ descriptor, clientKeyAgreementKey }) {
+    const generations = [];
+    for (const epoch of descriptor.epochs ?? []) {
+        const entry = epoch.recipients.find(recipient => recipient.header.kid === clientKeyAgreementKey.id);
+        if (!entry) {
+            continue;
+        }
+        const secret = await unwrapEpochSecret({
+            entry,
+            keyAgreementKey: clientKeyAgreementKey
+        });
+        if (secret) {
+            generations.push({ id: epoch.id, secret });
+        }
+    }
+    return generations;
+}
+/**
+ * Brings ONE encrypted collection's epoch roster onto the current PUK -- the
+ * per-collection op of the revocation cascade and of the completion sweep:
+ *
+ * - **No epochs yet**: install the newest PRIOR generation as the first epoch
+ *   (see the module doc), wrapped to that generation and the current PUK,
+ *   then fall through to the rotation. A first-generation account (nothing
+ *   prior) installs the current PUK alone and is done.
+ * - **Stale current epoch** (names a non-current generation): one
+ *   `replaceRecipient` write -- the current PUK escrowed into every epoch,
+ *   a fresh epoch minted without the stale generations. Two requests per
+ *   collection; app recipients and other readers ride through untouched (the
+ *   default did:key resolver re-wraps them).
+ * - **Current already** and fully escrowed: no write at all, so a naive
+ *   re-run after a mid-cascade crash converges with zero redundant epochs.
+ *
+ * The pull axis is deliberately a no-op here: a PUK rotation follows a
+ * document edit (client revocation, code retirement) that already killed the
+ * revoked party's server-side access everywhere under the current-key-set
+ * rule -- there is no per-collection revoke.
+ *
+ * @param options {object}
+ * @param options.store {EncryptionDescriptorStore}   the collection's
+ *   descriptor store
+ * @param options.puk {Puk}   the roster's CURRENT PUK
+ * @param options.generations {Puk[]}   every roster generation this client
+ *   could unwrap ({@link unwrapPukGenerations}), oldest first
+ * @returns {Promise<CollectionPukRotationOutcome>}
+ */
+export async function rotateCollectionEpochsToPuk({ store, puk, generations }) {
+    const current = await store.read();
+    if (current === null) {
+        return 'noop';
+    }
+    let descriptor = current.descriptor;
+    const staleGenerations = generations.filter(generation => generation.id !== puk.id);
+    if (!descriptor.epochs?.length || !descriptor.currentEpoch) {
+        // Pre-epoch: the collection's envelopes are sealed to the era's PUK KAK,
+        // which -- the PUK being the epoch construction -- makes them epoch-of-
+        // that-generation envelopes. Install that generation as the first epoch.
+        const previous = staleGenerations[staleGenerations.length - 1];
+        if (!previous) {
+            await initRecipients({
+                store,
+                recipients: [pukAsRecipient({ puk })],
+                epoch: { epochId: puk.id, secret: puk.secret }
+            });
+            return 'installed';
+        }
+        try {
+            descriptor = await initRecipients({
+                store,
+                recipients: [
+                    pukAsRecipient({ puk: previous }),
+                    pukAsRecipient({ puk })
+                ],
+                epoch: { epochId: previous.id, secret: previous.secret }
+            });
+        }
+        catch (err) {
+            // A concurrent cascade won the first-epoch race; re-read and continue
+            // into the rotation below against whatever it installed.
+            if (!(err instanceof ValidationError)) {
+                throw err;
+            }
+            const reread = await store.read();
+            if (reread === null) {
+                throw err;
+            }
+            descriptor = reread.descriptor;
+        }
+    }
+    const currentEpoch = descriptor.epochs.find(epoch => epoch.id === descriptor.currentEpoch) ??
+        descriptor.epochs[descriptor.epochs.length - 1];
+    const currentKids = new Set(currentEpoch.recipients.map(entry => entry.header.kid));
+    const staleKids = staleGenerations
+        .map(generation => epochKeyIdFor(generation.id))
+        .filter(kid => currentKids.has(kid));
+    const pukKid = epochKeyIdFor(puk.id);
+    if (staleKids.length === 0) {
+        const escrowComplete = (descriptor.epochs ?? []).every(epoch => epoch.recipients.some(entry => entry.header.kid === pukKid));
+        if (currentKids.has(pukKid) && escrowComplete) {
+            return 'noop';
+        }
+    }
+    if (staleKids.length > 0) {
+        // The escrow owner: the newest stale generation still named by the
+        // current epoch, which the cascade invariant escrowed into every prior
+        // epoch -- so it unwraps the whole history for the fresh PUK's escrow.
+        const ownerGeneration = [...staleGenerations]
+            .reverse()
+            .find(generation => currentKids.has(epochKeyIdFor(generation.id)));
+        const owner = pukVaultKeys({ puk: ownerGeneration });
+        await replaceRecipient({
+            store,
+            retire: staleKids,
+            recipient: pukAsRecipient({ puk }),
+            owner: { keyAgreementKey: owner.keyAgreementKey },
+            pull: async () => { }
+        });
+        return 'rotated';
+    }
+    if (!currentKids.has(pukKid)) {
+        // No stale generation to retire, but the current PUK is not a recipient
+        // at all: this collection's roster is not PUK-owned in a shape this
+        // cascade can heal -- surface it rather than silently minting an epoch
+        // whose history the account cannot read.
+        throw new Error('The collection current epoch names no PUK generation this client ' +
+            'can recognize; its roster cannot be rotated to the current PUK.');
+    }
+    // Escrow completion only: the current epoch is already on the current PUK,
+    // but some historical epoch is missing its wrap. The owner must unwrap
+    // exactly those epochs -- the newest generation named by every incomplete
+    // epoch.
+    const incomplete = (descriptor.epochs ?? []).filter(epoch => !epoch.recipients.some(entry => entry.header.kid === pukKid));
+    const escrowOwner = [...generations]
+        .reverse()
+        .find(generation => incomplete.every(epoch => epoch.recipients.some(entry => entry.header.kid === epochKeyIdFor(generation.id))));
+    if (!escrowOwner) {
+        throw new Error("The current PUK cannot be escrowed into this collection's history: " +
+            'no held PUK generation is a recipient of every incomplete epoch.');
+    }
+    const owner = pukVaultKeys({ puk: escrowOwner });
+    await addRecipient({
+        store,
+        recipient: pukAsRecipient({ puk }),
+        owner: { keyAgreementKey: owner.keyAgreementKey }
+    });
+    return 'escrowed';
+}
+/**
+ * The collection fan-out of the PUK rotation cascade: re-epochs every named
+ * collection onto the roster's current PUK, in parallel, unwrapping the PUK
+ * generations from the roster once. The wallet supplies what only it knows --
+ * which collections exist (`collectionIds`) and how to reach each one's
+ * descriptor (`storeFor`); the per-collection staleness rule and re-epoch live
+ * in {@link rotateCollectionEpochsToPuk}.
+ *
+ * A collection that fails is reported in `failed` and the rest proceed; the
+ * caller decides what a failure means (the login-time completion sweep is the
+ * standing backstop, and the staleness rule makes a naive full re-run
+ * converge with zero redundant epochs).
+ *
+ * @param options {object}
+ * @param options.collectionIds {string[]}   the encrypted collections to
+ *   cover, deduplicated by the caller
+ * @param options.storeFor {Function}   `(collectionId) =>
+ *   EncryptionDescriptorStore` -- the collection's descriptor store
+ * @param [options.isEncrypted] {Function}   `(collectionId) =>
+ *   Promise<boolean>` -- optional pre-filter, checked inside each collection's
+ *   own task so a throwing check lands in that collection's `failed` entry
+ *   (e.g. a standard collection an account never provisioned server-side)
+ * @param options.rosterDescriptor {CollectionEncryption}   the freshly read
+ *   `key-map/puk.json` roster (the source of the PUK generations)
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key, unwrapping the generations
+ * @param options.puk {Puk}   the roster's current PUK
+ * @returns {Promise<PukCascadeResult>}
+ */
+export async function cascadeCollectionsToPuk({ collectionIds, storeFor, isEncrypted, rosterDescriptor, clientKeyAgreementKey, puk }) {
+    const generations = await unwrapPukGenerations({
+        descriptor: rosterDescriptor,
+        clientKeyAgreementKey
+    });
+    const outcomes = {};
+    const failed = [];
+    await Promise.all(collectionIds.map(async (collectionId) => {
+        try {
+            if (isEncrypted && !(await isEncrypted(collectionId))) {
+                return;
+            }
+            outcomes[collectionId] = await rotateCollectionEpochsToPuk({
+                store: storeFor(collectionId),
+                puk,
+                generations
+            });
+        }
+        catch (err) {
+            failed.push({ collectionId, error: err });
+        }
+    }));
+    return { outcomes, failed };
+}
+//# sourceMappingURL=pukCascade.js.map

package/dist/keys/pukCascade.js.map

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