@interop/wallet-core 0.71.0 → 0.73.0

package/dist/keys/userKey.d.ts

@@ -1,27 +1,73 @@
 import type { IKeyAgreementKey, IKeyResolver } from '@interop/data-integrity-core';
+import type { RecordSigner } from '../keyring/record.js';
+/**
+ * The HKDF salt for the user key's client-side expansions, and the one info
+ * label under it. Both permanent: two wallet apps must expand the same user
+ * key to byte-identical output, or a record one of them signs is a record the
+ * other refuses.
+ */
+export declare const USER_KEY_SALT = "freewallet/keys/user-key/v1";
 /**
  * The user key material: the X25519 key-agreement half as minted by the epoch
  * construction (`id` is the key's own did:key; `secret` its raw 32-byte private
- * key), plus the 32-byte seed of the user key's Ed25519 signing pair. Random
- * per account; held in memory for the life of a session and persisted only
- * inside a wrapped client-key record. The signing seed is absent on a user key
- * adopted from a roster rotation -- the roster wraps the key-agreement secret
- * alone, and the signing half has no consumer yet.
+ * key). Random per account; held in memory for the life of a session and
+ * persisted only inside a wrapped client-key record. The Ed25519 signing half
+ * is not a member: it derives from `secret`, so a user key adopted from a
+ * roster rotation is as complete an identity as a freshly minted one.
  */
 export interface UserKey {
     id: string;
     secret: Uint8Array;
-    signingSeed?: Uint8Array;
 }
 /**
  * Mints a fresh user key: the X25519 key-agreement pair via the was-client
- * epoch construction (its did:key is the key id, its raw secret is what wraps),
- * plus a random 32-byte Ed25519 signing seed -- a minted user key is always a
- * complete identity (only a rotation-adopted one lacks the signing half).
+ * epoch construction (its did:key is the key id, its raw secret is what wraps).
+ * The signing half needs no minting -- it derives from the same secret.
+ *
+ * @returns {Promise<UserKey>}
+ */
+export declare function mintUserKey(): Promise<UserKey>;
+/**
+ * Derives the 32-byte Ed25519 seed of the user key's signing half from the
+ * key-agreement half's raw secret: HKDF-SHA256 under {@link USER_KEY_SALT},
+ * info `signing`. Deterministic and wire-level -- the same user key always
+ * yields the same signing key, which is what lets one holder sign a record
+ * another holder verifies with nothing server-served in hand.
+ *
+ * @param options {object}
+ * @param options.userKey {UserKey}
+ * @returns {Uint8Array}
+ */
+export declare function userKeySigningSeed({ userKey }: {
+    userKey: UserKey;
+}): Uint8Array;
+/**
+ * The user key's record signer: the keyring record's signing seam over the
+ * derived Ed25519 half, for an app-side record sealed to the vault KAK
+ * (`signRecordFrame`). Its `keyMultibase` is exactly what a reader's
+ * allowlist holds, so a writer that already has the signer reads the multibase
+ * off it rather than calling {@link userKeySigningKeyMultibase} as well.
+ *
+ * @param options {object}
+ * @param options.userKey {UserKey}
+ * @returns {Promise<RecordSigner>}
+ */
+export declare function userKeyRecordSigner({ userKey }: {
+    userKey: UserKey;
+}): Promise<RecordSigner>;
+/**
+ * The public multibase of the user key's signing half: the one key a reader
+ * accepts on a record sealed under this user key, handed to
+ * `verifyRecordProof` as its allowlist. For a reader alone -- a writer takes
+ * the same value off {@link userKeyRecordSigner}'s `keyMultibase`.
  *
- * @returns {Promise<Required<UserKey>>}
+ * @param options {object}
+ * @param options.userKey {UserKey}
+ * @returns {Promise<string>}
  */
