@vincentt-xr/harness 0.4.0 → 1.1.0

package/dist/tunnel/cbor.js

@@ -0,0 +1,403 @@
+/**
+ * The CBOR SUBSET, Node half. It mirrors `api/internal/edge/cbor.go` decision
+ * for decision, because two implementations of one wire format that were
+ * written independently are two implementations that drift.
+ *
+ * It decodes CONTROL payloads only — OPEN and HEAD. It NEVER touches a DATA
+ * payload.
+ *
+ * It is hand-written rather than a library for the same reason the Go one is: a
+ * general CBOR library's allocation behavior on hostile input would be someone
+ * else's decision, and the limits below are the whole point.
+ *
+ * Everything indefinite-length, every tag, every float, every byte string and
+ * every negative integer is REFUSED — not because they are dangerous in
+ * themselves, but because the encoder we own never emits them, so accepting
+ * them would only widen the input this parser has to be correct about.
+ */
+import { MAX_CBOR_DEPTH, MAX_HEADERS, MAX_HEADER_BYTES, MAX_OPEN_PAYLOAD, MAX_PATH_LEN, ProtocolError, } from "./frame.js";
+const MAX_METHOD_LEN = 16;
+const MAX_VIEWER_LABEL_LEN = 11;
+/** Every CBOR error is STREAM-level: the stream dies, the tunnel SURVIVES. */
+function fail(code) {
+    throw new ProtocolError(code, false);
+}
+/**
+ * VIEWER_LABEL_RE is the SAME regex the edge assigns against, and this client
+ * RE-VALIDATES rather than trusting the edge. That is closure (c) of the three
+ * that keep viewer-supplied bytes out of the creator's agent's context: the
+ * label flows viewerLabel -> the relay ring-buffer key -> CLI terminal output
+ * and MCP tool output, which is a terminal/log-injection path INTO the agent,
+ * and a Go-only check would pass on a client that trusted the edge.
+ */
+export const VIEWER_LABEL_RE = /^viewer-[0-9]{1,4}$/;
+export function parseViewerLabel(s) {
+    return VIEWER_LABEL_RE.test(s) ? s : null;
+}
+/**
+ * UA_CLASSES is the CLOSED ENUM OF SIX, mirroring the Go edge. `unknown` is the
+ * TOTAL fallback. This client validates the class it receives against this set
+ * before stamping the relay handshake, so an unmatched or forged class becomes
+ * `unknown` rather than an echo.
+ */
+export const UA_CLASSES = [
+    "ios_safari",
+    "android_chrome",
+    "desktop_chrome",
+    "desktop_safari",
+    "desktop_firefox",
+    "unknown",
+];
+export function parseUAClass(s) {
+    return UA_CLASSES.includes(s) ? s : "unknown";
+}
+/**
+ * CONTROL_ARITY is the EXACT map length per kind, mirroring controlArity in the
+ * Go edge. The grammar stays closed per-kind rather than becoming "one or two
+ * keys, whatever arrives": a decoder that accepts a viewerLabel on `revoke`, or
+ * omits it on `viewer_gone`, is a decoder with a shape the encoder never emits.
+ */
+const CONTROL_ARITY = new Map([
+    ["revoke", 1],
+    ["expiring", 1],
+    ["superseded", 1],
+    ["viewer_gone", 2],
+]);
+// ---- decoding ---------------------------------------------------------------
+class Reader {
+    b;
+    i = 0;
+    depth = 1;
+    constructor(b) {
+        this.b = b;
+    }
+    /**
+     * head reads a CBOR initial byte and its argument. Indefinite-length
+     * (ai === 31) is REFUSED outright: it is the one CBOR shape whose length is
+     * not knowable before reading, which is the property every limit depends on.
+     */
+    head() {
+        if (this.i >= this.b.length)
+            fail("cbor_malformed");
+        const c = this.b[this.i++];
+        const major = c >> 5;
+        const ai = c & 0x1f;
+        if (ai < 24)
+            return { major, arg: ai };
+        if (ai === 24) {
+            if (this.i >= this.b.length)
+                fail("cbor_malformed");
+            return { major, arg: this.b[this.i++] };
+        }
+        if (ai === 25) {
+            if (this.i + 2 > this.b.length)
+                fail("cbor_malformed");
+            const v = (this.b[this.i] << 8) + this.b[this.i + 1];
+            this.i += 2;
+            return { major, arg: v };
+        }
+        if (ai === 26) {
+            if (this.i + 4 > this.b.length)
+                fail("cbor_malformed");
+            const v = this.b[this.i] * 0x1000000 +
+                (this.b[this.i + 1] << 16) +
+                (this.b[this.i + 2] << 8) +
+                this.b[this.i + 3];
+            this.i += 4;
+            return { major, arg: v };
+        }
+        if (ai === 27) {
+            if (this.i + 8 > this.b.length)
+                fail("cbor_malformed");
+            let v = 0;
+            for (let k = 0; k < 8; k++)
+                v = v * 256 + this.b[this.i + k];
+            this.i += 8;
+            return { major, arg: v };
+        }
+        // 28..30 reserved; 31 indefinite-length. Both refused.
+        return fail("cbor_malformed");
+    }
+    /**
+     * text reads a definite-length UTF-8 string, bounded by `max` BEFORE the
+     * slice is taken — so a declared 4 GiB string costs a comparison, not a copy.
+     */
+    text(max) {
+        const { major, arg } = this.head();
+        if (major !== 3)
+            fail("cbor_malformed");
+        if (arg > max)
+            fail("cbor_malformed");
+        if (this.i + arg > this.b.length)
+            fail("cbor_malformed");
+        const s = new TextDecoder("utf-8", { fatal: false }).decode(this.b.subarray(this.i, this.i + arg));
+        this.i += arg;
+        return s;
+    }
+    uint(max) {
+        const { major, arg } = this.head();
+        if (major !== 0 || arg > max)
+            fail("cbor_malformed");
+        return arg;
+    }
+    /**
+     * headerPairs reads a map of text->text, enforcing MAX_HEADERS and
+     * MAX_HEADER_BYTES as it goes. The COUNT bound is checked against the
+     * DECLARED map size before a single pair is read, so a payload claiming 2^32
+     * headers allocates nothing.
+     */
+    headerPairs() {
+        this.depth++;
+        if (this.depth > MAX_CBOR_DEPTH)
+            fail("cbor_depth");
+        try {
+            const { major, arg } = this.head();
+            if (major !== 5)
+                fail("cbor_malformed");
+            if (arg > MAX_HEADERS)
+                fail("cbor_headers");
+            const out = [];
+            let total = 0;
+            for (let k = 0; k < arg; k++) {
+                const name = this.text(MAX_HEADER_BYTES);
+                const val = this.text(MAX_HEADER_BYTES);
+                total += name.length + val.length;
+                if (total > MAX_HEADER_BYTES)
+                    fail("cbor_header_bytes");
+                out.push([name, val]);
+            }
+            return out;
+        }
+        finally {
+            this.depth--;
+        }
+    }
+}
+export function decodeOpen(b) {
+    if (b.length > MAX_OPEN_PAYLOAD)
+        fail("open_payload_too_large");
+    const r = new Reader(b);
+    const { major, arg } = r.head();
+    if (major !== 5 || arg > 8)
+        fail("cbor_malformed");
+    let viewerLabel;
+    let method;
+    let path;
+    let headers = [];
+    let upgrade;
+    for (let k = 0; k < arg; k++) {
+        const key = r.text(32);
+        switch (key) {
+            case "viewerLabel": {
+                const raw = r.text(MAX_VIEWER_LABEL_LEN);
+                // RE-VALIDATED here, not merely trusted because the edge assigned it.
+                const parsed = parseViewerLabel(raw);
+                if (parsed === null)
+                    fail("cbor_viewer");
+                viewerLabel = parsed;
+                break;
+            }
+            case "method":
+                method = r.text(MAX_METHOD_LEN);
+                break;
+            case "path": {
+                const p = r.text(MAX_PATH_LEN + 1);
+                if (p.length > MAX_PATH_LEN)
+                    fail("cbor_path_len");
+                path = p;
+                break;
+            }
+            case "headers":
+                headers = r.headerPairs();
+                break;
+            case "upgrade":
+                upgrade = r.text(32);
+                break;
+            default:
+                // An unknown key is a MALFORMED payload, not a skipped field. Skipping
+                // would mean accepting bytes we do not understand on the one payload
+                // this client parses.
+                fail("cbor_malformed");
+        }
+    }
+    if (viewerLabel === undefined || method === undefined || path === undefined) {
+        fail("cbor_malformed");
+    }
+    // Trailing bytes after a complete payload are a second message hiding in one
+    // frame.
+    if (r.i !== b.length)
+        fail("cbor_malformed");
+    const out = { viewerLabel, method, path, headers };
+    if (upgrade !== undefined)
+        out.upgrade = upgrade;
+    return out;
+}
+export function decodeHead(b) {
+    if (b.length > MAX_OPEN_PAYLOAD)
+        fail("open_payload_too_large");
+    const r = new Reader(b);
+    const { major, arg } = r.head();
+    if (major !== 5 || arg > 4)
+        fail("cbor_malformed");
+    let status;
+    let headers = [];
+    for (let k = 0; k < arg; k++) {
+        const key = r.text(32);
+        switch (key) {
+            case "status": {
+                const v = r.uint(0xffff);
+                // A status outside 100..599 is a protocol violation and never a
+                // relayed status.
+                if (v < 100 || v > 599)
+                    fail("cbor_status");
+                status = v;
+                break;
+            }
+            case "headers":
+                headers = r.headerPairs();
+                break;
+            default:
+                fail("cbor_malformed");
+        }
+    }
+    if (status === undefined)
+        fail("cbor_malformed");
+    if (r.i !== b.length)
+        fail("cbor_malformed");
+    return { status, headers };
+}
+/**
+ * The map arity is asserted AGAINST THE KIND, so a payload claiming `revoke`
+ * with a trailing label is refused as malformed rather than quietly accepted
+ * with the extra key ignored.
+ */
+export function decodeControl(b) {
+    if (b.length > MAX_OPEN_PAYLOAD)
+        fail("open_payload_too_large");
+    const r = new Reader(b);
+    const { major, arg } = r.head();
+    if (major !== 5)
+        fail("cbor_malformed");
+    if (r.text(32) !== "kind")
+        fail("cbor_malformed");
+    const v = r.text(32);
+    const want = CONTROL_ARITY.get(v);
+    if (want === undefined || arg !== want)
+        fail("cbor_malformed");
+    const kind = v;
+    let viewerLabel;
+    if (kind === "viewer_gone") {
+        if (r.text(32) !== "viewerLabel")
+            fail("cbor_malformed");
+        // Parsed, not copied: the label reaches the creator's terminal.
+        const raw = r.text(MAX_VIEWER_LABEL_LEN);
+        if (parseViewerLabel(raw) === null)
+            fail("cbor_viewer");
+        viewerLabel = raw;
+    }
+    if (r.i !== b.length)
+        fail("cbor_malformed");
+    return viewerLabel === undefined ? { kind } : { kind, viewerLabel };
+}
+// ---- encoding ---------------------------------------------------------------
+/**
+ * The encoder emits CANONICAL CBOR for the subset: definite lengths, shortest
+ * integer encoding, and map keys in a fixed order, with header pairs SORTED.
+ *
+ * Canonicality is what makes the checked-in golden fixture comparable
+ * byte-for-byte against BOTH implementations' output. A non-deterministic
+ * encoder would make the fixture assertable in one direction only.
+ */
+function head(major, arg) {
+    const m = major << 5;
+    if (arg < 24)
+        return [m | arg];
+    if (arg <= 0xff)
+        return [m | 24, arg];
+    if (arg <= 0xffff)
+        return [m | 25, (arg >>> 8) & 0xff, arg & 0xff];
+    if (arg <= 0xffffffff) {
+        return [
+            m | 26,
+            (arg >>> 24) & 0xff,
+            (arg >>> 16) & 0xff,
+            (arg >>> 8) & 0xff,
+            arg & 0xff,
+        ];
+    }
+    const out = [m | 27];
+    let v = arg;
+    const bytes = [];
+    for (let k = 0; k < 8; k++) {
+        bytes.unshift(v % 256);
+        v = Math.floor(v / 256);
+    }
+    return out.concat(bytes);
+}
+function text(s) {
+    const b = Array.from(new TextEncoder().encode(s));
+    return head(3, b.length).concat(b);
+}
+function headerMap(h) {
+    // Sorted by name then value, so two encoders handed the same headers in a
+    // different order still produce the same bytes.
+    const sorted = [...h].sort((a, b) => a[0] === b[0] ? (a[1] < b[1] ? -1 : 1) : a[0] < b[0] ? -1 : 1);
+    let out = head(5, sorted.length);
+    for (const [k, v] of sorted)
+        out = out.concat(text(k), text(v));
+    return out;
+}
+/** Canonical key order: viewerLabel, method, path, headers, [upgrade]. */
+export function encodeOpen(p) {
+    if (parseViewerLabel(p.viewerLabel) === null)
+        fail("cbor_viewer");
+    if (p.path.length > MAX_PATH_LEN)
+        fail("cbor_path_len");
+    if (p.headers.length > MAX_HEADERS)
+        fail("cbor_headers");
+    const n = p.upgrade ? 5 : 4;
+    let out = head(5, n);
+    out = out.concat(text("viewerLabel"), text(p.viewerLabel));
+    out = out.concat(text("method"), text(p.method));
+    out = out.concat(text("path"), text(p.path));
+    out = out.concat(text("headers"), headerMap(p.headers));
+    if (p.upgrade)
+        out = out.concat(text("upgrade"), text(p.upgrade));
+    const b = new Uint8Array(out);
+    if (b.length > MAX_OPEN_PAYLOAD)
+        fail("open_payload_too_large");
+    return b;
+}
+/** Canonical key order: status, headers. */
+export function encodeHead(p) {
+    if (p.status < 100 || p.status > 599)
+        fail("cbor_status");
+    if (p.headers.length > MAX_HEADERS)
+        fail("cbor_headers");
+    let out = head(5, 2);
+    out = out.concat(text("status"), head(0, p.status));
+    out = out.concat(text("headers"), headerMap(p.headers));
+    const b = new Uint8Array(out);
+    if (b.length > MAX_OPEN_PAYLOAD)
+        fail("open_payload_too_large");
+    return b;
+}
+export function encodeControl(kind, viewerLabel) {
+    const arity = CONTROL_ARITY.get(kind);
+    if (arity === undefined)
+        fail("cbor_malformed");
+    if (kind === "viewer_gone") {
+        if (viewerLabel === undefined || parseViewerLabel(viewerLabel) === null) {
+            fail("cbor_viewer");
+        }
+    }
+    else if (viewerLabel !== undefined) {
+        // A label on a terminal kind is a caller bug, refused rather than dropped.
+        fail("cbor_malformed");
+    }
+    const out = head(5, arity).concat(text("kind"), text(kind));
+    if (kind === "viewer_gone") {
+        out.push(...text("viewerLabel"), ...text(viewerLabel));
+    }
+    return new Uint8Array(out);
+}

