@interop/wallet-core 0.50.0 → 0.52.1

package/dist/resourceLog/entry.js

@@ -1,167 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * Resource-log entry construction: the two-pass SCID genesis build and the
- * ordinary next-entry build, both signed under the writer's enrolled Ed25519
- * key with the entry anchor riding as a `versionId` DID parameter on the
- * proof's `verificationMethod` -- the writer anchors at the head of the
- * controller document as it last verified it. All hashing and proof
- * construction comes from the did:webvh log kernel; nothing is re-derived
- * here.
- */
-import { buildVersionId, createDataIntegrityProofTemplate, deriveHash, parseAndValidateVersionId, SCID_PLACEHOLDER, signDataIntegrityProof, signerFromExternalKey } from '@interop/did-method-webvh';
-/**
- * The writer's anchored verification-method DID URL: the controller DID, the
- * anchor at the controller's verified head as a `versionId` DID parameter
- * (omitted for an unversioned controller), and the signing key's multibase as
- * the fragment.
- *
- * @param options {object}
- * @param options.controller {ResourceLogController}
- * @param options.keyMultibase {string}
- * @returns {string}
- */
-function anchoredVerificationMethod({ controller, keyMultibase }) {
-    const anchor = controller.versionIds[controller.versionIds.length - 1];
-    const query = anchor === undefined ? '' : `?versionId=${anchor}`;
-    return `${controller.did}${query}#${keyMultibase}`;
-}
-/**
- * Refuses a state document the profile forbids in an entry: one without a
- * `type` schema identifier, or one carrying the projection-only `history`
- * member.
- *
- * @param state {ResourceLogEntry['state']}
- */
-function checkState(state) {
-    if (typeof state.type !== 'string') {
-        throw new Error('A resource log entry state must carry a type schema identifier.');
-    }
-    if ('history' in state) {
-        throw new Error('A resource log entry state must not carry a history member (the ' +
-            'profile reserves that member name).');
-    }
-}
-/**
- * Signs a fully version-identified entry under the profile's fixed proof
- * shape.
- *
- * @param options {object}
- * @param options.entry {object}   the entry, `proof` absent
- * @param options.signer {ResourceLogSigner}
- * @param options.verificationMethod {string}   the anchored DID URL
- * @param options.created {string}   the proof timestamp
- * @returns {Promise<ResourceLogEntry>}
- */
-async function signEntry({ entry, signer, verificationMethod, created }) {
-    const proofTemplate = createDataIntegrityProofTemplate({
-        verificationMethod,
-        created
-    });
-    const proof = await signDataIntegrityProof(entry, proofTemplate, signerFromExternalKey({
-        publicKeyMultibase: signer.keyMultibase,
-        sign: signer.sign
-    }));
-    // The kernel's proof type keeps proofPurpose as the full union; the
-    // template fixed it to the profile's assertionMethod shape.
-    return { ...entry, proof: [proof] };
-}
-/**
- * Builds and signs a genesis entry by the profile's two-pass SCID procedure:
- * the preliminary entry carries the `{SCID}` placeholder as `versionId` and
- * `parameters.scid`, its hash is the SCID, and the final entry substitutes it
- * back in before the ordinary entry hash is computed (`versionId` input
- * value: the SCID).
- *
- * @param options {object}
- * @param options.state {ResourceLogEntry['state']}   the full initial state
- *   (with its `type`)
- * @param options.method {string}   the format identifier
- *   (`RESOURCE_LOG_METHOD`)
- * @param options.controller {ResourceLogController}   the verified controller
- *   view -- the anchor source
- * @param options.signer {ResourceLogSigner}
- * @param [options.previousLog] {object}   handover successors only: the prior
- *   log's SCID and the `versionId` of its terminal entry's predecessor
- * @param [options.versionTime] {string}   RFC3339 UTC; defaults to now
- * @returns {Promise<ResourceLogEntry>}
- */
-export async function buildResourceLogGenesis({ state, method, controller, signer, previousLog, versionTime }) {
-    checkState(state);
-    const time = versionTime ?? new Date().toISOString();
-    const parametersOf = (scid) => ({
-        method,
-        scid,
-        ...(previousLog === undefined ? {} : { previousLog })
-    });
-    const scid = await deriveHash({
-        versionId: SCID_PLACEHOLDER,
-        versionTime: time,
-        parameters: parametersOf(SCID_PLACEHOLDER),
-        state
-    });
-    const parameters = parametersOf(scid);
-    const entryHash = await deriveHash({
-        versionId: scid,
-        versionTime: time,
-        parameters,
-        state
-    });
-    return signEntry({
-        entry: {
-            versionId: buildVersionId(1, entryHash),
-            versionTime: time,
-            parameters,
-            state
-        },
-        signer,
-        verificationMethod: anchoredVerificationMethod({
-            controller,
-            keyMultibase: signer.keyMultibase
-        }),
-        created: time
-    });
-}
-/**
- * Builds and signs the next ordinary entry against a verified head: full
- * state, empty `parameters`, hash chained off the head's `versionId`, proof
- * anchored at the controller's verified head. Callers hold a verified head
- * by construction (an entry is never built on an unverified one).
- *
- * @param options {object}
- * @param options.head {ResourceLogEntry}   the verified head entry
- * @param options.state {ResourceLogEntry['state']}   the full next state
- * @param options.controller {ResourceLogController}
- * @param options.signer {ResourceLogSigner}
- * @param [options.versionTime] {string}   RFC3339 UTC; defaults to now
- * @returns {Promise<ResourceLogEntry>}
- */
-export async function buildResourceLogEntry({ head, state, controller, signer, versionTime }) {
-    checkState(state);
-    const time = versionTime ?? new Date().toISOString();
-    const headOrdinal = Number.parseInt(head.versionId, 10);
-    const ordinal = headOrdinal + 1;
-    parseAndValidateVersionId(head.versionId, headOrdinal);
-    const entryHash = await deriveHash({
-        versionId: head.versionId,
-        versionTime: time,
-        parameters: {},
-        state
-    });
-    return signEntry({
-        entry: {
-            versionId: buildVersionId(ordinal, entryHash),
-            versionTime: time,
-            parameters: {},
-            state
-        },
-        signer,
-        verificationMethod: anchoredVerificationMethod({
-            controller,
-            keyMultibase: signer.keyMultibase
-        }),
-        created: time
-    });
-}
-//# sourceMappingURL=entry.js.map

