@wenathlan/devthink 2.0.14 → 2.0.19

package/dist/engine.d.ts

@@ -1,74 +0,0 @@
-/**
- * engine — universal gateway engine
- * one file one responsibility — the generic request pipeline for all versions
- * 0 to 100 correlated logics grouped in this one file
- *
- * consumes a gatewayconfig produces all 7 route handlers
- * supports any llm any baseurl any api key via configuration
- * v1 zai sdk v2 babel v3 nvidia v4 opencode kilo v5 openrouter are all
- * just config objects feeding this single engine
- *
- * pipeline per request:
- *   1 paused check → 503 fallback
- *   2 model resolution — requested or default or meta rotation pick
- *   3 auth resolution — 12 methods db env inline ephemeral
- *   4 body building — sampling params per policy thinking param per config
- *   5 execution — retry backoff rotation timeout circuit breaker
- *   6 streaming — byte passthrough sse parsing heartbeat discard masking
- *   7 persistence — savemsg with version specific fields
- *   8 response building — chat completion anthropic message response formats
- */
-import type { gatewayconfig, modeldef, sessionstate, thinkinglevel, versionhandlers } from "./types";
-/** find a model by id in the catalog — returns undefined when unknown */
-declare function findmodel(cfg: gatewayconfig, id: string): modeldef | undefined;
-/** resolve the model for a request — meta rotation individual or default */
-declare function resolvemodel(cfg: gatewayconfig, requested: string | undefined, session: sessionstate, globalcounter: {
-    n: number;
-}): {
-    model: modeldef | undefined;
-    modelid: string;
-    display: string;
-    ismeta: boolean;
-    rotationindex: number;
-};
-/** compute the fusion context — sum of model contexts or explicit override */
-declare function fusioncontext(cfg: gatewayconfig, modelsonly?: modeldef[]): number;
-/** build the upstream request body per config policy
- * model is optional: callers without a resolved model fall back to
- * cfg.defaultmodel then the meta id for the model id mapping */
-declare function buildbody(cfg: gatewayconfig, body: Record<string, unknown>, model?: modeldef, overridemodel?: string): Record<string, unknown>;
-/** reconstruct message history from db when context restoresessionhistory */
-declare function reconstructhistory(cfg: gatewayconfig, sessionid: string, incoming: unknown[]): Promise<unknown[]>;
-/** truncate messages to fit the per-call context */
-declare function fitcontext(cfg: gatewayconfig, messages: unknown[], model: modeldef | undefined): unknown[];
-/** compute backoff with jitter */
-declare function backoffms(cfg: gatewayconfig, attempt: number): number;
-/** classify a status against the retry rotate fallback sets
- * the rotate set only comes from an explicit rotation config: the old
- * implicit default (any maxretries turned on rotate-on-529-404-410) stole
- * 404 and 410 from the fallback classification a user configured
- * explicitly — rotation is declared, never inferred from retry settings */
-declare function classifystatus(cfg: gatewayconfig, status: number): "retry" | "rotate" | "fallback" | "fail";
-/**
- * createversion — the universal engine entry
- * consumes one gatewayconfig produces all 7 route handlers
- * every behavior is config driven — nothing hardcoded
- */
-export declare function createversion(cfg: gatewayconfig): versionhandlers;
-/** export internals for testing and advanced usage */
-export declare const engineinternals: {
-    resolvemodel: typeof resolvemodel;
-    findmodel: typeof findmodel;
-    fusioncontext: typeof fusioncontext;
-    buildbody: typeof buildbody;
-    classifystatus: typeof classifystatus;
-    backoffms: typeof backoffms;
-    reconstructhistory: typeof reconstructhistory;
-    fitcontext: typeof fitcontext;
-    defaultbudgets: Record<thinkinglevel, number>;
-    defaultretrystatuses: number[];
-    defaultrotatestatuses: number[];
-    defaultfallbackstatuses: number[];
-};
-export {};
-//# sourceMappingURL=engine.d.ts.map

package/dist/environments.d.ts

