keri-ts 1.0.0 → 2.0.0

package/esm/keri/npm/src/app/ipex-v2.js

@@ -1,438 +0,0 @@
-import { IPEX_V2_PREDECESSORS, isIpexVerb, nestedIpexRoute } from "../core/protocol-exchanging.js";
-/** V2 IPEX route policy; v1 routing remains independently registered. */
-import { Diger, ParserError, Prefixer, } from "cesr-ts";
-import { validateUpdate, verifyRegistryAnchor, vetBinds } from "../acdc/regeventing.js";
-import { validateSchema } from "../acdc/scheming.js";
-import { DatabaseOperationError } from "../core/errors.js";
-import { validDisclosurePlan, verifyIpexDisclosure, verifyIpexRelations, walkIpexGraph, } from "./ipex-graph.js";
-import { acceptedRegistryEvidence, authenticateIpexNode } from "./ipex-node-authentication.js";
-import { envelopeFromFrame } from "./parsering.js";
-/** SAD payloads include application-defined keys; named protocol fields are checked below before use. */
-function record(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-/** Require the current single-DAG outer list shape. */
-function single(value, type) {
-    return Array.isArray(value) && value.length === 1
-        && (type === "array" ? Array.isArray(value[0]) : typeof value[0] === type);
-}
-/** Parsed exchange bodies retain the exact same ordered disclosure plan through dittos. */
-function samePlan(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
-}
-/** The workflow owns a proof dependency cue and retry; no child is published here. */
-function missing(reason) {
-    return { kind: "escrow", reason };
-}
-/**
- * Authenticate each disclosed node independently before Exchanger persists an EXN.
- * Registry evidence is caller-owned; notifier delivery follows durable acceptance.
- * Presentation registries require the retained receiver receipt and node-local proofs.
- */
-export class IpexV2Handler {
-    constructor(resource, hby, notifier = null, registry = null) {
-        Object.defineProperty(this, "resource", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: resource
-        });
-        Object.defineProperty(this, "hby", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: hby
-        });
-        Object.defineProperty(this, "notifier", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: notifier
-        });
-        Object.defineProperty(this, "registry", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: registry
-        });
-        Object.defineProperty(this, "protocolMajor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 2
-        });
-        Object.defineProperty(this, "acceptsSscs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "acceptsEvidence", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "acceptsMissingEvidence", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "acceptsNests", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.acceptsMissingEvidence = resource === "/ipex/grant";
-        this.acceptsNests = nestedIpexRoute(resource);
-    }
-    /** Select only fresh foreign grant evidence, preferring a seal to the same AID's signatures. */
-    verifyEvidence({ serder, factors, invalid, missing: unresolved = [] }) {
-        if (serder.route !== "/ipex/grant") {
-            return invalid || unresolved.length || factors.tsgs.length || factors.cigars.length || factors.sourceSeals.length
-                ? null
-                : { tsgs: [], cigars: [], sourceSeals: [] };
-        }
-        const sourceSeals = factors.sourceSeals.filter((seal) => {
-            const kever = this.hby.db.getKever(seal.i.qb64);
-            if (!kever || seal.s.num < BigInt(kever.lastEst.s))
-                return false;
-            return seal.s.num === BigInt(kever.lastEst.s)
-                ? seal.d.qb64 === kever.lastEst.d
-                : this.hby.db.getEvtSerder(seal.i.qb64, seal.d.qb64)?.ilk === "ixn";
-        });
-        const sealers = new Set(sourceSeals.map((seal) => seal.i.qb64));
-        const tsgs = factors.tsgs.filter((group) => {
-            const kever = this.hby.db.getKever(group.pre);
-            return !sealers.has(group.pre) && kever && group.sn === BigInt(kever.lastEst.s) && group.said === kever.lastEst.d;
-        });
-        return { tsgs, cigars: factors.cigars.filter((cigar) => !sealers.has(cigar.verfer.qb64)), sourceSeals };
-    }
-    /** Validate conversation, disclosure and authentication obligations in reference order. */
-    verify({ serder, nests = [], sscs = [], evidence, receiverTime }) {
-        if (serder.pvrsn.major !== 2 || serder.route !== this.resource)
-            return false;
-        const route = serder.route.split("/");
-        const verb = route[2];
-        if (route.length !== 3 || route[0] !== "" || route[1] !== "ipex"
-            || !isIpexVerb(verb))
-            return false;
-        const attrs = serder.sad.a;
-        const q = serder.sad.q;
-        const priorSaid = serder.sad.p;
-        if (!record(attrs) || !Object.hasOwn(attrs, "m") || !record(q))
-            return false;
-        if (Object.hasOwn(attrs, "ax") && !single(attrs.ax, "boolean"))
-            return false;
-        if (["apply", "offer", "agree", "grant"].includes(verb)) {
-            if (!single(q.dp, "array") || !validDisclosurePlan(q.dp[0]))
-                return false;
-        }
-        if (verb === "agree" && q.dp[0].length)
-            return false;
-        if (verb === "offer") {
-            if (Object.hasOwn(attrs, "o")) {
-                if (!single(attrs.o, "string") || !this.validOrigin(attrs.o[0]))
-                    return false;
-            }
-            else if (nests.length)
-                return false;
-        }
-        else if (verb !== "grant" && nests.length)
-            return false;
-        let previous = null;
-        if (!priorSaid) {
-            if (!["apply", "offer", "grant"].includes(verb) || !serder.sad.ri || !serder.sad.x)
-                return false;
-        }
-        else {
-            if (verb === "apply" || typeof priorSaid !== "string")
-                return false;
-            previous = this.prior(verb, serder, priorSaid);
-            if (!previous)
-                return false;
-        }
-        const requiresAnchor = attrs.ax?.[0] === true;
-        const priorAttrs = previous?.sad?.a;
-        const priorAnchor = record(priorAttrs) && priorAttrs.ax?.[0] === true;
-        if (previous) {
-            if (["agree", "grant", "admit"].includes(verb) && requiresAnchor !== priorAnchor)
-                return false;
-            if (verb === "offer" && priorAnchor && !requiresAnchor)
-                return false;
-        }
-        if (["agree", "admit"].includes(verb) && (requiresAnchor || priorAnchor)) {
-            return sscs.length ? this.sourceAnchor(serder, serder.pre, sscs.at(-1)) : false;
-        }
-        if (verb === "offer" && nests.length) {
-            const graph = walkIpexGraph(attrs.o[0], nests, false);
-            return graph ? this.nodeSchemas(graph) : false;
-        }
-        if (verb !== "grant")
-            return true;
-        const plan = this.plan(serder);
-        if (!plan)
-            return false;
-        if (previous) {
-            const priorPlan = this.plan(previous);
-            if (!priorPlan || !samePlan(plan, priorPlan))
-                return false;
-        }
-        if (!plan.length) {
-            if (!Array.isArray(attrs.o) || attrs.o.length || nests.length)
-                return false;
-            return requiresAnchor || priorAnchor
-                ? sscs.length ? this.sourceAnchor(serder, serder.pre, sscs.at(-1)) : false
-                : true;
-        }
-        if (!single(attrs.o, "string") || !this.validOrigin(attrs.o[0]) || !nests.length)
-            return false;
-        const origin = attrs.o[0];
-        const graph = walkIpexGraph(origin, nests, true);
-        if (!graph || !verifyIpexDisclosure(plan, origin, graph))
-            return false;
-        const registrations = new Map();
-        for (const said of graph.order) {
-            const frame = graph.nodes.get(said);
-            const envelope = envelopeFromFrame(frame);
-            if (!frame.body.regid && this.presentationRegistries(frame.body) === null)
-                return false;
-            const result = authenticateIpexNode(frame.body, envelope, this.hby.db, this.registry);
-            if (result.kind === "missing")
-                return missing(result.reason);
-            if (result.kind === "reject")
-                return false;
-            if (result.registration)
-                registrations.set(said, result.registration);
-        }
-        const schemas = this.nodeSchemas(graph);
-        if (schemas !== true)
-            return schemas;
-        const relations = verifyIpexRelations(graph, this.hby.db, registrations);
-        if (typeof relations === "object") {
-            if (relations.kind === "unknownState")
-                return false;
-            if (relations.kind === "missingKel")
-                return missing(`Missing delegation KEL approval for ${relations.pre}.`);
-            return { kind: "escrow", reason: "Missing edge schema.", schema: relations.said };
-        }
-        if (!relations)
-            return false;
-        if (!evidence)
-            return false; // Exchanger must supply its selected supplemental factor set.
-        const tethered = new Set();
-        for (const said of graph.order) {
-            const node = graph.nodes.get(said);
-            const declarations = this.presentationRegistries(node.body);
-            if (declarations === null)
-                return false;
-            if (declarations.length && !receiverTime)
-                return false;
-            for (const [issuee, registry] of declarations) {
-                const result = this.presentation(node, registry, issuee, serder.said, receiverTime);
-                if (result !== true)
-                    return result;
-                tethered.add(issuee);
-            }
-        }
-        if (requiresAnchor || priorAnchor) {
-            const anchorers = tethered;
-            if (sscs.length) {
-                const result = this.sourceAnchor(serder, serder.pre, sscs.at(-1));
-                if (typeof result === "object")
-                    return result;
-                if (result)
-                    anchorers.add(serder.pre);
-            }
-            for (const seal of evidence?.sourceSeals ?? []) {
-                const result = this.sourceAnchor(serder, seal.i.qb64, seal);
-                if (typeof result === "object")
-                    return result;
-                if (result)
-                    anchorers.add(seal.i.qb64);
-            }
-            const node = graph.nodes.get(origin).body;
-            if (![serder.pre, node.issuee, node.issuer].some((aid) => aid && anchorers.has(aid)))
-                return false;
-        }
-        return true;
-    }
-    /** Notify only after Exchanger has durably accepted the parent and its evidence. */
-    handle({ serder }) {
-        this.notifier?.add({ r: `/exn${serder.route}`, d: serder.said, m: serder.sad.a.m });
-    }
-    /** Metadata offers withhold issuer proofs; grants call this only after every issuer authenticates. */
-    nodeSchemas(graph) {
-        for (const said of graph.order) {
-            const result = validateSchema(graph.nodes.get(said).body, this.hby.db);
-            if (result.kind === "invalid")
-                return false;
-            if (result.kind === "missing")
-                return { kind: "escrow", reason: "Missing node schema.", schema: result.said };
-        }
-        return true;
-    }
-    /** Origin commitments are SAIDs, never implicit signatures over the node. */
-    validOrigin(value) {
-        if (typeof value !== "string")
-            return false;
-        try {
-            return new Diger({ qb64: value }).qb64 === value;
-        }
-        catch {
-            return false;
-        }
-    }
-    /** Enforce reciprocal parties, exchange id and the prior's single accepted response. */
-    prior(verb, current, said) {
-        const prior = this.hby.db.exns.get(said);
-        const previous = prior?.route?.split("/");
-        if (!prior || previous?.length !== 3 || previous[0] !== "" || previous[1] !== "ipex"
-            || !IPEX_V2_PREDECESSORS[verb].some((allowed) => allowed === previous[2]))
-            return null;
-        if (verb === "spurn" && previous[2] === "grant" && prior.sad.p)
-            return null;
-        if (current.sad.ri !== prior.pre || !prior.sad.ri || current.pre !== prior.sad.ri
-            || current.sad.x !== prior.sad.x)
-            return null;
-        const response = this.hby.db.erpy.get(said);
-        if (response && this.hby.db.exns.get(response.qb64))
-            return null;
-        return prior;
-    }
-    /** Resolve empty-plan dittos only through accepted prior exchanges. */
-    plan(serder) {
-        const seen = new Set();
-        let current = serder;
-        while (current) {
-            if (!current.said || seen.has(current.said)
-                || !["/ipex/apply", "/ipex/offer", "/ipex/agree", "/ipex/grant"].includes(current.route ?? ""))
-                return null;
-            seen.add(current.said);
-            const q = current.sad.q;
-            if (!record(q) || !single(q.dp, "array") || !validDisclosurePlan(q.dp[0]))
-                return null;
-            if (q.dp[0].length)
-                return q.dp[0];
-            const prior = current.sad.p;
-            if (!prior)
-                return [];
-            current = typeof prior === "string" ? this.hby.db.exns.get(prior) : null;
-        }
-        return null;
-    }
-    /** A negotiated outer anchor must be at or after the anchorer's current establishment. */
-    sourceAnchor(serder, aid, seal) {
-        const kever = this.hby.db.getKever(aid);
-        if (!kever)
-            return missing(`Missing current anchorer key state for ${aid}.`);
-        if (seal.s.num < BigInt(kever.lastEst.s)
-            || (seal.s.num === BigInt(kever.lastEst.s) && seal.d.qb64 !== kever.lastEst.d))
-            return false;
-        if (seal.s.num > BigInt(Number.MAX_SAFE_INTEGER))
-            return false;
-        const said = this.hby.db.kels.getLast(aid, Number(seal.s.num));
-        const event = said ? this.hby.db.getEvtSerder(aid, said) : null;
-        if (!event)
-            return missing(`Missing anchorer KEL evidence for ${aid}.`);
-        if (said !== seal.d.qb64 || (seal.s.num > BigInt(kever.lastEst.s) && event.ilk !== "ixn"))
-            return false;
-        return event.seals.some((seal) => record(seal) && seal.d === serder.said);
-    }
-    /** Authenticate a grant target against this node's Issuee TEL and explicit fully witnessed KEL sources. */
-    presentation(frame, regid, issuee, target, cutoff) {
-        const envelope = envelopeFromFrame(frame), blinders = [...envelope.bsqs, ...envelope.bsss];
-        if (!blinders.length || !this.registry)
-            return false;
-        const chain = acceptedRegistryEvidence(this.registry, regid);
-        if (!chain)
-            return missing(`Missing presentation TEL evidence for ${regid}.`);
-        const sources = new Map();
-        let unresolved = false;
-        for (const seal of envelope.ssts) {
-            if (seal.i.qb64 !== issuee)
-                continue;
-            const said = seal.s.num > BigInt(Number.MAX_SAFE_INTEGER)
-                ? null
-                : this.hby.db.kels.getLast(issuee, Number(seal.s.num));
-            if (!said) {
-                unresolved = true;
-                continue;
-            }
-            if (said !== seal.d.qb64)
-                continue;
-            if (!this.hby.db.getEvtSerder(issuee, said)) {
-                unresolved = true;
-                continue;
-            }
-            for (const update of chain.updates) {
-                const checked = validateUpdate(update, regid);
-                if (checked.kind !== "valid")
-                    throw new DatabaseOperationError("Accepted presentation update is corrupt.");
-                if (verifyRegistryAnchor(checked.event, { db: this.hby.db, issuer: issuee, number: seal.s, diger: seal.d })) {
-                    sources.set(update.said, seal.d.qb64);
-                }
-            }
-        }
-        if (!sources.size && unresolved)
-            return missing(`Missing presentation anchor source for ${regid}.`);
-        const result = vetBinds({
-            ...chain,
-            db: this.hby.db,
-            blinders,
-            target,
-            controller: issuee,
-            cutoff,
-            sources,
-            requireSource: true,
-        });
-        if (result.kind === "missing" || (result.kind === "reject" && result.reason === "anchor" && unresolved)) {
-            return missing(`Missing presentation TEL anchor for ${regid}.`);
-        }
-        return result.kind === "verified" && result.state.regid === regid;
-    }
-    /** Reject hidden requirements and preserve unique, validated Issuee/registry pairs in wire order. */
-    presentationRegistries(serder) {
-        const a = serder.sad.a;
-        const aggregate = serder.sad.A;
-        if (!serder.regid) {
-            if (record(a) && a.rd)
-                return null;
-            const sections = Array.isArray(aggregate) ? aggregate.slice(1) : [aggregate];
-            return sections.some((section) => record(section) && section.rd) ? null : [];
-        }
-        if (typeof a === "string" || typeof aggregate === "string")
-            return null;
-        const sections = record(a) ? [a] : [];
-        if (Array.isArray(aggregate)) {
-            if (!aggregate.slice(1).every(record))
-                return null;
-            sections.push(...aggregate.slice(1));
-        }
-        else if (record(aggregate))
-            sections.push(aggregate);
-        const declarations = [];
-        for (const section of sections) {
-            const regid = section.rd, issuee = section.i;
-            if (!regid || !issuee)
-                continue;
-            if (typeof regid !== "string" || typeof issuee !== "string")
-                return null;
-            try {
-                if (new Diger({ qb64: regid }).qb64 !== regid || new Prefixer({ qb64: issuee }).qb64 !== issuee)
-                    return null;
-            }
-            catch (error) {
-                if (!(error instanceof ParserError))
-                    throw error;
-                return null;
-            }
-            if (!declarations.some(([aid, registry]) => aid === issuee && registry === regid)) {
-                declarations.push([issuee, regid]);
-            }
-        }
-        return declarations;
-    }
-}