package/dist/resourceLog/entry.js.map

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

package/dist/resourceLog/pin.d.ts

@@ -1,82 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * The chain-head pin: the client-local durable record of a resource log's
- * verified identity and latest verified head, kept per log beside the app's
- * other continuity pins (the account pointer, the roster epoch pin). The pin
- * is what turns one-shot verification into continuity: a served log whose
- * SCID or method differs from the pin outside a verified handover, or whose
- * history is not a descendant of the pinned head, is refused instead of
- * adopted. Storage is the app's concern (freewallet: beside its other pins in
- * localStorage; DCW: a table row), so only the seam lives here, plus an
- * in-memory implementation for tests and single-session use.
- *
- * The seam is keyed: every read and write names the log it concerns with a
- * `logId`, so one store instance serves every log a wallet holds. Wallet-core
- * supplies the key at every call, built by {@link resourceLogPinId} (or one of
- * the named builders over it), so an app implements one keyed store and never
- * chooses keys itself.
- */
-/**
- * One log's pin: the format identifier from the genesis `parameters.method`,
- * the SCID, and the `versionId` of the latest verified head. Established at
- * first contact (trust-on-first-use of the log's identity), advanced only
- * after a full verification whose head is the pinned head or a descendant,
- * and replaced wholesale only across a verified handover.
- */
-export interface ResourceLogHeadPin {
-    method: string;
-    scid: string;
-    head: string;
-}
-/**
- * Where a client keeps its chain-head pins, one record per log, keyed by
- * `logId`. `read` resolves `null` before first contact with that log. Writes
- * happen only on the two legal transitions (advance after full verification,
- * replace across a verified handover) -- the verifier never regresses a pin.
- *
- * The `logId` uniquely names one log among all the logs this store instance
- * serves: one store may serve every log a wallet holds, keyed per log, and two
- * different logs must never share a `logId`. Wallet-core supplies the key at
- * every read and write, built by {@link resourceLogPinId} (or one of the named
- * builders over it), so an implementation never chooses keys of its own.
- */
-export interface ResourceLogPinStore {
-    read(options: {
-        logId: string;
-    }): Promise<ResourceLogHeadPin | null>;
-    write(options: {
-        logId: string;
-        pin: ResourceLogHeadPin;
-    }): Promise<void>;
-}
-/**
- * The pin-slot key for one log: an opaque per-log identity key for pin
- * storage, not a fetchable path or URL.
- *
- * It is deliberately host-free. The `spaceId` is the account's stable random
- * id, so a log served from a claimed new host lands in the SAME pin slot and
- * is checked against the pin already held, rather than opening a fresh
- * trust-on-first-use slate (the mirror-fork concern).
- *
- * @param options {object}
- * @param options.spaceId {string}   the Space the log lives in
- * @param options.collectionId {string}   the collection holding the log
- * @param options.resourceId {string}   the log resource's id
- * @returns {string}
- */
-export declare function resourceLogPinId({ spaceId, collectionId, resourceId }: {
-    spaceId: string;
-    collectionId: string;
-    resourceId: string;
-}): string;
-/**
- * An in-memory pin store: continuity within one session only, keyed by
- * `logId` like any other implementation, so one instance serves several logs.
- * Tests use it as the seam's reference implementation; apps persist for real.
- *
- * @returns {ResourceLogPinStore}
- */
-export declare function memoryResourceLogPinStore(): ResourceLogPinStore;
-//# sourceMappingURL=pin.d.ts.map

