keri-ts 1.0.0 → 2.0.0

package/esm/keri/npm/src/app/witness/http-endpoints.js

@@ -0,0 +1,185 @@
+/** Witness HTTP semantic policies for receipts, log queries and endorsed key state; adapters format decisions. */
+import { Ilks, Vrsn_2_0 } from "cesr-ts";
+import { receipt as receiptEvent, reply as replyEvent } from "../../core/protocol-eventing.js";
+import { dgKey } from "../../db/core/keys.js";
+import { inspectCesrRequest } from "../transport/cesr-http.js";
+import { processWitnessIngress } from "./ingress.js";
+import { buildEndpointDetachedReceiptMessage, buildWitnessReceiptMessage, inspectReceiptMessage, } from "./receipt-messages.js";
+/** Authorize the hosted witness against the accepted event, retaining pending dependencies in escrow. */
+function witnessReceiptEligibility(serviceHab, serder) {
+    const pre = serder.pre;
+    const said = serder.said;
+    if (!pre || said === null) {
+        return {
+            kind: "reject",
+            message: "Receipted event must expose pre, sn, and said.",
+        };
+    }
+    const acceptedSaid = serder.sn === null ? null : serviceHab.db.kels.getLast(pre, serder.sn);
+    if (!acceptedSaid)
+        return { kind: "escrow" };
+    if (acceptedSaid !== said)
+        return { kind: "reject", message: "Receipted event is not the accepted KEL event." };
+    const witnesses = serviceHab.db.acceptedEventWitnesses(serder);
+    if (!witnesses)
+        return { kind: "escrow" };
+    if (!witnesses.includes(serviceHab.pre)) {
+        return {
+            kind: "reject",
+            message: `${serviceHab.pre} is not an authorized witness for ${pre}:${said}: wits=${JSON.stringify(witnesses)}.`,
+        };
+    }
+    return { kind: "accept", accepted: serder };
+}
+/** Handle the synchronous witness receipt POST policy. */
+export function* witnessReceiptPost(runtime, serviceHab, bytes, { local = true } = {}) {
+    const serder = inspectCesrRequest(bytes);
+    if (!serder) {
+        return { kind: "reject", status: 400, message: "Invalid CESR request" };
+    }
+    if (serder.ilk !== Ilks.icp
+        && serder.ilk !== Ilks.rot
+        && serder.ilk !== Ilks.ixn
+        && serder.ilk !== Ilks.dip
+        && serder.ilk !== Ilks.drt) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: `invalid event type (${serder.ilk}) for receipting`,
+        };
+    }
+    yield* processWitnessIngress(runtime, serviceHab, bytes, {
+        local,
+        deliver: false,
+    });
+    const eligibility = witnessReceiptEligibility(serviceHab, serder);
+    if (eligibility.kind === "reject") {
+        return { kind: "reject", status: 400, message: eligibility.message };
+    }
+    if (eligibility.kind === "escrow") {
+        return { kind: "escrow", status: 202 };
+    }
+    const inspected = inspectReceiptMessage(serviceHab.receipt(eligibility.accepted));
+    const body = buildEndpointDetachedReceiptMessage(inspected.serder, {
+        wigers: inspected.wigers,
+        cigars: inspected.cigars,
+    });
+    return { kind: "accepted", status: 200, body };
+}
+/** Handle `GET /receipts` witness retrieval. */
+export function witnessReceiptGet(serviceHab, query) {
+    const pre = query.pre ?? null;
+    if (!pre) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: "query param 'pre' is required",
+        };
+    }
+    let said = query.said ?? null;
+    if (query.sn === null && !said) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: "either 'sn' or 'said' query param is required",
+        };
+    }
+    if (query.sn !== null && query.sn !== undefined) {
+        said = serviceHab.db.kels.getLast(pre, query.sn);
+    }
+    if (!said) {
+        return {
+            kind: "reject",
+            status: 404,
+            message: `event for ${pre} at ${String(query.sn ?? "")} (${String(said)}) not found`,
+        };
+    }
+    const serder = serviceHab.db.getEvtSerder(pre, said);
+    if (!serder) {
+        return {
+            kind: "reject",
+            status: 404,
+            message: `Missing event for dig=${said}.`,
+        };
+    }
+    const wits = serviceHab.db.acceptedEventWitnesses(serder);
+    if (!wits || !wits.includes(serviceHab.pre)) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: `${serviceHab.pre} is not a valid witness for ${pre} event at ${serder.sn}.`,
+        };
+    }
+    const reserder = receiptEvent(pre, serder.sn ?? 0, said, { pvrsn: serder.pvrsn, gvrsn: serder.pvrsn });
+    const body = buildWitnessReceiptMessage(reserder, serviceHab.db.wigs.get(dgKey(pre, said)));
+    return { kind: "accepted", status: 200, body };
+}
+/** Handle `GET /query` witness log replay. */
+export function witnessQueryGet(serviceHab, query) {
+    const typ = query.typ ?? null;
+    if (!typ) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: "'typ' query param is required",
+        };
+    }
+    if (typ === "kel") {
+        const pre = query.pre ?? null;
+        if (!pre) {
+            return {
+                kind: "reject",
+                status: 400,
+                message: "'pre' query param is required",
+            };
+        }
+        if (query.sn !== null && query.sn !== undefined) {
+            const first = serviceHab.db.kels.getLast(pre, query.sn);
+            if (!first) {
+                return {
+                    kind: "reject",
+                    status: 400,
+                    message: `non-existent event at seq-num ${query.sn}`,
+                };
+            }
+        }
+        return {
+            kind: "accepted",
+            status: 200,
+            messages: serviceHab.db.witnessReplay(pre, query.sn ?? null) ?? [],
+        };
+    }
+    if (typ === "tel") {
+        return {
+            kind: "reject",
+            status: 501,
+            message: "TEL witness query replay is not yet available in tufa.",
+        };
+    }
+    return {
+        kind: "reject",
+        status: 400,
+        message: "unknown query type.",
+    };
+}
+/** Return an actual signed KERI reply; unknown or incompletely witnessed state is not advertised. */
+export function witnessKeyStateGet(serviceHab, query) {
+    if (!query.destination || query.destination !== serviceHab.pre) {
+        return { kind: "reject", status: 400, message: "Recognized CESR destination required" };
+    }
+    if (!query.pre)
+        return { kind: "reject", status: 400, message: "'pre' query param is required" };
+    const kever = serviceHab.db.getKever(query.pre, { refresh: true });
+    if (!kever || !serviceHab.db.fullyWitnessed(kever.serder)) {
+        return { kind: "reject", status: 404, message: "Fully witnessed key state not found" };
+    }
+    return {
+        kind: "accepted",
+        status: 200,
+        body: serviceHab.endorse(replyEvent(`/ksn/${serviceHab.pre}`, kever.state().asDict(), {
+            pre: serviceHab.pre,
+            pvrsn: Vrsn_2_0,
+            gvrsn: Vrsn_2_0,
+        }), { gvrsn: Vrsn_2_0 }),
+    };
+}

