@interop/wallet-core 0.5.0 → 0.7.0

package/dist/keys/pukRoster.d.ts

@@ -0,0 +1,210 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The PUK wrap set: the `key-map/puk.json` roster resource. Its body is a
+ * `CollectionEncryption` marker verbatim, whose current epoch IS the current
+ * per-user key -- the epoch id is the PUK's did:key and the wrapped secret is
+ * the PUK's raw 32-byte key, wrapped to each enrolled client's key-agreement
+ * key. The roster is the delivery channel for PUK rotation: each client keeps
+ * the PUK in its own local state under the unlock layer, and the roster's
+ * epoch stamp marks a cached copy stale.
+ *
+ * Everything mutates through was-client's marker-store seam (the
+ * plain-resource adapter): read-with-etag, compare-and-swap writes, and a
+ * guarded create for the initially-absent roster. No marker logic is
+ * reimplemented here.
+ *
+ * A resource-hosted marker gets NONE of the server-side epoch invariants a
+ * Collection Description enforces (append-only epochs, monotone
+ * `currentEpoch`), so three client-side compensations are load-bearing alone
+ * against a tampering host:
+ *
+ * - **`epochsMac`** -- the epoch configuration is authenticated under the
+ *   current epoch's secret, which the server never holds; a fabricated
+ *   configuration fails the MAC (`PukRosterIntegrityError`).
+ * - **The epoch pin** -- the latest-seen roster epoch is pinned locally by the
+ *   consuming app (beside the account-pointer pin); a served
+ *   roster that rolls back behind the pin is refused
+ *   (`PukRosterContinuityError`) rather than followed. Stale-roster replay
+ *   thereby lands in the same accepted continuity class as a substituted
+ *   account pointer.
+ * - **The roster delivers, never sources** -- the recipient-key source of
+ *   record is the locally verified did:webvh document (one `keyAgreement`
+ *   verification method per enrolled client). When an epoch rotates, each
+ *   remaining recipient's key is resolved from that document
+ *   (`pukRosterRecipientResolver`); a roster entry with no matching document
+ *   verification method is dropped and never receives a wrap, so a
+ *   server-injected entry sits ignored. Wraps are minted only by enrolled
+ *   clients, against log-verified keys.
+ */
+import type { IKeyAgreementKey } from '@interop/data-integrity-core';
+import type { CollectionEncryption } from '@interop/was-client';
+import { type MarkerStore, type RecipientPublicKey } from '@interop/was-client/edv';
+import type { Puk } from './puk.js';
+/**
+ * Thrown when a served roster fails its client-side authentication: a
+ * missing/unsupported/invalid `epochsMac`, or a marker whose `currentEpoch`
+ * names no epoch in its own list. The server (or whoever can write to it) has
+ * produced a configuration no enrolled client authenticated.
+ */
+export declare class PukRosterIntegrityError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a served roster conflicts with the locally pinned latest-seen
+ * epoch -- the epochs list no longer contains the pinned epoch, or
+ * `currentEpoch` precedes it in the (append-only) list. A rollback/replay of
+ * an older consistent configuration, which a valid `epochsMac` alone cannot
+ * catch; refused rather than followed.
+ */
+export declare class PukRosterContinuityError extends Error {
+    pinnedEpochId: string;
+    constructor({ pinnedEpochId }: {
+        pinnedEpochId: string;
+    });
+}
+/**
+ * Thrown when this client holds no usable wrap in the roster's current epoch
+ * (no recipient entry for its key-agreement key, or the entry fails to
+ * unwrap). The client cannot obtain the current PUK -- it may have been
+ * rotated off the roster.
+ */
+export declare class PukRosterUnwrapError extends Error {
+    constructor(message: string);
+}
+/**
+ * The subset of a resolved DID document the recipient resolver consumes: the
+ * `keyAgreement` relation (VM references or embedded VMs) and the
+ * `verificationMethod` list references resolve against.
+ */
+export interface RosterRecipientDocument {
+    keyAgreement?: Array<string | {
+        id?: string;
+        publicKeyMultibase?: string;
+    }>;
+    verificationMethod?: Array<{
+        id?: string;
+        publicKeyMultibase?: string;
+    }>;
+}
+/**
+ * Builds the recipient resolver for roster rotations, backed by a locally
+ * verified did:webvh document -- the enforcement point for "the roster
+ * delivers, never sources". Given a remaining recipient's `kid`, it answers
+ * with that recipient's public key ONLY when the document carries a matching
+ * `keyAgreement` verification method (matched on the public-key multibase, so
+ * a did:key-form kid matches its `<did:webvh>#<multibase>` VM); otherwise it
+ * resolves `null` -- the was-client skip contract -- so the entry is dropped
+ * from the fresh epoch and never receives a wrap.
+ *
+ * @param options {object}
+ * @param options.document {RosterRecipientDocument}   the locally verified
+ *   did:webvh document (never a server-supplied roster field)
+ * @returns {function}   a `resolveRecipientKey` for `removeRecipient`
+ */
+export declare function pukRosterRecipientResolver({ document }: {
+    document: RosterRecipientDocument;
+}): (kid: string) => Promise<RecipientPublicKey | null>;
+/**
+ * Ensures the roster exists, create-if-absent: an absent roster is
+ * initialized with the account's existing PUK installed as the first epoch,
+ * wrapped to this client's key-agreement key; an existing roster is returned
+ * as-is (authentication is the read path's job, and provisioning must never
+ * clobber an established roster). Idempotent -- losing the guarded-create
+ * race to a concurrent first init converges on the winner's roster.
+ *
+ * @param options {object}
+ * @param options.store {MarkerStore}   the roster's marker store
+ * @param options.puk {Puk}   the account's per-user key
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key -- the roster recipient
+ * @returns {Promise<CollectionEncryption>}   the roster marker
+ */
+export declare function ensurePukRoster({ store, puk, clientKeyAgreementKey }: {
+    store: MarkerStore;
+    puk: Puk;
+    clientKeyAgreementKey: IKeyAgreementKey;
+}): Promise<CollectionEncryption>;
+/**
+ * Wraps the PUK to a client being enrolled -- the roster half of the
+ * enrollment ceremony, and deliberately its FIRST write (decryption material
+ * before authorization, the push order): the wrap lands before the did:webvh
+ * log entries, so no enrolled client is ever authorized but blind, and a tear
+ * right after this write leaves only an orphan wrap -- invisible to
+ * authorization, harmless, resumed by re-running the ceremony.
+ *
+ * Escrow semantics ride on was-client's `addRecipient`: the new client
+ * receives EVERY epoch's key, current and prior, so it decrypts
+ * pre-enrollment history. The recipient key arrives over the point-to-point
+ * enrollment channel and is verified there by the enrolling client (the
+ * document VM it writes next comes from the same exchange) -- never sourced
+ * from the roster. Idempotent: a wrap already standing in the current epoch
+ * is returned as-is.
+ *
+ * @param options {object}
+ * @param options.store {MarkerStore}   the roster's marker store
+ * @param options.recipient {RecipientPublicKey}   the enrollee's public
+ *   key-agreement key; `id` is the kid its own roster reads will look for
+ * @param options.ownerKeyAgreementKey {IKeyAgreementKey}   the enrolling
+ *   client's own (identity) key-agreement key, unwrapping each epoch for
+ *   re-wrapping
+ * @returns {Promise<CollectionEncryption>}   the refreshed roster marker
+ */
+export declare function addPukRosterRecipient({ store, recipient, ownerKeyAgreementKey }: {
+    store: MarkerStore;
+    recipient: RecipientPublicKey;
+    ownerKeyAgreementKey: IKeyAgreementKey;
+}): Promise<CollectionEncryption>;
+/**
+ * What a roster read resolves to: the authenticated marker, the current PUK
+ * (the cached one confirmed current, or a fresh one unwrapped from a rotated
+ * epoch -- `rotated` says which), and the epoch id the caller must pin as the
+ * new latest-seen.
+ */
+export interface PukRosterReadResult {
+    marker: CollectionEncryption;
+    puk: Puk;
+    rotated: boolean;
+    latestEpochId: string;
+}
+/**
+ * Reads and authenticates the roster -- the direct read at login and on epoch
+ * mismatch. Resolves `null` when the roster does not exist yet (an account
+ * provisioned before the roster, or provisioning still in flight); otherwise:
+ *
+ * 1. **Continuity**: the served epochs must contain the pinned latest-seen
+ *    epoch, and `currentEpoch` must not precede it in the append-only list
+ *    (`PukRosterContinuityError` -- the rollback/replay refusal).
+ * 2. **Possession**: `currentEpoch === puk.id` confirms the cached PUK
+ *    current; otherwise the current epoch was rotated by another client and
+ *    this client's wrap is unwrapped with its own key-agreement key
+ *    (`PukRosterUnwrapError` when it holds none).
+ * 3. **Authentication**: the marker's `epochsMac` is verified under the
+ *    current epoch's secret (`PukRosterIntegrityError` on any mismatch -- a
+ *    fabricated configuration).
+ *
+ * A rotated read returns the fresh PUK; its Ed25519 signing seed does not
+ * travel through the roster (the roster wraps the key-agreement secret
+ * alone), so the returned PUK carries none.
+ *
+ * A caller with no cached PUK at all -- a freshly enrolled client making its
+ * first post-enrollment read -- omits `puk` and always takes the unwrap path;
+ * the result's `rotated` is then true (the PUK was adopted from the roster).
+ *
+ * @param options {object}
+ * @param options.store {MarkerStore}   the roster's marker store
+ * @param [options.puk] {Puk}   this client's cached PUK, when it holds one
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key, unwrapping a rotated epoch
+ * @param [options.pinnedEpochId] {string}   the locally pinned latest-seen
+ *   roster epoch, when this client has seen the roster before
+ * @returns {Promise<PukRosterReadResult | null>}
+ */
+export declare function readPukRoster({ store, puk, clientKeyAgreementKey, pinnedEpochId }: {
+    store: MarkerStore;
+    puk?: Puk;
+    clientKeyAgreementKey: IKeyAgreementKey;
+    pinnedEpochId?: string | null;
+}): Promise<PukRosterReadResult | null>;
+//# sourceMappingURL=pukRoster.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pukRoster.d.ts","sourceRoot":"","sources":["../../src/keys/pukRoster.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAA;AACpE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAA;AAC/D,OAAO,EAML,KAAK,WAAW,EAChB,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAEnC;;;;;GAKG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;gBACpC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;GAMG;AACH,qBAAa,wBAAyB,SAAQ,KAAK;IACjD,aAAa,EAAE,MAAM,CAAA;gBACT,EAAE,aAAa,EAAE,EAAE;QAAE,aAAa,EAAE,MAAM,CAAA;KAAE;CAQzD;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC3E,kBAAkB,CAAC,EAAE,KAAK,CAAC;QAAE,EAAE,CAAC,EAAE,MAAM,CAAC;QAAC,kBAAkB,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACzE;AAgBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,0BAA0B,CAAC,EACzC,QAAQ,EACT,EAAE;IACD,QAAQ,EAAE,uBAAuB,CAAA;CAClC,GAAG,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAsCtD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CAAC,EACpC,KAAK,EACL,GAAG,EACH,qBAAqB,EACtB,EAAE;IACD,KAAK,EAAE,WAAW,CAAA;IAClB,GAAG,EAAE,GAAG,CAAA;IACR,qBAAqB,EAAE,gBAAgB,CAAA;CACxC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAUhC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,KAAK,EACL,SAAS,EACT,oBAAoB,EACrB,EAAE;IACD,KAAK,EAAE,WAAW,CAAA;IAClB,SAAS,EAAE,kBAAkB,CAAA;IAC7B,oBAAoB,EAAE,gBAAgB,CAAA;CACvC,GAAG,OAAO,CAAC,oBAAoB,CAAC,CA0BhC;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,oBAAoB,CAAA;IAC5B,GAAG,EAAE,GAAG,CAAA;IACR,OAAO,EAAE,OAAO,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,aAAa,CAAC,EAClC,KAAK,EACL,GAAG,EACH,qBAAqB,EACrB,aAAa,EACd,EAAE;IACD,KAAK,EAAE,WAAW,CAAA;IAClB,GAAG,CAAC,EAAE,GAAG,CAAA;IACT,qBAAqB,EAAE,gBAAgB,CAAA;IACvC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B,GAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAAC,CAwEtC"}