@@ -1,244 +0,0 @@
-/**
- * The environments module of the 1.1.90 consolidation: every correlated variation of the execution environment, emulation and sandbox rendering logic interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the execution environment family: environments holds the base grammar (the per kind requirement table, the executor registry, the offscreen document lifecycle with its worker pool plan, the executor traffic envelopes and the isolated world injection of reviewed arguments); emulation stacks the device, network, location, agent and permission presets as revertible layers with the blackbox rules that hide the stack frames of the host page; and sandboxframe renders the untrusted markup of a reviewed step inside the sandboxed page with scripts, schemes and handlers stripped before render and the result posted back through a per render nonce.
- * No pool size, preset, retention or posture is ever hardcoded: every interval, ceiling and grant stays the user's choice, and no environment ever bypasses the human review.
- */
-import type { actionkind, environmentkind, environmentrequirement, offscreenregistryentry, toolstep, workerrequest, workerresponse } from "./types.js";
-/** Reads the parse family of one offload eligible kind; a kind outside the families returns undefined. */
-export declare function offfamilyof(kind: actionkind): string | undefined;
-/** Reads the environments one action kind may run in: evaluate runs in the isolated world only, a step carrying untrusted markup renders inside the sandboxframe only, the parse heavy kinds may offload into the offscreen worker pool beside the live page and every other kind keeps the pagecontext of the page bridge. */
-export declare function environmentsof(step: Pick<toolstep, "kind" | "options">): environmentkind[];
-/** Reads the default environment of one step: the absent environment field routes to the isolated world for evaluate, the sandboxframe for untrusted markup and the pagecontext for everything else including the parse offload candidates until the user turns the offload on. */
-export declare function defaultenvironment(step: Pick<toolstep, "kind" | "options">): environmentkind;
-/** Lists the parse heavy kinds the offscreen worker pool may take over, grouped by their parse family. */
-export declare function offloadkinds(): Array<{
-    task: string;
-    kinds: string[];
-}>;
-/** Reads whether one step carries untrusted markup for rendering: a reviewed options object with a markup string renders inside the sandboxframe only, so the untrusted markup never reenters the page dom. */
-export declare function markuprenderstep(step: Pick<toolstep, "kind" | "options">): boolean;
-/** Builds the per kind environment requirement table the policy exposes: one profile per action kind with its allowed environments and its default. */
-export declare function environmentrequirementsof(kinds: actionkind[]): environmentrequirement[];
-/** Maps every environmentkind to its runtime adapter: pagecontext rides the page bridge in the live page, isolatedworld rides the scripting api world page scripts cannot touch, offscreenworker rides the offscreen document worker pool and sandboxframe rides the sandboxed page with no extension privileges. */
-export declare function executorregistry(): Array<{
-    environment: environmentkind;
-    adapter: string;
-    description: string;
-}>;
-/** Routes one step to its environment: the reviewed environment field wins when it sits inside the requirement table, the offload toggle moves parse heavy kinds into the offscreen worker pool, and a missing offscreen capability grant falls the step back to inline parsing inside the page instead of refusing the reviewed work. */
-export declare function routeenvironment(step: toolstep, input: {
-    offload: boolean;
-    granted: boolean;
-}): {
-    environment: environmentkind;
-    fallback: boolean;
-    reason: string;
-};
-/** Builds one executor traffic envelope for the offscreen worker pool: the parse family of the kind, the payload reference and the transferable keys the payload carries. */
-export declare function workerrequestof(input: {
-    id: string;
-    runid: string;
-    stepid: string;
-    kind: actionkind;
-    payload: string;
-    options?: Record<string, unknown>;
-    sentat: number;
-}): workerrequest;
-/** Reads the payload keys the executor moves as transferable buffers where possible: every ArrayBuffer value travels as a transferable so the worker owns its bytes without a copy. */
-export declare function transferablekeys(options: Record<string, unknown>): string[];
-/** Builds one worker answer to the executor: the finished result or one streamed partial chunk with its sequence number. */
-export declare function workerresponseof(input: {
-    id: string;
-    requestid: string;
-    ok: boolean;
-    result?: string;
-    partial?: number;
-    summary: string;
-    receivedat: number;
-}): workerresponse;
-/** Reads one worker answer: a partial chunk streams on while the final answer without a partial sequence completes the request, and a failed answer refuses without a result. */
-export declare function acceptworkerresponse(response: workerresponse): {
-    done: boolean;
-    partial: boolean;
-    result?: string;
-    reason: string;
-};
-/** Plans the worker pool against the pending parse queue: the pool grows with the pending parses and shrinks with the idle workers, a user configured size pins the pool with no engine cap, and an absent size lets the queue alone decide. */
-export declare function poolplan(input: {
-    pending: number;
-    current: number;
-    size?: number;
-}): {
-    workers: number;
-    added: number;
-    retired: number;
-    reason: string;
-};
-/** Spawns the offscreen document of one run on first use and reuses the same document across the steps of the run: a registry entry already open for the run carries on while the first need records its reasons and justification. */
-export declare function openoffscreen(input: {
-    registry: offscreenregistryentry[];
-    document: string;
-    runid: string;
-    reasons: string[];
-    justification: string;
-    now: number;
-}): {
-    registry: offscreenregistryentry[];
-    entry: offscreenregistryentry;
-    reused: boolean;
-};
-/** Closes the offscreen document of one run when the run completes: the registry entry records its close time so the audit reads every spawn with its teardown. */
-export declare function closeoffscreen(registry: offscreenregistryentry[], runid: string, now: number): {
-    registry: offscreenregistryentry[];
-    closed: boolean;
-};
-/** Builds the isolated world injection of one evaluate step: the scripting api injects the reviewed code inside the isolated world where page globals stay unreachable from step code, and the injection carries reviewed arguments only. */
-export declare function isolatedinjection(step: toolstep): {
-    world: "ISOLATED";
-    code: string;
-    args: string[];
-};
-/** The runsummary task family of the 1.1.63 session interface: the distillation of a completed run runs as one offscreen worker task beside the parse families. */
-export declare const runsummarytask = "runsummary";
-/** Builds the offscreen worker request of one runsummary distillation: the task family name, the run and session provenance and the distilled payload reference; the step id slot carries the session id because the distillation belongs to the whole run. */
-export declare function summaryrequestof(input: {
-    id: string;
-    runid: string;
-    sessionid: string;
-    payload: string;
-    sentat: number;
-}): workerrequest;
-import type { agentpreset, blackboxrule, devicepreset, emulationlayer, emulationstate, locationconsent, locationpreset, networkpreset, permissiongrant, permissionstate, presetlibrary, stackframe } from "./types.js";
-/**
- * Emulation layer engine for the 1.1.48 family.
- * Every correlated rule for the reviewed masks of the run lives in this file: the preset normalizers of the user curated device, network, location and agent libraries, the reviewed revert plan grammar, the layer apply and revert math with prior state capture and reverse order restore, the stacking conflict order where the last applied layer wins, the latitude, longitude and user agent grammars, the browser permission set, the blackbox pattern matching that hides third party frames from stack traces, the retention expiry of reverted layer states and the versioned preset library import and export.
- * True device metric, network condition, geolocation and user agent override needs browser debugger or platform permissions that the manifest gate forbids, so every layer applies page-injected overrides through the scripting api and shapes only the traffic the extension itself initiates; the derivation is recorded on every layer instead of hidden.
- */
-/** The emulation kinds of the 1.1.48 family, listed among the available capabilities of every proposal request. */
-export declare const emulationkinds: string[];
-/** The reviewed browser permission set of the override grammar; overrides outside this set are refused. */
-export declare const browserpermissions: string[];
-/** The reviewed permission states of an override: granted, denied or the browser default prompt. */
-export declare const permissionstates: permissionstate[];
-/** The emulation family of one emulation action kind. */
-export declare function familyofkind(kind: string): "device" | "network" | "location" | "agent" | "permission" | "blackbox" | undefined;
-/** Normalizes one user curated device preset: the name, width, height, pixel ratio and the mobile flag with every bound a user choice only. */
-export declare function devicepresetof(value: unknown): devicepreset | undefined;
-/** Normalizes one user curated network preset: the name, latency, download and upload bounds and the offline flag. */
-export declare function networkpresetof(value: unknown): networkpreset | undefined;
-/** Normalizes one user curated location preset: the name, the latitude and longitude inside the reviewed ranges and the non-negative accuracy radius. */
-export declare function locationpresetof(value: unknown): locationpreset | undefined;
-/** Normalizes one user curated agent preset: the user agent string of the reviewed grammar, the platform and the non-empty brand list reported together. */
-export declare function agentpresetof(value: unknown): agentpreset | undefined;
-/** Normalizes one reviewed permission override: the name of the reviewed browser permission set, the state of the reviewed permission states and the run scope flag. */
-export declare function permissiongrantof(value: unknown): permissiongrant | undefined;
-/** Normalizes one reviewed blackbox rule: a non-empty url pattern list where every pattern names its origin explicitly and the trace scope of profiles, traces or both. */
-export declare function blackboxruleof(value: unknown): blackboxrule | undefined;
-/** Normalizes one reviewed revert plan: a non-empty ordered list of revert steps kept beside its layer; plans without steps are refused. */
-export declare function revertplanof(value: unknown): string[] | undefined;
-/** Builds one emulation layer record with its origin scope, apply time, captured prior state and reviewed revert plan. */
-export declare function newlayer(input: {
-    id: string;
-    runid: string;
-    stepid: string;
-    family: emulationlayer["family"];
-    name: string;
-    originscope: string;
-    revertplan: string[];
-    prior?: Record<string, unknown>;
-    at: number;
-}): emulationlayer;
-/** Builds the initial emulation state of one run scoped to its tab and origin. */
-export declare function emulationstateof(input: {
-    runid: string;
-    tabid: number;
-    origin: string;
-    now: number;
-}): emulationstate;
-/** Stacks one layer onto the emulation state in apply order: a second layer of the same family replaces the first in effect while both stay in the history, so the last applied layer wins conflicts. */
-export declare function applylayer(state: emulationstate, layer: emulationlayer, at: number): emulationstate;
-/** Reverts one layer of the state by its id: the revert time stamps the record while the layer history survives for review. */
-export declare function revertlayer(state: emulationstate, layerid: string, at: number): emulationstate;
-/** Reverts every active layer of the state in reverse apply order: the reversed list is the exact restore sequence and every layer keeps its revert stamp. */
-export declare function revertalllayers(state: emulationstate, at: number): {
-    state: emulationstate;
-    reverted: emulationlayer[];
-};
-/** Returns the active layers of the state in apply order. */
-export declare function activelayers(state: emulationstate | undefined): emulationlayer[];
-/** Returns the names of the active layers for the response envelope and the review panel. */
-export declare function layernames(state: emulationstate | undefined): string[];
-/** Counts the active layers of one family so the panel can warn when layers stack on one tab. */
-export declare function stackedcount(state: emulationstate | undefined): number;
-/** True when the reviewed latitude stays inside the -90 to 90 degree range and the longitude inside the -180 to 180 degree range. */
-export declare function locationrangevalid(latitude: number, longitude: number): boolean;
-/** Validates one user agent string against the reviewed grammar: tokens of word characters, separators, slashes, spaces, numbers and version dots; the string must carry at least one token pair and refuse line breaks. */
-export declare function agentgrammarvalid(useragent: string): boolean;
-/** Grades one reviewed permission name by its power: location, camera, microphone and notification overrides carry the user's most sensitive signals and stay the highest grade. */
-export declare function permissiongrade(name: string): "powerful" | "standard";
-/** Matches one script url against a reviewed blackbox pattern of an explicit https origin with single star segments and double star subtrees. */
-export declare function blackboxmatches(urlpattern: string, url: string): boolean;
-/** Hides blackboxed frames from one stack trace: every frame whose url matches a rule pattern with a traces scope of traces or both is dropped so third party frames never enter the shaped trace. */
-export declare function hideblackboxedframes(rules: blackboxrule[], frames: stackframe[]): stackframe[];
-/** Marks one url as blackboxed when any rule with a profiles or both trace scope matches it, so the trace shaping lists the hidden third party urls. */
-export declare function blackboxedurls(rules: blackboxrule[], urls: string[]): string[];
-/** Expires the prior states of reverted layers after the retention window while the layer history itself always survives; an absent window keeps every prior state. */
-export declare function expirelayers(state: emulationstate, retention: number | undefined, now: number): emulationstate;
-/** Builds one shareable preset library file of the user curated presets; the version carries the library contract for imports through review. */
-export declare function exportpresetlibrary(input: {
-    devices: devicepreset[];
-    networks: networkpreset[];
-    locations: locationpreset[];
-    agents: agentpreset[];
-    now: number;
-}): presetlibrary;
-/** Parses one reviewed preset library file: every preset entry must pass its normalizer and a file without any valid preset is refused; unknown fields stay ignored. */
-export declare function importpresetlibrary(value: unknown): presetlibrary | undefined;
-/** True when one approved location consent of that origin covers the reviewed coordinates; the prompt shows the exact latitude and longitude before the override applies. */
-export declare function locationconsentcovers(origin: string, latitude: number, longitude: number, consents: locationconsent[]): boolean;
-import type { environmentprovenance, sandboxrender, sandboxrenderresult } from "./types.js";
-/**
- * Sandbox frame logic of the 1.1.60 family.
- * Correlated rules for untrusted markup live here: the render descriptor with its per render nonce, the stripping of scripts and event handlers before any render, the postmessage envelope the sandboxed page answers through, the nonce checked acceptance of every render result and the provenance each render records with its source origin.
- * The sandboxed page carries no extension privileges: a render result never reenters the dom outside the frame, and the untrusted markup never touches the page the session granted.
- */
-/** Strips every script and event handler from untrusted markup before render through one linear character scan, because a replace chain over reassembled payloads (`<scr<script>ipt>` or `javajavascript:script:`) reads as incomplete sanitization to static analysis even inside a convergence loop. The scan rebuilds the markup instead of removing fragments from it: a well formed tag keeps its name and its safe attributes with the script url schemes stripped from the values, every `on` event handler attribute drops, a script element drops with its whole content through the closing tag, and a malformed tag whose body carries another open angle (the reassembly payloads live on) drops entirely so no `<script` or `on...=` sequence ever survives into the sanitized output. */
-export declare function stripscripts(markup: string): string;
-/** Issues the per render nonce of one sandbox render: every message the sandboxed page answers carries the nonce of exactly one render so a stale or replayed message never passes. */
-export declare function nonceof(seed: string): string;
-/** Builds one sandbox render descriptor: the sanitized markup, the per render nonce and the source origin of the untrusted markup, ready for the sandboxed page that holds no extension privileges. */
-export declare function sandboxrenderof(input: {
-    id: string;
-    markup: string;
-    sourceorigin: string;
-    stepid: string;
-    now: number;
-}): sandboxrender;
-/** Builds the postmessage envelope the executor posts into the sandboxed page: the render nonce and the sanitized markup travel together so the frame answers with the same nonce only. */
-export declare function rendermessage(render: sandboxrender): {
-    channel: string;
-    type: string;
-    nonce: string;
-    markup: string;
-};
-/** Accepts one sandbox render result posted back through postmessage: the nonce must answer exactly one known unanswered render, an unknown, replayed or already answered nonce refuses, and the accepted result stays plain text that never reenters the dom outside the frame. The returned renders carry the answeredat marker of the accepted render so the caller threads the closed render out of its pending set. */
-export declare function acceptrenderresult(input: {
-    renders: sandboxrender[];
-    message: {
-        channel?: string;
-        type?: string;
-        nonce?: string;
-        ok?: boolean;
-        text?: string;
-        summary?: string;
-    };
-    now: number;
-}): {
-    accepted: boolean;
-    result?: sandboxrenderresult;
-    reason: string;
-    renders: sandboxrender[];
-};
-/** Reads the provenance of one sandbox render: the source origin, the step and the sandboxframe environment land beside the stored render so the audit reads where every untrusted markup came from. */
-export declare function renderprovenance(render: sandboxrender): environmentprovenance;
-//# sourceMappingURL=environments.d.ts.map