package/esm/keri/npm/src/app/witness/ingress.js

@@ -0,0 +1,148 @@
+/** Compose witness intake, local receipt production and cue publication within the host-owned lifetime. */
+import { parse } from "cesr-ts";
+import { call, ensure } from "effection";
+import { rethrowCleanupFailure } from "../runtime/abortable.js";
+import { chunkBytes } from "../transport/byte-source.js";
+/** Return the active wire-message habitat or `null` when selection is ambiguous. */
+function cueHab(runtime, serviceHab) {
+    if (serviceHab) {
+        return serviceHab;
+    }
+    const habitats = runtime.hby.habs.values();
+    const first = habitats.next();
+    return first.done || !habitats.next().done ? null : first.value;
+}
+/**
+ * Route one initial witness cue batch, leaving saved key-state facts for the
+ * application cue worker and its optional command-owned noticer destination.
+ * Respondant publishes Poster work; this ingress helper never drains Poster
+ * network delivery. Query network I/O stays with the independent sender.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param serviceHab Optional hosted witness signer; absent selection must be unambiguous.
+ * @param cues Exact runtime application Deck; foreign Decks are rejected.
+ * @param options deliver defaults true: publish outgoing work for the independent senders. False performs local signing side effects only.
+ */
+export function* drainWitnessCues(runtime, serviceHab, cues, { deliver = true } = {}) {
+    if (cues !== runtime.cues)
+        throw new RangeError("Witness cue drain requires the runtime source deck");
+    const hab = cueHab(runtime, serviceHab);
+    if (!hab)
+        return;
+    const count = cues.length;
+    for (let index = 0; index < count; index++) {
+        const cue = cues.peekHead();
+        if (!cue)
+            break;
+        if (cue.kin === "keyStateSaved") {
+            cues.pull();
+            cues.append(cue);
+            continue;
+        }
+        if (deliver) {
+            if (cue.kin === "query") {
+                runtime.querying.enqueueCue(cue, hab);
+            }
+            else if (cue.kin === "stream") {
+                runtime.mailboxDirector.retainQueryCue(cue);
+            }
+            else if (["receipt", "witness", "replay", "reply"].includes(cue.kin)) {
+                const msgs = [...hab.processCuesIter([cue])];
+                runtime.respondant.enqueueMsgs(hab, cue, msgs);
+            }
+        }
+        else {
+            // Exhaust local signing side effects without collecting discarded wire.
+            for (const _msg of hab.processCuesIter([cue])) { /* local proof persisted */ }
+        }
+        cues.pull();
+    }
+}
+/**
+ * Own one witness input and settle each frame before requesting more input.
+ * Each complete frame publishes its prepared replies before requesting more input.
+ * Source abort and cleanup belong to this input scope.
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param serviceHab Hosted witness/controller habitat used for local replies.
+ * @param source Creates cancellation-aware wire input owned by this operation.
+ * @param options local defaults false; deliver defaults true and controls cue publication, not Poster queue draining.
+ */
+export function* processWitnessIngressSource(runtime, serviceHab, source, { local = false, deliver = true } = {}) {
+    yield* call(function* () {
+        const controller = new AbortController();
+        const signal = controller.signal;
+        try {
+            signal.throwIfAborted();
+            const frames = parse(source(signal));
+            let pending;
+            // The earlier resource joins the read after processing children stop.
+            yield* ensure(function* () {
+                try {
+                    if (pending) {
+                        try {
+                            yield* call(() => pending);
+                        }
+                        catch (error) {
+                            rethrowCleanupFailure(error, signal);
+                        }
+                    }
+                }
+                finally {
+                    yield* call(() => frames.return());
+                }
+            });
+            while (true) {
+                signal.throwIfAborted();
+                pending = frames.next();
+                let result;
+                try {
+                    result = yield* call(() => pending);
+                }
+                catch (error) {
+                    pending = undefined;
+                    throw error;
+                }
+                pending = undefined;
+                signal.throwIfAborted();
+                if (result.done)
+                    break;
+                const frame = result.value;
+                yield* runtime.protocol.dispatch(frame, { local, escrows: true });
+                yield* drainWitnessCues(runtime, serviceHab, runtime.cues, { deliver });
+            }
+        }
+        finally {
+            controller.abort();
+        }
+    });
+}
+/**
+ * Parse and settle one inbound witness-host payload.
+ *
+ * This is the witness-host counterpart to generic runtime ingress.
+ *
+ * Responsibilities:
+ * - settle one inbound CESR payload with the correct witness-local semantics
+ * - immediately drain the resulting cues through the hosted witness habitat
+ * - leave request-scoped receipt construction with the endpoint owner
+ *
+ * `local=true` is the crucial switch for the witness receipt path: accepted
+ * events that list the hosted witness emit `witness` cues instead of ordinary
+ * `receipt` cues.
+ *
+ * Durable routing rule:
+ * - TCP witness ingress, witness `/receipts`, and ordinary HTTP root ingress
+ *   that targets the hosted witness AID should all reach this seam when the
+ *   host is acting as that witness
+ * - generic runtime ingress should remain separate for mailbox streaming,
+ *   `/ksn` replay publication, and other non-witness-root policies
+ *
+ * @param runtime Borrowed composed runtime; caller owns its worker and store lifetime.
+ * @param serviceHab Hosted reply signer.
+ * @param bytes Finite signed input bytes adapted to the same source path.
+ * @param options Witness intake/local-production policy forwarded to processWitnessIngressSource.
+ */
+export function* processWitnessIngress(runtime, serviceHab, bytes, options = {}) {
+    yield* processWitnessIngressSource(runtime, serviceHab, (signal) => chunkBytes(bytes, { signal }), options);
+}