package/dist/keys/pukRoster.js

@@ -0,0 +1,263 @@
+import { addRecipient, initRecipients, ownerRecipient, unwrapEpochSecret, verifyEpochsMac } from '@interop/was-client/edv';
+/**
+ * Thrown when a served roster fails its client-side authentication: a
+ * missing/unsupported/invalid `epochsMac`, or a marker whose `currentEpoch`
+ * names no epoch in its own list. The server (or whoever can write to it) has
+ * produced a configuration no enrolled client authenticated.
+ */
+export class PukRosterIntegrityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PukRosterIntegrityError';
+    }
+}
+/**
+ * Thrown when a served roster conflicts with the locally pinned latest-seen
+ * epoch -- the epochs list no longer contains the pinned epoch, or
+ * `currentEpoch` precedes it in the (append-only) list. A rollback/replay of
+ * an older consistent configuration, which a valid `epochsMac` alone cannot
+ * catch; refused rather than followed.
+ */
+export class PukRosterContinuityError extends Error {
+    pinnedEpochId;
+    constructor({ pinnedEpochId }) {
+        super('The PUK roster no longer carries the epoch this client has pinned -- ' +
+            'a rolled-back or replayed roster.');
+        this.name = 'PukRosterContinuityError';
+        this.pinnedEpochId = pinnedEpochId;
+    }
+}
+/**
+ * Thrown when this client holds no usable wrap in the roster's current epoch
+ * (no recipient entry for its key-agreement key, or the entry fails to
+ * unwrap). The client cannot obtain the current PUK -- it may have been
+ * rotated off the roster.
+ */
+export class PukRosterUnwrapError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'PukRosterUnwrapError';
+    }
+}
+/**
+ * The fragment after the last `#` of a key/VM id -- for the ids this roster
+ * handles (did:key KAK ids, `<did>#<multibase>` VM ids) that fragment is the
+ * key's public multibase, which is what makes kid-to-VM matching key-material
+ * equality rather than string equality across id formats.
+ *
+ * @param id {string}
+ * @returns {string | undefined}
+ */
+function multibaseFragmentOf(id) {
+    const hash = id.lastIndexOf('#');
+    return hash === -1 ? undefined : id.slice(hash + 1);
+}
+/**
+ * Builds the recipient resolver for roster rotations, backed by a locally
+ * verified did:webvh document -- the enforcement point for "the roster
+ * delivers, never sources". Given a remaining recipient's `kid`, it answers
+ * with that recipient's public key ONLY when the document carries a matching
+ * `keyAgreement` verification method (matched on the public-key multibase, so
+ * a did:key-form kid matches its `<did:webvh>#<multibase>` VM); otherwise it
+ * resolves `null` -- the was-client skip contract -- so the entry is dropped
+ * from the fresh epoch and never receives a wrap.
+ *
+ * @param options {object}
+ * @param options.document {RosterRecipientDocument}   the locally verified
+ *   did:webvh document (never a server-supplied roster field)
+ * @returns {function}   a `resolveRecipientKey` for `removeRecipient`
+ */
+export function pukRosterRecipientResolver({ document }) {
+    // Materialize the document's keyAgreement VMs once: embedded VMs verbatim,
+    // string references resolved against `verificationMethod`.
+    const byId = new Map();
+    for (const method of document.verificationMethod ?? []) {
+        if (typeof method?.id === 'string') {
+            byId.set(method.id, method);
+        }
+    }
+    const keyAgreementMethods = [];
+    for (const entry of document.keyAgreement ?? []) {
+        const method = typeof entry === 'string' ? byId.get(entry) : entry;
+        if (method && typeof method.publicKeyMultibase === 'string') {
+            keyAgreementMethods.push(method);
+        }
+    }
+    return async function resolveRecipientKey(kid) {
+        const fragment = multibaseFragmentOf(kid);
+        if (!fragment) {
+            return null;
+        }
+        const match = keyAgreementMethods.find(method => method.publicKeyMultibase === fragment ||
+            (typeof method.id === 'string' &&
+                multibaseFragmentOf(method.id) === fragment));
+        if (!match) {
+            // No document verification method backs this roster entry: drop it.
+            return null;
+        }
+        return { id: kid, publicKeyMultibase: match.publicKeyMultibase };
+    };
+}
+/**
+ * Ensures the roster exists, create-if-absent: an absent roster is
+ * initialized with the account's existing PUK installed as the first epoch,
+ * wrapped to this client's key-agreement key; an existing roster is returned
+ * as-is (authentication is the read path's job, and provisioning must never
+ * clobber an established roster). Idempotent -- losing the guarded-create
+ * race to a concurrent first init converges on the winner's roster.
+ *
+ * @param options {object}
+ * @param options.store {MarkerStore}   the roster's marker store
+ * @param options.puk {Puk}   the account's per-user key
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key -- the roster recipient
+ * @returns {Promise<CollectionEncryption>}   the roster marker
+ */
+export async function ensurePukRoster({ store, puk, clientKeyAgreementKey }) {
+    const current = await store.read();
+    if (current !== null) {
+        return current.marker;
+    }
+    return initRecipients({
+        store,
+        recipients: [ownerRecipient({ keyAgreementKey: clientKeyAgreementKey })],
+        epoch: { epochId: puk.id, secret: puk.secret }
+    });
+}
+/**
+ * Wraps the PUK to a client being enrolled -- the roster half of the
+ * enrollment ceremony, and deliberately its FIRST write (decryption material
+ * before authorization, the push order): the wrap lands before the did:webvh
+ * log entries, so no enrolled client is ever authorized but blind, and a tear
+ * right after this write leaves only an orphan wrap -- invisible to
+ * authorization, harmless, resumed by re-running the ceremony.
+ *
+ * Escrow semantics ride on was-client's `addRecipient`: the new client
+ * receives EVERY epoch's key, current and prior, so it decrypts
+ * pre-enrollment history. The recipient key arrives over the point-to-point
+ * enrollment channel and is verified there by the enrolling client (the
+ * document VM it writes next comes from the same exchange) -- never sourced
+ * from the roster. Idempotent: a wrap already standing in the current epoch
+ * is returned as-is.
+ *
+ * @param options {object}
+ * @param options.store {MarkerStore}   the roster's marker store
+ * @param options.recipient {RecipientPublicKey}   the enrollee's public
+ *   key-agreement key; `id` is the kid its own roster reads will look for
+ * @param options.ownerKeyAgreementKey {IKeyAgreementKey}   the enrolling
+ *   client's own (identity) key-agreement key, unwrapping each epoch for
+ *   re-wrapping
+ * @returns {Promise<CollectionEncryption>}   the refreshed roster marker
+ */
+export async function addPukRosterRecipient({ store, recipient, ownerKeyAgreementKey }) {
+    const current = await store.read();
+    if (current === null) {
+        throw new Error('The PUK roster does not exist yet; the account must finish ' +
+            'provisioning before a client can be enrolled.');
+    }
+    const marker = current.marker;
+    const currentEpoch = (marker.epochs ?? []).find(epoch => epoch.id === marker.currentEpoch);
+    const wrapped = currentEpoch?.recipients.some(entry => entry.header.kid === recipient.id);
+    if (wrapped) {
+        // A completed (or torn-after-the-wrap) earlier run: addRecipient writes
+        // every epoch's wrap in one marker write, so the current epoch standing
+        // means the escrow set is complete.
+        return marker;
+    }
+    return addRecipient({
+        store,
+        recipient,
+        owner: { keyAgreementKey: ownerKeyAgreementKey }
+    });
+}
+/**
+ * Reads and authenticates the roster -- the direct read at login and on epoch
+ * mismatch. Resolves `null` when the roster does not exist yet (an account
+ * provisioned before the roster, or provisioning still in flight); otherwise:
+ *
+ * 1. **Continuity**: the served epochs must contain the pinned latest-seen
+ *    epoch, and `currentEpoch` must not precede it in the append-only list
+ *    (`PukRosterContinuityError` -- the rollback/replay refusal).
+ * 2. **Possession**: `currentEpoch === puk.id` confirms the cached PUK
+ *    current; otherwise the current epoch was rotated by another client and
+ *    this client's wrap is unwrapped with its own key-agreement key
+ *    (`PukRosterUnwrapError` when it holds none).
+ * 3. **Authentication**: the marker's `epochsMac` is verified under the
+ *    current epoch's secret (`PukRosterIntegrityError` on any mismatch -- a
+ *    fabricated configuration).
+ *
+ * A rotated read returns the fresh PUK; its Ed25519 signing seed does not
+ * travel through the roster (the roster wraps the key-agreement secret
+ * alone), so the returned PUK carries none.
+ *
+ * A caller with no cached PUK at all -- a freshly enrolled client making its
+ * first post-enrollment read -- omits `puk` and always takes the unwrap path;
+ * the result's `rotated` is then true (the PUK was adopted from the roster).
+ *
+ * @param options {object}
+ * @param options.store {MarkerStore}   the roster's marker store
+ * @param [options.puk] {Puk}   this client's cached PUK, when it holds one
+ * @param options.clientKeyAgreementKey {IKeyAgreementKey}   this client's own
+ *   (identity) key-agreement key, unwrapping a rotated epoch
+ * @param [options.pinnedEpochId] {string}   the locally pinned latest-seen
+ *   roster epoch, when this client has seen the roster before
+ * @returns {Promise<PukRosterReadResult | null>}
+ */
+export async function readPukRoster({ store, puk, clientKeyAgreementKey, pinnedEpochId }) {
+    const current = await store.read();
+    if (current === null) {
+        return null;
+    }
+    const marker = current.marker;
+    const epochIds = (marker.epochs ?? []).map(epoch => epoch.id);
+    const currentIndex = marker.currentEpoch
+        ? epochIds.indexOf(marker.currentEpoch)
+        : -1;
+    if (currentIndex === -1) {
+        throw new PukRosterIntegrityError('The PUK roster names no current epoch in its own epoch list.');
+    }
+    if (pinnedEpochId) {
+        const pinnedIndex = epochIds.indexOf(pinnedEpochId);
+        if (pinnedIndex === -1 || currentIndex < pinnedIndex) {
+            throw new PukRosterContinuityError({ pinnedEpochId });
+        }
+    }
+    // The epochsMac construction's own version/alg are the caller's to check.
+    const epochsMac = marker.epochsMac;
+    if (!epochsMac || epochsMac.v !== 1 || epochsMac.alg !== 'HS256') {
+        throw new PukRosterIntegrityError('The PUK roster carries no supported epoch-configuration MAC.');
+    }
+    let currentPuk;
+    let rotated;
+    if (puk && marker.currentEpoch === puk.id) {
+        currentPuk = puk;
+        rotated = false;
+    }
+    else {
+        // Rotated by another client: unwrap this client's entry in the current
+        // epoch with its own key-agreement key (rotation delivery).
+        const entry = marker.epochs[currentIndex].recipients.find(recipient => recipient.header.kid === clientKeyAgreementKey.id);
+        if (!entry) {
+            throw new PukRosterUnwrapError('The PUK roster current epoch carries no wrap for this client.');
+        }
+        const secret = await unwrapEpochSecret({
+            entry,
+            keyAgreementKey: clientKeyAgreementKey
+        });
+        if (!secret) {
+            throw new PukRosterUnwrapError("This client's PUK roster entry failed to unwrap.");
+        }
+        currentPuk = { id: marker.currentEpoch, secret };
+        rotated = true;
+    }
+    if (!(await verifyEpochsMac({ marker, epochSecret: currentPuk.secret }))) {
+        throw new PukRosterIntegrityError('The PUK roster epoch configuration failed authentication.');
+    }
+    return {
+        marker,
+        puk: currentPuk,
+        rotated,
+        latestEpochId: marker.currentEpoch
+    };
+}
+//# sourceMappingURL=pukRoster.js.map