package/dist/evidence.d.ts

@@ -1,277 +0,0 @@
-/** The evidence module of the 1.1.90 consolidation: every correlated variation of the capture forensics and the run comparison logic interned in this one file, so the module family carries one surface without duplicate variations. */
-import type { beforeafterpair, capturebundle, capturenamerule, consoletraceentry, diffbaserecord, diffresult, nettraceentry, outputcomparesession, provlogentry, runlogentry, timelapseconfig, timelapseframe, thumbnailrecord } from "./types.js";
-/**
- * Capture forensics logic of the 1.1.78 family.
- * Every correlated rule for recording what a run changed lives in this one module: the beforeafter pairing that captures the page state around every action step, skips the pre capture for read only steps because a page a read never changed needs no before state, and links both captures to the stepid they wrap; the consoletimeline that collects the console entries in capture order, attaches the stepid active at each entry, preserves the run wide sequence numbers across page reloads and classifies errors, warnings and logs by level; the nettimeline that collects the request and response trace entries, attaches each entry to the step running at its timestamp and joins the request and response sides through the correlateids map of the run; the diffbase baseline that freezes one stored screenshot for one page state under the user configured threshold; the diffshot comparison that runs a new capture against its baseline through the pixel diff seam, computes the changed regions by pixel blocks, reports the similarity score and flags the visual regression only above the user threshold; the thumbshot sizing that keeps a configurable maximum edge; the timelapse that captures a changing page on the user interval, stops on the plan completion or the user stop and assembles its frames into an ordered sequence; the namecaptures naming that builds the lowercase file names from the plan, step and timestamp parts and keeps them unique per run with a counter; and the exportcaptures bundling that assembles the captures, the timelines, the diffs, the thumbnails and the lapse frames into one export payload with the provlog provenance of every capture, because a bundle without provenance never leaves the device.
- * The module extends the reviewed families instead of duplicating them: the capture rectangle grammar rides the ocrregion shape the vision family already reads, the correlation joining composes the correlateids map the web api family of the 1.1.76 release already assigns, the console levels and sources reuse the loglevel and timelinesource grammars the run timeline family serves, and the naming carries the capturename grammar of the files family forward into the lowercase identifier rule.
- * Every impure move stays behind an injected seam — the pixel diff and the capture grab resolve through functions the executor wires — while every threshold, interval, edge, retention and duration stays the user's with no code default: an absent value never hides a hardcoded ceiling, an absent diff threshold never flags a regression, an absent thumbnail edge never rescales a capture, and no forensic path ever bypasses a review.
- */
-/** Pixel diff seam: one baseline image and one capture image with the reviewed block grid resolve to the image size and the per block changed pixel fractions in row major order; the extension executor wires the capture canvas pixel walk, tests wire plain fixtures. */
-export type pixeldiff = (baseline: string, capture: string, grid: {
-    cols: number;
-    rows: number;
-}) => Promise<{
-    width: number;
-    height: number;
-    blocks: number[];
-}>;
-/** Capture grab seam: one live tab resolves to the grabbed capture with its id, bytes, size and capture time; the extension executor wires the tab capture, tests wire plain fixtures. */
-export type capturegrab = () => Promise<{
-    id: string;
-    bytes: string;
-    width: number;
-    height: number;
-    at: number;
-}>;
-/** The forensic kinds of the 1.1.78 family, listed among the available capabilities of every proposal request. */
-export declare const forensickinds: string[];
-/**
- * Builds the beforeafter pair around one action step: a sensitive or interactive step captures the pre state and the post state, both linked to the stepid the pair wraps, while a read only step skips the pre capture because a page a read never changed needs no before state; the pair records the step kind and the heartbeat beat so the forensic view names what changed the page and which beat window the pair landed under.
- */
-export declare function beforeafter(input: {
-    runid: string;
-    stepid: string;
-    stepkind: string;
-    risk: string;
-    pre?: {
-        id: string;
-        at: number;
-    };
-    post?: {
-        id: string;
-        at: number;
-    };
-    beat?: number;
-    now: number;
-    id?: string;
-}): {
-    pair: beforeafterpair;
-    skipped?: "precapture" | "postcapture";
-    reason: string;
-};
-/**
- * Collects the console entries of one run into the forensic timeline: the entries sort into capture order, each entry attaches the stepid active at its timestamp, the run wide sequence numbers climb across page reloads so a reload never resets the ordering, and the level classification keeps errors, warnings and logs apart by the loglevel grammar.
- */
-export declare function consoletimeline(input: {
-    runid: string;
-    entries: Array<{
-        level?: string;
-        text: string;
-        source?: string;
-        at: number;
-        reload?: number;
-    }>;
-    steps: Array<{
-        id: string;
-        startedat: number;
-        endedat?: number;
-    }>;
-    beat?: number;
-    startsequence?: number;
-    now: number;
-}): consoletraceentry[];
-/**
- * Collects the request and response trace entries of one run into the forensic net timeline: each entry attaches to the step running at its timestamp, the correlation map of the run joins the request and its response through the shared correlation id — the correlateids grammar of the 1.1.76 family — and a request without its pair stays unjoined so the gap names itself instead of inventing a status.
- */
-export declare function nettimeline(input: {
-    runid: string;
-    entries: Array<{
-        url: string;
-        method: string;
-        status?: number;
-        at: number;
-        correlationid?: string;
-        requestid?: string;
-    }>;
-    steps: Array<{
-        id: string;
-        startedat: number;
-        endedat?: number;
-    }>;
-    correlations: Array<{
-        requestid: string;
-        correlationid: string;
-        responseid?: string;
-        status?: number;
-    }>;
-    beat?: number;
-}): nettraceentry[];
-/**
- * Stores one diff baseline for a page state: the baseline freezes the stored capture under its page state label and the user configured similarity threshold; the threshold rides the user choice with no code default so an absent value never flags a regression on its own.
- */
-export declare function diffbase(input: {
-    runid: string;
-    captureid: string;
-    pagestate: string;
-    threshold?: number;
-    beat?: number;
-    now: number;
-    id?: string;
-}): diffbaserecord;
-/**
- * Compares one new capture against its diff baseline through the pixel diff seam: the seam walks the two images block by block over the reviewed grid, the changed blocks merge into region rectangles in css pixels, the similarity score reports the agreeing block fraction between zero and one, and the visual regression flag answers the user threshold alone — an absent threshold never flags because the bound stays the user's choice with no code default.
- */
-export declare function diffshot(input: {
-    baseline: diffbaserecord;
-    capture: {
-        id: string;
-        bytes: string;
-        width: number;
-        height: number;
-    };
-    diff: pixeldiff;
-    blocks?: {
-        cols: number;
-        rows: number;
-    };
-    stepid?: string;
-    beat?: number;
-    now: number;
-    id?: string;
-}): Promise<diffresult & {
-    summary: string;
-}>;
-/**
- * Sizes one thumbnail for the capture log: the user configured maximum edge scales the capture while the aspect ratio holds, the longer edge lands exactly on the reviewed bound, and an absent edge keeps the thumbnail at its capture size because the bound never defaults in code.
- */
-export declare function thumbshot(input: {
-    runid: string;
-    capture: {
-        id: string;
-        width: number;
-        height: number;
-    };
-    edge?: number;
-    now: number;
-    id?: string;
-}): {
-    thumb: thumbnailrecord;
-    width: number;
-    height: number;
-    scale: number;
-    reason: string;
-};
-/**
- * Plans one timelapse from the user reviewed interval and duration: the frames capture at startedat + k times the interval while they sit inside the duration, the lapse stops on the plan completion or the user stop — a stop before the end clamps the frame list — and every bound stays the user's with no code floor, so a missing interval leaves the lapse to the explicit user start.
- */
-export declare function timelapse(input: {
-    runid: string;
-    interval: number;
-    duration: number;
-    startedat: number;
-    stoppedat?: number;
-}): {
-    config: timelapseconfig;
-    frames: number;
-    stopsat: number;
-    reason: string;
-};
-/**
- * Assembles the lapse frames into the ordered sequence the playback reads: the frames sort by their sequence numbers so a late stored frame lands in its place, and a duplicate sequence keeps the newest capture because one frame slot answers one capture.
- */
-export declare function assemblelapse(frames: timelapseframe[]): timelapseframe[];
-/**
- * Builds the capture file names from the reviewed naming rule: the lowercase pattern stamps the {plan}, {step}, {timestamp} and {sequence} parts, every name folds into the lowercase identifier rule, and a name that already sits inside the run bumps its counter suffix so the names stay unique per run.
- */
-export declare function namecaptures(input: {
-    rule: capturenamerule;
-    parts: Array<{
-        plan: string;
-        step: string;
-        timestamp: number;
-        sequence: number;
-    }>;
-    taken?: string[];
-}): {
-    names: string[];
-    taken: string[];
-    reason: string;
-};
-/**
- * Assembles the export bundle of the forensic surface: the captures, their beforeafter pairs, the console and net timeline counts, the diff results, the thumbnails and the lapse frames bundle under their capture names, and every capture must carry its provlog provenance entry — a payload without provenance entries refuses loudly because an export that cannot answer where its captures came from never leaves the device.
- */
-export declare function exportcaptures(input: {
-    runid: string;
-    captures: string[];
-    pairs: string[];
-    consoleentries: number;
-    netentries: number;
-    diffs: string[];
-    thumbnails: string[];
-    lapses: string[];
-    names: Array<{
-        captureid: string;
-        name: string;
-    }>;
-    provlog: provlogentry[];
-    masked: boolean;
-    now: number;
-    id?: string;
-}): capturebundle;
-/**
- * Outputcompare logic of the 1.1.66 family.
- * Two competing runs stand beside each other here: the join pairs the runs on their step sequence, each pair grades its agreement, divergence and duration delta, the first divergent step highlights, and the metric set the session used records in the audit trail.
- * The comparison never executes a step and never reads the page: it joins the stored runlog outcomes only, so an outputcompare session touches no browser state.
- */
-/** Reads the task input signature of one run: the objective digest proxy over its step kinds and step count that two comparable runs must share. */
-export declare function taskinputsignatureof(input: {
-    objective: string;
-    steps: string[];
-}): string;
-/** Reads the default metric set of one comparison session: agreement, divergence and the duration delta of every step pair. */
-export declare function comparemetricdefaults(): string[];
-/** Joins the runlogs of two runs on their step sequence: the pairs walk the shared step ids in order while a step only one run carries grades as onlyone. */
-export declare function joinruns(logsa: runlogentry[], logsb: runlogentry[]): Array<{
-    stepid: string;
-    index: number;
-    a?: runlogentry;
-    b?: runlogentry;
-}>;
-/** Grades one joined step pair: the pair agrees when both runs completed the step with the same state, diverges when their states or summaries differ and onlyone marks a step one run lacks. */
-export declare function stepcomparisonof(pair: {
-    stepid: string;
-    index: number;
-    a?: runlogentry;
-    b?: runlogentry;
-}): {
-    stepid: string;
-    index: number;
-    agreement: "agree" | "diverge" | "onlyone";
-    summarya: string;
-    summaryb: string;
-    durationdelta: number;
-};
-/** Reads the first divergent step of one comparison; an absent index marks agreement across the whole sequence. */
-export declare function firstdivergenceof(steps: Array<{
-    stepid: string;
-    index: number;
-    agreement: "agree" | "diverge" | "onlyone";
-}>): number | undefined;
-/** Builds one outputcompare session of two runs that share a task input signature: the join, the per step grades and the metric set the session used. */
-export declare function outputcomparesessionof(input: {
-    runids: [string, string];
-    logsa: runlogentry[];
-    logsb: runlogentry[];
-    metrics?: string[];
-    now: number;
-}): outputcomparesession;
-/** Reads the metric summary of one comparison session for the audit trail: the metric set beside the agree, diverge and onlyone counts and the first divergence. */
-export declare function comparesessionmetrics(session: outputcomparesession): {
-    metrics: string[];
-    agree: number;
-    diverge: number;
-    onlyone: number;
-    firstdivergence?: number;
-    reason: string;
-};
-/** Reads the side by side view of one comparison session: one row per joined step with both summaries and the duration delta beside the divergence highlight. */
-export declare function outputcompareview(session: outputcomparesession): Array<{
-    stepid: string;
-    index: number;
-    agreement: string;
-    summarya: string;
-    summaryb: string;
-    durationdelta: number;
-    highlighted: boolean;
-}>;
-//# sourceMappingURL=evidence.d.ts.map