-export declare function mintUserKey(): Promise<Required<UserKey>>;
+export declare function userKeySigningKeyMultibase({ userKey }: {
+    userKey: UserKey;
+}): Promise<string>;
 /**
  * Reconstructs the user key's key-agreement key and its single-key resolver
  * from the stored material -- the vault-key pair a session supplies to the

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

@@ -1 +1 @@
-{"version":3,"file":"userKey.d.ts","sourceRoot":"","sources":["../../src/keys/userKey.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAA;AAIrC;;;;;;;;GAQG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;IAClB,WAAW,CAAC,EAAE,UAAU,CAAA;CACzB;AAED;;;;;;;GAOG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAK9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG;IACnE,eAAe,EAAE,gBAAgB,CAAA;IACjC,WAAW,EAAE,YAAY,CAAA;CAC1B,CAQA"}
+{"version":3,"file":"userKey.d.ts","sourceRoot":"","sources":["../../src/keys/userKey.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EACV,gBAAgB,EAChB,YAAY,EACb,MAAM,8BAA8B,CAAA;AAIrC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AAExD;;;;;GAKG;AACH,eAAO,MAAM,aAAa,gCAAgC,CAAA;AAQ1D;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,UAAU,CAAA;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC,CAGpD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,OAAO,EACR,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,UAAU,CASb;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CAAC,EACxC,OAAO,EACR,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,OAAO,CAAC,YAAY,CAAC,CAExB;AAED;;;;;;;;;GASG;AACH,wBAAsB,0BAA0B,CAAC,EAC/C,OAAO,EACR,EAAE;IACD,OAAO,EAAE,OAAO,CAAA;CACjB,GAAG,OAAO,CAAC,MAAM,CAAC,CAGlB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,OAAO,EAAE,EAAE;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,GAAG;IACnE,eAAe,EAAE,gBAAgB,CAAA;IACjC,WAAW,EAAE,YAAY,CAAA;CAC1B,CAQA"}

package/dist/keys/userKey.js

@@ -12,27 +12,92 @@
  * The key-agreement half is exactly what `@interop/was-client`'s epoch
  * construction mints: a fresh X25519 pair whose did:key is the key's id and
  * whose raw 32-byte secret is what gets wrapped to recipients -- so the roster
- * machinery consumes the user key unchanged. The Ed25519 signing half is a
- * second independent 32-byte seed, minted now so the user key is a complete
- * identity, with no consumer yet (the pair derives from the seed on demand once
- * one lands).
+ * machinery consumes the user key unchanged. The Ed25519 signing half DERIVES
+ * from that same secret ({@link userKeySigningSeed}), so it needs no storage
+ * and no delivery channel of its own: every holder of the user key holds it,
+ * an enrolled session, a transient one, and a session-less signup or recovery
+ * writer alike, and a roster rotation that hands a client the fresh
+ * key-agreement secret hands it the fresh signing half with it.
+ *
+ * Its consumer is record authenticity. An app-side record sealed to the vault
+ * KAK is not authenticated by being decryptable -- a storage host that knows
+ * the epoch's public half can seal a body of its own that decrypts perfectly,
+ * which is the property the keyring record's `proof` member exists to defeat.
+ * So such a record carries the same proof, signed by {@link
+ * userKeyRecordSigner} and verified against {@link
+ * userKeySigningKeyMultibase} before it is decrypted.
  */
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 } from '@noble/hashes/sha2.js';
 import { X25519KeyAgreementKey2020 } from '@interop/x25519-key-agreement-key';
 import { epochKeyIdFor, mintEpoch } from '@interop/was-client/edv';
 import { singleKeyResolver } from '@interop/was-client/identity';