package/dist/keys/pukRoster.js.map

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

package/dist/keys/rosterStore.d.ts

@@ -0,0 +1,18 @@
+import type { ZcapClient } from '@interop/ezcap';
+import { type MarkerStore } from '@interop/was-client/edv';
+/**
+ * Builds the compare-and-swap marker store over `key-map/puk.json` in a data
+ * Space.
+ *
+ * @param options {object}
+ * @param options.storageServerUrl {string}
+ * @param options.zcapClient {ZcapClient}   the session's root signing client
+ * @param options.spaceId {string}   the data Space id
+ * @returns {MarkerStore}
+ */
+export declare function pukRosterMarkerStore({ storageServerUrl, zcapClient, spaceId }: {
+    storageServerUrl: string;
+    zcapClient: ZcapClient;
+    spaceId: string;
+}): MarkerStore;
+//# sourceMappingURL=rosterStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rosterStore.d.ts","sourceRoot":"","sources":["../../src/keys/rosterStore.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAChD,OAAO,EAAuB,KAAK,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAM/E;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,gBAAgB,EAChB,UAAU,EACV,OAAO,EACR,EAAE;IACD,gBAAgB,EAAE,MAAM,CAAA;IACxB,UAAU,EAAE,UAAU,CAAA;IACtB,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,WAAW,CAQd"}

