@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/net.d.ts

@@ -0,0 +1,325 @@
+/**
+ * The net module of the 1.1.90 consolidation: every correlated variation of the network logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the network plane of a run, ordered from observation through transport to control: netwatch holds the derived request observation of the run tab (the timing buffer facts, the correlation ids that join request and response pairs, the header allowlists with redaction, the body capture inside reviewed byte ceilings and the page api map with its ranking and replay extraction); socketbus holds the transport plane (the websocket channel lifecycle with reconnection backoff, the multiplexed named message streams with their channel scoped sequences, the message filter matching of waitmessage steps, the server sent events parsing with last event id resume and the long polling cursor loop with its stop conditions); and netcontrol holds the control plane (request blocking, response mocking, header rewriting, cookie scoping, proxy routing, the rate limit reads and the retry after waits, every rule run scoped and reverted the moment a run ends, fails or is cancelled).
+ * No byte ceiling, reconnect budget, backoff base, rate window or poll bound is ever hardcoded anywhere in the family: every bound stays the user's choice, header values redact before storage, body bytes never enter any audit summary, and no network control rule ever bypasses the human review.
+ */
+import type { apimapentry, apireplayspec, bodyfilter, bodyrecord, exchangerecord, headerfilter, responseentry } from "./types.js";
+/**
+ * Network observation part two watch logics for the 1.1.43 family.
+ * Every correlated rule for the derived request observation of the run tab, the correlation ids that join request and response pairs, the header reading with allowlists and redaction, the response body capture inside reviewed byte ceilings, the page api mapping with frequency, json share and payload stability ranking and the api replay extraction paths lives in this file.
+ * The page observation derives from the timing and navigation buffers the page itself exposes, so request and response headers and bodies exist only for exchanges captured through the extension context; header values are redacted before storage and body bytes never enter any audit summary.
+ */
+/** The netwatch kinds, listed among the available capabilities of every proposal request. */
+export declare const netwatchkinds: string[];
+/** One derived request fact of the page timing buffers: url, initiator, timing, transfer size, protocol and the status a navigation entry exposes. */
+export interface resourcefact {
+    url: string;
+    initiator: string;
+    entrytype: string;
+    start: number;
+    duration: number;
+    transfer: number;
+    protocol: string;
+    status?: number;
+    /** Explicit failure flag a navigation buffer reports, for example a net error. */
+    failed?: boolean;
+}
+/** Normalizes raw timing buffer entries into derived request facts; navigation entries contribute the response status they expose. */
+export declare function resourcefacts(entries: Array<Record<string, unknown>>): resourcefact[];
+/** Classifies one derived request failure: an exposed status of four hundred or more is an http error and an explicit failure flag or a zero transfer fetch without a protocol is a network error; everything else reports no error class. */
+export declare function failureclass(fact: resourcefact): {
+    errorclass?: "httperror" | "networkerror";
+    status: number;
+};
+/** Assigns one correlation id per run request, ordered by first observation. */
+export declare function correlationid(runid: string, index: number): string;
+/** Creates one observed exchange record from a derived request fact: the method stays honest with a question mark for fetch initiators the timing buffers cannot name, and the status and error class come from what the buffers expose. */
+export declare function newexchange(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    correlationid: string;
+    fact: resourcefact;
+    at: number;
+}): exchangerecord;
+/** Joins one captured response entry onto its exchange through the shared correlation id; a mismatching correlation id is refused instead of paired. */
+export declare function pairexchange(exchange: exchangerecord, response: responseentry): exchangerecord;
+/** Filters observed exchanges by run, origin and status; the status filter accepts one status code or the failed class of every exchange with an error class. */
+export declare function filterexchanges(exchanges: exchangerecord[], filter: {
+    runid?: string;
+    origin?: string;
+    status?: number | "failed";
+}): exchangerecord[];
+/** Normalizes a reviewed header filter: the name allowlist and the redaction list, both lowercased; the redaction list is required before any header value is stored. */
+export declare function headerfilterof(value: unknown): headerfilter;
+/** Applies one header filter to captured headers: only allowlisted names survive and redaction listed names keep their name with the value replaced by the redaction marker before storage. */
+export declare function capturedheaders(headers: Record<string, string>, filter: headerfilter): Record<string, string>;
+/** Normalizes a reviewed body filter: url pattern, mime list and the byte ceiling of one captured body; the ceiling stays a user configured value with no code ceiling. */
+export declare function bodyfilterof(value: unknown): bodyfilter;
+/** True when one exchange matches the reviewed body filter: the url pattern appears inside the exchange url and the mime list, when reviewed, carries the exchange mime. */
+export declare function bodymatches(filter: bodyfilter, exchange: {
+    url: string;
+    mime?: string;
+}): boolean;
+/** True when a mime type carries private document or data payloads instead of public static assets. */
+export declare function privatemime(mime: string): boolean;
+/** Captures one response body inside the reviewed byte ceiling: the stored body truncates at the ceiling and the record keeps the stored byte size with its correlation linkage. */
+export declare function capturebody(input: {
+    ref: string;
+    runid: string;
+    exchange: exchangerecord;
+    body: string;
+    mime: string;
+    filter: bodyfilter;
+    at: number;
+}): {
+    record: bodyrecord;
+    truncated: boolean;
+} | {
+    refused: string;
+};
+/** Reads the payload shape of one captured body: the field names of a json object in first seen order, with array bodies reporting the shape of their first element. */
+export declare function payloadshapeof(body: string | undefined): string[];
+/** Builds the page api map of the run from observed exchanges and captured bodies: endpoint, method, mime, frequency, json share and payload stability with their correlation ids. */
+export declare function apientries(exchanges: exchangerecord[], bodies: bodyrecord[]): apimapentry[];
+/** Ranks page api entries by frequency, json share and payload stability so the most used stable json endpoints surface first. */
+export declare function rankapis(entries: apimapentry[]): apimapentry[];
+/** Normalizes a reviewed api replay spec: the captured endpoint, the replay verb, the parameter overrides and the dotted extraction paths. */
+export declare function apireplayspecof(value: unknown): apireplayspec | undefined;
+/** Builds the replay url of one captured endpoint with the reviewed parameter overrides applied as query parameters. */
+export declare function replayurl(spec: apireplayspec): string;
+/** Maps one replayed response body onto the reviewed dotted extraction paths, reporting a miss instead of crashing when a path finds nothing. */
+export declare function extractvalues(body: string, paths: string[]): Array<{
+    path: string;
+    value?: unknown;
+    missing?: boolean;
+}>;
+import type { channelrecord, messageenvelope, messagefilter, pollcursor, socketoptions } from "./types.js";
+/**
+ * Network observation part two socket logics for the 1.1.43 family.
+ * Every correlated rule for the websocket channel lifecycle with reconnection backoff, the multiplexing of named message streams over one channel with channel scoped sequence numbers, the message filter matching of waitmessage steps, the server sent events parsing with last event id resume and the long polling cursor loop with its stop conditions lives in this file.
+ * Message payloads are opaque reviewed text; no payload value enters any audit summary built from these results.
+ */
+/** The socket and stream kinds, listed among the available capabilities of every proposal request. */
+export declare const socketkinds: string[];
+/** Connect seam signature: one reviewed channel url with its protocols; the extension executor wires the browser websocket, tests wire plain fixtures. */
+export type socketconnect = (url: string, protocols: string[]) => Promise<{
+    open: boolean;
+    code?: number;
+    error?: string;
+}>;
+/** Resolves the reviewed https origin behind a channel url: wss channels map onto their https origin so the origin grants cover both. */
+export declare function channelorigin(url: string): string;
+/** Normalizes reviewed channel open options: url plus the socket options of protocols, reconnect budget, backoff base and backoff ceiling; every bound stays a user choice with no code ceiling. */
+export declare function channeloptionsof(value: unknown): {
+    url: string;
+    options: socketoptions;
+} | undefined;
+/** Creates one channel record in the connecting state with its origin, protocols and zeroed message counters. */
+export declare function newchannel(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    kind: "websocket" | "sse";
+    url: string;
+    protocols?: string[];
+    at: number;
+}): channelrecord;
+/** Builds the exponential backoff waits of the reviewed reconnect budget: each wait doubles the base and growth stops at the user configured ceiling, so the budget bounds the growth and no code ceiling exists. */
+export declare function reconnectwaits(attempts: number, base: number, ceiling: number | undefined): number[];
+/**
+ * Opens one reviewed channel through the connect seam with the reviewed reconnect budget and backoff: failed attempts wait the exponential backoff before the retry, the channel opens on the first success and a budget exhausted without a connection fails the channel with the last error class.
+ */
+export declare function openchannel(input: {
+    record: channelrecord;
+    options: socketoptions;
+    connect: socketconnect;
+    sleep?: (milliseconds: number) => Promise<void>;
+    now?: () => number;
+}): Promise<channelrecord>;
+/** Closes one channel record cleanly with its close time and an optional error class, keeping every counter for the audit trail. */
+export declare function closechannel(record: channelrecord, at: number, error?: string): channelrecord;
+/** Live multiplexing state of one run: the per channel sequence counters and the inbound message queue. */
+export interface busstate {
+    sequences: Record<string, number>;
+    queue: messageenvelope[];
+}
+/** Publishes one reviewed payload on a named stream of an open channel and returns the tagged envelope. */
+export declare function publishmessage(state: busstate, channelid: string, stream: string, payload: string, at: number): {
+    state: busstate;
+    envelope: messageenvelope;
+};
+/** Receives one inbound channel message on a named stream, tags it with the next channel sequence and queues it for the waitmessage matchers. */
+export declare function receivemessage(state: busstate, channelid: string, stream: string, payload: string, at: number): {
+    state: busstate;
+    envelope: messageenvelope;
+};
+/** True when one message envelope matches the reviewed filter: the stream name when reviewed, the dotted json path when reviewed and always the sequence integrity of the channel. */
+export declare function matchmessage(filter: messagefilter | undefined, envelope: messageenvelope): boolean;
+/** Collects the queued messages of one channel matching the reviewed filter up to the reviewed match limit, removing the matched envelopes from the queue. */
+export declare function collectmessages(state: busstate, channelid: string, filter: messagefilter | undefined): {
+    state: busstate;
+    matched: messageenvelope[];
+};
+/** Verifies the sequence integrity of a message stream: per channel the sequences must form one strictly increasing run from one with no gaps. */
+export declare function sequenceintegrity(envelopes: messageenvelope[]): {
+    ok: boolean;
+    gaps: Array<{
+        channelid: string;
+        expected: number;
+        found: number;
+    }>;
+};
+/** Normalizes a reviewed message filter: stream name, dotted json path and the reviewed match limit with no code ceiling. */
+export declare function messagefilterof(value: unknown): messagefilter;
+/** One parsed server sent event: id, event name, joined data lines and the reviewed retry hint. */
+export interface sseevent {
+    id?: string;
+    event?: string;
+    data: string;
+    retry?: number;
+}
+/** Parses one server sent events text chunk into complete events with id, event name, data and retry fields, returning the incomplete trailing block as the rest buffer; comment lines stay ignored. */
+export declare function parsessetext(text: string): {
+    events: sseevent[];
+    rest: string;
+};
+/** Builds the request headers of one server sent events subscription, resuming from the last event id after a reconnect. */
+export declare function sserequestheaders(record: {
+    lasteventid?: string;
+}): Record<string, string>;
+/** Normalizes reviewed subscription options: the event stream url, the lifetime window, the resume point and the reviewed cancellation path. */
+export declare function subscriptionoptionsof(value: unknown): {
+    url: string;
+    lifetime?: number;
+    lasteventid?: string;
+    cancel: {
+        kind: "stop" | "lifetime";
+        value: string | number;
+    };
+} | undefined;
+/** Normalizes a reviewed long poll cursor: url, cursor field, interval, stop condition, optional poll ceiling and the cursor query parameter; every bound stays a user choice with no code ceiling. */
+export declare function pollcursorof(value: unknown): pollcursor | undefined;
+/** Reads one cursor value from a polled response body by its dotted field path. */
+export declare function cursorfrom(response: unknown, field: string): string | undefined;
+/** Builds the next poll url of a cursor loop: the cursor rides the reviewed query parameter when one is set and posts inside the request body otherwise. */
+export declare function pollurl(cursor: pollcursor, value: string | undefined): {
+    url: string;
+    body?: string;
+};
+/**
+ * Decides one long poll iteration: the loop stops on the reviewed stop condition, the cancellation flag, the plan expiry or the reviewed poll ceiling, and otherwise returns the next poll url with the reviewed interval wait.
+ */
+export declare function polldecision(input: {
+    cursor: pollcursor;
+    polls: number;
+    response: unknown;
+    cancelled?: () => boolean;
+    expiresat?: number;
+    now: number;
+}): {
+    continue: boolean;
+    reason: string;
+    cursor?: string;
+    next?: {
+        url: string;
+        body?: string;
+        wait: number;
+    };
+};
+/** Correlated network control logics of the 1.1.44 family: request blocking, response mocking, header rewriting, cookie scoping, proxy routing and the rate limiter, all run scoped and reverted the moment a run ends, fails or is cancelled. */
+import type { blockrule, cookierecord, headerule, mockspec, proxyroute, ratelimitread } from "./types.js";
+/** Every reviewed network control kind of the 1.1.44 family. */
+export declare const controlkinds: string[];
+/** Resolves the origin a reviewed url pattern names; a pattern without an https origin prefix names no origin and is refused. */
+export declare function patternorigin(pattern: string): string | undefined;
+/** Matches a reviewed url pattern against one request url: the pattern must name its https origin, then an optional path pattern where a single star matches within one segment and a double star matches across segments. */
+export declare function matchurlpattern(pattern: string, url: string): boolean;
+/** Parses one reviewed block rule from step options: the url pattern and an optional resource type list. */
+export declare function blockruleof(value: unknown): {
+    urlpattern: string;
+    resourcetypes?: string[];
+} | undefined;
+/** Creates one registered block rule of a run with its hit counter at zero; every rule removes itself at run end. */
+export declare function newblockrule(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    urlpattern: string;
+    resourcetypes?: string[];
+    at: number;
+}): blockrule;
+/** Parses one reviewed mock fixture from step options: url pattern, status, headers and either the reviewed body or the reference of a captured body of the 1.1.43 body store the fixture replays. */
+export declare function mockspecof(value: unknown): {
+    urlpattern: string;
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+    bodyref?: string;
+    reviewed?: boolean;
+} | undefined;
+/** Creates one registered mock fixture of a run; the fixture serves matched requests and clears at run end. */
+export declare function newmockspec(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    urlpattern: string;
+    status: number;
+    headers?: Record<string, string>;
+    body?: string;
+    bodyref?: string;
+    reviewed: boolean;
+    at: number;
+}): mockspec;
+/** Returns the first active mock fixture that matches the url; matched fixtures count their hits for the step result. */
+export declare function mockfor(url: string, specs: mockspec[]): mockspec | undefined;
+/** Parses one reviewed header rewrite rule from step options: url pattern, header name, operation and value. */
+export declare function headeruleof(value: unknown): {
+    urlpattern: string;
+    name: string;
+    operation: "set" | "append" | "remove";
+    value?: string;
+} | undefined;
+/** Creates one registered header rewrite rule of a run; the rule reverts at run end. */
+export declare function newheaderule(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    urlpattern: string;
+    name: string;
+    operation: "set" | "append" | "remove";
+    value?: string;
+    at: number;
+}): headerule;
+/** Applies the active header rewrite rules of one outgoing url: set overwrites, append joins with a comma and remove drops the header, returning the rewritten headers with the provenance of every applied rule for the audit trail. */
+export declare function applyheaderules(url: string, headers: Record<string, string>, rules: headerule[]): {
+    headers: Record<string, string>;
+    applied: headerule[];
+};
+/** Marks one registered rule as reverted at the given time; reversion is idempotent and never touches the hit counter. */
+export declare function revertrule<T extends blockrule | mockspec | headerule | proxyroute>(rule: T, at: number): T;
+/** Parses one reviewed cookie record from step options: name, domain, path, value and optional expiry. */
+export declare function cookierecordof(value: unknown): cookierecord | undefined;
+/** True when the reviewed cookie domain stays inside the granted hosts: the domain equals a granted origin host or sits beneath it as a subdomain; every other domain is refused. */
+export declare function cookiedomaingranted(domain: string, grants: string[]): boolean;
+/** Redacts the values of reviewed cookies for the audit trail: only names, domains, paths and expiry windows survive. */
+export declare function redactedcookies(records: cookierecord[]): Array<{
+    name: string;
+    domain: string;
+    path: string;
+    expiresat?: number;
+}>;
+/** Parses one reviewed proxy route from step options: scheme, host, port and the required bypass list of origins that stay direct. */
+export declare function proxyrouteof(value: unknown): {
+    scheme: "http" | "https" | "socks4" | "socks5";
+    host: string;
+    port: number;
+    bypass: string[];
+} | undefined;
+/** Parses one rate limit read from response headers: the remaining and limit counts plus the reset time; a reset value beyond the read time counts as epoch seconds and a smaller value as seconds remaining. */
+export declare function ratelimitreadof(headers: Record<string, string>, origin: string, now: number): ratelimitread | undefined;
+/** Resolves the retry after wait of one 429 or 503 response in milliseconds from the reviewed Retry-After header; a seconds value counts from now and an HTTP date resolves to its absolute time. */
+export declare function retryafterof(status: number, headers: Record<string, string>): number | undefined;
+/** Resolves the rate limit wait in milliseconds until the reset window passes; an absent or passed state waits nothing and the wait itself stays a user configured behavior with no code ceiling. */
+export declare function ratelimitwait(state: ratelimitread | undefined, now: number): number;
+//# sourceMappingURL=net.d.ts.map