package/esm/keri/npm/src/app/witness/receipt-client.js

@@ -0,0 +1,248 @@
+/** Controller-side witness transport: HTTP receipts, explicit media fallback and optional duplex TCP intake. */
+import { concatBytes, Counter, Vrsn_1_0 } from "cesr-ts";
+import { action, call, scoped } from "effection";
+import { ValidationError } from "../../core/errors.js";
+import { Schemes } from "../../core/schemes.js";
+import { abortable } from "../runtime/abortable.js";
+import { collectBytes } from "../transport/byte-source.js";
+import { buildCesrRequest, CESR_CONTENT_TYPE, KERIPY_CESR_JSON_CONTENT_TYPE } from "../transport/cesr-http.js";
+import { HTTPMessenger } from "../transport/http-messenger.js";
+import { TCPMessenger } from "../transport/tcp-messenger.js";
+import { inspectReceiptMessage } from "./receipt-messages.js";
+const WitnessReceiptPollAttempts = 20;
+const WitnessReceiptPollDelayMs = 100;
+const KERIPY_CONTENT_TYPE_ERROR = "content type";
+const WITNESS_HTTP_CONTENT_TYPES = [
+    CESR_CONTENT_TYPE,
+    KERIPY_CESR_JSON_CONTENT_TYPE,
+];
+/**
+ * Receipt endpoints return one finite proof; cancellation joins the reader before leaving this operation.
+ *
+ * @param response Borrowed finite receipt-proof HTTP response.
+ * @returns Complete proof bytes after read cleanup.
+ */
+function* readResponseBytes(response) {
+    return yield* abortable((signal) => collectBytes(response.body(signal)));
+}
+/** Sleep for one short polling interval while staying cancellable. */
+function* sleepMs(ms) {
+    yield* action((resolve) => {
+        const timeoutId = setTimeout(() => resolve(undefined), ms);
+        return () => clearTimeout(timeoutId);
+    });
+}
+/** Return the full advertised scheme map for one witness endpoint. */
+function witnessUrls(hab, witness) {
+    return hab.fetchUrls(witness);
+}
+/** Resolve the HTTP or HTTPS witness endpoint when available. */
+export function witnessHttpUrl(hab, witness) {
+    const urls = witnessUrls(hab, witness);
+    return urls[Schemes.https] ?? urls[Schemes.http] ?? null;
+}
+/** Resolve the TCP witness endpoint when available. */
+export function witnessTcpUrl(hab, witness) {
+    const urls = witnessUrls(hab, witness);
+    return urls[Schemes.tcp] ?? null;
+}
+/** Choose the generic witness transport URL: HTTP first, TCP fallback second. */
+function preferredWitnessTransportUrl(hab, witness) {
+    return witnessHttpUrl(hab, witness) ?? witnessTcpUrl(hab, witness);
+}
+/**
+ * Send via HTTP first; an explicit protocol processor processes same-socket TCP replies.
+ * Without a protocol processor TCP reports local transmission only. Actual socket/parser
+ * cleanup finishes before this borrowed protocol processor can be released.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Target witness AID whose accepted locations choose HTTP-first/TCP fallback.
+ * @param bytes Complete signed event/introduction wire.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param clock Borrowed clock with epoch-millisecond now and millisecond timer delays.
+ * @param protocol Optional same-socket reply processor; null selects transmit-only TCP.
+ * @param auth Optional HTTP Authorization header value.
+ * @throws Missing endpoint, peer refusal, transport/parser or cleanup failures propagate.
+ */
+export function* sendWitnessMessage(hab, witness, bytes, http, clock, protocol, auth) {
+    const url = preferredWitnessTransportUrl(hab, witness);
+    if (!url) {
+        throw new ValidationError(`Unable to find a valid endpoint for witness ${witness}.`);
+    }
+    const parsed = new URL(url);
+    if (parsed.protocol === "tcp:") {
+        yield* new TCPMessenger(url, clock, protocol).send(bytes, {
+            replies: Boolean(protocol),
+            local: true,
+        });
+        return;
+    }
+    const outcome = yield* new HTTPMessenger(url, http, {
+        destination: witness,
+        headers: auth ? { Authorization: auth } : undefined,
+    }).send(bytes);
+    if (outcome.kind === "refuse")
+        throw outcome.error;
+}
+function isKeripyContentTypeRejection(status, contentType, responseText) {
+    return status === 406
+        && contentType === CESR_CONTENT_TYPE
+        && responseText.toLowerCase().includes(KERIPY_CONTENT_TYPE_ERROR);
+}
+/**
+ * Poll one witness `GET /receipts` endpoint until the receipt becomes available.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Witness AID whose HTTP receipt endpoint is selected.
+ * @param pre Event subject AID.
+ * @param sn Event sequence number.
+ * @param said Exact event SAID to verify against returned proof.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param gvrsn Configured endpoint's reply attachment genus, selected before its complete response body.
+ * @returns Receipt endpoint status and wire result for later verification; HTTP success alone is not accepted witness state.
+ */
+export function* pollWitnessReceipt(hab, witness, pre, sn, said, http, gvrsn = Vrsn_1_0) {
+    const httpUrl = witnessHttpUrl(hab, witness);
+    if (!httpUrl) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: `Witness ${witness} does not advertise an HTTP(S) endpoint for receipt polling.`,
+        };
+    }
+    for (let attempt = 0; attempt < WitnessReceiptPollAttempts; attempt += 1) {
+        const response = yield* call(() => getWitnessReceiptEndpoint(hab, witness, {
+            pre,
+            sn,
+            said,
+        }, http, gvrsn));
+        if (response.kind === "accepted") {
+            return response;
+        }
+        if (response.kind === "reject" && response.status !== 404) {
+            return response;
+        }
+        yield* sleepMs(WitnessReceiptPollDelayMs);
+    }
+    return {
+        kind: "reject",
+        status: 408,
+        message: `Timed out waiting for witness receipt from ${witness}.`,
+    };
+}
+/**
+ * Request one witness receipt via `POST /receipts`.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Witness AID whose HTTP receipt endpoint is selected.
+ * @param message Complete signed event wire requesting a witness receipt.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param auth Optional witness HTTP Authorization value.
+ * @param gvrsn Reply attachment genus; the caller already encoded request proofs with this endpoint's selection.
+ * @returns Receipt endpoint status and wire result for later verification; HTTP success alone is not accepted witness state.
+ */
+export function* postWitnessReceiptEndpoint(hab, witness, message, http, auth, gvrsn = Vrsn_1_0) {
+    const url = witnessHttpUrl(hab, witness);
+    if (!url) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: `Witness ${witness} does not advertise an HTTP(S) receipt endpoint.`,
+        };
+    }
+    const responseUrl = new URL(url);
+    responseUrl.pathname = `${responseUrl.pathname.replace(/\/+$/, "") || ""}/receipts`;
+    let lastStatus = 0;
+    let lastText = "";
+    for (const contentType of WITNESS_HTTP_CONTENT_TYPES) {
+        const request = buildCesrRequest(message, {
+            contentType,
+            destination: witness,
+        });
+        const response = yield* scoped(function* () {
+            const response = yield* http.open(responseUrl.toString(), {
+                method: "POST",
+                headers: { ...request.headers, ...(auth ? { Authorization: auth } : {}) },
+                body: request.body,
+            });
+            // Escrow is a status-only result. Other outcomes require their complete proof/diagnostic body.
+            const body = response.status === 202 ? new Uint8Array() : yield* readResponseBytes(response);
+            return { status: response.status, body };
+        });
+        if (response.status === 202) {
+            return { kind: "escrow", status: 202 };
+        }
+        if (response.status === 200) {
+            const body = gvrsn.major === 1 ? response.body : concatBytes(Counter.makeGVC(gvrsn), response.body);
+            const inspected = inspectReceiptMessage(body);
+            return {
+                kind: "accepted",
+                status: 200,
+                body,
+                wigers: inspected.wigers,
+                cigars: inspected.cigars,
+            };
+        }
+        const body = response.body;
+        lastStatus = response.status;
+        lastText = new TextDecoder().decode(body);
+        if (isKeripyContentTypeRejection(response.status, contentType, lastText)) {
+            continue;
+        }
+        return { kind: "reject", status: response.status, message: lastText };
+    }
+    return {
+        kind: "reject",
+        status: lastStatus,
+        message: lastText,
+    };
+}
+/**
+ * Request one stored witness receipt via `GET /receipts`.
+ *
+ * @param hab Local signing habitat; its state/store lifetime remains with the caller.
+ * @param witness Witness AID whose HTTP receipt endpoint is selected.
+ * @param query Receipt lookup subject, sequence and digest fields.
+ * @param http Borrowed HTTP implementation selected by composition.
+ * @param gvrsn Explicit response attachment genus; preserve v1 by default.
+ * @returns Receipt endpoint status and wire result for later verification; HTTP success alone is not accepted witness state.
+ */
+export function* getWitnessReceiptEndpoint(hab, witness, query, http, gvrsn = Vrsn_1_0) {
+    const url = witnessHttpUrl(hab, witness);
+    if (!url) {
+        return {
+            kind: "reject",
+            status: 400,
+            message: `Witness ${witness} does not advertise an HTTP(S) receipt endpoint.`,
+        };
+    }
+    const endpoint = new URL(url);
+    endpoint.pathname = `${endpoint.pathname.replace(/\/+$/, "") || ""}/receipts`;
+    endpoint.searchParams.set("pre", query.pre);
+    if (query.sn !== undefined) {
+        endpoint.searchParams.set("sn", String(query.sn));
+    }
+    if (query.said) {
+        endpoint.searchParams.set("said", query.said);
+    }
+    const response = yield* http.request(endpoint.toString(), {
+        method: "GET",
+    });
+    if (response.status !== 200) {
+        const body = response.body;
+        return {
+            kind: "reject",
+            status: response.status,
+            message: new TextDecoder().decode(body),
+        };
+    }
+    const body = gvrsn.major === 1 ? response.body : concatBytes(Counter.makeGVC(gvrsn), response.body);
+    const inspected = inspectReceiptMessage(body);
+    return {
+        kind: "accepted",
+        status: 200,
+        body,
+        wigers: inspected.wigers,
+        cigars: inspected.cigars,
+    };
+}