package/dist/keys/rosterStore.js

@@ -0,0 +1,38 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The marker store over a Space's PUK wrap-set roster (`key-map/puk.json`).
+ * Standalone rather than a method on a wallet's remote-store class, because
+ * the login-time direct read checks the roster BEFORE any storage client (or
+ * cipher) is built: it takes the bare signing client instead of a store
+ * instance.
+ *
+ * The `plaintext` collection override is load-bearing. Without it the client
+ * decides plaintext vs encrypted by describing the collection first, and a 404
+ * from an absent Space or collection then surfaces as an encryption error
+ * rather than as an absent roster.
+ */
+import { WasClient } from '@interop/was-client';
+import { resourceMarkerStore } from '@interop/was-client/edv';
+import { KEY_MAP_COLLECTION, PUK_ROSTER_RESOURCE } from '../space/collections.js';
+/**
+ * Builds the compare-and-swap marker store over `key-map/puk.json` in a data
+ * Space.
+ *
+ * @param options {object}
+ * @param options.storageServerUrl {string}
+ * @param options.zcapClient {ZcapClient}   the session's root signing client
+ * @param options.spaceId {string}   the data Space id
+ * @returns {MarkerStore}
+ */
+export function pukRosterMarkerStore({ storageServerUrl, zcapClient, spaceId }) {
+    const was = new WasClient({ serverUrl: storageServerUrl, zcapClient });
+    return resourceMarkerStore({
+        resource: was
+            .space(spaceId)
+            .collection(KEY_MAP_COLLECTION.id, { encryption: 'plaintext' })
+            .resource(PUK_ROSTER_RESOURCE)
+    });
+}
+//# sourceMappingURL=rosterStore.js.map