package/dist/neutral.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Neutral entry of the 1.1.81 family, widened by the 1.1.83 gateway integration.
+ * The shared core for browser condition consumers: the build emits this entry as dist/index.neutral.js on the browser platform with the node imports stripped behind the adapter seam, because the whole core reaches the platform only through the storage, clock, logger and fetch adapters the runtime injects.
+ * The provider gateway logics of the 1.1.83 family ride the llm module this entry star-exports: the neutral browser condition carries no transport binding of its own, so a host that wants the provider gateways imports the per module entry `@wenathlan/devthink/llm` or one of the runtime shells and supplies its own transport through the seam — the module list below mirrors the core modules the freeze governs.
+ */
+export * from "./agent.js";
+export * from "./gates.js";
+export * from "./swarm.js";
+export * from "./capture.js";
+export * from "./debug.js";
+export * from "./auth.js";
+export * from "./workflow.js";
+export * from "./environments.js";
+export * from "./http.js";
+export * from "./security.js";
+export * from "./llm.js";
+export * from "./memory.js";
+export * from "./mcp.js";
+export * from "./commands.js";
+export * from "./data.js";
+export * from "./net.js";
+export * from "./run.js";
+export * from "./session.js";
+export * from "./plan.js";
+export * from "./views.js";
+export * from "./export.js";
+export * from "./flow.js";
+export * from "./evidence.js";
+export * from "./headless.js";
+export * from "./runtime.js";
+export * from "./version.js";
+export * from "./perf.js";
+export * from "./tools.js";
+export { argkind, attachtimeline, blockingduration, consolecapture, consolediff, errorcapture, filterentries, levelrank, loglevels, longtaskcapture, netfailureentryof, redactconsoletext, rejectioncapture, rotatelogs, serializearg, spamdetect, stackframes, timelinecounts, timelinekinds, timelinesources, watcherdetached, type timeline, } from "./run.js";
+export { actionrisk as deriveactionrisk, agentbudgetvalid, agentscopevalid, apikeyconsentgranted, authconsentgranted, blackboardconsentgrade, blockgate, breakpointbudgetallowed, breakpointceilingof, canexecute, confirmcredsgate, confirmdeletegate, confirmpaygate, connectallowgate, consoleconsentcovers, controltarget, cookiegate, debuggate, debuggerconsentcovers, debugwaitbudgetallowed, diffreviewgrade, dryrunprojection, editorsavegate, emugate, emulationretentionwindow, emulationstackallowed, environmentgrantgate, environmentrequirements, exportcontentreview, gatebatchgate, generatedvalueallowed, hostpattern, iscdpkind, isdebugkind, isformkind, isnetwatchkind, iscontrolkind, isprofilekind, issocketkind, iswatchkind, issessionkind, isworkflowkind, istriggeraction, keepalivegate, keepaliveintervalvalid, killswitchgate, agentscopegate, budgetgate, escalateholdgate, reviewrequestgate, pauseagentgate, agentnamevalid, fleetoperationgrade, replayexportgate, voteweightvalid, messageegressgrade, normalizeendpoint, observationmodeof, offscreencapabilitygate, origincheckgate, pauseretentionwindow, passwordconsentgranted, permissionnamevalid, permissionstatevalid, phishguardgate, phishthresholdgate, planallowlist, profilegrantgranted, profileretentionwindow, proxygate, queuelanesvalid, ratelimitbudgetallowed, ratelimitboundsvalid, ratelimitgate, resolvedrisk, resolutionverdict, restoreoriginsgranted, restorereviewgranted, reviewedkinds, readonlyactionkinds, rotationruleof, runreviewgranted, safedefaultsgate, sandboxorigingate, schemaguardgate, serverbindgate, serverenablementgate, sessionfolderunique, sessionnameunique, sessionrestoregate, snapshotretentionwindow, socketgate, sourcemapconsentcovers, spamruleof, spawngrade, stackgate, stepenvironmentvalid, submitreviewgranted, targetgate, toolconsentrequired, tooldispatchgate, toolnamespacegate, toolriskgrade, toolversionfloor, untrustedrendergate, validatetoolcatalog, vaultsecretgate, workstealgrade, workerpoolsizevalid, isemulationkind, locationconsentgate, automationallowlistgate, consentdurationvalid, consentwindowgate, logreadgate, originprofilegate, revokerungate, sensitiveclassgate, sensitivepipelingate, sitenotesreadgate, sitenoteswritegate, scratchpadscopegate, memoryreadscopegate, semanticrecallscopegate, summarywindowvalid, sessionretentionvalid, consentmemoryadvisorygate, cancelrungate, retrydispatchgate, timelinegate, costbudgetvalid, egressconsentgate, guardverdictgate, localsensitivegrade, planlint, plandraftreviewgate, provideregressgrade, providervalid, replanreviewgate, timelineretentionwindow, traceceilingof, triggergate, triggerorigins, validatebreakpointcondition, validatefieldmatch, validateformrecord, validatestep, validatesiteoverride, validateregexrule, validatetargetref, validatevaluegen, watchdogconfigvalid, watchgate, workflowgate, paletteactiongate, taskinputproposalgate, planreviewgate, stepapprovegate, diffpreviewgate, onboardingconsentgate, logbufferboundvalid, logstreamegressgate, quickactiongate, omniboxtaskgate, shortcutkeygate, notificationcontentgate, pickeroverlaygate, shotpanelgate, siteprofilegate, importexportgate, librarymanifestgate, librarycapabilitygate, librarygrantgate, librarysensitivegate, libraryquarantinegate, libraryimportgate, syncbridgeoptingate, syncbridgescopegate, runreplaygate, outputcomparegate, outputcomparereadonlygate, backgroundrungate, portablerulefamilies, portablerulesetof, portablerulesetgate, portablecapabilitygate, flowrungrantgate, exportchaingate, exportmaskgate, headlessconsentgate, headlesstelemetrygate, platformmatrixgate, adaptermappinggate, capabilitydowngradegate, lazyloadgate, debouncewindowvalid, batchqueryplangate, incrsnapshotgate, selcachegate, streamparsegate, chunkextractgate, workerbackpressuregate, virtlistwindowvalid, perfprovenancegate, lazybudgetvalid, batchwindowvalid, domainlimitsvalid, politedelayvalid, adaptivepollvalid, runbudgetvalid, budgetthresholdsvalid, timeoutboundvalid, timeoutrecordeventgate, suspendwindowvalid, sessionreusegate, resumefingerprintgate, logprunegate, stepprefetchgate, slowmofactorvalid, replaycheck, checkpointgate, rollbackgate, zombiegate, rollbackorigingate, heartbeatwindowvalid, offlinegate, queuedtaskexpirygate, queuedepthvalid, actionkindcatalog, prefetchgate, preconnectgate, deeplinkgate, reopentabgate, pausenavconsentgate, navratelimitgate, clipboardgate, safetygate, batchsizelimitgate, navigationobservationgrade, trailexportgate, trailorigingate, streamgate, transformgate, dedupeconfiggate, samplegate, provgate, resumegate, pipelinetargetgate, gridexportconfirmgate, streamchunkgate, provlogappendonlygate, rowstampgate, streamnamespacegate, transportgate, subscribegate, postgate, uploadgate, cachegate, ratelimitrespectgate, correlationmappinggate, pollchoices, subscriptionboundgate, apicallgrade, transportcancelgate, pollwaitbudgetgate, visiongate, ocrgate, redactgate, groundgate, pairgate, visionchoices, visioncostgrade, visionconsentgate, visionsensitivegrade, regionboundsgate, framebudgetgate, visioncacheexpirygate, serverurlgate, bridgeconsentgate, bridgemembergate, bridgecontentgate, bridgepairingwindowvalid, bridgeidlewindowvalid, bridgeheartbeatvalid, bridgeratecapvalid, bridgekillswitchgate, bridgeframeorigingate, bridgechoices, gatewaybaseurlgate, gatewayprefixgate, gatewayconsentgate, gatewaykeyconsentgate, gatewayretrycapvalid, gatewaycachewindowvalid, } from "./policy.js";
+export * from "./protocol.js";
+export * from "./bridge.js";
+export * from "./types.js";
+export type { actionrisk, loopstep } from "./types.js";
+export { retryhintof } from "./session.js";
+//# sourceMappingURL=neutral.d.ts.map