package/dist/resourceLog/pin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pin.d.ts","sourceRoot":"","sources":["../../src/resourceLog/pin.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,IAAI,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAA;IACpE,KAAK,CAAC,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,kBAAkB,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,YAAY,EACZ,UAAU,EACX,EAAE;IACD,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,MAAM,CAAA;IACpB,UAAU,EAAE,MAAM,CAAA;CACnB,GAAG,MAAM,CAET;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,IAAI,mBAAmB,CAU/D"}

package/dist/resourceLog/pin.js

@@ -1,57 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * The chain-head pin: the client-local durable record of a resource log's
- * verified identity and latest verified head, kept per log beside the app's
- * other continuity pins (the account pointer, the roster epoch pin). The pin
- * is what turns one-shot verification into continuity: a served log whose
- * SCID or method differs from the pin outside a verified handover, or whose
- * history is not a descendant of the pinned head, is refused instead of
- * adopted. Storage is the app's concern (freewallet: beside its other pins in
- * localStorage; DCW: a table row), so only the seam lives here, plus an
- * in-memory implementation for tests and single-session use.
- *
- * The seam is keyed: every read and write names the log it concerns with a
- * `logId`, so one store instance serves every log a wallet holds. Wallet-core
- * supplies the key at every call, built by {@link resourceLogPinId} (or one of
- * the named builders over it), so an app implements one keyed store and never
- * chooses keys itself.
- */
-/**
- * The pin-slot key for one log: an opaque per-log identity key for pin
- * storage, not a fetchable path or URL.
- *
- * It is deliberately host-free. The `spaceId` is the account's stable random
- * id, so a log served from a claimed new host lands in the SAME pin slot and
- * is checked against the pin already held, rather than opening a fresh
- * trust-on-first-use slate (the mirror-fork concern).
- *
- * @param options {object}
- * @param options.spaceId {string}   the Space the log lives in
- * @param options.collectionId {string}   the collection holding the log
- * @param options.resourceId {string}   the log resource's id
- * @returns {string}
- */
-export function resourceLogPinId({ spaceId, collectionId, resourceId }) {
-    return `space/${spaceId}/${collectionId}/${resourceId}`;
-}
-/**
- * An in-memory pin store: continuity within one session only, keyed by
- * `logId` like any other implementation, so one instance serves several logs.
- * Tests use it as the seam's reference implementation; apps persist for real.
- *
- * @returns {ResourceLogPinStore}
- */
-export function memoryResourceLogPinStore() {
-    const pins = new Map();
-    return {
-        async read({ logId }) {
-            return pins.get(logId) ?? null;
-        },
-        async write({ logId, pin }) {
-            pins.set(logId, pin);
-        }
-    };
-}
-//# sourceMappingURL=pin.js.map