package/dist/keys/rosterStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rosterStore.js","sourceRoot":"","sources":["../../src/keys/rosterStore.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAE/C,OAAO,EAAE,mBAAmB,EAAoB,MAAM,yBAAyB,CAAA;AAC/E,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,yBAAyB,CAAA;AAEhC;;;;;;;;;GASG;AACH,MAAM,UAAU,oBAAoB,CAAC,EACnC,gBAAgB,EAChB,UAAU,EACV,OAAO,EAKR;IACC,MAAM,GAAG,GAAG,IAAI,SAAS,CAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,EAAE,CAAC,CAAA;IACtE,OAAO,mBAAmB,CAAC;QACzB,QAAQ,EAAE,GAAG;aACV,KAAK,CAAC,OAAO,CAAC;aACd,UAAU,CAAC,kBAAkB,CAAC,EAAE,EAAE,EAAE,UAAU,EAAE,WAAW,EAAE,CAAC;aAC9D,QAAQ,CAAC,mBAAmB,CAAC;KACjC,CAAC,CAAA;AACJ,CAAC"}

package/dist/markers/acquire.d.ts

@@ -0,0 +1,107 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * Collection-encryption marker acquisition: reading a collection's
+ * `CollectionEncryption` marker (its key-epoch roster) from the Collection
+ * Description, caching each success, and falling back to the cached copy when
+ * the description cannot be fetched -- offline, a previously-shared collection
+ * must keep encrypting under its current epoch. A successful fetch that
+ * returns no marker (an unshared collection) yields `undefined`: the
+ * single-key path.
+ *
+ * The two seams are deliberately narrow, so a wallet app's own classes satisfy
+ * them structurally -- no adapter needed. A {@link MarkerSource} is one signed
+ * describe; a {@link MarkerCache} is a durable get/put the host has already
+ * scoped to one account's Space (a web wallet: a localStorage pair keyed by
+ * Space id; a mobile wallet: a per-(profile, collection) table column), so no
+ * scope key appears in the interface.
+ */
+import type { CollectionEncryption, WasClient } from '@interop/was-client';
+/**
+ * Where markers come from: one signed read of the collection's Description.
+ * Resolves `undefined` for a collection that is plaintext or has no marker;
+ * network errors throw through (callers treat the fetch as best-effort and
+ * fall back to a cached copy).
+ */
+export interface MarkerSource {
+    collectionEncryption(options: {
+        collectionId: string;
+    }): Promise<CollectionEncryption | undefined>;
+}
+/**
+ * Where fetched markers survive offline: a durable get/put pre-scoped by the
+ * host to one account's Space. `readMarker` resolves `undefined` when nothing
+ * is cached (never throws for absence).
+ */
+export interface MarkerCache {
+    readMarker(options: {
+        collectionId: string;
+    }): Promise<CollectionEncryption | undefined>;
+    writeMarker(options: {
+        collectionId: string;
+        marker: CollectionEncryption;
+    }): Promise<void>;
+}
+/**
+ * The {@link MarkerSource} over a was-client handle: reads the collection's
+ * Description in the given Space and returns its `encryption` marker.
+ *
+ * @param options {object}
+ * @param options.was {WasClient}   a client whose signer can read the Space
+ * @param options.spaceId {string}
+ * @returns {MarkerSource}
+ */
+export declare function wasMarkerSource({ was, spaceId }: {
+    was: WasClient;
+    spaceId: string;
+}): MarkerSource;
+/**
+ * Acquires one collection's marker: fetches it from the source, caching a
+ * success; falls back to the cached copy when the fetch fails; and with no
+ * source at all (a purely local code path) reads the cache alone. A
+ * successful fetch that returns no marker resolves `undefined` -- an unshared
+ * collection stays on the single-key path -- and deliberately leaves any
+ * cached copy in place, mirroring the fetch-failure fallback.
+ *
+ * @param options {object}
+ * @param [options.source] {MarkerSource}   omit for cache-only acquisition
+ * @param options.cache {MarkerCache}
+ * @param options.collectionId {string}
+ * @param [options.onFetchError] {function}   observes a swallowed fetch
+ *   failure (the cached-fallback branch); errors from the cache itself throw
+ *   through
+ * @returns {Promise<CollectionEncryption | undefined>}
+ */
+export declare function acquireMarker({ source, cache, collectionId, onFetchError }: {
+    source?: MarkerSource;
+    cache: MarkerCache;
+    collectionId: string;
+    onFetchError?: (err: unknown, info: {
+        collectionId: string;
+    }) => void;
+}): Promise<CollectionEncryption | undefined>;
+/**
+ * Acquires markers for a set of collections concurrently (each fetch is an
+ * independent signed round trip, so a session start is not gated on a serial
+ * chain of describes). Collections that resolve no marker are simply absent
+ * from the result.
+ *
+ * @param options {object}
+ * @param [options.source] {MarkerSource}   omit for cache-only acquisition
+ * @param options.cache {MarkerCache}
+ * @param options.collectionIds {string[]}
+ * @param [options.onFetchError] {function}   observes each swallowed fetch
+ *   failure
+ * @returns {Promise<Record<string, CollectionEncryption>>}   keyed by
+ *   collection id
+ */
+export declare function acquireMarkers({ source, cache, collectionIds, onFetchError }: {
+    source?: MarkerSource;
+    cache: MarkerCache;
+    collectionIds: string[];
+    onFetchError?: (err: unknown, info: {
+        collectionId: string;
+    }) => void;
+}): Promise<Record<string, CollectionEncryption>>;
+//# sourceMappingURL=acquire.d.ts.map