+import { recordSignerFromSeed } from '../keyring/record.js';
+/**
+ * The HKDF salt for the user key's client-side expansions, and the one info
+ * label under it. Both permanent: two wallet apps must expand the same user
+ * key to byte-identical output, or a record one of them signs is a record the
+ * other refuses.
+ */
+export const USER_KEY_SALT = 'freewallet/keys/user-key/v1';
+const USER_KEY_SIGNING_INFO = 'signing';
+/**
+ * The number of bytes the signing expansion produces (a 32-byte Ed25519 seed).
+ */
+const USER_KEY_SIGNING_SEED_BYTES = 32;
 /**
  * Mints a fresh user key: the X25519 key-agreement pair via the was-client
- * epoch construction (its did:key is the key id, its raw secret is what wraps),
- * plus a random 32-byte Ed25519 signing seed -- a minted user key is always a
- * complete identity (only a rotation-adopted one lacks the signing half).
+ * epoch construction (its did:key is the key id, its raw secret is what wraps).
+ * The signing half needs no minting -- it derives from the same secret.
  *
- * @returns {Promise<Required<UserKey>>}
+ * @returns {Promise<UserKey>}
  */
 export async function mintUserKey() {
     const { epochId, secret } = await mintEpoch();
-    const signingSeed = new Uint8Array(32);
-    crypto.getRandomValues(signingSeed);
-    return { id: epochId, secret, signingSeed };
+    return { id: epochId, secret };
+}
+/**
+ * Derives the 32-byte Ed25519 seed of the user key's signing half from the
+ * key-agreement half's raw secret: HKDF-SHA256 under {@link USER_KEY_SALT},
+ * info `signing`. Deterministic and wire-level -- the same user key always
+ * yields the same signing key, which is what lets one holder sign a record
+ * another holder verifies with nothing server-served in hand.
+ *
+ * @param options {object}
+ * @param options.userKey {UserKey}
+ * @returns {Uint8Array}
+ */
+export function userKeySigningSeed({ userKey }) {
+    const encoder = new TextEncoder();
+    return hkdf(sha256, userKey.secret, encoder.encode(USER_KEY_SALT), encoder.encode(USER_KEY_SIGNING_INFO), USER_KEY_SIGNING_SEED_BYTES);
+}
+/**
+ * The user key's record signer: the keyring record's signing seam over the
+ * derived Ed25519 half, for an app-side record sealed to the vault KAK
+ * (`signRecordFrame`). Its `keyMultibase` is exactly what a reader's
+ * allowlist holds, so a writer that already has the signer reads the multibase
+ * off it rather than calling {@link userKeySigningKeyMultibase} as well.
+ *
+ * @param options {object}
+ * @param options.userKey {UserKey}
+ * @returns {Promise<RecordSigner>}
+ */
+export async function userKeyRecordSigner({ userKey }) {
+    return recordSignerFromSeed({ seed: userKeySigningSeed({ userKey }) });
+}
+/**
+ * The public multibase of the user key's signing half: the one key a reader
+ * accepts on a record sealed under this user key, handed to
+ * `verifyRecordProof` as its allowlist. For a reader alone -- a writer takes
+ * the same value off {@link userKeyRecordSigner}'s `keyMultibase`.
+ *
+ * @param options {object}
+ * @param options.userKey {UserKey}
+ * @returns {Promise<string>}
+ */
+export async function userKeySigningKeyMultibase({ userKey }) {
+    const { keyMultibase } = await userKeyRecordSigner({ userKey });
+    return keyMultibase;
 }
 /**
  * Reconstructs the user key's key-agreement key and its single-key resolver

package/dist/keys/userKey.js.map

@@ -1 +1 @@
-{"version":3,"file":"userKey.js","sourceRoot":"","sources":["../../src/keys/userKey.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAK7E,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAiBhE;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW;IAC/B,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,SAAS,EAAE,CAAA;IAC7C,MAAM,WAAW,GAAG,IAAI,UAAU,CAAC,EAAE,CAAC,CAAA;IACtC,MAAM,CAAC,eAAe,CAAC,WAAW,CAAC,CAAA;IACnC,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,CAAA;AAC7C,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAE,OAAO,EAAwB;IAIhE,MAAM,eAAe,GAAG,yBAAyB,CAAC,aAAa,CAAC;QAC9D,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,UAAU,EAAE,OAAO,CAAC,EAAE;QACtB,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;KAC9B,CAAqB,CAAA;IACtB,MAAM,WAAW,GAAG,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAC,CAAA;IAC1D,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,CAAA;AACzC,CAAC"}
+{"version":3,"file":"userKey.js","sourceRoot":"","sources":["../../src/keys/userKey.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AAC9C,OAAO,EAAE,yBAAyB,EAAE,MAAM,mCAAmC,CAAA;AAK7E,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAG3D;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,6BAA6B,CAAA;AAC1D,MAAM,qBAAqB,GAAG,SAAS,CAAA;AAEvC;;GAEG;AACH,MAAM,2BAA2B,GAAG,EAAE,CAAA;AAetC;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW;IAC/B,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,SAAS,EAAE,CAAA;IAC7C,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAA;AAChC,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,EACjC,OAAO,EAGR;IACC,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAA;IACjC,OAAO,IAAI,CACT,MAAM,EACN,OAAO,CAAC,MAAM,EACd,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,EAC7B,OAAO,CAAC,MAAM,CAAC,qBAAqB,CAAC,EACrC,2BAA2B,CAC5B,CAAA;AACH,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,EACxC,OAAO,EAGR;IACC,OAAO,oBAAoB,CAAC,EAAE,IAAI,EAAE,kBAAkB,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAA;AACxE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,EAC/C,OAAO,EAGR;IACC,MAAM,EAAE,YAAY,EAAE,GAAG,MAAM,mBAAmB,CAAC,EAAE,OAAO,EAAE,CAAC,CAAA;IAC/D,OAAO,YAAY,CAAA;AACrB,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,gBAAgB,CAAC,EAAE,OAAO,EAAwB;IAIhE,MAAM,eAAe,GAAG,yBAAyB,CAAC,aAAa,CAAC;QAC9D,MAAM,EAAE,OAAO,CAAC,MAAM;QACtB,UAAU,EAAE,OAAO,CAAC,EAAE;QACtB,EAAE,EAAE,aAAa,CAAC,OAAO,CAAC,EAAE,CAAC;KAC9B,CAAqB,CAAA;IACtB,MAAM,WAAW,GAAG,iBAAiB,CAAC,EAAE,eAAe,EAAE,CAAC,CAAA;IAC1D,OAAO,EAAE,eAAe,EAAE,WAAW,EAAE,CAAA;AACzC,CAAC"}

package/dist/keys/userKeyRoster.d.ts

@@ -503,9 +503,9 @@ export interface UserKeyRosterReadResult {
  *    this client's wrap is unwrapped with its own key-agreement key
  *    (`UserKeyRosterUnwrapError` when it holds none).
  *
- * A rotated read returns the fresh user key; its Ed25519 signing seed does not
- * travel through the roster (the roster wraps the key-agreement secret
- * alone), so the returned user key carries none.
+ * A rotated read returns the fresh user key, and with it the fresh signing
+ * half: the roster wraps the key-agreement secret alone, and the Ed25519 half
+ * derives from that secret, so a rotation delivers a complete identity.
  *
  * A caller with no cached user key at all -- a freshly enrolled client making
  * its first post-enrollment read -- omits `userKey` and always takes the unwrap

package/dist/menders/derive.d.ts

@@ -0,0 +1,85 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The derived sets a wallet's audit tests assert: the invariants a transient
+ * visit reaches, the gaps the registration index implies, and census
+ * completeness. Each is computed from the table and the sites alone, so a
+ * converger that quietly loses a trigger a transient visit fires, or an
+ * invariant no registration reports any more, moves a derived set and fails
+ * the wallet's pin.
+ */
+import { type InvariantId } from './ids.js';
+import type { MenderRegistry } from './registry.js';
+import type { InvariantGap, RegistrationSite } from './types.js';
+/**
+ * One derived gap: the declared row's key and kind, without its prose.
+ */
+type DerivedGap = Pick<InvariantGap, 'invariant' | 'kind'>;
+/**
+ * The invariants a transient visit on a standing credential reaches. The
+ * two chain triggers are read through `dueAt` over the ladder held set; a
+ * `login-routing` site counts unless the client-key-record probe guards it;
+ * a `ceremony-tail` entry counts, every such ceremony running on any
+ * session type; and a detector no site reports (a declaration carrying
+ * `holdsWhen`) counts when it is checked at a trigger a transient visit
+ * fires and, on the chain, under an authority the ladder held set carries.
+ * An unreported declaration with no detector is reached by nothing.
+ *
+ * @param options {object}
+ * @param options.registry {MenderRegistry}
+ * @returns {ReadonlyArray<InvariantId>}   in table order
+ */
+export declare function transientReachableInvariants({ registry }: {
+    registry: MenderRegistry<RegistrationSite, never>;
+}): ReadonlyArray<InvariantId>;
+/**
+ * The gaps the index implies. An invariant no site reports derives `none`,
+ * unless it is checked at ceremony tails alone (converged by the ceremony's
+ * own sequenced code, which is never registered). A detector is not a
+ * mender: a declaration carrying `holdsWhen` and no registration derives
+ * `none` like any other unreported one, so adding a detector never retires
+ * a gap. A declaration naming a chain or routing trigger no site backs
+ * derives `none` whatever else it names. An invariant reported only at sites
+ * a transient visit cannot reach, on an account shape the violation can
+ * stand on, derives `unreachable`. Nothing else derives a gap.
+ *
+ * @param options {object}
+ * @param options.registry {MenderRegistry}
+ * @returns {ReadonlyArray<DerivedGap>}
+ */
+export declare function deriveGaps({ registry }: {
+    registry: MenderRegistry<RegistrationSite, never>;
+}): ReadonlyArray<DerivedGap>;
+/**
+ * Compares the derived gaps with a wallet's declared allowlist. The
+ * derivation admits gaps and retires none: a declared row the derivation no
+ * longer produces passes, and a derived gap with no declaration fails. A
+ * derived `none` needs a declared `none` row for its invariant; a derived
+ * `unreachable` needs any declared row for it, since a declared `none` may
+ * be scoped to a different torn state of the same predicate.
+ *
+ * @param options {object}
+ * @param options.derived {ReadonlyArray<DerivedGap>}
+ * @param options.declared {ReadonlyArray<InvariantGap>}
+ * @returns {ReadonlyArray<DerivedGap>}   the
+ *   derived gaps no declaration covers; empty when the allowlist is complete
+ */
+export declare function undeclaredGaps({ derived, declared }: {
+    derived: ReadonlyArray<DerivedGap>;
+    declared: ReadonlyArray<InvariantGap>;
+}): ReadonlyArray<DerivedGap>;
+/**
+ * Census completeness: the ids in {@link INVARIANT_IDS} the table does not
+ * declare. Duplicated ids and undeclared reports are refused by
+ * `menderRegistry` at construction, so a registry in hand has neither.
+ *
+ * @param options {object}
+ * @param options.registry {MenderRegistry}
+ * @returns {ReadonlyArray<InvariantId>}   empty when the census is complete
+ */
+export declare function undeclaredInvariants({ registry }: {
+    registry: MenderRegistry<RegistrationSite, never>;
+}): ReadonlyArray<InvariantId>;
+export {};
+//# sourceMappingURL=derive.d.ts.map

