keri-ts 1.0.0 → 2.0.1

package/esm/keri/npm/src/did/webs/resolving.js

@@ -1,38 +1,51 @@
-/**
- * Verified `did:webs` resolution.
- *
- * Resolution succeeds only when hosted `did.json` matches the DID document
- * regenerated from the fetched `keri.cesr` KERI/VDR stream.
- */
-import { call } from "effection";
-import { abortable } from "../../app/abortable.js";
-import { collectBytes, streamBytes } from "../../app/byte-source.js";
-import { requireRegery } from "../../app/credential-workflows.js";
-import { defaultRuntimeHttpClient } from "../../app/runtime-services.js";
+import { TransportError } from "../../app/transport/transport-error.js";
+import { call, resource, scoped } from "effection";
+import { abortable } from "../../app/runtime/abortable.js";
+import { collectBytes } from "../../app/transport/byte-source.js";
 import { ValidationError } from "../../core/errors.js";
 import { pinDesignatedAliasesSchema } from "./designated-aliases.js";
 import { didWebsArtifactUrls, normalizeHostedDidDocument, parseDidWebs } from "./dids.js";
 import { didResolutionResult, generateBareDidDocument, } from "./documenting.js";
-/** Resolve one `did:webs` by fetching and verifying hosted artifacts. */
-export function resolveDidWebs(runtime, options) {
-    return call(() => resolveArtifacts(runtime, options));
+/**
+ * Resolve one `did:webs` by fetching and verifying hosted artifacts.
+ *
+ * @param rgy Borrowed registry owner used to regenerate DID state.
+ * @param reactor Borrowed ingress owner for fetched KERI/VDR artifacts.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param options DID, resolution metadata and HTTP preference choices.
+ * @returns DID document verified against accepted artifact-derived state, plus resolution metadata.
+ */
+export function resolveDidWebs(rgy, reactor, http, options) {
+    return call(() => resolveArtifacts(rgy, reactor, http, options));
 }
-/** Keep finite JSON ownership local even when a long-lived caller resolves multiple DIDs. */
-function* resolveArtifacts(runtime, options) {
+/**
+ * Keep finite JSON ownership local even when a long-lived caller resolves multiple DIDs.
+ *
+ * @param rgy Borrowed registry owner used to regenerate DID state.
+ * @param reactor Borrowed ingress owner for fetched KERI/VDR artifacts.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param options DID, resolution metadata and HTTP preference choices.
+ * @returns DID document verified against accepted artifact-derived state, plus resolution metadata.
+ */
+function* resolveArtifacts(rgy, reactor, http, options) {
     const parsed = parseDidWebs(options.did);
     const urls = didWebsArtifactUrls(parsed, { scheme: "https" });
     const fallbackUrls = didWebsArtifactUrls(parsed, { scheme: "http" });
-    pinDesignatedAliasesSchema(runtime.hby.db);
+    pinDesignatedAliasesSchema(rgy.hby.db);
     const preferHttp = options.insecureHttp ?? false;
     yield* call(function* () {
-        yield* runtime.reactor.process((signal) => artifactBytes(runtime.services.http, urls.keriCesr, fallbackUrls.keriCesr, preferHttp, signal), { local: false });
+        const response = yield* artifactResponse(http, urls.keriCesr, fallbackUrls.keriCesr, preferHttp);
+        yield* reactor.process((signal) => response.body(signal), { local: false });
     });
     // EOF and parser cleanup precede convergence and any claim of a complete DID.
-    yield* runtime.reactor.processEscrowsOnce();
+    yield* reactor.protocol.processEscrowsOnce();
     // Preserve the second convergence turn previously run after settleRuntimeIngress's own pass.
-    yield* runtime.reactor.processEscrowsOnce();
-    const expected = generateBareDidDocument(runtime.hby, requireRegery(runtime), parsed.canonical);
-    const bytes = yield* abortable((signal) => collectBytes(artifactBytes(runtime.services.http, urls.didJson, fallbackUrls.didJson, preferHttp, signal)));
+    yield* reactor.protocol.processEscrowsOnce();
+    const expected = generateBareDidDocument(rgy.hby, rgy, parsed.canonical);
+    const bytes = yield* call(function* () {
+        const response = yield* artifactResponse(http, urls.didJson, fallbackUrls.didJson, preferHttp);
+        return yield* abortable((signal) => collectBytes(response.body(signal)));
+    });
     let hosted;
     try {
         hosted = JSON.parse(new TextDecoder().decode(bytes));
@@ -52,42 +65,46 @@ function* resolveArtifacts(runtime, options) {
         resolution,
     };
 }
-/** Native header transport fallback only; a started body never retries another artifact URL. */
-async function* artifactBytes(http, httpsUrl, httpUrl, preferHttp, signal) {
-    const urls = preferHttp ? [httpUrl, httpsUrl] : [httpsUrl, httpUrl];
-    let lastError;
-    for (const url of urls) {
-        signal.throwIfAborted();
-        let response;
-        try {
-            response = await http.fetch(url, { signal });
-        }
-        catch (error) {
-            signal.throwIfAborted();
-            // Injected clients can throw programmer/infrastructure TypeErrors; never recast those as transport.
-            if (http !== defaultRuntimeHttpClient || !(error instanceof TypeError))
-                throw error;
-            lastError = error;
-            continue;
-        }
-        let readerOwnsBody = false;
-        try {
-            signal.throwIfAborted();
-            if (!response.ok) {
-                lastError = new ValidationError(`Unable to fetch ${url}: HTTP ${response.status}.`);
-                continue;
+/**
+ * Try alternate artifact URLs only while opening headers; a borrowed body never starts another attempt.
+ *
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param httpsUrl HTTPS artifact candidate.
+ * @param httpUrl HTTP artifact candidate.
+ * @param preferHttp Try HTTP first when explicitly requested.
+ * @returns Scoped response borrowed until its enclosing operation closes.
+ * @throws Only opening TransportError/non-ok status permits alternate URL selection; body/parser/cleanup failures propagate.
+ */
+function artifactResponse(http, httpsUrl, httpUrl, preferHttp) {
+    return resource(function* (provide) {
+        const urls = preferHttp ? [httpUrl, httpsUrl] : [httpsUrl, httpUrl];
+        let lastError;
+        for (const url of urls) {
+            let receivedHeaders = false;
+            // Each unsuccessful request finishes cleanup before another URL may be attempted.
+            try {
+                const delivered = yield* scoped(function* () {
+                    const response = yield* http.open(url);
+                    receivedHeaders = true;
+                    if (!response.ok) {
+                        lastError = new ValidationError(`Unable to fetch ${url}: HTTP ${response.status}.`);
+                        return false;
+                    }
+                    // Keep the request open for protocol/JSON consumption, after the fallback decision.
+                    yield* provide(response);
+                    return true;
+                });
+                if (delivered)
+                    return;
+            }
+            catch (error) {
+                if (receivedHeaders || !(error instanceof TransportError))
+                    throw error;
+                lastError = error;
             }
-            readerOwnsBody = true;
-            yield* streamBytes(response.body, { signal });
-            return;
-        }
-        finally {
-            // The shared reader owns started-body cancellation; dispose only unacquired/failed headers here.
-            if (!readerOwnsBody && response.body)
-                await response.body.cancel();
         }
-    }
-    throw lastError;
+        throw lastError;
+    });
 }
 function hostedDidDocument(value) {
     if (!isRecord(value)) {

package/esm/keri/npm/src/library/index.js

@@ -10,5 +10,5 @@ export * from "../core/cues.js";
 export * from "../core/deck.js";
 export * from "../core/errors.js";
 export * from "../core/logger.js";
-export * from "../core/mailbox-topics.js";
+export * from "../core/mailbox/mailbox-topics.js";
 export * from "../core/roles.js";

package/esm/keri/npm/src/npm/cli.js

@@ -1,3 +1,3 @@
 /** npm subpath entrypoint for `keri-ts/cli`. */
 import "../_dnt.polyfills.js";
-export * from "../app/cli/index.js";
+export * from "../cli/index.js";

package/esm/keri/npm/src/npm/index.js

@@ -7,4 +7,4 @@
  */
 import "../_dnt.polyfills.js";
 export * from "../library/index.js";
-export { BUILD_METADATA, DISPLAY_VERSION, PACKAGE_VERSION, } from "../app/version.js";
+export { BUILD_METADATA, DISPLAY_VERSION, PACKAGE_VERSION, } from "../version.js";

package/esm/keri/npm/src/runtime/index.js

@@ -7,67 +7,92 @@
  * internal export must not silently expand this package contract.
  */
 // Host lifecycle, direct ingress and concrete I/O boundaries.
-export { abortable, rethrowCleanupFailure, } from "../app/abortable.js";
-export { createAgentRuntime, runAgentRuntime, runAgentRuntimeUntil, runtimeOobiConverged, settleMailboxPollBatch, settleRuntimeIngress, } from "../app/agent-runtime.js";
-export { chunkBytes, collectBytes, fileBytes, streamBytes, } from "../app/byte-source.js";
-export { CesrHttpRefusal, postCesr, requestFrame, } from "../app/cesr-egress.js";
-export { buildCesrRequest, buildCesrStreamRequest, CESR_ATTACHMENT_HEADER, CESR_CONTENT_TYPE, CESR_DESTINATION_HEADER, DEFAULT_CESR_BODY_MODE, isCesrContentType, isMultipartFormContentType, KERIPY_CESR_JSON_CONTENT_TYPE, MULTIPART_CONTENT_TYPE, normalizeCesrBodyMode, readCesrRequestBytes, readMailboxAdminRequest, readRequiredCesrRequestBytes, requestBytes, } from "../app/cesr-http.js";
-export { cueDo, processCuesOnce, } from "../app/cue-runtime.js";
-export { fetchResponseHandle, } from "../app/httping.js";
-export { envelopeFromFrame, queryEnvelopeFromDispatch, } from "../app/parsering.js";
-export { Reactor, } from "../app/reactor.js";
-export { Respondant, } from "../app/respondant.js";
-export { defaultRuntimeServices, } from "../app/runtime-services.js";
-export { socketBytes, } from "../app/socket-source.js";
-export { converseCesrTcp, streamCesrTcpConversation, } from "../app/tcp-conversation.js";
-export { openTcpConnection, sendCesrTcp, sendCesrTcpFrame, sendCesrTcpSocket, streamCesrTcp, writeCesrTcpSocket, } from "../app/tcp-egress.js";
+export { Respondant, } from "../app/delivery/respondant.js";
+export { envelopeFromFrame, queryEnvelopeFromDispatch, } from "../app/protocol/parsering.js";
+export { createProtocolProcessor, ProtocolProcessor, } from "../app/protocol/protocol-processing.js";
+export { Reactor, } from "../app/protocol/reactor.js";
+export { abortable, rethrowCleanupFailure, } from "../app/runtime/abortable.js";
+export { createAgentRuntime, runAgentRuntime, runAgentRuntimeUntil, runtimeOobiConverged, settleMailboxPollBatch, settleRuntimeIngress, } from "../app/runtime/agent-runtime.js";
+export { cueDo, processCuesOnce, } from "../app/runtime/cue-runtime.js";
+export { chunkBytes, collectBytes, fileBytes, } from "../app/transport/byte-source.js";
+export { CesrHttpRefusal, postCesr, requestFrame, } from "../app/transport/cesr-egress.js";
+export { buildCesrRequest, buildCesrStreamRequest, CESR_ATTACHMENT_HEADER, CESR_CONTENT_TYPE, CESR_DESTINATION_HEADER, isCesrContentType, isMultipartFormContentType, KERIPY_CESR_JSON_CONTENT_TYPE, MULTIPART_CONTENT_TYPE, readCesrRequestBytes, readMailboxAdminRequest, readRequiredCesrRequestBytes, requestBytes, } from "../app/transport/cesr-http.js";
+export { FetchHttpClient, } from "../app/transport/http-client.js";
+export { socketBytes, } from "../app/transport/socket-source.js";
+export { TCPMessenger, } from "../app/transport/tcp-messenger.js";
+export { openTcpConnection, sendCesrTcp, sendCesrTcpFrame, sendCesrTcpSocket, streamCesrTcp, writeCesrTcpSocket, } from "../app/transport/tcp-egress.js";
+export { TransportError } from "../app/transport/transport-error.js";
 // Controller state, credentials and protocol operations.
-export { findVerifiedChallengeResponse, generateChallengeWords, markChallengeVerified, parseChallengeWords, } from "../app/challenging.js";
-export { Configer, createConfiger, } from "../app/configing.js";
-export { createCredential, credentialRegistryRecords, credentialRegistryStatus, exportCredentialStream, importCredentialStream, inceptCredentialRegistry, listCredentials, pinSchemaBytes, requireRegery, revokeCredential, } from "../app/credential-workflows.js";
-export { Anchorer, } from "../app/delegating.js";
-export { endpointRoleAccepted, loadAcceptedEndpointRole, proposeGroupEndpointRole, } from "../app/endpoint-roleing.js";
-export { EssrRecipient, } from "../app/essr.js";
-export { Exchanger, sendSignedExchangeMessage, } from "../app/exchanging.js";
-export { MailboxPoller, postCesrMessage, Poster, sendExchangeMessage, } from "../app/forwarding.js";
-export { isLocalGroupHab } from "../app/group-members.js";
-export { Multiplexor, MULTISIG_ROUTES, multisigExn, multisigInceptExn, multisigInteractExn, multisigIssueExn, multisigRegistryInceptExn, multisigRevokeExn, multisigRotateExn, multisigRpyExn, } from "../app/grouping.js";
-export { createHabery, Hab, Habery, } from "../app/habbing.js";
-export { credentialPresentationArtifacts, ipexCredentialAdmit, ipexCredentialGrant, processCredentialPresentationArtifacts, } from "../app/ipex-credentialing.js";
-export { IPEX_ROUTES, ipexAdmitExn, ipexAgreeExn, ipexApplyExn, ipexGrantExn, ipexOfferExn, ipexSpurnExn, } from "../app/ipexing.js";
-export { Algos, Manager, } from "../app/keeping.js";
-export { MailboxDirector, } from "../app/mailbox-director.js";
-export { consumeMailboxSse, parseMailboxSse, readMailboxSseBody, } from "../app/mailbox-sse.js";
-export { directDeliveryEndpoints, endpointBasePath, fetchEndpointUrls, mailboxDeliveryEndpoints, mailboxPollEndpoints, mailboxQueryTopics, mailboxTopicKey, preferredUrl, resolveHostedEndpointPath, } from "../app/mailboxing.js";
-export { Notifier, } from "../app/notifying.js";
-export { Oobiery, oobiRequestExn, } from "../app/oobiery.js";
-export { Organizer, } from "../app/organizing.js";
-export { Signal, Signaler, } from "../app/signaling.js";
-export { VerifierAgent, } from "../app/verifier-agent.js";
-export { Verifier, } from "../app/verifying.js";
-export { BUILD_METADATA, DISPLAY_VERSION, PACKAGE_VERSION, } from "../app/version.js";
-export { drainWitnessCues, processWitnessIngress, processWitnessIngressSource, Receiptor, witnessKeyStateGet, witnessQueryGet, witnessReceiptGet, WitnessReceiptor, witnessReceiptPost, } from "../app/witnessing.js";
+export { evaluateChain } from "../acdc/chaining.js";
+export { decodePublicKey, deriveRoot, Dhke, generateKeyPair, } from "../acdc/dhking.js";
+export { RegistryRoot, RootDeferred, rootExn, RootRefused, RootUnverified, } from "../acdc/salting.js";
+export { Unblind } from "../acdc/unblinding.js";
+export { Oobiery, oobiRequestExn, } from "../app/bootstrap/oobiery.js";
+export { importCredentialStream, } from "../app/credentials/credential-importing.js";
+export { deliverCredentialRevocation, revokeCredential, } from "../app/credentials/credential-revoking.js";
+export { createCredential, credentialRegistryRecords, credentialRegistryStatus, exportCredentialStream, inceptCredentialRegistry, listCredentials, pinSchemaBytes, } from "../app/credentials/credential-workflows.js";
+export { Poster, } from "../app/delivery/forwarding.js";
+export { EssrRecipient, } from "../app/exchanges/essr.js";
+export { createExchangeMessage, sendExchangeMessage, } from "../app/exchanges/exchange-messaging.js";
+export { Exchanger, RouteRefuser, } from "../app/exchanges/exchanging.js";
+export { findVerifiedChallengeResponse, generateChallengeWords, markChallengeVerified, parseChallengeWords, } from "../app/identity/challenging.js";
+export { Configer, createConfiger, } from "../app/identity/configing.js";
+export { Anchorer, } from "../app/identity/delegating.js";
+export { endpointRoleAccepted, loadAcceptedEndpointRole, proposeGroupEndpointRole, } from "../app/identity/endpoint-roleing.js";
+export { acceptedEventReplayMessage, createHabery, Hab, Habery, } from "../app/identity/habbing.js";
+export { Algos, Manager, } from "../app/identity/keeping.js";
+export { Organizer, } from "../app/identity/organizing.js";
+export { ipexExnBody, prepareIpexExn } from "../app/ipex/ipex-building.js";
+export { credentialPresentationArtifacts, credentialSaidFromGrant, ipexCredentialAdmit, ipexCredentialGrant, processCredentialPresentationArtifacts, storedGrantArtifacts, } from "../app/ipex/ipex-credentialing.js";
+export { walkIpexGraph } from "../app/ipex/ipex-graph.js";
+export { approveStoredMultisigIpexWrappers, prepareAcdcV2GroupIpex, publishInitialGroupIpex, requireAcdcV2GroupUse, sendCompletedGroupIpex, } from "../app/ipex/ipex-grouping.js";
+export { acceptedRegistryEvidence, authenticateIpexNode, issuedNodeVerdict, } from "../app/ipex/ipex-node-authentication.js";
+export { IPEX_GRANT_ROUTE, IPEX_ROUTES, ipexAdmitExn, ipexAgreeExn, ipexApplyExn, ipexGrantExn, ipexOfferExn, ipexSpurnExn, } from "../app/ipex/ipexing.js";
+export { MailboxDirector, } from "../app/mailbox/mailbox-director.js";
+export { MailboxPoller, } from "../app/mailbox/mailbox-poller.js";
+export { consumeMailboxSse, parseMailboxSse, readMailboxSseBody, } from "../app/mailbox/mailbox-sse.js";
+export { endpointBasePath, fetchEndpointUrls, mailboxPollEndpoints, mailboxQueryTopics, mailboxTopicKey, preferredUrl, resolveHostedEndpointPath, } from "../app/mailbox/mailboxing.js";
+export { groupSigningMembers, groupWitnesserSelection, isLocalGroupHab, latestGroupContribution, localGroupMember, } from "../app/multisig/group-members.js";
+export { Multiplexor, MULTISIG_ROUTES, multisigExn, multisigExnBody, multisigInceptExn, multisigInteractExn, multisigIpexProofExn, multisigIssueExn, multisigQueryExn, multisigRegistryInceptExn, multisigRevokeExn, multisigRotateExn, multisigRpyExn, } from "../app/multisig/grouping.js";
+export { signGroupMessage } from "../app/multisig/multisig-messaging.js";
+export { approveAcdcV2Registry, publishAcdcV2Registry } from "../app/multisig/multisig-workflows.js";
+export { Notifier, } from "../app/notifications/notifying.js";
+export { Signal, Signaler, } from "../app/notifications/signaling.js";
+export { RawRecord } from "../core/records.js";
+export { Verifier, } from "../app/credentials/verifying.js";
+export { witnessKeyStateGet, witnessQueryGet, witnessReceiptGet, witnessReceiptPost, } from "../app/witness/http-endpoints.js";
+export { drainWitnessCues, processWitnessIngress, processWitnessIngressSource, } from "../app/witness/ingress.js";
+export { Receiptor, WitnessReceiptor, } from "../app/witness/receipting.js";
+export { registerWithWitness, } from "../app/witness/registration.js";
+export { BUILD_METADATA, DISPLAY_VERSION, PACKAGE_VERSION, } from "../version.js";
 // Pure protocol construction and typed evidence.
 export { acdcagg, acdcatt, acdcmap, acgSchemaDefault, acmSchemaDefault, actSchemaDefault, blindate, regcept, sectaggr, sectattr, sectedge, sectionate, sectrule, sectschema, update, } from "../acdc/messaging.js";
 export { RegistryObserver, } from "../acdc/observing.js";
-export { vet, vetBinds, } from "../acdc/regeventing.js";
+export { matchesRegistrySeal, vet, vetBinds, vetBlind, vetBound, } from "../acdc/regeventing.js";
+/** ACDC v2 services are distinct from the legacy VDR Regery/Registry exports. */
+export { createRegery as createAcdcV2Regery, Regery as AcdcV2Regery, Registry as AcdcV2Registry, } from "../acdc/registraring.js";
+export { validateSchema as validateAcdcSchema } from "../acdc/scheming.js";
+export { publishPendingTel } from "../app/credentials/tel-publishing.js";
 export { Deck } from "../core/deck.js";
 export { AppError, DatabaseError, DatabaseKeyError, DatabaseNotOpenError, DatabaseOperationError, InvalidPathNameError, PathError, ValidationError, } from "../core/errors.js";
-export { Kevery, } from "../core/eventing.js";
-export { Kever, } from "../core/kever.js";
-export { Kramer } from "../core/kraming.js";
+export { verifyExchangeProofs } from "../core/exchange/exchange-proofing.js";
+export { exchange } from "../core/exchange/protocol-exchanging.js";
+export { Kevery, } from "../core/kel/eventing.js";
+export { Kever, } from "../core/kel/kever.js";
 export { consoleLogger, getLogLevel, LOG_LEVELS, noopLogger, setLogLevel, } from "../core/logger.js";
-export { CREDENTIAL_MAILBOX_TOPIC, DELEGATE_MAILBOX_TOPIC, normalizeMbxTopicCursor, OOBI_MAILBOX_TOPIC, RECEIPT_MAILBOX_TOPIC, REPLAY_MAILBOX_TOPIC, REPLY_MAILBOX_TOPIC, } from "../core/mailbox-topics.js";
+export { Kramer } from "../core/mailbox/kraming.js";
+export { CREDENTIAL_MAILBOX_TOPIC, DELEGATE_MAILBOX_TOPIC, normalizeMbxTopicCursor, OOBI_MAILBOX_TOPIC, RECEIPT_MAILBOX_TOPIC, REPLAY_MAILBOX_TOPIC, REPLY_MAILBOX_TOPIC, } from "../core/mailbox/mailbox-topics.js";
 export { incept, interact, query, reply, rotate } from "../core/protocol-eventing.js";
-export { exchange } from "../core/protocol-exchanging.js";
-export { messagize } from "../core/protocol-serialization.js";
+export { messageAttachmentGroups, messagize } from "../core/protocol-serialization.js";
 export { incept as inceptRegistry, issue, revoke } from "../core/protocol-vdr-eventing.js";
 export { CacheTypeRecord, EndAuthRecord, EndpointRecord, EventSourceRecord, HabitatRecord, KeyStateRecord, LocationRecord, MsgCacheRecord, ObservedRecord, OobiQueryRecord, OobiRecord, RegistryRecord, RegStateRecord, StateEERecord, TopicsRecord, TxnMsgCacheRecord, VcStateRecord, WellKnownAuthN, } from "../core/records.js";
 export { EndpointRoles, isEndpointRole, isRole, Roles, } from "../core/roles.js";
 export { isScheme, Schemes, } from "../core/schemes.js";
 export { dumpSchema, Schemer, } from "../core/scheming.js";
+export { UnsupportedTelReplayError } from "../db/replay/tel-replay.js";
 export { credential, Credentialer, CredentialWallet, Regery, Registry, serializeCredential, } from "../vdr/credentialing.js";
 export { Tever, Tevery, } from "../vdr/eventing.js";
+export { TelPublication } from "../vdr/tel-publication.js";
 // Accepted-state DID projection and artifact operations.
 export { resolveDidKeri, } from "../did/keri/resolving.js";
 export { generateDidWebsArtifacts, generateDidWebsCesr, generateDidWebsJson, } from "../did/webs/artifacts.js";
@@ -75,4 +100,11 @@ export { bindDesignatedAliases, DESIGNATED_ALIASES_SCHEMA_SAID, listActiveDesign
 export { didWebsArtifactUrls, didWebsFromArtifactRequest, parseDid, parseDidKeriIdentifier, parseDidWebs, toCanonicalDidWebs, toHostedDidWeb, } from "../did/webs/dids.js";
 export { didResolutionError, didResolutionResult, generateBareDidDocument, generateDidDocument, } from "../did/webs/documenting.js";
 export { resolveDidWebs, } from "../did/webs/resolving.js";
-export { makeNowIso8601, } from "../time/mod.js";
+export { makeNowIso8601, timestampMicros, } from "../time/mod.js";
+export { HTTPMessenger } from "../app/transport/http-messenger.js";
+export { HTTPStreamMessenger } from "../app/transport/http-stream-messenger.js";
+export { messengerFrom, streamMessengerFrom } from "../app/transport/messengering.js";
+export { TCPStreamMessenger } from "../app/transport/tcp-stream-messenger.js";
+export { systemClock } from "../app/runtime/runtime-clock.js";
+export { AnchorQuerier, KeyStateNoticer, LogQuerier, SeqNoQuerier } from "../app/queries/querying.js";
+export { WitnessInquisitor } from "../app/queries/witness-inquisitor.js";

package/esm/keri/npm/src/vdr/backer-state.js

@@ -0,0 +1,55 @@
+/** Historical TEL backer selection from accepted management coordinates. */
+import { Ilks, ParserError, SerderKERI } from "cesr-ts";
+import { DatabaseOperationError } from "../core/errors.js";
+import { dgKey } from "../db/core/keys.js";
+/** Decode the entire wire threshold; a partial parse or inexact count cannot authorize a quorum. */
+export function backerThreshold(value) {
+    if (typeof value !== "string" || !/^[0-9a-f]+$/i.test(value))
+        return null;
+    const count = Number(BigInt(`0x${value}`));
+    return Number.isSafeInteger(count) ? count : null;
+}
+/**
+ * Resolve the complete ra.i/ra.s/ra.d tuple before reading its ordered roster.
+ * Raw/escrowed management bodies confer no authority. KERIpy's digest-only raw
+ * lookup is deliberately strengthened here; wire fields and signature indexes stay unchanged.
+ */
+export function resolveBackerState(reger, regk, seal) {
+    if (!seal || typeof seal !== "object" || Array.isArray(seal)
+        || !("i" in seal) || seal.i !== regk || !("s" in seal) || typeof seal.s !== "string"
+        || !/^[0-9a-f]+$/.test(seal.s) || !("d" in seal) || typeof seal.d !== "string")
+        return { kind: "reject", reason: "Backer TEL event registry anchor mismatch." };
+    const ordinal = BigInt(`0x${seal.s}`);
+    if (ordinal > BigInt(Number.MAX_SAFE_INTEGER)) {
+        return { kind: "reject", reason: "Backer management ordinal exceeds exact storage representation." };
+    }
+    const accepted = reger.tels.getOn(regk, Number(ordinal));
+    if (!accepted)
+        return { kind: "missing", reason: "Backer TEL event awaits accepted registry management state." };
+    if (accepted.qb64 !== seal.d)
+        return { kind: "reject", reason: "Backer TEL event registry anchor digest mismatch." };
+    const key = dgKey(regk, accepted.qb64), raw = reger.tvts.get(key);
+    if (!raw)
+        throw new DatabaseOperationError("Accepted backer management body is missing.");
+    let event;
+    try {
+        event = new SerderKERI({ raw });
+    }
+    catch (error) {
+        if (!(error instanceof ParserError))
+            throw error;
+        throw new DatabaseOperationError("Accepted backer management body is corrupt.", { cause: error });
+    }
+    if (!event.verify() || event.pre !== regk || event.sn !== Number(ordinal) || event.said !== accepted.qb64
+        || (event.ilk !== Ilks.vcp && event.ilk !== Ilks.vrt))
+        throw new DatabaseOperationError("Accepted backer management coordinate is inconsistent.");
+    const toad = backerThreshold(event.ked?.bt);
+    if (toad === null) {
+        throw new DatabaseOperationError("Accepted backer threshold is invalid.");
+    }
+    const baks = reger.baks.get(key);
+    if (!Number.isSafeInteger(toad) || toad > baks.length || (baks.length > 0 && toad < 1)
+        || new Set(baks).size !== baks.length)
+        throw new DatabaseOperationError("Accepted backer roster and threshold are inconsistent.");
+    return { kind: "backers", toad, baks };
+}

package/esm/keri/npm/src/vdr/credential-tsn-record.js

@@ -0,0 +1,59 @@
+import { Diger } from "cesr-ts";
+import { VcStateRecord } from "../core/records.js";
+import { timestampMicros } from "../time/mod.js";
+import { qualifiedPrefix } from "./registry-tsn-record.js";
+/** Legacy storage ordinals are safe integers even though protocol numbers may be wider. */
+function ordinal(value) {
+    return typeof value === "string" && /^[0-9a-f]{1,14}$/i.test(value)
+        && BigInt(`0x${value}`) <= BigInt(Number.MAX_SAFE_INTEGER);
+}
+/** Require the full qualified digest rather than accepting trailing bytes. */
+function qualifiedDigest(value) {
+    try {
+        return typeof value === "string" && new Diger({ qb64: value }).qb64 === value;
+    }
+    catch {
+        return false;
+    }
+}
+/** Validate unknown fields and construct an owned record without erasing its guarantees. */
+export function credentialRecord(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data))
+        return null;
+    if (Object.keys(data).some((key) => !["vn", "i", "s", "d", "ri", "ra", "a", "dt", "et"].includes(key))
+        || !("s" in data) || !ordinal(data.s)
+        || !("et" in data) || (data.et !== "iss" && data.et !== "bis" && data.et !== "rev" && data.et !== "brv")
+        || !("ri" in data) || !qualifiedPrefix(data.ri)
+        || !("dt" in data) || typeof data.dt !== "string" || timestampMicros(data.dt) === null
+        || !("i" in data) || !qualifiedDigest(data.i) || !("d" in data) || !qualifiedDigest(data.d)
+        || !("vn" in data) || !Array.isArray(data.vn) || data.vn.length !== 2
+        || !("a" in data) || !data.a || typeof data.a !== "object" || Array.isArray(data.a)
+        || !("ra" in data) || !data.ra || typeof data.ra !== "object" || Array.isArray(data.ra))
+        return null;
+    const version = data.vn;
+    const [major, minor] = version;
+    const a = data.a, rawSeal = data.ra;
+    if (typeof major !== "number" || !Number.isSafeInteger(major) || major < 0
+        || typeof minor !== "number" || !Number.isSafeInteger(minor) || minor < 0
+        || Object.keys(a).length !== 2 || !("s" in a) || typeof a.s !== "number"
+        || !Number.isSafeInteger(a.s) || a.s < 0 || !("d" in a) || !qualifiedDigest(a.d))
+        return null;
+    let ra = {};
+    if (Object.keys(rawSeal).length) {
+        if (Object.keys(rawSeal).length !== 3 || !("i" in rawSeal) || !qualifiedPrefix(rawSeal.i)
+            || !("s" in rawSeal) || !ordinal(rawSeal.s) || !("d" in rawSeal) || !qualifiedDigest(rawSeal.d))
+            return null;
+        ra = { i: rawSeal.i, s: rawSeal.s, d: rawSeal.d };
+    }
+    return Object.assign(new VcStateRecord(), {
+        vn: [major, minor],
+        i: data.i,
+        s: data.s,
+        d: data.d,
+        ri: data.ri,
+        ra,
+        a: { s: a.s, d: a.d },
+        dt: data.dt,
+        et: data.et,
+    });
+}