keri-ts 2.2.4 → 2.2.6

package/esm/keri/npm/src/_dnt.polyfills.js

@@ -1,3 +1,17 @@
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
 function findLastIndex(self, callbackfn, that) {
     const boundFunc = that === undefined ? callbackfn : callbackfn.bind(that);
     let index = self.length - 1;
@@ -34,18 +48,4 @@ if (!Uint8Array.prototype.findLast) {
         return findLast(this, callbackfn, that);
     };
 }
-// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
-if (!Object.hasOwn) {
-    Object.defineProperty(Object, "hasOwn", {
-        value: function (object, property) {
-            if (object == null) {
-                throw new TypeError("Cannot convert undefined or null to object");
-            }
-            return Object.prototype.hasOwnProperty.call(Object(object), property);
-        },
-        configurable: true,
-        enumerable: false,
-        writable: true,
-    });
-}
 export {};

package/esm/keri/npm/src/acdc/dhking.js

@@ -17,6 +17,7 @@ import { query, reply } from "../core/protocol-eventing.js";
 import { messagize } from "../core/protocol-serialization.js";
 import { fetchStoredTsgs, unverifiedReplyDecision } from "../core/routing.js";
 import { timestampMicros } from "../time/mod.js";
+import { QUERY_RESEND_MS } from "./query-resend.js";
 import { validateUpdate, verifyRegistryAnchor } from "./regeventing.js";
 import { publicOpeningAttachment } from "./registering.js";
 const domain = new TextEncoder().encode("KERI/ipex/dhke/X25519-HKDF-SHA256-Salt128/v1");
@@ -343,6 +344,8 @@ export class Dhke {
             peer: null,
             query: null,
             reply: null,
+            accepted: null,
+            repliedAt: 0,
             proposal: null,
             contribution: null,
             custody: null,
@@ -493,6 +496,12 @@ export class Dhke {
             if (own && (!op.proposal || !bytesEqual(op.proposal, serder.raw))) {
                 throw new ValidationError("Own DH query lacks exact local proposal approval");
             }
+            // A group re-sends its frozen query unchanged (one member cannot re-date it), and KERIpy resends identical
+            // bytes. The wire, attachments included, is compared against the one already authenticated, so a copy is
+            // never trusted on its body or SAID alone.
+            const wire = auxiliaryQueryWire(envelope);
+            if (!own && op.accepted && bytesEqual(op.accepted, wire))
+                return this.duplicateQuery(op);
             if (!verifyQueryAttachments(this.hab.db, envelope)) {
                 return { kind: "drop", reason: "missingAuthentication" };
             }
@@ -513,6 +522,7 @@ export class Dhke {
             }
             if (this.group && !this.custody(op)) {
                 op.peer = { ...peer };
+                op.accepted = wire;
                 return { kind: "accept" };
             }
             if (!op.reply) {
@@ -537,10 +547,12 @@ export class Dhke {
                 }
                 if (this.group) {
                     this.outgoing.push({ kin: "sign", dest: this.hab.pre, msg: op.contribution.slice() });
+                    op.accepted = wire;
                     return { kind: "accept" };
                 }
             }
-            this.outgoing.push({ kin: "reply", dest: op.issuer, msg: op.reply.slice() });
+            this.emitReply(op);
+            op.accepted = wire;
             return { kind: "accept" };
         }
         catch (error) {
@@ -549,6 +561,21 @@ export class Dhke {
             throw error;
         }
     }
+    /**
+     * A copy of the accepted query: nothing is verified, derived or contributed again, so a member round that
+     * already holds its `sign` contribution is not asked for another. If the reply exists it is queued again for a
+     * peer that lost it, at most once per {@link QUERY_RESEND_MS}.
+     */
+    duplicateQuery(op) {
+        if (op.reply && this.now() - op.repliedAt >= QUERY_RESEND_MS)
+            this.emitReply(op);
+        return { kind: "accept" };
+    }
+    /** Queue the stored reply for the issuer and note when. */
+    emitReply(op) {
+        this.outgoing.push({ kin: "reply", dest: op.issuer, msg: op.reply.slice() });
+        op.repliedAt = this.now();
+    }
     /** Revery decides reply threshold acceptance before any issuer derivation or retention. */
     processReply({ serder, diger, route, cigars = [], tsgs = [] }) {
         try {
@@ -574,7 +601,7 @@ export class Dhke {
                     });
                 }
                 if (this.custody(op))
-                    this.outgoing.push({ kin: "reply", dest: op.issuer, msg: op.reply.slice() });
+                    this.emitReply(op);
             }
             else if (this.custody(op) && !op.completed)
                 this.retain(op, peer, this.derive(op, peer, "issuer"));