package/dist/menders/derive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.d.ts","sourceRoot":"","sources":["../../src/menders/derive.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;GAOG;AACH,OAAO,EAAiB,KAAK,WAAW,EAAE,MAAM,UAAU,CAAA;AAC1D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAEhE;;GAEG;AACH,KAAK,UAAU,GAAG,IAAI,CAAC,YAAY,EAAE,WAAW,GAAG,MAAM,CAAC,CAAA;AAW1D;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,EAC3C,QAAQ,EACT,EAAE;IACD,QAAQ,EAAE,cAAc,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAA;CAClD,GAAG,aAAa,CAAC,WAAW,CAAC,CAuC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACT,EAAE;IACD,QAAQ,EAAE,cAAc,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAA;CAClD,GAAG,aAAa,CAAC,UAAU,CAAC,CAoB5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,EAC7B,OAAO,EACP,QAAQ,EACT,EAAE;IACD,OAAO,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IAClC,QAAQ,EAAE,aAAa,CAAC,YAAY,CAAC,CAAA;CACtC,GAAG,aAAa,CAAC,UAAU,CAAC,CAS5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,QAAQ,EACT,EAAE;IACD,QAAQ,EAAE,cAAc,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAA;CAClD,GAAG,aAAa,CAAC,WAAW,CAAC,CAG7B"}