package/esm/keri/npm/src/app/mailbox-sse.js

@@ -1,240 +0,0 @@
-import { call, resource } from "effection";
-import { abortable } from "./abortable.js";
-import { defaultRuntimeServices } from "./runtime-services.js";
-/** Shared encoder for complete mailbox event payloads. */
-const textEncoder = new TextEncoder();
-/** Decode one complete SSE block; an unterminated block is never delivered. */
-function eventMessage(lines) {
-    let idx = -1;
-    let topic = "";
-    const data = [];
-    for (const line of lines) {
-        const colon = line.indexOf(":");
-        const field = colon < 0 ? line : line.slice(0, colon);
-        let value = colon < 0 ? "" : line.slice(colon + 1);
-        // SSE removes exactly one optional space, not meaningful payload whitespace.
-        if (value.startsWith(" "))
-            value = value.slice(1);
-        if (field === "id")
-            idx = /^\d+$/.test(value) ? Number(value) : -1;
-        else if (field === "event")
-            topic = value;
-        else if (field === "data")
-            data.push(value);
-    }
-    if (!Number.isSafeInteger(idx) || idx < 0 || !topic || !data.length)
-        return;
-    return { idx, topic, msg: textEncoder.encode(data.join("\n")) };
-}
-/** Geometric byte growth keeps fragmentation from creating one retained metadata entry per chunk. */
-function appendBytes(bytes, size, chunk) {
-    if (size + chunk.length > bytes.length) {
-        const grown = new Uint8Array(Math.max(size + chunk.length, 1024, bytes.length * 2));
-        grown.set(bytes.subarray(0, size));
-        bytes = grown;
-    }
-    bytes.set(chunk, size);
-    return bytes;
-}
-/**
- * Consume complete mailbox events with backpressure from the awaited consumer.
- * Returning false stops the poll without acknowledging an unread event. Timeout,
- * EOF, and cancellation discard an incomplete final event so its cursor can retry.
- */
-export function consumeMailboxSse(response, controller, consume, options = {}) {
-    return call(function* () {
-        let lines = [];
-        let lineBytes = new Uint8Array(0);
-        let lineSize = 0;
-        const decoder = new TextDecoder();
-        let completed = false;
-        yield* consumeChunks(response, controller, function* (chunk) {
-            let start = 0;
-            for (let index = 0; index < chunk.length; index++) {
-                if (chunk[index] !== 10)
-                    continue;
-                lineBytes = appendBytes(lineBytes, lineSize, chunk.subarray(start, index));
-                lineSize += index - start;
-                let line = decoder.decode(lineBytes.subarray(0, lineSize));
-                if (line.endsWith("\r"))
-                    line = line.slice(0, -1);
-                lineSize = 0;
-                start = index + 1;
-                if (line) {
-                    lines.push(line);
-                }
-                else {
-                    const message = eventMessage(lines);
-                    lines = [];
-                    if (message) {
-                        completed = true;
-                        if ((yield* consume(message)) === false)
-                            return false;
-                    }
-                }
-            }
-            if (start < chunk.length) {
-                lineBytes = appendBytes(lineBytes, lineSize, chunk.subarray(start));
-                lineSize += chunk.length - start;
-            }
-        }, options, () => completed);
-    });
-}
-/**
- * Collect a raw SSE diagnostic report for one poll window. Production polling
- * uses consumeMailboxSse to deliver complete events as they arrive.
- */
-export function readMailboxSseBody(response, controller, options = {}) {
-    return call(function* () {
-        const decoder = new TextDecoder();
-        let bytes = new Uint8Array(0);
-        let size = 0;
-        let blockStart = 0;
-        let completed = false;
-        yield* consumeChunks(response, controller, function* (chunk) {
-            bytes = appendBytes(bytes, size, chunk);
-            const end = size + chunk.length;
-            // Inspect each terminated block once. A retry/comment header alone must not start the idle deadline.
-            for (let index = size; !completed && index < end; index++) {
-                if (bytes[index] !== 10)
-                    continue;
-                if (bytes[index - 1] === 10
-                    || (bytes[index - 1] === 13 && bytes[index - 2] === 10 && bytes[index - 3] === 13)) {
-                    completed = parseMailboxSse(decoder.decode(bytes.subarray(blockStart, index + 1))).length > 0;
-                    blockStart = index + 1;
-                }
-            }
-            size = end;
-        }, options, () => completed);
-        return new TextDecoder().decode(bytes.subarray(0, size));
-    });
-}
-/** Parse only terminated events from an already finite diagnostic report. */
-export function parseMailboxSse(text) {
-    return text.replaceAll("\r\n", "\n").split("\n\n").slice(0, -1)
-        .map((block) => eventMessage(block.split("\n")))
-        .filter((message) => message !== undefined);
-}
-/** Own one reader; a timed-out read is canceled and joined before this operation exits. */
-function* consumeChunks(response, controller, consume, options, hasEvent) {
-    const { idleTimeoutMs = 500, maxDurationMs = 30_000, services = defaultRuntimeServices, } = options;
-    for (const value of [idleTimeoutMs, maxDurationMs]) {
-        if (!Number.isSafeInteger(value) || value < 1)
-            throw new RangeError("Invalid mailbox SSE timeout");
-    }
-    if (!response.body)
-        return;
-    const reader = response.body.getReader();
-    let closing;
-    let pendingRead;
-    let reportedFailure;
-    let readAbort;
-    /** Repeated cancellation joins the original underlying source cleanup, including asynchronous cancel. */
-    const close = (reason) => closing ??= reader.cancel(reason);
-    // This owner predates the cancellable read leaf, so teardown joins the read before releasing its lock.
-    yield* resource(function* (provide) {
-        try {
-            yield* provide();
-        }
-        finally {
-            controller.abort();
-            yield* call(async () => {
-                const failures = [];
-                const remember = (error) => {
-                    if ((reportedFailure && error === reportedFailure.error) || error === controller.signal.reason
-                        || (readAbort && error === readAbort.reason)) {
-                        return;
-                    }
-                    if (!failures.includes(error))
-                        failures.push(error);
-                };
-                try {
-                    // The read leaf joins this Promise too, but cancellation can discard its result.
-                    try {
-                        await pendingRead;
-                    }
-                    catch (error) {
-                        remember(error);
-                    }
-                    try {
-                        await close();
-                    }
-                    catch (error) {
-                        remember(error);
-                    }
-                }
-                finally {
-                    try {
-                        reader.releaseLock();
-                    }
-                    catch (error) {
-                        remember(error);
-                    }
-                }
-                if (failures.length && reportedFailure)
-                    failures.unshift(reportedFailure.error);
-                if (failures.length === 1)
-                    throw failures[0];
-                if (failures.length)
-                    throw new AggregateError(failures, "Mailbox SSE read and cleanup failed");
-            });
-        }
-    });
-    const deadline = services.clock.now() + maxDurationMs;
-    try {
-        while (services.clock.now() < deadline) {
-            const wait = Math.max(1, Math.min(hasEvent() ? idleTimeoutMs : maxDurationMs, deadline - services.clock.now()));
-            const next = yield* abortable(async (signal) => {
-                // Keep exactly one read alive. A timeout ends the poll, never starts a competing reader.read().
-                const pending = pendingRead = reader.read();
-                readAbort = undefined;
-                let timer;
-                const cancel = () => {
-                    readAbort = { reason: signal.reason };
-                    // Observe notification rejection; the earlier owner joins the original Promise.
-                    void close(signal.reason).catch(() => { });
-                };
-                signal.addEventListener("abort", cancel, { once: true });
-                // abortable checks before entry; also cover synchronous abort inside the source read hook.
-                if (signal.aborted)
-                    cancel();
-                try {
-                    const result = await Promise.race([
-                        pending,
-                        new Promise((resolve) => {
-                            timer = services.clock.setTimeout(() => resolve(undefined), wait);
-                        }),
-                    ]);
-                    if (!result) {
-                        controller.abort();
-                        try {
-                            await close();
-                        }
-                        catch (error) {
-                            // Native fetch errors its body with this exact timeout reason.
-                            if (error !== controller.signal.reason)
-                                throw error;
-                        }
-                    }
-                    return result;
-                }
-                finally {
-                    if (timer !== undefined)
-                        services.clock.clearTimeout(timer);
-                    signal.removeEventListener("abort", cancel);
-                    await pending.catch(() => undefined);
-                }
-            }, options.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal);
-            if (!next || next.done)
-                return;
-            if (next.value.length) {
-                if ((yield* consume(next.value)) === false)
-                    return;
-            }
-        }
-    }
-    catch (error) {
-        reportedFailure = { error };
-        throw error;
-    }
-}