package/dist/resourceLog/pin.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"pin.js","sourceRoot":"","sources":["../../src/resourceLog/pin.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;GAgBG;AAgCH;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAC/B,OAAO,EACP,YAAY,EACZ,UAAU,EAKX;IACC,OAAO,SAAS,OAAO,IAAI,YAAY,IAAI,UAAU,EAAE,CAAA;AACzD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,yBAAyB;IACvC,MAAM,IAAI,GAAG,IAAI,GAAG,EAA8B,CAAA;IAClD,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE;YAClB,OAAO,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,CAAA;QAChC,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE;YACxB,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;QACtB,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/resourceLog/seal.d.ts

@@ -1,97 +0,0 @@
-/*!
- * Copyright (c) 2026 Interop Alliance. All rights reserved.
- */
-/**
- * The sealing sweep (App Connect spec `#log-authorization`): after a
- * controller-document edit removes a member's append authority, every
- * co-managed resource log must gain an entry anchored at (or past) the
- * post-removal document version -- the "sealing append" that proves the
- * surviving writers extended the log under the new membership. An ordinary
- * post-edit write (a roster rotation) is that append by construction; the gap
- * this module closes is the run where no such write happens -- a rotation
- * that no-ops because the retiree held no current-epoch wrap (an orphan
- * client, or any re-run), leaving the log's head still anchored pre-removal.
- *
- * Both halves are computed from durable state alone, keeping every cascade's
- * no-checkpoint convergence rule: the membership change is read off the
- * controller view (the latest version whose `assertionMethod` set lost a
- * member against its predecessor -- only assertion removals affect append
- * authority, so a spent recovery code's `keyAgreement`-only method never
- * registers here), and the log's side is the verified head's effective anchor
- * ({@link VerifiedResourceLog}`.headAnchorIndex`). "Sealed" is simply "head
- * anchor at or past the removal", so the backstop append is idempotent and a
- * torn sweep is finished by a naive re-run.
- */
-import type { ResourceLogStore } from '@interop/was-client/log';
-import type { ResourceLogController } from './controller.js';
-import type { ResourceLogSigner } from './entry.js';
-import type { ResourceLogPinStore } from './pin.js';
-import type { VerifiedResourceLog } from './verify.js';
-/**
- * The controller's latest membership change: the largest index into
- * `controller.versionIds` whose `assertionMethod` key set LOST a member
- * against its predecessor's, or `0` when no version ever removed one (the
- * genesis version has no predecessor and can never register as a removal, so
- * `0` doubles as "nothing to seal against" -- every anchor satisfies it). An
- * unversioned controller resolves `0` for the same reason: with no version
- * history there is no removal to locate.
- *
- * @param options {object}
- * @param options.controller {ResourceLogController}   the verified controller
- *   view
- * @returns {Promise<number>}
- */
-export declare function latestAssertionRemovalIndex({ controller }: {
-    controller: ResourceLogController;
-}): Promise<number>;
-/**
- * Seals one resource log against the controller's latest membership change,
- * idempotently: when the verified head already anchors at or past the latest
- * `assertionMethod` removal (or the controller never removed one, or the log
- * does not exist yet, or the controller is unversioned) nothing is written;
- * otherwise the head state is re-appended VERBATIM as a no-op entry whose
- * only job is its post-removal anchor -- ordinary entries may repeat state
- * (only terminal entries are state-constrained), so the resource itself is
- * untouched. A closed log that needs sealing propagates the append path's
- * `ResourceLogClosedError`.
- *
- * `sealed` reports whether this call found the log unsealed (and it now is,
- * by this call's append or a concurrent writer's -- the rebase hook converges
- * rather than duplicating); `verified` is the log as last verified, `null`
- * when it was never read (absent, or nothing to seal against).
- *
- * @param options {object}
- * @param options.store {ResourceLogStore}   the log's transport seam
- * @param options.controller {ResourceLogController}   the verified controller
- *   view
- * @param options.expectedMethod {string}   the format identifier expected
- * @param options.pinStore {ResourceLogPinStore}   this client's chain-head
- *   pin for this log
- * @param options.logId {string}   the pin-slot key for this log, from
- *   `resourceLogPinId`
- * @param options.signer {ResourceLogSigner}   this client's enrolled signing
- *   key
- * @param [options.versionTime] {string}   RFC3339 UTC; defaults to now
- * @param [options.verified] {VerifiedResourceLog}   a log view the caller
- *   verified moments ago (the most recent read or confirmed append on the same
- *   store), letting the sweep skip its own read. Staleness is safe in both
- *   directions: entry anchors are verifier-enforced monotone, so a stale head
- *   anchoring at or past the removal means the true head does too, and an
- *   unsealed verdict is re-checked by the append path's own read before
- *   anything is written
- * @returns {Promise<{ sealed: boolean, verified: VerifiedResourceLog | null }>}
- */
-export declare function sealResourceLog({ store, controller, expectedMethod, pinStore, logId, signer, versionTime, verified: knownVerified }: {
-    store: ResourceLogStore;
-    controller: ResourceLogController;
-    expectedMethod: string;
-    pinStore: ResourceLogPinStore;
-    logId: string;
-    signer: ResourceLogSigner;
-    versionTime?: string;
-    verified?: VerifiedResourceLog;
-}): Promise<{
-    sealed: boolean;
-    verified: VerifiedResourceLog | null;
-}>;
-//# sourceMappingURL=seal.d.ts.map

package/dist/resourceLog/seal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"seal.d.ts","sourceRoot":"","sources":["../../src/resourceLog/seal.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAA;AAE/D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAA;AACnD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AAEtD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,2BAA2B,CAAC,EAChD,UAAU,EACX,EAAE;IACD,UAAU,EAAE,qBAAqB,CAAA;CAClC,GAAG,OAAO,CAAC,MAAM,CAAC,CAgBlB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAsB,eAAe,CAAC,EACpC,KAAK,EACL,UAAU,EACV,cAAc,EACd,QAAQ,EACR,KAAK,EACL,MAAM,EACN,WAAW,EACX,QAAQ,EAAE,aAAa,EACxB,EAAE;IACD,KAAK,EAAE,gBAAgB,CAAA;IACvB,UAAU,EAAE,qBAAqB,CAAA;IACjC,cAAc,EAAE,MAAM,CAAA;IACtB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,iBAAiB,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,QAAQ,CAAC,EAAE,mBAAmB,CAAA;CAC/B,GAAG,OAAO,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,mBAAmB,GAAG,IAAI,CAAA;CAAE,CAAC,CA6CrE"}

package/dist/resourceLog/seal.js

@@ -1,113 +0,0 @@
-import { appendResourceLog, readResourceLog } from './append.js';
-/**
- * The controller's latest membership change: the largest index into
- * `controller.versionIds` whose `assertionMethod` key set LOST a member
- * against its predecessor's, or `0` when no version ever removed one (the
- * genesis version has no predecessor and can never register as a removal, so
- * `0` doubles as "nothing to seal against" -- every anchor satisfies it). An
- * unversioned controller resolves `0` for the same reason: with no version
- * history there is no removal to locate.
- *
- * @param options {object}
- * @param options.controller {ResourceLogController}   the verified controller
- *   view
- * @returns {Promise<number>}
- */
-export async function latestAssertionRemovalIndex({ controller }) {
-    let removalIndex = 0;
-    let previous = null;
-    for (const [index, versionId] of controller.versionIds.entries()) {
-        const keys = await controller.assertionKeysAt(versionId);
-        if (previous !== null) {
-            for (const key of previous) {
-                if (!keys.has(key)) {
-                    removalIndex = index;
-                    break;
-                }
-            }
-        }
-        previous = keys;
-    }
-    return removalIndex;
-}
-/**
- * Seals one resource log against the controller's latest membership change,
- * idempotently: when the verified head already anchors at or past the latest
- * `assertionMethod` removal (or the controller never removed one, or the log
- * does not exist yet, or the controller is unversioned) nothing is written;
- * otherwise the head state is re-appended VERBATIM as a no-op entry whose
- * only job is its post-removal anchor -- ordinary entries may repeat state
- * (only terminal entries are state-constrained), so the resource itself is
- * untouched. A closed log that needs sealing propagates the append path's
- * `ResourceLogClosedError`.
- *
- * `sealed` reports whether this call found the log unsealed (and it now is,
- * by this call's append or a concurrent writer's -- the rebase hook converges
- * rather than duplicating); `verified` is the log as last verified, `null`
- * when it was never read (absent, or nothing to seal against).
- *
- * @param options {object}
- * @param options.store {ResourceLogStore}   the log's transport seam
- * @param options.controller {ResourceLogController}   the verified controller
- *   view
- * @param options.expectedMethod {string}   the format identifier expected
- * @param options.pinStore {ResourceLogPinStore}   this client's chain-head
- *   pin for this log
- * @param options.logId {string}   the pin-slot key for this log, from
- *   `resourceLogPinId`
- * @param options.signer {ResourceLogSigner}   this client's enrolled signing
- *   key
- * @param [options.versionTime] {string}   RFC3339 UTC; defaults to now
- * @param [options.verified] {VerifiedResourceLog}   a log view the caller
- *   verified moments ago (the most recent read or confirmed append on the same
- *   store), letting the sweep skip its own read. Staleness is safe in both
- *   directions: entry anchors are verifier-enforced monotone, so a stale head
- *   anchoring at or past the removal means the true head does too, and an
- *   unsealed verdict is re-checked by the append path's own read before
- *   anything is written
- * @returns {Promise<{ sealed: boolean, verified: VerifiedResourceLog | null }>}
- */
-export async function sealResourceLog({ store, controller, expectedMethod, pinStore, logId, signer, versionTime, verified: knownVerified }) {
-    if (controller.versionIds.length === 0) {
-        return { sealed: false, verified: null };
-    }
-    const removalIndex = await latestAssertionRemovalIndex({ controller });
-    if (removalIndex === 0) {
-        return { sealed: false, verified: knownVerified ?? null };
-    }
-    let verified = knownVerified ?? null;
-    if (verified === null) {
-        const current = await readResourceLog({
-            store,
-            controller,
-            expectedMethod,
-            pinStore,
-            logId
-        });
-        if (current === null) {
-            return { sealed: false, verified: null };
-        }
-        verified = current.verified;
-    }
-    if (verified.headAnchorIndex !== null &&
-        verified.headAnchorIndex >= removalIndex) {
-        return { sealed: false, verified };
-    }
-    const confirmed = await appendResourceLog({
-        store,
-        controller,
-        expectedMethod,
-        pinStore,
-        logId,
-        signer,
-        // The rebase hook doubles as the convergence check: a concurrent writer
-        // whose entry already anchors past the removal sealed the log for us.
-        buildState: rebased => rebased.headAnchorIndex !== null &&
-            rebased.headAnchorIndex >= removalIndex
-            ? null
-            : rebased.head.state,
-        ...(versionTime === undefined ? {} : { versionTime })
-    });
-    return { sealed: true, verified: confirmed };
-}
-//# sourceMappingURL=seal.js.map

package/dist/resourceLog/seal.js.map

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

package/dist/resourceLog/verify.d.ts

@@ -1,96 +0,0 @@
-import type { ResourceLogEntry } from '@interop/was-client/log';
-import type { ResourceLogController } from './controller.js';
-import type { ResourceLogHeadPin } from './pin.js';
-/**
- * What full verification resolves to. `state` is the profile's definition of
- * the resource's current state -- the verified head entry's `state` -- and
- * `pin` is the record the caller must store as its new chain-head pin.
- * `terminal` is the head's `nextLog` when the log is closed by a handover
- * entry (appends must be refused), `previousLog` the genesis back-reference
- * when this log is a handover successor. `headAnchorIndex` is the head's
- * effective anchor -- the verifier's anchor floor after the whole loop, which
- * monotonicity makes the head entry's own anchor -- as an index into the
- * controller's `versionIds` (`null` on an unversioned controller, whose
- * entries carry no anchors); the sealing sweep compares it against the
- * controller's latest membership change.
- */
-export interface VerifiedResourceLog {
-    entries: ResourceLogEntry[];
-    method: string;
-    scid: string;
-    head: ResourceLogEntry;
-    state: ResourceLogEntry['state'];
-    pin: ResourceLogHeadPin;
-    headAnchorIndex: number | null;
-    terminal: {
-        method: string;
-        scid: string;
-    } | null;
-    previousLog: {
-        scid: string;
-        head: string;
-    } | null;
-}
-/**
- * Whether an entry is a terminal handover entry: its `parameters` carry a
- * `nextLog` member. Position, exact member set, and state equality are the
- * verifier's checks; this is only the discriminant.
- *
- * @param entry {ResourceLogEntry}
- * @returns {boolean}
- */
-export declare function isTerminalResourceLogEntry(entry: ResourceLogEntry): boolean;
-/**
- * Runs the profile's full verification over a parsed log, in order: parse
- * shape, genesis (SCID recomputation, format identifier), chain-hash
- * recomputation, per-entry proofs, the external-authorization rule with
- * anchor monotonicity, termination, and continuity against the chain-head
- * pin. Throws {@link ResourceLogIntegrityError} on fabrication-class
- * failures, {@link ResourceLogContinuityError} on pin conflicts, and
- * `ResourceLogLicenseError` on a ladder-signed append outside the
- * ceremony-tail license; any failure rejects the whole log.
- *
- * The controller view is the independently verified controller document --
- * never material served beside the log. An unversioned controller (empty
- * `versionIds`) degrades every anchor rule to current-document verification
- * and requires anchorless proofs.
- *
- * @param options {object}
- * @param options.entries {ResourceLogEntry[]}   the parsed served log
- * @param options.controller {ResourceLogController}   the verified controller
- *   view ({@link webvhResourceLogController})
- * @param options.expectedMethod {string}   the format identifier this caller
- *   expects (`RESOURCE_LOG_METHOD`; also confirmed against any `history`
- *   dispatch hint the caller followed)
- * @param [options.pin] {ResourceLogHeadPin}   the held chain-head pin, when
- *   this client has verified the log before
- * @returns {Promise<VerifiedResourceLog>}
- */
-export declare function verifyResourceLog({ entries, controller, expectedMethod, pin }: {
-    entries: ResourceLogEntry[];
-    controller: ResourceLogController;
-    expectedMethod: string;
-    pin?: ResourceLogHeadPin | null;
-}): Promise<VerifiedResourceLog>;
-/**
- * Verifies a handover link from both sides: the prior log's terminal entry
- * and the successor log's genesis back-reference. Both logs must already have
- * passed {@link verifyResourceLog}. Checks: the terminal `nextLog` names the
- * successor's SCID and method; the successor's `previousLog` names the prior
- * log's SCID; and the successor's `previousLog.head` is the `versionId` of
- * the terminal entry's immediate predecessor -- the terminal entry chains
- * directly off the head the successor references. A verified handover is the
- * one transition that replaces a chain-head pin wholesale (the caller stores
- * `successor.pin`).
- *
- * @param options {object}
- * @param options.prior {VerifiedResourceLog}   the closed log
- * @param options.successor {VerifiedResourceLog}   the log its terminal entry
- *   names
- * @returns {void}
- */
-export declare function verifyResourceLogHandover({ prior, successor }: {
-    prior: VerifiedResourceLog;
-    successor: VerifiedResourceLog;
-}): void;
-//# sourceMappingURL=verify.d.ts.map

package/dist/resourceLog/verify.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../src/resourceLog/verify.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EACV,gBAAgB,EAEjB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAA;AAO5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAclD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,gBAAgB,EAAE,CAAA;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,gBAAgB,CAAA;IACtB,KAAK,EAAE,gBAAgB,CAAC,OAAO,CAAC,CAAA;IAChC,GAAG,EAAE,kBAAkB,CAAA;IACvB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,QAAQ,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;IACjD,WAAW,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CACnD;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,gBAAgB,GAAG,OAAO,CAM3E;AA0OD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,OAAO,EACP,UAAU,EACV,cAAc,EACd,GAAG,EACJ,EAAE;IACD,OAAO,EAAE,gBAAgB,EAAE,CAAA;IAC3B,UAAU,EAAE,qBAAqB,CAAA;IACjC,cAAc,EAAE,MAAM,CAAA;IACtB,GAAG,CAAC,EAAE,kBAAkB,GAAG,IAAI,CAAA;CAChC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAqP/B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,KAAK,EACL,SAAS,EACV,EAAE;IACD,KAAK,EAAE,mBAAmB,CAAA;IAC1B,SAAS,EAAE,mBAAmB,CAAA;CAC/B,GAAG,IAAI,CAqBP"}