package/dist/menders/derive.js

@@ -0,0 +1,138 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The derived sets a wallet's audit tests assert: the invariants a transient
+ * visit reaches, the gaps the registration index implies, and census
+ * completeness. Each is computed from the table and the sites alone, so a
+ * converger that quietly loses a trigger a transient visit fires, or an
+ * invariant no registration reports any more, moves a derived set and fails
+ * the wallet's pin.
+ */
+import { INVARIANT_IDS } from './ids.js';
+import { heldAuthorities } from './registry.js';
+/**
+ * The ids some site reports, whatever its trigger.
+ */
+function reportedIds(registry) {
+    return new Set(registry.sites().flatMap(site => site.reports));
+}
+/**
+ * The invariants a transient visit on a standing credential reaches. The
+ * two chain triggers are read through `dueAt` over the ladder held set; a
+ * `login-routing` site counts unless the client-key-record probe guards it;
+ * a `ceremony-tail` entry counts, every such ceremony running on any
+ * session type; and a detector no site reports (a declaration carrying
+ * `holdsWhen`) counts when it is checked at a trigger a transient visit
+ * fires and, on the chain, under an authority the ladder held set carries.
+ * An unreported declaration with no detector is reached by nothing.
+ *
+ * @param options {object}
+ * @param options.registry {MenderRegistry}
+ * @returns {ReadonlyArray<InvariantId>}   in table order
+ */
+export function transientReachableInvariants({ registry }) {
+    const reached = new Set();
+    const held = heldAuthorities({ kind: 'ladder' });
+    for (const site of registry.dueAt({
+        held,
+        trigger: 'transient-login-chain'
+    })) {
+        for (const id of site.reports) {
+            reached.add(id);
+        }
+    }
+    for (const site of registry.sites()) {
+        if (site.trigger === 'login-routing' && !site.guardedBy) {
+            for (const id of site.reports) {
+                reached.add(id);
+            }
+        }
+    }
+    const reported = reportedIds(registry);
+    for (const decl of registry.all()) {
+        if (decl.triggers.includes('ceremony-tail')) {
+            reached.add(decl.id);
+            continue;
+        }
+        if (reported.has(decl.id) || !decl.holdsWhen) {
+            continue;
+        }
+        const checkedOnVisit = decl.triggers.includes('login-routing') ||
+            (decl.triggers.includes('transient-login-chain') &&
+                held.includes(decl.authority));
+        if (checkedOnVisit) {
+            reached.add(decl.id);
+        }
+    }
+    return registry
+        .all()
+        .filter(decl => reached.has(decl.id))
+        .map(decl => decl.id);
+}
+/**
+ * The gaps the index implies. An invariant no site reports derives `none`,
+ * unless it is checked at ceremony tails alone (converged by the ceremony's
+ * own sequenced code, which is never registered). A detector is not a
+ * mender: a declaration carrying `holdsWhen` and no registration derives
+ * `none` like any other unreported one, so adding a detector never retires
+ * a gap. A declaration naming a chain or routing trigger no site backs
+ * derives `none` whatever else it names. An invariant reported only at sites
+ * a transient visit cannot reach, on an account shape the violation can
+ * stand on, derives `unreachable`. Nothing else derives a gap.
+ *
+ * @param options {object}
+ * @param options.registry {MenderRegistry}
+ * @returns {ReadonlyArray<DerivedGap>}
+ */
+export function deriveGaps({ registry }) {
+    const reported = reportedIds(registry);
+    const reachable = new Set(transientReachableInvariants({ registry }));
+    const gaps = [];
+    for (const decl of registry.all()) {
+        if (!reported.has(decl.id)) {
+            const tailOnly = decl.triggers.length > 0 &&
+                decl.triggers.every(trigger => trigger === 'ceremony-tail');
+            if (!tailOnly) {
+                gaps.push({ invariant: decl.id, kind: 'none' });
+            }
+        }
+        else if (!reachable.has(decl.id) &&
+            decl.standsOn.includes('client-less')) {
+            gaps.push({ invariant: decl.id, kind: 'unreachable' });
+        }
+    }
+    return gaps;
+}
+/**
+ * Compares the derived gaps with a wallet's declared allowlist. The
+ * derivation admits gaps and retires none: a declared row the derivation no
+ * longer produces passes, and a derived gap with no declaration fails. A
+ * derived `none` needs a declared `none` row for its invariant; a derived
+ * `unreachable` needs any declared row for it, since a declared `none` may
+ * be scoped to a different torn state of the same predicate.
+ *
+ * @param options {object}
+ * @param options.derived {ReadonlyArray<DerivedGap>}
+ * @param options.declared {ReadonlyArray<InvariantGap>}
+ * @returns {ReadonlyArray<DerivedGap>}   the
+ *   derived gaps no declaration covers; empty when the allowlist is complete
+ */
+export function undeclaredGaps({ derived, declared }) {
+    return derived.filter(({ invariant, kind }) => !declared.some(gap => gap.invariant === invariant &&
+        (kind === 'unreachable' || gap.kind === 'none')));
+}
+/**
+ * Census completeness: the ids in {@link INVARIANT_IDS} the table does not
+ * declare. Duplicated ids and undeclared reports are refused by
+ * `menderRegistry` at construction, so a registry in hand has neither.
+ *
+ * @param options {object}
+ * @param options.registry {MenderRegistry}
+ * @returns {ReadonlyArray<InvariantId>}   empty when the census is complete
+ */
+export function undeclaredInvariants({ registry }) {
+    const declared = new Set(registry.all().map(decl => decl.id));
+    return INVARIANT_IDS.filter(id => !declared.has(id));
+}
+//# sourceMappingURL=derive.js.map