package/esm/keri/npm/src/acdc/observing.js

@@ -11,9 +11,10 @@ import { publicOpeningAttachment } from "./registering.js";
  * event commits independently; a later failure preserves the already accepted prefix.
  * Parsed evidence stays borrowed. Composition supplies this owner to v2 protocol dispatch;
  * no local habitat, alias or application disclosure custody is created by public intake.
+ * `cues` receives the issuer KEL `logs` query of each event that first waits for its anchoring KEL event.
  */
 export class RegistryObserver {
-    constructor(db, store) {
+    constructor(db, store, cues = null) {
         Object.defineProperty(this, "db", {
             enumerable: true,
             configurable: true,
@@ -26,6 +27,12 @@ export class RegistryObserver {
             writable: true,
             value: store
         });
+        Object.defineProperty(this, "cues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cues
+        });
     }
     /** Stage parsed events before inception, otherwise delegate ordinary validation and acceptance. */
     processEvent(serder, locators = {}) {
@@ -62,7 +69,7 @@ export class RegistryObserver {
         if (event.ilk === Ilks.rip) {
             if (!event.issuer)
                 return { kind: "reject", reason: "issuer" };
-            engine ??= new RegistryEventer(this.db, event.issuer, this.store, event.regid);
+            engine ??= new RegistryEventer(this.db, event.issuer, this.store, event.regid, this.cues);
         }
         if (engine) {
             const decision = engine.processEvent(serder, locators);
@@ -124,6 +131,6 @@ export class RegistryObserver {
         if (result.kind !== "valid" || result.event.regid !== regid || !result.event.issuer) {
             throw new Error("Corrupt observer registry inception.");
         }
-        return new RegistryEventer(this.db, result.event.issuer, this.store, regid);
+        return new RegistryEventer(this.db, result.event.issuer, this.store, regid, this.cues);
     }
 }

package/esm/keri/npm/src/acdc/query-resend.js

@@ -0,0 +1,74 @@
+/**
+ * Resend schedule for a group's threshold DH or Unblind query.
+ *
+ * A single signer re-dates every resend (`Dhke.requery`, `Unblind.requery`), so a resend is a new query the peer's
+ * KRAM accepts. A group cannot: re-dating needs the members' signatures, so the frozen query is resent as the same
+ * bytes. The peer's KRAM drops identical copies cheaply only while its replay cache row lives, and once the query's
+ * `dt` is older than the multi-key acceptance window it refuses every copy as untimely. This schedule therefore
+ * backs off and stops resending an unchanged query when the peer can no longer accept it. It never ends the
+ * operation: the owner keeps waiting until its own deadline, exactly as before.
+ */
+import { parseBytes } from "cesr-ts";
+import { ValidationError } from "../core/errors.js";
+import { timestampMicros } from "../time/mod.js";
+/** Milliseconds between the first resends of a query, and the shortest gap a receiver re-sends a stored reply. */
+export const QUERY_RESEND_MS = 1000;
+/** The longest gap the backoff reaches, in milliseconds. */
+export const QUERY_RESEND_CAP_MS = 8000;
+/** One group operation's frozen threshold query and when it may next be sent; memory only. */
+export class ThresholdQueryResend {
+    constructor() {
+        /** The frozen signed query, unchanged on every resend; absent until the members' contributions complete it. */
+        Object.defineProperty(this, "query", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "queryAt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "next", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "wait", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+    }
+    /** Take the frozen query and restart the schedule; its own `dt` is what the acceptance window is measured from. */
+    set(query) {
+        const body = parseBytes(query)[0]?.body;
+        const micros = timestampMicros(body?.sad?.dt);
+        if (micros === null)
+            throw new ValidationError("Threshold query has no valid date");
+        this.query = query;
+        this.queryAt = Number(micros / 1000n);
+        this.next = 0;
+        this.wait = 0;
+    }
+    /** Whether a query is frozen and the running gap has elapsed at `now` (epoch ms). */
+    ready(now) {
+        return !!this.query && now >= this.next;
+    }
+    /**
+     * Whether the query is still younger than `windowMs` at `now`; past it a receiver can no longer accept the
+     * unchanged query, so it is not sent again. A null window (this store never ran KRAM) never closes.
+     */
+    fresh(now, windowMs) {
+        return windowMs === null || now - this.queryAt < windowMs;
+    }
+    /** Record a send at `now`: the next gap doubles from `baseMs` up to {@link QUERY_RESEND_CAP_MS}. */
+    sent(now, baseMs) {
+        this.wait = this.wait ? Math.max(baseMs, Math.min(this.wait * 2, QUERY_RESEND_CAP_MS)) : baseMs;
+        this.next = now + this.wait;
+    }
+}

package/esm/keri/npm/src/acdc/regengine.js

@@ -2,14 +2,18 @@
 import { Diger, Ilks, NumberPrimitive, } from "cesr-ts";
 import { DatabaseNotOpenError, DatabaseOperationError } from "../core/errors.js";
 import { consoleLogger } from "../core/logger.js";
+import { missingAnchorCue, missingAnchorQuery } from "../core/missing-anchor-query.js";
 import { findRegistryAnchor, validateRegistrySourceLocators, validateRip, validateUpdate, verifyRegistryAnchor, } from "./regeventing.js";
 /**
  * Borrow the issuer's accepted KEL and registry store; no keys or handles are acquired.
  * The local facade and foreign observer share this accepted-state engine.
  * Publication is atomic; binding this instance happens only after successful commit.
+ * An event that first enters the anchor escrow publishes one issuer KEL `logs` query to `cues` after that write.
  */
 export class RegistryEventer {
-    constructor(db, issuer, store, regk = null) {
+    constructor(db, issuer, store, regk = null, 
+    /** Application cue flow for missing-anchor queries; null for a local issuer, whose own KEL holds every anchor. */
+    cues = null) {
         Object.defineProperty(this, "db", {
             enumerable: true,
             configurable: true,
@@ -34,6 +38,12 @@ export class RegistryEventer {
             writable: true,
             value: regk
         });
+        Object.defineProperty(this, "cues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: cues
+        });
     }
     /** Validated accepted head metadata; local construction may inspect it without duplicating acceptance checks. */
     get acceptedHeadEvent() {
@@ -234,6 +244,9 @@ export class RegistryEventer {
         const decision = this.processOne(serder, locators);
         if (decision.kind === "accept")
             this.processQueued();
+        // The escrow row is committed; ask the issuer's KEL holders for what the anchor needs through the ordinary cue path.
+        if (decision.kind === "escrow" && decision.query)
+            this.cues?.push(missingAnchorCue(decision.query));
         return decision;
     }
     /** Decide and persist one event; callers own subsequent chain progression. */
@@ -269,10 +282,8 @@ export class RegistryEventer {
                 return previous;
             this.store.putEvent(serder);
             this.discoverAnchor(event);
-            if (!this.store.anchor(event.said)) {
-                this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
-                return { kind: "escrow", reason: "anchor", event };
-            }
+            if (!this.store.anchor(event.said))
+                return this.escrowAnchorless(event, locators);
             this.store.baser.maes.rem(event.regid, Number(event.sn), [event.said]);
             if (!prior) {
                 this.store.escrowOutOfOrder(event.regid, Number(event.sn), event.said);
@@ -314,10 +325,8 @@ export class RegistryEventer {
                 throw new Error("Registry head exists without its accepted inception.");
             this.store.putEvent(serder);
             this.discoverAnchor(event);
-            if (!this.store.anchor(event.said)) {
-                this.store.escrowMissingAnchor(event.regid, 0, event.said);
-                return { kind: "escrow", reason: "anchor", event };
-            }
+            if (!this.store.anchor(event.said))
+                return this.escrowAnchorless(event, locators);
             this.commit(event);
             return { kind: "accept", event };
         });
@@ -325,6 +334,27 @@ export class RegistryEventer {
             this.regk = event.regid;
         return decision;
     }
+    /**
+     * Retain an event whose anchoring issuer KEL event is not accepted yet and decide whether to ask for it.
+     *
+     * The decision names the missing KEL only when this call put the event into the anchor escrow; retries and repeat
+     * arrivals find the row present. A source seal naming this issuer supplies the anchor's sequence number, and the
+     * highest one bounds the replay; without one the query names only where the recipient's KEL ends.
+     */
+    escrowAnchorless(event, locators) {
+        const added = this.store.escrowMissingAnchor(event.regid, Number(event.sn), event.said);
+        const decision = { kind: "escrow", reason: "anchor", event };
+        if (!added)
+            return decision;
+        const seals = [
+            ...(locators.sscs ?? []).map((seal) => seal.s.num),
+            ...(locators.ssts ?? []).filter((seal) => seal.i.qb64 === this.issuer).map((seal) => seal.s.num),
+        ];
+        const anchor = seals.length ? seals.reduce((high, sn) => (sn > high ? sn : high)) : null;
+        const accepted = this.db.getKever(this.issuer, { refresh: true })?.sner.num ?? null;
+        const query = missingAnchorQuery(this.issuer, accepted, anchor);
+        return query ? { ...decision, query } : decision;
+    }
     /** Replay is read-only; first acceptance repeats this check under its write transaction. */
     acceptedEvent(event) {
         const existing = this.acceptedAt(event.regid, Number(event.sn));

package/esm/keri/npm/src/acdc/regeventing.js

@@ -150,8 +150,9 @@ function sealDigests(event) {
 export function findRegistryAnchor(db, issuer, registry) {
     let earliest = null;
     for (const event of currentRegistryBranch(db, issuer)) {
-        if (db.fullyWitnessed(event)
-            && event.seals.some((seal) => matchesRegistrySeal(seal, registry))) {
+        // Seal test first: fullyWitnessed walks back to the governing establishment, so it runs only on matches.
+        if (event.seals.some((seal) => matchesRegistrySeal(seal, registry))
+            && db.fullyWitnessed(event)) {
             earliest = [event.sn, event.said];
         }
     }
@@ -161,7 +162,8 @@ export function findRegistryAnchor(db, issuer, registry) {
 function findDigestAnchor(db, issuer, digest) {
     let earliest = null;
     for (const event of currentRegistryBranch(db, issuer)) {
-        if (db.fullyWitnessed(event) && sealDigests(event).includes(digest)) {
+        // Seal test first: fullyWitnessed walks back to the governing establishment, so it runs only on matches.
+        if (sealDigests(event).includes(digest) && db.fullyWitnessed(event)) {
             earliest = [event.sn, event.said];
         }
     }

package/esm/keri/npm/src/acdc/registering.js

@@ -202,6 +202,25 @@ export class RegistryStore {
         const said = this.seqSaider(regk, sn);
         return said ? this.event(said.qb64) : null;
     }
+    /**
+     * Registry identifiers with an accepted head, in key order: a scan of `heds.`. With `issuer`, only those whose
+     * accepted inception (`rip` at ordinal 0) names that issuer. Local aliases (`regs.`) play no part, so this also
+     * lists registries a store learned from others, such as a group registry a co-member incepted.
+     */
+    registries(issuer) {
+        const found = [];
+        for (const [keys] of this.baser.heads.getTopItemIter()) {
+            const regk = String(keys[0]);
+            if (issuer === undefined) {
+                found.push(regk);
+                continue;
+            }
+            const rip = this.seqEvent(regk, 0);
+            if (rip?.ilk === Ilks.rip && rip.issuer === issuer)
+                found.push(regk);
+        }
+        return found;
+    }
     /** Publish caller-approved storage markers; validation and duplicate/head policy belong to the engine. */
     accept(regk, sn, serder) {
         sn = registryOrdinal(sn);

package/esm/keri/npm/src/acdc/salting.js

@@ -641,6 +641,10 @@ export class RegistryRoot {
                 throw new RootUnverified(error.message, { cause: error });
             throw error;
         }
+        // The recipient's key opens the box; without its signer the copy stays pending until the host holds it.
+        if (!hab.mgr.hasSigner(hab.kever.verfers[0].qb64)) {
+            throw new RootUnverified("the recipient's signer is not held; the copy stays pending until it is");
+        }
         let plain;
         try {
             const opened = hab.mgr.open(essr, hab.kever.verfers[0]);

package/esm/keri/npm/src/acdc/unblinding.js

@@ -25,6 +25,7 @@ import { query, reply } from "../core/protocol-eventing.js";
 import { messagize } from "../core/protocol-serialization.js";
 import { fetchStoredTsgs, unverifiedReplyDecision } from "../core/routing.js";
 import { prepareNests, publishNests } from "../db/exchange/exchange-nests.js";
+import { QUERY_RESEND_MS } from "./query-resend.js";
 import { validateUpdate, verifyRegistryAnchor, vet, vetBlind, vetBound, } from "./regeventing.js";
 import { publicOpeningAttachment } from "./registering.js";
 /** Ordinary registry states an Unblind operation may reveal unless its approval names others. */
@@ -89,7 +90,7 @@ const KEL_ASK_MS = 5000;
  */
 export class Unblind {
     /** Bind the exact Grant verifier's store; the state vocabulary is chosen per approved operation. */
-    constructor({ hab, exc, registry, rvy = hab.rvy, kram = true }) {
+    constructor({ hab, exc, registry, rvy = hab.rvy, now = Date.now, kram = true }) {
         Object.defineProperty(this, "resource", {
             enumerable: true,
             configurable: true,
@@ -162,7 +163,14 @@ export class Unblind {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "now", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.kram = kram;
+        this.now = now;
         if (!(hab instanceof Hab) || hab.db !== exc.hby.db || registry.db !== hab.db || rvy.db !== hab.db
             || exc.hby.habs.get(hab.pre) !== hab) {
             throw new ValidationError("Unblind requires a local signing habitat");
@@ -228,6 +236,8 @@ export class Unblind {
             scope: new Map([...context.registries].map(([regid, nodes]) => [regid, [...nodes]])),
             query: null,
             reply: null,
+            accepted: null,
+            repliedAt: 0,
             requested: null,
             selected: null,
             openings: new Map(),
@@ -389,6 +399,11 @@ export class Unblind {
             if (own && (!op.proposal || !bytesEqual(op.proposal, serder.raw))) {
                 throw new ValidationError("Own Unblind query lacks its exact locally approved proposal");
             }
+            // A group re-sends its frozen query unchanged (one member cannot re-date it), and KERIpy resends identical
+            // bytes. The wire, attachments and evidence included, is compared against the one already authenticated, so
+            // a copy is never trusted on its body or SAID alone.
+            if (!own && op.accepted && bytesEqual(op.accepted, this.queryWire(envelope)))
+                return this.duplicateQuery(op);
             if (!verifyQueryAttachments(this.hab.db, envelope))
                 return { kind: "drop", reason: "missingAuthentication" };
             if (op.requested && !sameSelection(op.requested, selected)) {
@@ -429,9 +444,11 @@ export class Unblind {
             op.requestedByPeer = true;
             // KRAM now holds this query as seen, so a resend of it is a replay and a group cannot re-date it: the
             // owed reply must outlive this owner. The accepted request is the durable record; the operation is a cache.
-            this.hab.db.heldu.pin([this.hab.pre, op.xid], auxiliaryQueryWire(envelope, this.publicEvents(envelope.nests)));
+            const wire = this.queryWire(envelope);
+            this.hab.db.heldu.pin([this.hab.pre, op.xid], wire);
             if (!this.group)
                 this.respond(op.xid);
+            op.accepted = wire;
             return { kind: "accept" };
         }
         catch (error) {
@@ -533,9 +550,27 @@ export class Unblind {
             }
             op.reply = signed;
         }
-        this.outgoing.push({ kin: "reply", dest: op.recipient, msg: op.reply.slice() });
+        this.emitReply(op);
         return op.reply.slice();
     }
+    /** The query as held and compared: its frame, every attachment group, the public evidence and KRAM's normalized proof. */
+    queryWire(envelope) {
+        return auxiliaryQueryWire(envelope, this.publicEvents(envelope.nests));
+    }
+    /**
+     * A copy of the accepted query: nothing is verified or derived again. If the reply exists it is queued again for
+     * a peer that lost it, at most once per {@link QUERY_RESEND_MS}.
+     */
+    duplicateQuery(op) {
+        if (op.reply && this.now() - op.repliedAt >= QUERY_RESEND_MS)
+            this.emitReply(op);
+        return { kind: "accept" };
+    }
+    /** Queue the stored reply for the recipient and note when. */
+    emitReply(op) {
+        this.outgoing.push({ kin: "reply", dest: op.recipient, msg: op.reply.slice() });
+        op.repliedAt = this.now();
+    }
     /** Independently vet openings before caching them; Revery owns signature threshold and BADA. */
     processReply({ serder, diger, route, cigars = [], tsgs = [], attachments }) {
         try {

package/esm/keri/npm/src/app/bootstrap/authenticating.js

@@ -2,7 +2,8 @@ import { call, scoped } from "effection";
 import { persistResolvedContact } from "../identity/organizing.js";
 import { doEveryOnWrite, PROTOCOL_PACING } from "../runtime/doing.js";
 import { systemClock } from "../runtime/runtime-clock.js";
-import { isWellKnownOobiUrl, parseOobiUrl } from "./oobiery.js";
+import { isRequestableHttpUrl } from "../transport/http-client.js";
+import { isWellKnownOobiUrl, oobiJobFailure, parseOobiUrl } from "./oobiery.js";
 /**
  * Return true when a well-known URL has been authorized into `wkas.`.
  *
@@ -118,23 +119,20 @@ export class Authenticator {
         return null;
     }
     /**
-     * Fetch one `mfa.` record and persist the terminal auth result.
+     * Fetch one `mfa.` record and persist the terminal auth result. A URL the HTTP client refuses, a refused or failed
+     * request, or a non-OK status each end this authentication as failed in `rmfa.` and remove its `mfa.` row, so the
+     * next pass takes the next one; any other error is a fault and propagates.
      *
      * @param url Exact pending well-known authentication URL.
      * @param record Durable mfa record retained until response handling and cleanup establish terminal state.
      */
     *processPendingAuth(url, record) {
-        // Only HTTP status is needed; the response owner still joins body cleanup.
         const cid = record.cid
             ?? parseOobiUrl(url, record.oobialias ?? undefined).cid
             ?? null;
-        const http = this.http;
-        const response = yield* scoped(function* () {
-            const response = yield* http.open(url);
-            return { ok: response.ok, status: response.status };
-        });
+        const state = yield* this.authenticate(url);
         const date = new Date().toISOString();
-        const state = response.ok ? "resolved" : `http-${response.status}`;
+        const ok = state === "resolved";
         this.hby.db.mfa.rem(url);
         this.hby.db.rmfa.pin(url, {
             ...record,
@@ -142,7 +140,7 @@ export class Authenticator {
             state,
             cid,
         });
-        if (response.ok && cid) {
+        if (ok && cid) {
             this.hby.db.wkas.add(cid, { url, dt: date });
             persistResolvedContact(this.hby, cid, {
                 alias: record.oobialias,
@@ -150,4 +148,28 @@ export class Authenticator {
             });
         }
     }
+    /**
+     * Request one well-known URL and read only its status; the response owner still joins body cleanup.
+     *
+     * @param url Pending well-known authentication URL.
+     * @returns The terminal state: `resolved` for an OK status, `http-<status>` otherwise, or the
+     *   {@link OobiJobFailure} of a URL the client refuses or a refused or failed request.
+     */
+    *authenticate(url) {
+        if (!isRequestableHttpUrl(url))
+            return "url-refused";
+        const http = this.http;
+        try {
+            return yield* scoped(function* () {
+                const response = yield* http.open(url);
+                return response.ok ? "resolved" : `http-${response.status}`;
+            });
+        }
+        catch (error) {
+            const failure = oobiJobFailure(error);
+            if (failure === null)
+                throw error;
+            return failure;
+        }
+    }
 }