@wenathlan/devthink 1.1.16 → 2.0.2

package/http.d.ts

@@ -0,0 +1,636 @@
+/** The http module of the 1.1.88 consolidation: every correlated variation of the http logic interned in this one file, so the module family carries one surface without duplicate variations. */
+import type { endpointrecord, fetchrequest, fetchoptions, graphqlrequest, htmlquery, jsonpathrule, parsedfield, payloadschema, streamwindow, jsonrpcframe, mcpserverconfig, sessiontoken, tlsconfig, transportkind, allowlistentry, clientrecord, httpstreamconfig, rpcerror, streamchannel, relayserverstate, relayserversession, serverenvelope } from "./types.js";
+/**
+ * Network observation part one logics for the 1.1.42 family.
+ * Every correlated rule for the outbound fetch with timeout, retries, backoff and the redirect follow limit, the streamed reading of large bodies inside a byte budget, the dotted json path extraction, the html query evaluation over a parse seam, the typed rest call with payload schemas and url templating and the graphql envelope wrapping and unwrapping lives in this file.
+ * Header values and body bytes never enter any audit summary built from these results.
+ */
+/** The network observation kinds, listed among the available capabilities of every proposal request. */
+export declare const httpkinds: string[];
+/** One transport response as the seam reports it: status, response headers, body text and redirect facts. */
+export interface transportresponse {
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+    /** Location of a readable redirect response, when the transport exposes one. */
+    location?: string;
+    redirected?: boolean;
+}
+/** Transport seam signature: one reviewed request against one url; the extension executor wires the browser fetch, tests wire plain fixtures. */
+export type fetchtransport = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body?: string;
+    mode?: string;
+    redirect: "follow" | "error";
+}) => Promise<transportresponse>;
+/** Transport facts of one completed outbound request: status, response header names, body, byte size, duration, retries and redirect hops. */
+export interface calltransport {
+    url: string;
+    status: number;
+    statusclass: string;
+    headernames: string[];
+    body: string;
+    bytes: number;
+    duration: number;
+    retries: number;
+    redirects: number;
+}
+/** Maps one response status to its reviewed status class: informational, success, redirect, clienterror, servererror or unknown. */
+export declare function statusclassof(status: number): "informational" | "success" | "redirect" | "clienterror" | "servererror" | "unknown";
+/** Interpolates a reviewed url template by replacing every {variable} with the reviewed payload value of that name. */
+export declare function templateurl(template: string, values: Record<string, unknown>): string;
+/** Normalizes a reviewed fetch request value: url, method, custom header allowlist, body and mode; unknown fields stay ignored. */
+export declare function fetchrequestof(value: unknown): fetchrequest | undefined;
+/** Normalizes reviewed fetch policy options: timeout, retries, backoff base and redirect follow limit stay user choices with no code ceiling. */
+export declare function fetchoptionsof(value: unknown): fetchoptions;
+/** Normalizes a reviewed stream window: the byte budget ceiling stays a user choice. */
+export declare function streamwindowof(value: unknown): streamwindow;
+/** Normalizes reviewed json path rules: every rule needs a field name and a dotted path; kind and default stay optional. */
+export declare function jsonpathrulesof(value: unknown): jsonpathrule[];
+/** Normalizes reviewed html queries: selector, optional attribute and the multi flag for all matches versus the first. */
+export declare function htmlqueriesof(value: unknown): htmlquery[];
+/** Normalizes a reviewed graphql request: operation text, operation kind, variables and operation name. */
+export declare function graphqlrequestof(value: unknown): graphqlrequest | undefined;
+/**
+ * Sends one reviewed outbound request through the transport seam with the reviewed timeout, retries, backoff and redirect follow limit.
+ * Every bound stays a reviewed choice: the timeout races each attempt, failed attempts wait backoff times the attempt number before the retry, and redirect hops beyond the follow limit refuse instead of following.
+ */
+export declare function sendfetch(input: {
+    request: fetchrequest;
+    options?: fetchoptions;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    onretry?: (attempt: number, wait: number, reason: string) => void;
+    now?: () => number;
+}): Promise<calltransport>;
+/**
+ * Consumes a large response body in chunks inside the reviewed stream window: every chunk passes the reviewed handler path, the byte budget aborts past the ceiling and the abort flag stops the stream cleanly between chunks.
+ */
+export declare function readstream(input: {
+    chunks: string[] | (() => Promise<string | undefined>);
+    window: streamwindow;
+}): Promise<{
+    chunks: number;
+    bytes: number;
+    aborted: boolean;
+    reason?: string;
+}>;
+/**
+ * Extracts named fields from one parsed json body by dotted paths: array indexes use numeric segments, a miss fills the reviewed default and reports the miss instead of crashing, and every value carries its reviewed kind.
+ */
+export declare function readpath(parsed: unknown, rules: jsonpathrule[]): parsedfield[];
+/** One element match of an html query as the parse seam reports it: text content plus attribute values. */
+export interface htmlmatch {
+    text: string;
+    attributes: Record<string, string>;
+}
+/** The parsed document seam: one query function over fetched markup; the page bridge supplies the real domparser. */
+export interface parseddocument {
+    query(selector: string): htmlmatch[];
+}
+/** Parse seam signature: turns fetched markup into a queryable document. */
+export type domparse = (markup: string) => parseddocument;
+/** Result of one reviewed html query: attribute values or text, the element count and the multi flag. */
+export interface htmlqueryresult {
+    selector: string;
+    attribute?: string;
+    multi: boolean;
+    count: number;
+    values: string[];
+}
+/**
+ * Parses fetched markup through the parse seam and runs the reviewed html queries: every query returns attribute values or text plus the element count, and the multi flag widens the first match to every match.
+ */
+export declare function parsehtmlbody(input: {
+    body: string;
+    queries: htmlquery[];
+    parse?: domparse;
+}): htmlqueryresult[];
+/** Validates one reviewed payload against an endpoint payload schema: every required field must be present with its kind; extra fields pass through as reviewed values. */
+export declare function payloadvalid(payload: Record<string, unknown>, schema: payloadschema | undefined): {
+    ok: boolean;
+    errors: string[];
+};
+/** Applies the schema defaults to one reviewed payload: missing optional fields gain their reviewed default values. */
+export declare function payloadwithdefaults(payload: Record<string, unknown>, schema: payloadschema | undefined): Record<string, unknown>;
+/**
+ * Executes one typed rest endpoint call: the payload validates against the endpoint payload schema, the url templates its variables from the reviewed values, the reviewed success status list (or the two hundred class by default) maps the response code to the step outcome and json error bodies parse into structured errors.
+ */
+export declare function callrest(input: {
+    endpoint: endpointrecord;
+    payload: Record<string, unknown>;
+    options?: fetchoptions;
+    transport: fetchtransport;
+    success?: number[];
+    sleep?: (milliseconds: number) => Promise<void>;
+    onretry?: (attempt: number, wait: number, reason: string) => void;
+    now?: () => number;
+}): Promise<{
+    transport: calltransport;
+    url: string;
+    payload: Record<string, unknown>;
+    ok: boolean;
+    errors: string[];
+}>;
+/** Wraps one reviewed graphql request into the request body envelope with the operation text, the variables and the operation name. */
+export declare function graphqlopenvelope(request: graphqlrequest): string;
+/** Unwraps a graphql response into its data block and every returned error mapped to a plain string. */
+export declare function unwrapgraphql(value: unknown): {
+    data?: unknown;
+    errors: string[];
+};
+/**
+ * Executes one reviewed graphql query or mutation against a typed endpoint: the operation wraps with its variables and operation name, and the response unwraps its data block while every returned error maps into the step result details.
+ */
+export declare function callgraphql(input: {
+    endpoint: endpointrecord;
+    request: graphqlrequest;
+    options?: fetchoptions;
+    transport: fetchtransport;
+    sleep?: (milliseconds: number) => Promise<void>;
+    onretry?: (attempt: number, wait: number, reason: string) => void;
+    now?: () => number;
+}): Promise<{
+    transport: calltransport;
+    data?: unknown;
+    errors: string[];
+}>;
+/**
+ * Http transport of the 1.1.84 mcp server mode.
+ * Every streamable http concern lives in this file: the localhost bind with its documented default and the reviewed remote bind behind the explicit review, the posted envelope intake that parses one posted json rpc message — a bare frame or a batch — through the same frame pipeline the remote family owns, the server sent event frames of the stream channel with their event ids so a client resumes after a reconnect, the tls decision that turns on exactly when the user provides a certificate while an unverified peer refuses under the required mode, and the auth handshake requirement that keeps every non localhost connection behind the token exchange while localhost stays direct.
+ * The transport stays pure: the node listener reaches it through injected seams only, the bind, the port, the endpoint path and the tls material stay user choices with no code default beyond the documented localhost bind, and no certificate, endpoint or provider is ever hardcoded.
+ */
+/** Builds the http transport endpoint record of one server config: the bind with its port, the localhost state and the posted endpoint path the streamable transport serves. */
+export declare function httpendpoint(config: mcpserverconfig): {
+    kind: transportkind;
+    endpoint: string;
+    bind: string;
+    port: number;
+    localhost: boolean;
+    path: string;
+};
+/** Decides the tls termination of one http transport: the transport speaks tls exactly when the user provides a certificate, the presented fingerprint must match the reviewed one under the required mode and an unverified peer refuses while the off mode keeps the plain localhost listener. */
+export declare function tlsdecision(input: {
+    config: tlsconfig;
+    presented?: {
+        fingerprint?: string;
+    };
+    now: number;
+}): {
+    tls: boolean;
+    verified: boolean;
+    reason?: string;
+};
+/** Requires the auth handshake of one posted frame: a localhost connection stays direct while any non localhost connection must present a verified session token through the same pipeline the remote family owns — the pipeline answers the refusal error the listener returns. */
+export declare function postauth(input: {
+    config: mcpserverconfig;
+    local: boolean;
+    tokens: sessiontoken[];
+    rawtoken?: string;
+    fingerprint?: string;
+    toolname?: string;
+    now: number;
+}): Promise<{
+    error?: {
+        code: string;
+        message: string;
+        retryhint: "retry" | "wait" | "none";
+    };
+    token?: sessiontoken;
+}>;
+/** Parses one posted body into its wire message: a bare frame parses as itself, an array parses as a batch and anything else refuses with the parse error the listener answers. */
+export declare function parsepost(body: string): {
+    message?: jsonrpcframe | jsonrpcframe[];
+    error?: {
+        code: string;
+        message: string;
+    };
+};
+/** Encodes the http answer of one handled frame: the json body the post returns with its newline terminator so a line reader consumes it too. */
+export declare function httpanswer(frame: jsonrpcframe): string;
+/** Formats one server sent event of the stream channel: the event id the client resumes after, the event name and the json data line pair; the id advances with every event the channel emits. */
+export declare function sseframe(input: {
+    id: number;
+    event: string;
+    frame: jsonrpcframe;
+}): string;
+/** Builds the stream channel endpoint record of one server config: the stream path beside the posted endpoint, on the same localhost bind and port while the channel rides its own path. */
+export declare function streampathof(config: mcpserverconfig): {
+    path: string;
+    bind: string;
+    port: number;
+    localhost: boolean;
+};
+/** Answers whether one requested path is the posted endpoint or the stream channel of the configured transport; any other path refuses with the method error. */
+export declare function routepath(config: mcpserverconfig, path: string): "endpoint" | "stream" | undefined;
+/** The documented bind of the http listener: localhost only, kept beside the transport so the serve state and the docs share one name. */
+export declare const documentedbind = "127.0.0.1";
+/**
+ * Http stream transport of the 1.1.55 agent protocol part two.
+ * Every remote transport concern lives in this file: the http stream config with the posted json rpc endpoint and the server sent event channel paths, the stream channels the server keeps open for client streams, the heartbeat rhythm that keeps idle channels alive and closes dead ones, the tls termination that requires valid certificates before any remote traffic, the user configured client ceiling, the remote status report of endpoint, tls and client counts, and the ordered frame pipeline that terminates tls first, verifies the session token on every frame, checks the allowlist and runs the namespace scope check before any consent gate — auth failures answer with one fixed json rpc error so the pairing state never leaks.
+ * The transport stays honest: the browser runtime exposes no listening socket, so the frame intake rides the same seam as the stdio bridge while the endpoint, tls mode, heartbeat and ceiling all stay user configured with no code ceiling and no hardcoded endpoint or certificate.
+ */
+/** The documented default heartbeat interval of the event channels; any user configured rhythm wins. */
+export declare const defaultheartbeatms = 30000;
+/** The documented default idle window after which a silent channel counts as dead; any user configured window wins. */
+export declare const defaultidlewindowms = 90000;
+/** The documented default http stream config: the posted json rpc endpoint path, the server sent event channel path, tls off for the localhost default and the documented heartbeat rhythm. */
+export declare function defaulthttpstream(): httpstreamconfig;
+/** Opens one server sent event channel for a remote client stream: the open and first heartbeat times ride the record. */
+export declare function openstreamchannel(input: {
+    clientid: string;
+    now: number;
+    id?: string;
+}): streamchannel;
+/** Stamps one heartbeat on every open channel of a client so idle channels stay alive. */
+export declare function heartbeat(input: {
+    channels: streamchannel[];
+    clientid: string;
+    now: number;
+}): streamchannel[];
+/** Reports whether one channel stays live: an open channel inside its idle window counts as alive while closed channels and silent ones past the window count as dead. */
+export declare function channellive(channel: streamchannel, now: number, idlewindow?: number): boolean;
+/** Closes every dead channel: silent channels past the user configured idle window close while live channels stay open. */
+export declare function closeidlechannels(input: {
+    channels: streamchannel[];
+    now: number;
+    idlewindow?: number;
+}): streamchannel[];
+/** Terminates tls before any remote traffic: the off mode keeps the documented localhost default, the on mode negotiates while the required mode refuses any peer without a valid certificate that matches the user configured fingerprint. */
+export declare function starttls(input: {
+    config: tlsconfig;
+    presented?: {
+        fingerprint?: string;
+    };
+    now: number;
+}): {
+    tls: boolean;
+    verified: boolean;
+    reason?: string;
+};
+/** Enforces the user configured client ceiling: a configured maximum refuses connections past it while an absent value keeps the client count unbounded. */
+export declare function enforcemaxclients(input: {
+    clients: clientrecord[];
+    maxclients?: number;
+}): {
+    allowed: boolean;
+    reason?: string;
+};
+/** Reports the remote transport status: the advertised endpoint, the tls state, the client counts, the open and dead stream channels and the live token count. */
+export declare function listremotestatus(input: {
+    config: mcpserverconfig;
+    channels: streamchannel[];
+    clients: clientrecord[];
+    tokens: sessiontoken[];
+    now: number;
+}): {
+    endpoint: string;
+    tls: {
+        mode: string;
+        certificaterequired: boolean;
+        verified: boolean;
+    };
+    clients: number;
+    paired: number;
+    channelsopen: number;
+    channelsdead: number;
+    tokenslive: number;
+};
+/**
+ * Runs the ordered intake pipeline of one remote frame: tls terminates first, the session token verifies on every frame, the allowlist refuses unknown fingerprints and the namespace scope check runs before any consent gate so unknown tools fail fast.
+ * A clean frame returns the verified token; every failure returns its json rpc error while auth failures answer with the fixed message that leaks no pairing state.
+ */
+export declare function httpframepipeline(input: {
+    config: mcpserverconfig;
+    presented?: {
+        fingerprint?: string;
+    };
+    tokens: sessiontoken[];
+    rawtoken?: string;
+    allowlist: allowlistentry[];
+    fingerprint: string;
+    toolname?: string;
+    now: number;
+}): Promise<{
+    error?: rpcerror;
+    token?: sessiontoken;
+}>;
+/**
+ * Relayserve of the 1.1.87 self hosting family.
+ * Every server side relay concern of the publishing pipeline lives in this one pure module: the session state machine a self hosted relay drives for the extension and the site members, the pairing code exchange the extension side registers and the site side redeems, the per frame token authentication (the relay issues one token per member, keeps the hash in the session records and rotates the token on every rejoin — the raw token lives only in the memory-only issuance map so the routed frames address their member and no log or record ever carries it), the event routing between the two members of a session over the four servercontract operations, the idle sweep that closes a quiet connection inside the window the operator chose, and the deterministic reply list the runner writes back onto its sockets. The module stays pure: the wire frames reach it as text through injected seams, the ids and the token hashes come from injected seams (the container runner injects crypto randomness, tests inject counters), the relay never names an endpoint of its own because the operator hosts it at the address they choose, and no pairing code, token or page content ever enters an error message it builds.
+ * Example: `const outcome = relayserverframe({ state, connectionid: "conn-1", frame: text, now }); const routed = outcome.routed;`
+ */
+/** The id seam signature: one call resolves the next opaque id (a session id, a token or a pairing code); the container runner injects crypto randomness while the tests inject deterministic counters. */
+export type relayidseam = () => string;
+/** The hash seam signature: the relay hashes every token it issues so the session records keep the hash only; the container runner injects the sha256 digest, the tests inject the plain identity. */
+export type relayhashseam = (token: string) => string;
+/** Creates the empty relay server state: no session, no pairing, no connection and no token — the runner registers connections as its sockets open. */
+export declare function newrelayserverstate(): relayserverstate;
+/** Registers one connection the relay accepted: the connection starts with no role, no session and no token; the frame handler fills them as the servercontract handshake proceeds. */
+export declare function relayconnectionopen(state: relayserverstate, connectionid: string, now: number): relayserverstate;
+/** Removes one connection the relay lost: the session keeps its event log, the member slot frees for a rejoin, the memory-only token record of the connection drops with it and the pairing codes stay pending until they expire. */
+export declare function relayconnectionclose(state: relayserverstate, connectionid: string): relayserverstate;
+/** Reads the live token hashes of one session: the hashes the session issued minus the revoked ones — the frame authentication checks every incoming token against this list. */
+export declare function relaylivetokens(session: relayserversession): string[];
+/** Encodes one envelope as the wire frame text the runner writes onto the socket: the plain json text of the servercontract codec. */
+export declare function relayframeof(envelope: Omit<serverenvelope, "version"> & {
+    version?: number;
+}): string;
+/** Handles one wire frame of one connection: the frame parses through the servercontract codec, the sessioncreate operation opens a session for the extension member (issuing its token and registering the pairing code when the frame carries one), the sessionjoin operation redeems a pairing code for the site member or rotates the token of a returning member, the eventpost operation routes the event to the other member of the session, and the eventstream operation acks the subscription — every other frame answers the outside the contract error and a failed token authentication answers the refusal without touching the session state. */
+export declare function relayserverframe(input: {
+    state: relayserverstate;
+    connectionid: string;
+    frame: string;
+    now: number;
+    idof?: relayidseam;
+    hashof?: relayhashseam;
+}): {
+    state: relayserverstate;
+    replies: string[];
+    routed: Array<{
+        connectionid: string;
+        frame: string;
+    }>;
+};
+/** Lists the connection ids the idle sweep closes: a connection quiet past the window the operator chose leaves, while an absent window never expires a connection because the bound stays the operator's choice. */
+export declare function relayidleconnections(state: relayserverstate, now: number, idlewindow?: number): string[];
+/** Reads the pairing codes pending redemption: the codes the extension side registered, still unused and still inside their lifetime — the list the self hosting walkthrough prints so the operator pairs the site side. */
+export declare function relaypendingpairings(state: relayserverstate, now: number): string[];
+/**
+ * Stdio transport of the 1.1.84 mcp server mode.
+ * Every stdio wire concern lives in this file: the frame boundary handling that splits the raw stdin bytes into newline delimited json lines while a partial tail stays buffered until its newline arrives, the line pump a local client rides — every decoded message routes through the injected handler seam and every response frame encodes back to stdout through the injected write seam while notifications stay unanswered — the transport counters that mirror the frames both directions, and the transport record the serve state reports.
+ * The transport stays pure: the process pipes reach it through the injected read and write seams only, the handler seam carries the serve frame router, and no client process, host name or endpoint is ever hardcoded — the user launches the local client and its stdio wires the two together.
+ */
+/** One stdio transport record of the serve mode: the pipe channel it rides, the frame counters of both directions and the lifecycle times. */
+export interface stdiotransportrecord {
+    kind: "stdio";
+    endpoint: string;
+    startedat: number;
+    received: number;
+    sent: number;
+    lastframeat?: number;
+    closedat?: number;
+}
+/** Splits one raw stdin chunk into its complete newline delimited lines: every complete line parses while a trailing fragment without its newline stays buffered for the next chunk; a buffer without a newline yields no line. */
+export declare function splitlines(buffer: string): {
+    lines: string[];
+    rest: string;
+};
+/** Creates one stdio transport record for the serve state: the pipe channel of the spawned serve process with its frame counters at zero. */
+export declare function stdiotransport(now: number): stdiotransportrecord;
+/** Creates the line pump of one stdio session: raw stdin chunks feed the pump, complete lines decode through the message codec, every frame of the decoded message routes through the handler seam and every response frame encodes newline delimited back through the write seam — notifications carry no id and stay unanswered while a handler that throws answers the internal error frame so a failing frame never kills the transport. */
+export declare function createlinepump(input: {
+    write: (line: string) => void;
+    handle: (frame: jsonrpcframe) => Promise<jsonrpcframe | undefined>;
+    now: number;
+}): {
+    feed: (chunk: string) => Promise<void>;
+    record: () => stdiotransportrecord;
+    close: (now: number) => stdiotransportrecord;
+};
+import type { apicallrecord, cacheentry, correlationcontext, eventsubscription, formpayload, graphqlsubscription, longpollrequest, multipartfield, multipartpayload, pollcursor, ratelimitdirective } from "./types.js";
+/**
+ * Web api transport logics of the 1.1.76 family.
+ * Every correlated rule for the widened transport surface lives in this one module: the server sent events subscription lifecycle with field parsing, last event id resume, clean cancellation and channel error surfacing; the long poll request loop that waits on the response cursor, retries on the configured timeout backoff and stops on cancellation or plan expiry; the graphql subscription message mapping of next, error and complete frames into step results; the urlencoded form post and the streamed multipart upload with their part encodings and upload progress; the per run correlation id assignment that joins request and response pairs and exports one request map to the audit trail; the rate limit directive parsing that delays the next request until the reset window and honors the retry after wait of 429 and 503 answers; and the per run response cache that keys by url, method and body hash, serves repeated read only calls inside one run, expires entries by the response headers and the user policy and never caches a response that follows a mutation.
+ * The module reuses the socketbus parsing of the 1.1.43 family for the event stream grammar and the poll cursor decisions, and the netauth encodings of the 1.1.44 family for the urlencoded and multipart wire shapes, so the transport widening extends the reviewed families instead of duplicating them.
+ * Message payloads and field values are opaque reviewed text; no payload value enters any audit summary built from these results, and every timeout, backoff, retention and bound stays a user choice with no code default — an absent value never hides a hardcoded ceiling.
+ */
+import { type sseevent } from "./net.js";
+/** Stream open seam: one reviewed url with its request headers resolves to a reader of text chunks or an error class; the extension executor wires the fetch stream, tests wire plain fixtures. */
+export type streamopen = (url: string, headers: Record<string, string>) => Promise<{
+    ok: boolean;
+    status: number;
+    read: () => Promise<{
+        done: boolean;
+        text?: string;
+    }>;
+    error?: string;
+}>;
+/** Poll fetch seam: one poll url with its optional request body resolves to the response status, headers and text; the extension executor wires fetch, tests wire plain fixtures. */
+export type pollfetch = (url: string, body?: string) => Promise<{
+    status: number;
+    headers: Record<string, string>;
+    body: string;
+    timeout?: boolean;
+}>;
+/**
+ * Runs one server sent events subscription through the stream open seam: the channel reads chunk by chunk, every complete block parses into its event, data, id and retry fields, the last event id persists so a reconnect resumes exactly where the stream stopped, a cancelled step or an elapsed lifetime closes the channel cleanly, and a channel error surfaces to the run state machine instead of dying silently.
+ */
+export declare function subevents(input: {
+    record: eventsubscription;
+    open: streamopen;
+    cancelled?: () => boolean;
+    now?: () => number;
+}): Promise<{
+    record: eventsubscription;
+    events: sseevent[];
+    error?: string;
+}>;
+/** Normalizes one reviewed long poll request from step options: the url the poll drives, the user chosen timeout of one request and the resume cursor; an absent timeout never aborts a poll because the bound stays a user choice with no code default. */
+export declare function longpollrequestof(value: unknown): longpollrequest | undefined;
+/**
+ * Runs one long poll loop through the poll fetch seam: each iteration issues the request the reviewed cursor builds, waits on the response cursor, retries a timed out request under the configured backoff and stops on the reviewed stop condition, the cancellation flag, the plan expiry or the reviewed poll ceiling; the loop never invents a bound of its own.
+ */
+export declare function longpoll(input: {
+    request: longpollrequest;
+    cursor: pollcursor;
+    fetchpoll: pollfetch;
+    cancelled?: () => boolean;
+    expiresat?: number;
+    backoff?: number;
+    now?: () => number;
+    sleep?: (milliseconds: number) => Promise<void>;
+}): Promise<{
+    polls: number;
+    retries: number;
+    reason: string;
+    cursor?: string;
+    exchanges: Array<{
+        url: string;
+        status: number;
+        body: string;
+        timeout: boolean;
+    }>;
+    error?: string;
+}>;
+/** One parsed graphql subscription message of the graphql-ws grammar: the next payload, the error list or the complete marker with its operation id. */
+export interface graphqlmessage {
+    kind: "next" | "error" | "complete";
+    id?: string;
+    /** The payload of a next message, kept opaque for the step results. */
+    payload?: unknown;
+    /** The error messages of an error message. */
+    errors?: string[];
+}
+/** Normalizes one reviewed graphql subscription from step options: the query, its variables and the websocket channel the subscription rides. */
+export declare function graphqlsubscriptionof(value: unknown): graphqlsubscription | undefined;
+/** Parses one inbound graphql subscription message of the graphql-ws grammar into its next, error or complete kind; an unparseable frame reports itself as an error instead of dying silently. */
+export declare function parsegraphqlmessage(payload: string): graphqlmessage;
+/** Builds the graphql-ws subscribe frame of one reviewed subscription: the operation id, the query and its variables ride one json frame the channel publishes. */
+export declare function graphqlsubscribeframe(subscription: graphqlsubscription, operationid: string): string;
+/** Maps the inbound graphql subscription messages into step results: every next payload becomes one result with its operation id, the errors collect for the step outcome and the complete marker closes the mapping. */
+export declare function graphqlsub(input: {
+    subscription: graphqlsubscription;
+    messages: string[];
+}): {
+    results: Array<{
+        id?: string;
+        data: unknown;
+    }>;
+    errors: string[];
+    completed: boolean;
+};
+/** Builds one reviewed urlencoded form post for a granted origin: the fields encode with the urlencoded grammar under the application/x-www-form-urlencoded content type, and an origin outside the grants refuses before any byte moves. */
+export declare function formpost(input: {
+    payload: formpayload;
+    grants: string[];
+}): {
+    ok: true;
+    url: string;
+    method: "POST";
+    headers: Record<string, string>;
+    body: string;
+} | {
+    ok: false;
+    refusal: string;
+};
+/** Builds the part headers of one multipart file field: the content disposition names the field and the filename while the content type carries the reviewed mime of the part. */
+export declare function multipartfieldheader(field: multipartfield): string;
+/** Encodes one reviewed multipart upload for a granted origin: the fields and the files encode into ordered chunks under one boundary, the progress callback reports each streamed chunk with its sent and total bytes without ever buffering the whole payload, and an origin outside the grants or an unreviewed file refuses before any byte moves. */
+export declare function multipartpost(input: {
+    payload: multipartpayload;
+    grants: string[];
+    onprogress?: (progress: {
+        chunk: number;
+        chunks: number;
+        sent: number;
+        total: number;
+    }) => void;
+}): {
+    ok: true;
+    url: string;
+    method: "POST";
+    headers: Record<string, string>;
+    chunks: string[];
+    boundary: string;
+    bytes: number;
+} | {
+    ok: false;
+    refusal: string;
+};
+/** Assigns one request id per outbound request of the run: the correlation context grows by the request, the correlation id derives from the run and the request order, and the mapping stays read only inside the run. */
+export declare function correlateids(input: {
+    context: correlationcontext;
+    stepid: string;
+    url: string;
+    method: string;
+    now: number;
+}): {
+    context: correlationcontext;
+    requestid: string;
+};
+/** Joins one response onto its request through the shared correlation id: the request gains its response id and status, and a request id the map does not carry refuses instead of pairing the wrong pair. */
+export declare function joincorrelation(input: {
+    context: correlationcontext;
+    requestid: string;
+    responseid?: string;
+    status: number;
+    now: number;
+}): correlationcontext;
+/** Exports the per run request map for the audit trail: every request with its correlation id, its pair state and the paired share, read only beside the run it belongs to. */
+export declare function correlationexport(context: correlationcontext): {
+    runid: string;
+    requests: number;
+    pairs: number;
+    map: Array<{
+        requestid: string;
+        correlationid: string;
+        stepid: string;
+        url: string;
+        origin: string;
+        method: string;
+        paired: boolean;
+        status?: number;
+        at: number;
+    }>;
+};
+/** Parses one rate limit directive from the response headers: the remaining count and the reset window of the x-ratelimit family and the retry after wait of a 429 or 503 answer compose into one directive scoped to the origin; headers without any rate limit fact parse to nothing. */
+export declare function ratelimitdirectiveof(headers: Record<string, string>, origin: string, status: number, now: number): ratelimitdirective | undefined;
+/** Resolves the wait the next request of one origin owes: the newest directive of the origin names the milliseconds until its reset window passes, an absent or passed directive waits nothing, and the wait itself stays a user respected value with no code ceiling. */
+export declare function ratelimitwaitof(directives: ratelimitdirective[], origin: string, now: number): {
+    waitms: number;
+    directive?: ratelimitdirective;
+};
+/** Applies the rate limit respect before one transport call: the wait sleeps until the reset window of the origin passes so the call never crosses a limit the endpoint published, and the resolved wait reports itself for the audit trail. */
+export declare function ratelimitrespect(input: {
+    directives: ratelimitdirective[];
+    origin: string;
+    now?: () => number;
+    sleep?: (milliseconds: number) => Promise<void>;
+}): Promise<{
+    waitms: number;
+    directive?: ratelimitdirective;
+}>;
+/** Hashes one request body for the cache key with a stable rolling digest; the hash never carries the body values anywhere, only their shape identity. */
+export declare function bodyhashof(body: string): string;
+/** Builds the cache key of one call: the run namespace, the method, the url and the body hash compose into one key so a repeated read of the same run serves from its own entry only. */
+export declare function cachekeyof(input: {
+    runid: string;
+    url: string;
+    method: string;
+    body: string;
+}): string;
+/** Resolves the expiry timestamp of one stored response from its headers and the user policy: the cache-control max-age and the expires date cap the entry while the user configured retention bounds the entries per run, and an absent fact keeps the entry until the run ends. */
+export declare function cacheexpiryof(headers: Record<string, string>, now: number, retention?: number): number | undefined;
+/** True when the method reads only: GET and HEAD carry no mutation, every other verb mutates and its responses never cache. */
+export declare function readmethod(method: string): boolean;
+/** Stores one response in the per run cache: the entry keys by the run namespace, the url, the method and the body hash, only a read only method stores, a response that carries credentials refuses through the cache gate of the caller, and a response that follows a mutation on its origin never stores because the mutation invalidated the read it would answer. */
+export declare function cacheresponse(input: {
+    entries: cacheentry[];
+    url: string;
+    method: string;
+    body: string;
+    headers: Record<string, string>;
+    status: number;
+    runid: string;
+    now: number;
+    retention?: number;
+    credentials?: boolean;
+    mutatedat?: number;
+}): {
+    entries: cacheentry[];
+    entry?: cacheentry;
+    refusal?: string;
+};
+/** Serves one repeated read only call from the per run cache: the entry with the matching key serves while its expiry has not passed, a hit bumps its counter, an entry whose origin saw a mutation stops serving, and an expired entry drops with its expiry reported. */
+export declare function cacheserv(input: {
+    entries: cacheentry[];
+    url: string;
+    method: string;
+    body: string;
+    runid: string;
+    now: number;
+    mutatedat?: number;
+}): {
+    entries: cacheentry[];
+    entry?: cacheentry;
+    expired?: cacheentry;
+};
+/** Runs the cache expiry cleanup pass: every entry whose expiry passed drops while its metadata survives through the caller, and the pass reports exactly what it expired. */
+export declare function cachecleanup(entries: cacheentry[], now: number): {
+    kept: cacheentry[];
+    expired: cacheentry[];
+};
+/** Builds one observed page api call record from a captured exchange fact: the url, its origin, the endpoint path, the method, the status and the mime compose into one read only observation beside the discovered api map. */
+export declare function apicallrecordof(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    url: string;
+    method: string;
+    status: number;
+    mime?: string;
+    at: number;
+}): apicallrecord;
+//# sourceMappingURL=http.d.ts.map