package/dist/menders/derive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"derive.js","sourceRoot":"","sources":["../../src/menders/derive.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;GAOG;AACH,OAAO,EAAE,aAAa,EAAoB,MAAM,UAAU,CAAA;AAE1D,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAQ/C;;GAEG;AACH,SAAS,WAAW,CAClB,QAAiD;IAEjD,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAA;AAChE,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,4BAA4B,CAAC,EAC3C,QAAQ,EAGT;IACC,MAAM,OAAO,GAAG,IAAI,GAAG,EAAe,CAAA;IACtC,MAAM,IAAI,GAAG,eAAe,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAA;IAChD,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC;QAChC,IAAI;QACJ,OAAO,EAAE,uBAAuB;KACjC,CAAC,EAAE,CAAC;QACH,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YAC9B,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;QACjB,CAAC;IACH,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,KAAK,EAAE,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,OAAO,KAAK,eAAe,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YACxD,KAAK,MAAM,EAAE,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;gBAC9B,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;YACjB,CAAC;QACH,CAAC;IACH,CAAC;IACD,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;IACtC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC,EAAE,CAAC;YAC5C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;YACpB,SAAQ;QACV,CAAC;QACD,IAAI,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,CAAC;YAC7C,SAAQ;QACV,CAAC;QACD,MAAM,cAAc,GAClB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC;YACvC,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,uBAAuB,CAAC;gBAC9C,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAA;QAClC,IAAI,cAAc,EAAE,CAAC;YACnB,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;QACtB,CAAC;IACH,CAAC;IACD,OAAO,QAAQ;SACZ,GAAG,EAAE;SACL,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;SACpC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAA;AACzB,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,UAAU,CAAC,EACzB,QAAQ,EAGT;IACC,MAAM,QAAQ,GAAG,WAAW,CAAC,QAAQ,CAAC,CAAA;IACtC,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,4BAA4B,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAA;IACrE,MAAM,IAAI,GAAsB,EAAE,CAAA;IAClC,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC;QAClC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YAC3B,MAAM,QAAQ,GACZ,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC;gBACxB,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,KAAK,eAAe,CAAC,CAAA;YAC7D,IAAI,CAAC,QAAQ,EAAE,CAAC;gBACd,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAA;YACjD,CAAC;QACH,CAAC;aAAM,IACL,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACvB,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,aAAa,CAAC,EACrC,CAAC;YACD,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,aAAa,EAAE,CAAC,CAAA;QACxD,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,cAAc,CAAC,EAC7B,OAAO,EACP,QAAQ,EAIT;IACC,OAAO,OAAO,CAAC,MAAM,CACnB,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,EAAE,EAAE,CACtB,CAAC,QAAQ,CAAC,IAAI,CACZ,GAAG,CAAC,EAAE,CACJ,GAAG,CAAC,SAAS,KAAK,SAAS;QAC3B,CAAC,IAAI,KAAK,aAAa,IAAI,GAAG,CAAC,IAAI,KAAK,MAAM,CAAC,CAClD,CACJ,CAAA;AACH,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,EACnC,QAAQ,EAGT;IACC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;IAC7D,OAAO,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC,CAAA;AACtD,CAAC"}

package/dist/menders/ids.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The invariant ids: the closed census both wallets declare against and the
+ * mender event channel keys on. Each names the predicate an entry makes
+ * true rather than the code that converges it, so moving a converger between
+ * modules renames nothing. The ids are code-only; nothing persists them.
+ * Numbered in the order the design table assigned them, and a new one takes
+ * the next free number rather than renumbering.
+ */
+/**
+ * Every invariant id, in design-table order.
+ */
+export declare const INVARIANT_IDS: readonly ["roster-wraps-exactly-the-document-key-set", "governed-log-heads-anchor-past-the-membership-change", "collection-epochs-name-the-current-user-key", "unlock-registry-opens-under-the-current-user-key", "registry-passphrase-entry-names-the-standing-credential", "passkey-entry-carries-its-standing-configuration", "registry-lists-the-passphrase-method", "standing-delegations-verify-under-the-current-document", "registry-records-the-committed-ladder-rung", "unlock-record-points-at-the-account-did", "account-pointer-names-the-account-did", "space-controller-is-the-account-did", "roster-and-collection-epochs-exist", "registry-records-the-establishing-credential", "annex-generation-is-reachable", "generation-delegation-is-current", "acting-credential-manage-zcap-is-current", "did-web-projection-matches-the-log", "no-annex-generation-outlives-its-pointer", "app-keys-live-only-in-app-connections", "client-key-record-matches-the-pointed-account", "this-browser-is-still-an-enrolled-client", "no-client-key-record-stays-pending", "recovery-spend-is-completed", "retired-credential-leaves-no-annex-inventory", "document-lists-the-acting-credential", "keystore-controller-is-the-account-did", "account-document-publishes-an-authentication-key", "every-document-key-agreement-entry-has-a-locatable-credential", "no-unlock-space-outlives-its-credential", "no-keystore-outlives-its-account", "saved-recovery-codes-locate-their-account", "standard-collections-are-provisioned", "no-auxiliary-space-stands-unnamed"];
+/**
+ * One id from {@link INVARIANT_IDS}.
+ */
+export type InvariantId = (typeof INVARIANT_IDS)[number];
+//# sourceMappingURL=ids.d.ts.map

