@mdbase-dev/sdk 0.0.0-stage → 0.1.0-beta.149

package/dist/app-host/http-log.js

@@ -0,0 +1,609 @@
+/** First-party unary LS HTTP + staged object transfers. No account/key custody defaults. */
+import { LOCAL_APPLICATION_BUILD, localApplicationHttpOrigin } from "../application/local-build.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { decode, encode } from "../cbor.js";
+import { uuidToBytes } from "../codec.js";
+import { appServerBody, appServerOutcome, appServerProblem, isAppServerProblem } from "./cp-problem.js";
+const MAX_FRAME = 16 * 1024 * 1024, MAX_OBJECT = 9 * 1024 * 1024;
+const METHODS = new Set(["append", "read", "head", "subscribe", "unsubscribe", "put_object", "get_object", "has_objects", "put_snapshot", "get_snapshot", "endorse_snapshot", "stream_join", "stream_leave", "stream_send"]);
+const FORBIDDEN = new Set(["host", "content-length", "transfer-encoding", "connection", "keep-alive", "upgrade", "te", "trailer", "expect", "range", "cookie", "authorization", "proxy-authorization", "origin", "referer", "accept-charset", "accept-encoding", "access-control-request-headers", "access-control-request-method", "date", "dnt", "permissions-policy", "set-cookie", "via"]);
+const utf8 = new TextEncoder();
+export class AppHttpLogError extends Error {
+    reason;
+    server;
+    constructor(reason, server) {
+        super(`app log transport: ${reason}`);
+        this.reason = reason;
+        this.server = server;
+        this.name = "AppHttpLogError";
+    }
+}
+const error = (reason) => new AppHttpLogError(reason);
+function uint64(v) {
+    if ((typeof v !== "number" || !Number.isSafeInteger(v)) && typeof v !== "bigint")
+        throw error("shape");
+    const n = BigInt(v);
+    if (n < 0n || n > (1n << 64n) - 1n)
+        throw error("shape");
+    return n;
+}
+function number(v, max) { const n = uint64(v); if (n > BigInt(max))
+    throw error("shape"); return Number(n); }
+function map(v) { if (!(v instanceof Map))
+    throw error("shape"); return v; }
+function struct(m) {
+    const entries = [];
+    for (const [key, value] of m) {
+        if (typeof key !== "number" || !Number.isSafeInteger(key) || key < 0)
+            throw error("shape");
+        entries.push([key, value]);
+    }
+    return new Map(entries.sort(([a], [b]) => a - b));
+}
+function bytes(v, length) { if (!(v instanceof Uint8Array) || (length !== undefined && v.length !== length))
+    throw error("shape"); return v; }
+function equal(a, b) { return a.length === b.length && a.every((v, i) => v === b[i]); }
+function hex(b) { return [...b].map(v => v.toString(16).padStart(2, "0")).join(""); }
+function base64(b) { return btoa(String.fromCharCode(...b)); }
+function origin(input, loopback) {
+    let u;
+    try {
+        u = new URL(input);
+    }
+    catch {
+        throw error("binding");
+    }
+    const local = LOCAL_APPLICATION_BUILD ? localApplicationHttpOrigin(input) : ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname);
+    if (u.username || u.password || u.pathname !== "/" || u.search || u.hash || (u.protocol !== "https:" && !(loopback && local && u.protocol === "http:")))
+        throw error("binding");
+    return u.origin;
+}
+/** Fetch exposes decoded bytes; CORS can hide Content-Encoding. Wire length
+ * is never a decoded-size assertion, only an early over-cap hint. */
+function wireOverCap(response, cap) {
+    const input = response.headers.get("content-length");
+    return input !== null && /^(0|[1-9][0-9]*)$/.test(input) && Number(input) > cap;
+}
+/** Exact public ls-http transcript, shared with native/hosted verifier. */
+function proof(endpoint, originalCallId, method, collection, token, frame, nonce) {
+    const domain = utf8.encode("mdbase/v1/ls-http"), m = utf8.encode(method), path = utf8.encode("/v1/rpc");
+    const tokenBytes = utf8.encode(token), tokenHash = sha256(tokenBytes), bodyHash = sha256(frame);
+    tokenBytes.fill(0);
+    const pre = new Uint8Array(1 + domain.length + m.length + 1 + path.length + 1 + 16 + 96);
+    let at = 0;
+    for (const part of [Uint8Array.of(domain.length), domain, m, Uint8Array.of(0), path, Uint8Array.of(0), uuidToBytes(collection), tokenHash, bodyHash, nonce]) {
+        pre.set(part, at);
+        at += part.length;
+    }
+    const digest = sha256(pre);
+    pre.fill(0);
+    return Object.freeze({ endpoint, originalCallId, frame: frame.slice(), token, method, path: "/v1/rpc", collection, nonce: nonce.slice(), bodyHash, tokenHash, digest });
+}
+/** A worker's piggybacked next nonce (`x-mdbase-next-nonce`) is minted like
+ * `GET /v1/nonce` and lives 60 s server-side; use it well inside that. */
+const SPARE_NONCE_MS = 40_000, SPARE_NONCES = 6, NEXT_NONCE = "x-mdbase-next-nonce";
+function nonceBytes(text) { return /^[0-9a-f]{64}$/.test(text) ? Uint8Array.from(text.match(/../g).map(v => parseInt(v, 16))) : null; }
+/** An auth refusal of the nonce itself (never dispatched), safe to retry once with a fresh nonce. */
+function nonceRefused(reply) {
+    try {
+        const e = decode(reply).get(3);
+        if (!(e instanceof Map))
+            return false;
+        const m = e;
+        return m.get(0) === "unauthenticated" && (m.get(1) === "nonce" || m.get(1) === "replay");
+    }
+    catch {
+        return false;
+    }
+}
+/** All operations are bound to ONE immutable authenticated generation. A throw is
+ * unknown outcome; AppLogPump feeds NoResponse, never an invented rejection/save. */
+export class AppHttpLogTransport {
+    authority;
+    endpoint;
+    collection;
+    endpointId;
+    collectionBytes;
+    base;
+    approved;
+    fetchImpl;
+    now;
+    loopback;
+    commitId = (1n << 64n) - 1n;
+    /** Unused piggybacked nonces (one per reply, a few kept for concurrent RPCs);
+     * each is taken (never shared) by exactly one later RPC. */
+    spares = [];
+    responseId = 0;
+    receiving = new Map();
+    /** Only active logical sends, with bytes admitted under the existing body /
+     * range caps. Provisional network activity, never authenticated sync progress. */
+    responseProgress() {
+        return [...this.receiving].map(([id, bytes]) => ({ id, bytes }));
+    }
+    constructor(authority, options = {}) {
+        this.authority = authority;
+        try {
+            this.endpointId = uint64(authority.endpoint);
+            this.endpoint = this.endpointId;
+            this.collection = authority.collection;
+            this.collectionBytes = uuidToBytes(this.collection);
+            this.loopback = options.allowLoopbackHttp === true;
+            this.base = origin(authority.origin, this.loopback);
+            if (!Array.isArray(authority.directOrigins) || authority.directOrigins.length > 32)
+                throw error("binding");
+            // The log service mints its own direct URLs on its public origin, which this
+            // transport already trusts with every RPC; extra object-store origins are opt-in.
+            this.approved = new Set([this.base, ...authority.directOrigins.map(v => origin(v, this.loopback))]);
+            this.fetchImpl = options.fetch ?? globalThis.fetch;
+            this.now = options.now ?? Date.now;
+        }
+        catch {
+            throw error("binding");
+        }
+    }
+    isCurrent() {
+        try {
+            return this.authority.isCurrent() === true && uint64(this.authority.endpoint) === this.endpointId && this.authority.collection === this.collection && origin(this.authority.origin, this.loopback) === this.base;
+        }
+        catch {
+            return false;
+        }
+    }
+    check(signal) { if (signal.aborted || !this.isCurrent())
+        throw error("fenced"); }
+    request(frame) {
+        if (frame.length > MAX_FRAME)
+            throw error("shape");
+        const m = map(decode(frame));
+        if (m.get(0) !== 0 || typeof m.get(2) !== "string")
+            throw error("shape");
+        const method = m.get(2), params = map(m.get(3));
+        if (!METHODS.has(method) || !equal(bytes(params.get(0), 16), this.collectionBytes))
+            throw error("shape");
+        return { id: uint64(m.get(1)), method, params };
+    }
+    response(frame, id) {
+        const m = map(decode(frame));
+        if (m.get(0) !== 1 || uint64(m.get(1)) !== id || m.has(2) === m.has(3))
+            throw error("shape");
+        return m;
+    }
+    async fetch(url, init, parent, milliseconds) {
+        this.check(parent);
+        const ctrl = new AbortController(), abort = () => ctrl.abort();
+        parent.addEventListener("abort", abort, { once: true });
+        const timer = setTimeout(abort, milliseconds);
+        timer.unref?.();
+        try {
+            // Free-function invocation also works with browser/Worker native fetch.
+            const fetchImpl = this.fetchImpl;
+            // GETs (nonce, object reads) bypass the HTTP cache. POST/PUT responses are never
+            // HTTP-cached, and "no-store" there would also make Chrome skip its CORS preflight
+            // cache, costing an OPTIONS round trip per RPC despite Access-Control-Max-Age.
+            const cache = (init.method ?? "GET") === "GET" ? "no-store" : "default";
+            const r = await fetchImpl(url, { ...init, signal: ctrl.signal, redirect: "error", credentials: "omit", cache, referrerPolicy: "no-referrer" });
+            if (!this.isCurrent() || parent.aborted) {
+                void r.body?.cancel().catch(() => { });
+                throw error("fenced");
+            }
+            // Keep abort/timeout active through body consumption, not just headers.
+            return this.withCleanup(r, () => { clearTimeout(timer); parent.removeEventListener("abort", abort); });
+        }
+        catch {
+            clearTimeout(timer);
+            parent.removeEventListener("abort", abort);
+            throw error(parent.aborted || !this.isCurrent() ? "fenced" : "unavailable");
+        }
+    }
+    cleanups = new WeakMap();
+    withCleanup(r, cleanup) { this.cleanups.set(r, cleanup); return r; }
+    release(r) { this.cleanups.get(r)?.(); this.cleanups.delete(r); }
+    async read(r, cap, signal, receive) {
+        let buf = new Uint8Array(Math.min(1024, cap)), total = 0, reader = null;
+        try {
+            this.check(signal);
+            if (wireOverCap(r, cap))
+                throw error("integrity");
+            if (!r.body)
+                return buf.subarray(0, 0);
+            reader = r.body.getReader();
+            for (;;) {
+                const { done, value } = await reader.read();
+                try {
+                    this.check(signal);
+                    if (done)
+                        break;
+                    if (total + value.length > cap)
+                        throw error("integrity");
+                    if (total + value.length > buf.length) {
+                        const next = new Uint8Array(Math.min(cap, Math.max(buf.length * 2, total + value.length)));
+                        next.set(buf.subarray(0, total));
+                        buf.fill(0);
+                        buf = next;
+                    }
+                    buf.set(value, total);
+                    total += value.length;
+                    receive(value.length);
+                }
+                finally {
+                    value?.fill(0);
+                }
+            }
+            return buf.subarray(0, total);
+        }
+        catch (e) {
+            buf.fill(0);
+            void (reader?.cancel() ?? r.body?.cancel())?.catch(() => { });
+            throw e;
+        }
+        finally {
+            reader?.releaseLock();
+            this.release(r);
+        }
+    }
+    /** Bounded, sanitized server problem (code/reason/retry only). */
+    async refusal(r, signal, receive) {
+        let body;
+        try {
+            const raw = await this.read(r, 8 * 1024, signal, receive);
+            try {
+                body = appServerBody(raw);
+            }
+            finally {
+                raw.fill(0);
+            }
+        }
+        catch (e) {
+            if (e instanceof AppHttpLogError && e.reason === "fenced")
+                return e;
+            body = undefined;
+        }
+        const server = appServerProblem(r.status, body, r.headers);
+        return new AppHttpLogError(appServerOutcome(server) ?? "unavailable", server);
+    }
+    /** Take the newest fresh spare nonce; it is single use, so never hand it out twice. */
+    takeSpare() {
+        for (let spare = this.spares.pop(); spare; spare = this.spares.pop()) {
+            const age = this.now() - spare.at;
+            if (age >= 0 && age < SPARE_NONCE_MS)
+                return spare.nonce;
+            spare.nonce.fill(0);
+        }
+        return null;
+    }
+    keepSpare(r) {
+        const next = nonceBytes(r.headers.get(NEXT_NONCE) ?? "");
+        if (!next)
+            return;
+        this.spares.push({ nonce: next, at: this.now() });
+        while (this.spares.length > SPARE_NONCES)
+            this.spares.shift().nonce.fill(0);
+    }
+    async freshNonce(signal, receive) {
+        const nr = await this.fetch(`${this.base}/v1/nonce`, {}, signal, 15_000);
+        if (!nr.ok)
+            throw await this.refusal(nr, signal, receive);
+        const raw = await this.read(nr, 128, signal, receive);
+        try {
+            this.check(signal);
+            const nonce = nonceBytes(new TextDecoder("utf-8", { fatal: true }).decode(raw).trim());
+            if (!nonce)
+                throw error("shape");
+            return nonce;
+        }
+        finally {
+            raw.fill(0);
+        }
+    }
+    async rpc(frame, method, id, signal, receive, originalId = id, allowSpare = true) {
+        this.check(signal);
+        const token = await this.authority.accessToken({ signal });
+        this.check(signal);
+        if (typeof token !== "string" || !token || token.length > 16 * 1024 || /[\r\n]/.test(token))
+            throw error("shape");
+        // Steady state: the previous response's piggybacked nonce, so one request per RPC.
+        // Older workers send none; then (and when it is stale) fall back to GET /v1/nonce.
+        const spare = allowSpare ? this.takeSpare() : null;
+        const nonce = spare ?? await this.freshNonce(signal, receive);
+        this.check(signal);
+        const p = proof(this.endpoint, originalId, method, this.collection, token, frame, nonce);
+        nonce.fill(0);
+        let signature = null;
+        try {
+            signature = await this.authority.signLogProof(p, { signal });
+            this.check(signal);
+            if (!(signature instanceof Uint8Array) || signature.length !== 64)
+                throw error("shape");
+            const r = await this.fetch(`${this.base}/v1/rpc`, { method: "POST", headers: { authorization: `Bearer ${token}`, "content-type": "application/cbor", "x-mdbase-nonce": hex(p.nonce), "x-mdbase-sig": hex(signature) }, body: frame }, signal, 15_000);
+            this.keepSpare(r);
+            if (r.status === 401)
+                this.authority.invalidateToken?.(token);
+            if (!r.ok)
+                throw await this.refusal(r, signal, receive);
+            const reply = await this.read(r, method === "append" ? 64 * 1024 : MAX_FRAME, signal, receive);
+            try {
+                this.check(signal);
+                this.response(reply, id);
+            }
+            catch (e) {
+                reply.fill(0);
+                throw e;
+            }
+            // A refused spare (clock skew, or reused) was rejected before dispatch: retry once fresh.
+            if (spare && nonceRefused(reply)) {
+                reply.fill(0);
+                return await this.rpc(frame, method, id, signal, receive, originalId, false);
+            }
+            return reply;
+        }
+        finally {
+            signature?.fill(0);
+            p.frame.fill(0);
+            p.nonce.fill(0);
+            p.bodyHash.fill(0);
+            p.tokenHash.fill(0);
+            p.digest.fill(0);
+        }
+    }
+    direct(value, checksum) {
+        const m = map(value), rawUrl = m.get(0), rawHeaders = map(m.get(1)), expiry = m.get(2);
+        if (typeof rawUrl !== "string" || rawUrl.length > 16 * 1024 || typeof expiry !== "number" || !Number.isSafeInteger(expiry))
+            throw error("shape");
+        let url;
+        try {
+            url = new URL(rawUrl);
+        }
+        catch {
+            throw error("shape");
+        }
+        if (url.username || url.password || url.hash || !this.approved.has(url.origin))
+            throw error("binding");
+        const headers = new Headers(), names = new Set();
+        if (rawHeaders.size > 32)
+            throw error("shape");
+        for (const [key, val] of rawHeaders) {
+            if (typeof key !== "string" || typeof val !== "string")
+                throw error("shape");
+            const name = key.toLowerCase();
+            if (!/^[a-z0-9!#$%&'*+.^_`|~-]+$/.test(name) || FORBIDDEN.has(name) || name.startsWith("proxy-") || name.startsWith("sec-") || name.startsWith("x-mdbase-") || name.startsWith("x-http-method") || names.has(name) || val.length > 8 * 1024 || /[\r\n]/.test(val))
+                throw error("shape");
+            if (name === "x-amz-checksum-sha256" && val !== base64(checksum))
+                throw error("integrity");
+            names.add(name);
+            headers.set(name, val);
+        }
+        if (expiry - this.now() <= 5_000)
+            throw error("unavailable");
+        return { url: url.href, headers, expires: expiry };
+    }
+    timeout(d, size) { const left = d.expires - this.now(); if (left <= 5_000)
+        throw error("unavailable"); return Math.min(left, 30_000 + Math.ceil(size / (128 * 1024)) * 1_000); }
+    async upload(d, object, signal) {
+        this.check(signal);
+        let r;
+        try {
+            r = await this.fetch(d.url, { method: "PUT", headers: d.headers, body: object }, signal, this.timeout(d, object.length));
+        }
+        catch (e) {
+            this.check(signal);
+            if (e instanceof AppHttpLogError && e.reason === "unavailable")
+                return;
+            throw e;
+        } // Unknown PUT: only commit can decide.
+        try {
+            this.check(signal);
+            if (r.ok || r.status === 408 || r.status === 425 || r.status === 429 || r.status >= 500)
+                return;
+            throw error("unavailable");
+        }
+        finally {
+            void r.body?.cancel().catch(() => { });
+            this.release(r);
+        }
+    }
+    async download(d, size, checksum, signal, receive) {
+        const out = new Uint8Array(size);
+        let got = 0, stalled = 0;
+        try {
+            for (let requests = 0; requests < 32 && stalled < 5; requests++) {
+                this.check(signal);
+                const start = got, headers = new Headers(d.headers);
+                if (start > 0)
+                    headers.set("range", `bytes=${start}-${size - 1}`);
+                let r;
+                try {
+                    r = await this.fetch(d.url, { headers }, signal, this.timeout(d, size - start));
+                }
+                catch {
+                    this.check(signal);
+                    stalled++;
+                    continue;
+                }
+                let reader = null;
+                try {
+                    this.check(signal);
+                    if ([401, 403, 404, 410].includes(r.status))
+                        throw error("unavailable");
+                    if ([408, 425, 429].includes(r.status) || r.status >= 500) {
+                        stalled++;
+                        continue;
+                    }
+                    if (r.status !== (start === 0 ? 200 : 206) || wireOverCap(r, size - start) || (start > 0 ? r.headers.get("content-range") !== `bytes ${start}-${size - 1}/${size}` : r.headers.has("content-range")))
+                        throw error("integrity");
+                    if (r.headers.has("content-encoding") && r.headers.get("content-encoding") !== "identity")
+                        throw error("integrity");
+                    const ck = r.headers.get("x-amz-checksum-sha256");
+                    if (ck !== null && ck !== base64(checksum))
+                        throw error("integrity");
+                    if (!r.body)
+                        throw error("integrity");
+                    reader = r.body.getReader();
+                    for (;;) {
+                        let part;
+                        try {
+                            part = await reader.read();
+                        }
+                        catch {
+                            this.check(signal);
+                            break;
+                        }
+                        try {
+                            this.check(signal);
+                            if (part.done)
+                                break;
+                            if (part.value.length > size - got)
+                                throw error("integrity");
+                            out.set(part.value, got);
+                            got += part.value.length;
+                            receive(part.value.length);
+                        }
+                        finally {
+                            part.value?.fill(0);
+                        }
+                    }
+                }
+                finally {
+                    void (reader?.cancel() ?? r.body?.cancel())?.catch(() => { });
+                    reader?.releaseLock();
+                    this.release(r);
+                }
+                if (got === size) {
+                    if (!equal(sha256(out), checksum))
+                        throw error("integrity");
+                    return out;
+                }
+                stalled = got > start ? 0 : stalled + 1;
+            }
+            throw error("unavailable");
+        }
+        catch (e) {
+            out.fill(0);
+            throw e;
+        }
+    }
+    async send(call, options) {
+        let frame = null, sidecar = null, reply = null, object = null, commit = null;
+        const activity = ++this.responseId;
+        let received = 0;
+        this.receiving.set(activity, received);
+        const receive = (bytes) => { received += bytes; this.receiving.set(activity, received); };
+        try {
+            this.check(options.signal);
+            if (uint64(call.endpoint) !== this.endpointId || !(call.frame instanceof Uint8Array) || call.frame.length > MAX_FRAME || (call.sidecar !== undefined && (!(call.sidecar instanceof Uint8Array) || call.sidecar.length > MAX_OBJECT)))
+                throw error("shape");
+            frame = call.frame.slice();
+            sidecar = call.sidecar?.slice() ?? null;
+            const request = this.request(frame);
+            if (sidecar && request.method !== "put_object")
+                throw error("shape");
+            if (request.method === "put_object") {
+                const size = number(request.params.get(3), MAX_OBJECT), ck = bytes(request.params.get(4), 32), inline = request.params.get(5);
+                if (size === 0 || (sidecar !== null && (inline !== undefined || sidecar.length <= 1024 * 1024)) || (sidecar === null && size > 1024 * 1024))
+                    throw error("shape");
+                const body = sidecar ?? bytes(inline);
+                if (body.length !== size || !equal(sha256(body), ck))
+                    throw error("integrity");
+            }
+            reply = await this.rpc(frame, request.method, request.id, options.signal, receive);
+            this.check(options.signal);
+            const response = this.response(reply, request.id);
+            if (response.has(3)) {
+                const result = reply;
+                reply = null;
+                return result;
+            }
+            if (request.method === "put_object") {
+                const result = map(response.get(2)), status = result.get(0);
+                if (status === 0 || status === 2) {
+                    if (result.has(1))
+                        throw error("shape");
+                    const out = reply;
+                    reply = null;
+                    return out;
+                }
+                if (status !== 1 || !sidecar)
+                    throw error("shape");
+                const ck = bytes(request.params.get(4), 32), address = bytes(request.params.get(1), 32);
+                await this.upload(this.direct(result.get(1), ck), sidecar, options.signal);
+                this.check(options.signal);
+                // Host-only IDs occupy a separate descending namespace; never reuse the
+                // original ID. Unary HTTP has no multiplexed outstanding commit scope.
+                if (this.commitId === request.id || this.commitId === 0n)
+                    throw error("unavailable");
+                const id = this.commitId--;
+                commit = encode(new Map([[0, 0], [1, id], [2, "commit_object"], [3, new Map([[0, this.collectionBytes], [1, address]])]]));
+                const committed = await this.rpc(commit, "commit_object", id, options.signal, receive, request.id);
+                try {
+                    this.check(options.signal);
+                    const c = this.response(committed, id), result = c.get(2);
+                    if (c.has(3) || !(result instanceof Map) || result.size !== 1 || result.get(0) !== true)
+                        throw error("unavailable");
+                }
+                finally {
+                    committed.fill(0);
+                }
+                const normalized = new Map(result);
+                normalized.delete(1);
+                normalized.set(0, 0);
+                response.set(2, struct(normalized));
+                return encode(struct(response));
+            }
+            if (request.method === "get_object") {
+                const result = map(response.get(2)), size = number(result.get(2), MAX_OBJECT), ck = bytes(result.get(3), 32);
+                if (size === 0 || result.has(0) === result.has(1))
+                    throw error("shape");
+                const range = request.params.get(2);
+                let offset = 0, count = size;
+                if (range !== undefined) {
+                    if (!Array.isArray(range) || range.length !== 2)
+                        throw error("shape");
+                    offset = number(range[0], MAX_OBJECT);
+                    count = number(range[1], MAX_OBJECT);
+                    if (offset > size || count > size - offset)
+                        throw error("shape");
+                }
+                if (result.has(0)) {
+                    const inline = bytes(result.get(0));
+                    if (inline.length !== count || (count === size && !equal(sha256(inline), ck)))
+                        throw error("integrity");
+                    const out = reply;
+                    reply = null;
+                    return out;
+                }
+                object = await this.download(this.direct(result.get(1), ck), size, ck, options.signal, receive);
+                this.check(options.signal);
+                const normalized = new Map(result);
+                normalized.delete(1);
+                normalized.set(0, object.subarray(offset, offset + count));
+                response.set(2, struct(normalized));
+                return encode(struct(response));
+            }
+            const out = reply;
+            reply = null;
+            return out;
+        }
+        catch (e) {
+            if (e instanceof AppHttpLogError)
+                throw e;
+            if (options.signal.aborted || !this.isCurrent())
+                throw error("fenced");
+            // The CP authority's log-token refusal (e.g. collection_migrating) stays specific.
+            let server = null;
+            try {
+                server = e.server;
+            }
+            catch { /* hostile getter */ }
+            const outcome = isAppServerProblem(server) ? appServerOutcome(server) : null;
+            throw outcome && isAppServerProblem(server) ? new AppHttpLogError(outcome, server) : error("unavailable");
+        }
+        finally {
+            this.receiving.delete(activity);
+            frame?.fill(0);
+            sidecar?.fill(0);
+            reply?.fill(0);
+            object?.fill(0);
+            commit?.fill(0);
+        }
+    }
+}
+//# sourceMappingURL=http-log.js.map