package/esm/keri/npm/src/app/witness/receipt-messages.js

@@ -0,0 +1,29 @@
+/** Receipt framing follows the receipt body version; core serialization owns the counters. */
+import { parseBytes } from "cesr-ts";
+import { ValidationError } from "../../core/errors.js";
+import { messagize } from "../../core/protocol-serialization.js";
+import { envelopeFromFrame } from "../protocol/parsering.js";
+/** Build a collected receipt with an attachment enclosure. Signatures cover the receipted event. */
+export function buildDetachedReceiptMessage(serder, { wigers = [], cigars = [] }) {
+    if (!wigers.length && !cigars.length)
+        return serder.raw;
+    return messagize(serder, { wigers, cigars, pipelined: true, gvrsn: serder.pvrsn });
+}
+/** Match KERIpy receipt endpoints: body plus receipt material without an attachment enclosure. */
+export function buildEndpointDetachedReceiptMessage(serder, { wigers = [], cigars = [] }) {
+    if (!wigers.length && !cigars.length)
+        return serder.raw;
+    return messagize(serder, { wigers, cigars, gvrsn: serder.pvrsn });
+}
+/** Build one attached `rct` message carrying witness indexed signatures. */
+export function buildWitnessReceiptMessage(serder, wigers) {
+    return buildEndpointDetachedReceiptMessage(serder, { wigers });
+}
+/** Inspect one complete receipt; hydrated proof values have no asynchronous lifetime. */
+export function inspectReceiptMessage(bytes) {
+    const frames = parseBytes(bytes);
+    if (frames.length !== 1)
+        throw new ValidationError("Expected one witness receipt message.");
+    const envelope = envelopeFromFrame(frames[0], false);
+    return { serder: envelope.serder, wigers: envelope.wigers, cigars: envelope.cigars };
+}