package/dist/menders/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/menders/ids.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;GAOG;AAEH;;GAEG;AACH,eAAO,MAAM,aAAa,i/CAqEhB,CAAA;AAEV;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,aAAa,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/menders/ids.js

@@ -0,0 +1,85 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The invariant ids: the closed census both wallets declare against and the
+ * mender event channel keys on. Each names the predicate an entry makes
+ * true rather than the code that converges it, so moving a converger between
+ * modules renames nothing. The ids are code-only; nothing persists them.
+ * Numbered in the order the design table assigned them, and a new one takes
+ * the next free number rather than renumbering.
+ */
+/**
+ * Every invariant id, in design-table order.
+ */
+export const INVARIANT_IDS = [
+    // 1
+    'roster-wraps-exactly-the-document-key-set',
+    // 2
+    'governed-log-heads-anchor-past-the-membership-change',
+    // 3
+    'collection-epochs-name-the-current-user-key',
+    // 4
+    'unlock-registry-opens-under-the-current-user-key',
+    // 5
+    'registry-passphrase-entry-names-the-standing-credential',
+    // 6
+    'passkey-entry-carries-its-standing-configuration',
+    // 7
+    'registry-lists-the-passphrase-method',
+    // 8
+    'standing-delegations-verify-under-the-current-document',
+    // 9
+    'registry-records-the-committed-ladder-rung',
+    // 10
+    'unlock-record-points-at-the-account-did',
+    // 11
+    'account-pointer-names-the-account-did',
+    // 12
+    'space-controller-is-the-account-did',
+    // 13
+    'roster-and-collection-epochs-exist',
+    // 14
+    'registry-records-the-establishing-credential',
+    // 15
+    'annex-generation-is-reachable',
+    // 16
+    'generation-delegation-is-current',
+    // 17
+    'acting-credential-manage-zcap-is-current',
+    // 18
+    'did-web-projection-matches-the-log',
+    // 19
+    'no-annex-generation-outlives-its-pointer',
+    // 20
+    'app-keys-live-only-in-app-connections',
+    // 21
+    'client-key-record-matches-the-pointed-account',
+    // 22
+    'this-browser-is-still-an-enrolled-client',
+    // 23
+    'no-client-key-record-stays-pending',
+    // 24
+    'recovery-spend-is-completed',
+    // 25
+    'retired-credential-leaves-no-annex-inventory',
+    // 26
+    'document-lists-the-acting-credential',
+    // 27
+    'keystore-controller-is-the-account-did',
+    // 28
+    'account-document-publishes-an-authentication-key',
+    // 29
+    'every-document-key-agreement-entry-has-a-locatable-credential',
+    // 30
+    'no-unlock-space-outlives-its-credential',
+    // 31
+    'no-keystore-outlives-its-account',
+    // 32
+    'saved-recovery-codes-locate-their-account',
+    // 33
+    'standard-collections-are-provisioned',
+    // 34
+    'no-auxiliary-space-stands-unnamed'
+];
+//# sourceMappingURL=ids.js.map

package/dist/menders/ids.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.js","sourceRoot":"","sources":["../../src/menders/ids.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;GAOG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI;IACJ,2CAA2C;IAC3C,IAAI;IACJ,sDAAsD;IACtD,IAAI;IACJ,6CAA6C;IAC7C,IAAI;IACJ,kDAAkD;IAClD,IAAI;IACJ,yDAAyD;IACzD,IAAI;IACJ,kDAAkD;IAClD,IAAI;IACJ,sCAAsC;IACtC,IAAI;IACJ,wDAAwD;IACxD,IAAI;IACJ,4CAA4C;IAC5C,KAAK;IACL,yCAAyC;IACzC,KAAK;IACL,uCAAuC;IACvC,KAAK;IACL,qCAAqC;IACrC,KAAK;IACL,oCAAoC;IACpC,KAAK;IACL,8CAA8C;IAC9C,KAAK;IACL,+BAA+B;IAC/B,KAAK;IACL,kCAAkC;IAClC,KAAK;IACL,0CAA0C;IAC1C,KAAK;IACL,oCAAoC;IACpC,KAAK;IACL,0CAA0C;IAC1C,KAAK;IACL,uCAAuC;IACvC,KAAK;IACL,+CAA+C;IAC/C,KAAK;IACL,0CAA0C;IAC1C,KAAK;IACL,oCAAoC;IACpC,KAAK;IACL,6BAA6B;IAC7B,KAAK;IACL,8CAA8C;IAC9C,KAAK;IACL,sCAAsC;IACtC,KAAK;IACL,wCAAwC;IACxC,KAAK;IACL,kDAAkD;IAClD,KAAK;IACL,+DAA+D;IAC/D,KAAK;IACL,yCAAyC;IACzC,KAAK;IACL,kCAAkC;IAClC,KAAK;IACL,2CAA2C;IAC3C,KAAK;IACL,sCAAsC;IACtC,KAAK;IACL,mCAAmC;CAC3B,CAAA"}