package/dist/tunnel/client.d.ts

@@ -0,0 +1,219 @@
+/**
+ * The tunnel client: the creator's side of the wire.
+ *
+ * It opens ONE outbound WSS connection to the edge and multiplexes every
+ * viewer's request onto it. Nothing dials INTO the creator's machine; the
+ * client never opens a stream, and the edge rejects an even streamId from it as
+ * a protocol violation.
+ *
+ * What this file does NOT do, deliberately:
+ *   - it does not parse a DATA payload (they are opaque here too);
+ *   - it does not follow a redirect on the creator's behalf;
+ *   - it does not trust the edge's viewerLabel or ua-class without
+ *     re-validating both against the same regex and the same closed enum.
+ */
+import { WebSocket } from "ws";
+import { encodeCredit } from "./frame.js";
+import { type ControlKind, type UAClass } from "./cbor.js";
+import { type ForwardTarget } from "./forwardTarget.js";
+/**
+ * VIEWER_STAMP_HEADER carries the VALIDATED label to the creator's own local
+ * server, so the relay can key its ring buffer by viewer.
+ *
+ * The stamp happens HERE, on the creator's side of the wire, which is the whole
+ * point of 2.8: the device never chooses its own label, and the value written
+ * has already passed parseViewerLabel. It is added AFTER sanitizeHeaders, so a
+ * viewer-supplied header of the same name cannot survive to shadow it.
+ */
+export declare const VIEWER_STAMP_HEADER = "x-vincentt-viewer";
+export declare const UA_CLASS_STAMP_HEADER = "x-vincentt-ua-class";
+/**
+ * RESUME_HEADER is ONE spelling for both halves of the wire: the edge writes it
+ * on the 101 (`ResumeHeader` in `internal/edge/websocket.go`), and this client
+ * sends it back on the next dial.
+ *
+ * It is lower-case here because Node lower-cases every response header name,
+ * and `res.headers["X-Vincentt-Resume"]` is silently `undefined`. That mistake
+ * would reproduce the exact defect this constant exists to fix — a client that
+ * never learns its next credential — with a fully green suite, so the casing is
+ * asserted by a test rather than trusted.
+ */
+export declare const RESUME_HEADER = "x-vincentt-resume";
+/**
+ * SESSION_HEADER carries the sessionId hex on the RECONNECT dial only.
+ *
+ * It exists because the reconnect path carries NO GRANT
+ * (`D-The-reconnect-path-carries-no-grant`), and the grant is what used to carry
+ * the session id in its signed `sid` claim. With the grant gone the edge has no
+ * other way to name the row, so the id travels as its own header.
+ *
+ * It is NOT a secret — it is an ObjectID the edge immediately parses with
+ * `primitive.ObjectIDFromHex` before it touches anything (`ingress.go:288`) —
+ * but exactly one must be sent: the edge refuses duplicates on all three
+ * credential-bearing headers with `Header.Values()` rather than `Get`, because
+ * `Get` silently returns the first value and that is the bypass being closed
+ * (`ingress.go:120-126`).
+ *
+ * Lower-case for the same reason as RESUME_HEADER: Node normalizes header names.
+ */
+export declare const SESSION_HEADER = "x-vincentt-session";
+/** The Authorization header, named once so the never-send-both rule cites it. */
+export declare const AUTHORIZATION_HEADER = "authorization";
+/**
+ * RESUME_TOKEN_LEN is base64url(32 random bytes), unpadded. It mirrors
+ * `resumeTokenLen` in the Go edge so the two ends of this wire state the same
+ * fact rather than each carrying a magic number.
+ */
+export declare const RESUME_TOKEN_LEN = 43;
+/**
+ * parseResumeToken accepts only the grammar the API's issuer produces.
+ *
+ * ABSENCE IS LEGITIMATE, not an error: the edge OMITS the header rather than
+ * emitting it empty when it has no token to hand over, and the handshake still
+ * succeeds. The cost is one reconnect, which is recoverable — treating it as
+ * fatal would turn a token problem into a dead preview.
+ *
+ * A malformed value is discarded for the same reason it is validated at the
+ * edge before being written: this value is concatenated into an outbound header
+ * on the next dial, and a CR or LF in it would not be a bad credential, it
+ * would be a second request.
+ */
+export declare function parseResumeToken(raw: unknown): string | null;
+export interface TunnelClientOptions {
+    /** The edge's tunnel ingress: wss://edge-<env>.vincentt.studio/tunnel. */
+    readonly edgeUrl: string;
+    /**
+     * The opaque JWS the API minted. THE CLIENT NEVER PARSES IT.
+     *
+     * READONLY AND SINGLE-ASSIGNMENT, and that is a design property rather than
+     * style (`D-Client-holds-one-credential-per-state`). It is a FIRST-ATTACH
+     * credential and nothing else: 10-minute TTL, spent by the attach CAS, and
+     * never presented again. Two withdrawn designs needed a mutable grant field so
+     * the client could hold a second, longer-lived grant for the reconnect path;
+     * both were falsified, and the field staying readonly is what makes the
+     * "which credential for which door" question unaskable here.
+     */
+    readonly grant: string;
+    /**
+     * The session id hex from the MINT response, sent as X-Vincentt-Session on
+     * every redial. Not a credential — the reconnect path's two conditions are the
+     * resume token's single-use consume and the tunnel-slot CAS, both enforced by
+     * state at the API.
+     */
+    readonly sessionId: string;
+    readonly target: ForwardTarget;
+    /** onViewer is the CLI's connect line. It receives only VALIDATED values. */
+    readonly onViewer?: (label: string, uaClass: UAClass) => void;
+    /**
+     * onViewerGone is the CLI's disconnect line — the other half of onViewer.
+     *
+     * onViewer fires per OPEN frame (so the roster dedupes by label); this fires
+     * ONCE, when the viewer's connection closes. Without it the roster only ever
+     * grows: for a long time the edge logged the detach server-side and told the
+     * client nothing, so a phone refreshing read as an arriving crowd.
+     */
+    readonly onViewerGone?: (label: string) => void;
+    /** onControl carries revoke/expiring/superseded so the CLI prints the right ending. */
+    readonly onControl?: (kind: ControlKind) => void;
+    /** onOriginError is the creator-facing detail the 502 page must never carry. */
+    readonly onOriginError?: (label: string, code: string) => void;
+    readonly onStateChange?: (state: TunnelState) => void;
+    /**
+     * onTunnelError carries the error CODE of a failed dial (`ECONNREFUSED`,
+     * `CERT_HAS_EXPIRED`, …). Never the message: an error string from a TLS or
+     * HTTP layer can carry the URL, and the URL is the capability.
+     */
+    readonly onTunnelError?: (code: string) => void;
+    /**
+     * onReconnectRefused fires when the EDGE ANSWERED and refused a reconnect —
+     * a real HTTP status on the upgrade, not a transport failure.
+     *
+     * It exists because a refused reconnect stopped being routine noise: the edge
+     * emits `preview.resume_token_rejected` on it, which QA and security made an
+     * alertable theft signal, and the honest client is not supposed to trigger it.
+     * Without this callback the client retried silently forever and the creator
+     * watched "Reconnecting…" for a session that was already unrecoverable.
+     *
+     * The three statuses are deliberately distinguishable rather than collapsed
+     * (`ingress.go:299-310`): 401 the token was refused, 409 another tunnel holds
+     * this preview, 410 the session is gone. They map to different creator actions.
+     */
+    readonly onReconnectRefused?: (status: number) => void;
+    /** Injectable for tests; never a real socket in a unit test. */
+    readonly connect?: (url: string, headers: Record<string, string>) => WebSocket;
+}
+export type TunnelState = "connecting" | "live" | "reconnecting" | "closed";
+export declare class TunnelClient {
+    private readonly opts;
+    private ws;
+    private decoder;
+    private readonly streams;
+    /**
+     * resumeToken is 32 random bytes, single-use, rotated on every attach, bound
+     * to the session, 5-minute TTL. It is held in memory only and NEVER logged:
+     * "single-use" is enforced by the API's atomic consume, and a token in a log
+     * is a credential in a log.
+     */
+    private resumeToken;
+    private attempt;
+    private closed;
+    private state;
+    private pingTimer;
+    private lastPong;
+    constructor(opts: TunnelClientOptions);
+    start(): void;
+    close(): void;
+    private setState;
+    /**
+     * THE DIAL RULE. One boolean, two disjoint states, one credential each.
+     *
+     *   first dial   (resumeToken === null):  Authorization: Bearer <mint grant>
+     *   every redial (resumeToken !== null):  X-Vincentt-Resume + X-Vincentt-Session
+     *
+     * This function is the WIRING of `D-Client-holds-one-credential-per-state`:
+     * every dial's header set is built here and nowhere else, so the never-send-both
+     * rule is a property of one `if/else` rather than of a convention.
+     *
+     * NEVER BOTH, and this is the rule most likely to be "helpfully" broken later.
+     * The edge REFUSES a request carrying a grant alongside a valid resume token
+     * (`ingress.go:144-148`) — it does not ignore the grant — so adding
+     * `Authorization` here "for robustness" would break every reconnect while
+     * passing every functional test in the suite except the negative that exists
+     * for exactly this. The reason it is a refusal rather than a preference: a
+     * header that is sometimes meaningful and sometimes ignored is a branch waiting
+     * to be written.
+     *
+     * There is no per-door judgement to get wrong because the states are disjoint:
+     * the grant is spent by the attach CAS the moment the first dial succeeds, and
+     * a resume token only ever exists after a 101 has delivered one.
+     */
+    private dialHeaders;
+    private open;
+    private onClosed;
+    private startPing;
+    private stopPing;
+    private send;
+    private onBytes;
+    private dispatch;
+    /**
+     * serveOpen forwards ONE viewer request to the single configured target.
+     *
+     * Every 2.15.4 rule executes here, in order: the target is the configured one
+     * (never from the request), the request target is normalized-then-checked,
+     * the viewer's routing headers are dropped, loopback is RE-CHECKED at connect,
+     * and no redirect is followed.
+     */
+    private serveOpen;
+    /**
+     * serveUpgrade splices ONE viewer's WebSocket to the creator's local server.
+     *
+     * It re-issues the handshake over a raw socket rather than using an HTTP
+     * client, because Node's `http` module owns the connection after a 101 and
+     * will not hand back a usable duplex without the same hijack this does
+     * explicitly. The response's status line and headers are parsed only far
+     * enough to build the HEAD frame; every byte after the blank line is OPAQUE
+     * and is forwarded without being read.
+     */
+    private serveUpgrade;
+}
+export { encodeCredit };