package/dist/markers/acquire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"acquire.d.ts","sourceRoot":"","sources":["../../src/markers/acquire.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,YAAY;IAC3B,oBAAoB,CAAC,OAAO,EAAE;QAC5B,YAAY,EAAE,MAAM,CAAA;KACrB,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAAA;CAC9C;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,CAAC,OAAO,EAAE;QAClB,YAAY,EAAE,MAAM,CAAA;KACrB,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAAA;IAC7C,WAAW,CAAC,OAAO,EAAE;QACnB,YAAY,EAAE,MAAM,CAAA;QACpB,MAAM,EAAE,oBAAoB,CAAA;KAC7B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAClB;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,EAC9B,GAAG,EACH,OAAO,EACR,EAAE;IACD,GAAG,EAAE,SAAS,CAAA;IACd,OAAO,EAAE,MAAM,CAAA;CAChB,GAAG,YAAY,CAUf;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,aAAa,CAAC,EAClC,MAAM,EACN,KAAK,EACL,YAAY,EACZ,YAAY,EACb,EAAE;IACD,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,KAAK,EAAE,WAAW,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CACtE,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC,CAe5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,cAAc,CAAC,EACnC,MAAM,EACN,KAAK,EACL,aAAa,EACb,YAAY,EACb,EAAE;IACD,MAAM,CAAC,EAAE,YAAY,CAAA;IACrB,KAAK,EAAE,WAAW,CAAA;IAClB,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;CACtE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAiBhD"}