package/dist/menders/index.d.ts

@@ -0,0 +1,42 @@
+/*!
+ * Copyright (c) 2026 Interop Alliance. All rights reserved.
+ */
+/**
+ * The `@interop/wallet-core/menders` subpath: the mender registry keyed by
+ * invariant. A wallet declares its own table of invariants (data: what must
+ * hold between ceremonies) and its own registrations (code: what converges a
+ * violated one); this module carries the structure both wallets share.
+ *
+ * - the vocabularies: `AUTHORITIES`, `TRIGGERS`, `CHAIN_TRIGGERS`,
+ *   `ACCOUNT_SHAPES`, `EVIDENCE`, `MEND_OUTCOMES`, `GAP_KINDS`, and
+ *   `INVARIANT_IDS`, each an `as const` array with its union
+ * - the types: `InvariantDeclaration`, `RegistrationSite`, `Registration`,
+ *   `MendOutcome`, `MendReportEntry`, `MendReport`, `InvariantGap`,
+ *   `LoginRoute`
+ * - the readers: `menderRegistry` (`all`, `byId`, `sites`, `admits`,
+ *   `dueAt`), which refuses a duplicated id, an undeclared report, or a
+ *   guard on a non-routing site at construction, and `heldAuthorities`, the
+ *   held set a session's account-ceremony context derives
+ * - the runner: `runMenderBlock`, one try, warn, and skip discipline over
+ *   one chain trigger's registrations, `mendReportAccumulator`, the
+ *   pre-session report collector its `onOutcome` feeds, and `errorNameOf`,
+ *   the name a report carries for a thrown value of any shape
+ * - the derived sets a wallet's audit tests pin:
+ *   `transientReachableInvariants`, `deriveGaps`, `undeclaredGaps`, and
+ *   `undeclaredInvariants`
+ *
+ * Nothing here executes a ceremony. The runner calls the convergers a
+ * wallet registers and nothing else; the ceremonies stay explicit sequenced
+ * code, and the registry describes the menders from the outside.
+ */
+export { deriveGaps, transientReachableInvariants, undeclaredGaps, undeclaredInvariants } from './derive.js';
+export { INVARIANT_IDS } from './ids.js';
+export type { InvariantId } from './ids.js';
+export { heldAuthorities, menderRegistry } from './registry.js';
+export type { MenderRegistry, ResolvedAuthority } from './registry.js';
+export { errorNameOf, MEND_REPORT_SHAPE_ERROR, mendReportAccumulator, runMenderBlock } from './runner.js';
+export type { MendReportAccumulator } from './runner.js';
+export type { InvariantDeclaration, InvariantGap, LoginRoute, MendOutcome, MendReport, MendReportEntry, Registration, RegistrationSite } from './types.js';
+export { ACCOUNT_SHAPES, AUTHORITIES, CHAIN_TRIGGERS, EVIDENCE, GAP_KINDS, MEND_OUTCOMES, TRIGGERS } from './vocabulary.js';
+export type { AccountShape, Authority, ChainTrigger, Evidence, GapKind, MendOutcomeKind, Trigger } from './vocabulary.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/menders/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EACL,UAAU,EACV,4BAA4B,EAC5B,cAAc,EACd,oBAAoB,EACrB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AACxC,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,eAAe,CAAA;AAC/D,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACtE,OAAO,EACL,WAAW,EACX,uBAAuB,EACvB,qBAAqB,EACrB,cAAc,EACf,MAAM,aAAa,CAAA;AACpB,YAAY,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACxD,YAAY,EACV,oBAAoB,EACpB,YAAY,EACZ,UAAU,EACV,WAAW,EACX,UAAU,EACV,eAAe,EACf,YAAY,EACZ,gBAAgB,EACjB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,cAAc,EACd,WAAW,EACX,cAAc,EACd,QAAQ,EACR,SAAS,EACT,aAAa,EACb,QAAQ,EACT,MAAM,iBAAiB,CAAA;AACxB,YAAY,EACV,YAAY,EACZ,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,eAAe,EACf,OAAO,EACR,MAAM,iBAAiB,CAAA"}