@wenathlan/devthink 2.0.12 → 2.0.14

package/dist/run.d.ts

@@ -0,0 +1,779 @@
+/**
+ * The run module of the 1.1.90 consolidation: every correlated variation of the run logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the run lifecycle itself, ordered from the base outward: runstate holds the typed run state every other variation builds on (the keepalive heartbeat trail, the url history, the environment and turnaround provenance, the restart recovery, the zombie reaping, the storage level run lock, the integrity sealing and the quota pruning); resilience continues the same lifecycle at the runrecord level (the legal state machine, the offline queue with its replay, the checkpoints, the heartbeat staleness window, the zombie check beside the reap audit event and the rollback compensation the user chooses); runhistory keeps the per run url visits, the merged runtimeline stream, the tab isolation namespace and the session lock that serializes concurrent runs; runtimeline deepens the observation side of the same runs (console, error, rejection, long task and network failure capture with redaction, spam collapse, rotation and the console diff between two runs); runbudget guards the step and memory ceilings with the timeoutcancel bound; runresume, runreplay and runparallel optimize the identical lifecycle (the checkpoint resume with fingerprint revalidation, the audit walk replay of a sealed run and the parallel read lanes with carried selectors); and backgroundruns closes the family with the queue that keeps reviewed workflows executing with no open surface, holding the same keepalive signal of the base lifecycle.
+ * No window, depth, retention or ceiling is ever hardcoded anywhere in the family: every interval, tolerance, budget and bound stays the user's choice, and no recovery, replay, rollback or queue path ever bypasses the human review.
+ */
+import type { environmentkind, runlock, runstaterecord, sealedrunstate } from "./types.js";
+/**
+ * Run state logic of the 1.1.60 family.
+ * Correlated rules for the typed run state live here: the keepalive lifecycle with its start and stop events, its heartbeat trail and its reattach after a service worker restart, the url history of every navigation inside the run, the environment and worker turnaround of every step, the restart recovery of the pending step, the zombie reaping of runs whose heartbeat fell silent, the storage level run lock that holds a session against concurrent runs, the serialization of steps that share one tab across parallel branches, the integrity sealing of persisted run state and the quota pruning under storage pressure.
+ * No interval, window or lock expiry is ever hardcoded: the heartbeat interval, the zombie tolerance and the lock expiry stay user choices, the run state persists on every heartbeat, and no recovery path ever bypasses the human review.
+ */
+/** Opens one run state: the keepalive port opens, the start event records and the run waits for its first heartbeat. */
+export declare function openrun(input: {
+    runid: string;
+    sessionid: string;
+    planid: string;
+    profileid: string;
+    interval: number;
+    now: number;
+}): runstaterecord;
+/** Emits one keepalive heartbeat: the beat counter grows, the last beat time moves and the event trail records the beat so the persisted state carries it into any restart recovery. */
+export declare function beatrun(state: runstaterecord, now: number): runstaterecord;
+/** Closes one run at its terminal state: the keepalive port closes, the stop event records and the run state freezes for the audit trail. */
+export declare function closerun(state: runstaterecord, now: number): runstaterecord;
+/** Reattaches the keepalive port after a service worker restart: the persisted state rehydrates, the reattach event records and the pending step stays exactly where the run stopped. */
+export declare function reattachrun(state: runstaterecord, now: number): runstaterecord;
+/** Records one navigation inside the run: every url the run visits lands its history entry so the audit reads the full route of the run. */
+export declare function recordurl(state: runstaterecord, entry: {
+    url: string;
+    stepid: string;
+    now: number;
+}): runstaterecord;
+/** Records the environment of one executed step with its provenance: the step id, the environment and the origin land in the run state beside the outcome. */
+export declare function recordenvironment(state: runstaterecord, input: {
+    stepid: string;
+    environment: environmentkind;
+    origin: string;
+    now: number;
+}): runstaterecord;
+/** Records the worker turnaround of one offloaded step: the milliseconds between the worker request and its answer land in the run state for later profiling. */
+export declare function recordturnaround(state: runstaterecord, input: {
+    stepid: string;
+    milliseconds: number;
+    now: number;
+}): runstaterecord;
+/** Marks the pending step of one run for restart recovery: the executor resumes exactly this step after the service worker restart, and no other step ever moves. */
+export declare function markpending(state: runstaterecord, stepid: string | undefined, now: number): runstaterecord;
+/** Reads the recovery plan of one interrupted run: the pending step names the single step the executor resumes, and a run without a pending step starts over through the same review instead of guessing. */
+export declare function recoveryplan(state: runstaterecord): {
+    runid: string;
+    pendingstepid?: string;
+    recoverable: boolean;
+    reason: string;
+};
+/** Sweeps the zombie runs whose heartbeat fell silent: a run whose last beat sits past the tolerated silent intervals reaps, while a live run keeps its state; the tolerance stays the user configured number of intervals. */
+export declare function zombiesweep(input: {
+    states: runstaterecord[];
+    now: number;
+    interval: number;
+    missedlimit: number;
+}): {
+    states: runstaterecord[];
+    reaped: string[];
+};
+/** Acquires the storage level run lock of one session: a session with no live lock gains its run lock while a concurrent run of the same session refuses, so one session never carries two runs at once. */
+export declare function acquirerunlock(input: {
+    locks: runlock[];
+    sessionid: string;
+    runid: string;
+    holder: string;
+    expiresat?: number;
+    now: number;
+}): {
+    locks: runlock[];
+    acquired: boolean;
+    reason: string;
+};
+/** Releases the storage level run lock of one session: the run that holds the lock frees it while another holder refuses. */
+export declare function releaserunlock(input: {
+    locks: runlock[];
+    sessionid: string;
+    runid: string;
+    now: number;
+}): {
+    locks: runlock[];
+    released: boolean;
+    reason: string;
+};
+/** Expires the run locks past their user configured expiry: an expired lock frees its session while a lock without an expiry keeps holding until its run releases it. */
+export declare function expirerunlocks(locks: runlock[], now: number): {
+    locks: runlock[];
+    expired: string[];
+};
+/** Serializes the steps that share one tab across parallel branches: every branch keeps its inner order while the shared tab receives one deterministic lane, so two branches never touch one tab inside the same beat. */
+export declare function serializesteps(input: {
+    branches: Array<{
+        branchid: string;
+        steps: Array<{
+            stepid: string;
+            tabid: number;
+        }>;
+    }>;
+}): Array<{
+    branchid: string;
+    stepid: string;
+    tabid: number;
+    order: number;
+}>;
+/** Seals one persisted run state with its sha-256 integrity digest: the payload and its digest travel together so a tampered run state at rest stays detectable before any recovery uses it. */
+export declare function sealrunstate(state: runstaterecord): Promise<sealedrunstate>;
+/** Opens one sealed run state: the digest must match the payload before the recovery reads it, and a tampered or malformed seal refuses. */
+export declare function openseal(sealed: sealedrunstate): Promise<runstaterecord>;
+/** Prunes the stored run states under storage pressure: the oldest completed run states leave first while every active or recovered run keeps its state, and the pruned ids name what left. */
+export declare function prunerunstates(input: {
+    states: runstaterecord[];
+    used: number;
+    ceiling: number;
+}): {
+    states: runstaterecord[];
+    pruned: string[];
+    reason: string;
+};
+/** Exports the run states as one single audit record: every run, its url history, its environments, its turnarounds and its keepalive trail in one envelope the auditor reads at once. */
+export declare function exportrunstate(states: runstaterecord[], now: number): {
+    runs: number;
+    urls: number;
+    environments: number;
+    offloaded: number;
+    beats: number;
+    exportedat: number;
+};
+import type { agentplan, auditevent, checkpointrecord, heartbeatrecord, planprogress, rollbackitem, runrecord, runsettings, runstate, runtransition, queuedtask, toolstep } from "./types.js";
+/**
+ * Run lifecycle logic of the 1.1.70 family.
+ * The runstatemachine tracks every legal transition of a run so a service worker restart or a lost connection never loses work: approved plans queue offline with monotonic sequences, steps carry deterministic idempotencykeys so replays deduplicate, checkpoints capture the completed steps with their page digest, heartbeats time the live runs, zombies reap through the audit trail, and failed runs roll back through compensating steps the user explicitly chooses.
+ * No window, depth or retention is ever hardcoded: the heartbeat staleness window, the offline queue depth and the failed run retention stay user choices, and no recovery, replay or rollback path ever bypasses the human review.
+ */
+/** The documented heartbeat staleness window the roadmap names while the configured window stays the user's choice with no code ceiling. */
+export declare const roadmapheartbeatwindow = 60000;
+/** The legal transitions of each runstate: queued runs start or cancel, running runs pause, complete, fail or cancel, paused and awaitingapproval runs resume or stop, and only a failed or cancelled run rolls back. */
+export declare function runstatemachine(): Record<runstate, runstate[]>;
+/** Reads whether one run transition stays legal inside the state machine: every state allows only the pairs its lifecycle defines. */
+export declare function transitionislegal(transition: runtransition): boolean;
+/** Moves one runrecord through a single legal transition or throws: an illegal transition never silently mutates the run state. */
+export declare function advancerun(run: runrecord, to: runstate, now: number): runrecord;
+/** Creates one runrecord in the queued state for an approved plan: the run waits in the offlinequeue or the executor before it ever runs. */
+export declare function initialrun(input: {
+    planid: string;
+    sessionid: string;
+    now: number;
+    runid?: string;
+}): runrecord;
+/** Derives the deterministic idempotencykey of one step from its plan and step identity so a replay of the same step deduplicates on the same key. */
+export declare function stepkey(input: {
+    planid: string;
+    stepid: string;
+    kind: string;
+}): string;
+/** Returns the count of tasks waiting in the offlinequeue. */
+export declare function queuesize(queue: queuedtask[]): number;
+/** Appends one approved plan to the offlinequeue with a monotonic sequence number so the replay drains the tasks in their enqueue order. */
+export declare function enqueueoffline(queue: queuedtask[], input: {
+    plan: agentplan;
+    sessionid: string;
+    now: number;
+}): queuedtask[];
+/** Returns the next queuedtask in sequence order and the queue without it; an empty queue returns no task. */
+export declare function dequeueoffline(queue: queuedtask[]): {
+    queue: queuedtask[];
+    task?: queuedtask;
+};
+/** Reads the replay plan of the offlinequeue once connectivity returns: every task drains in sequence order while the tasks whose plan window passed offline expire and fail instead of running. */
+export declare function replayqueue(queue: queuedtask[], now: number): {
+    ready: queuedtask[];
+    expired: queuedtask[];
+};
+/** Captures one checkpoint of a run: the completed step ids, the step boundary, the page digest a resume revalidates and the timestamp. */
+export declare function makecheckpoint(input: {
+    runid: string;
+    stepid: string;
+    completed: string[];
+    digest: string;
+    now: number;
+}): checkpointrecord;
+/** Returns the steps that follow the last stored checkpoint so the resume continues at the first open step instead of repeating completed work. */
+export declare function resumecheckpoint(input: {
+    checkpoint: checkpointrecord | undefined;
+    steps: string[];
+}): string[];
+/** Verifies one checkpointrecord against its run and page digest: a checkpoint of another run or a page that changed since the capture never validates. */
+export declare function checkpointisvalid(input: {
+    checkpoint: checkpointrecord;
+    runid: string;
+    digest: string;
+}): boolean;
+/** Refreshes the heartbeatrecord of a running run: the beat counter grows and the last beat time moves so the zombiecheck sees the run alive. */
+export declare function runheartbeat(input: {
+    runid: string;
+    beat?: number;
+    now: number;
+}): heartbeatrecord;
+/** Reads whether the last heartbeat of a run sits older than the configured window: a stale heartbeat turns a running run into a zombie candidate. */
+export declare function heartbeatisstale(input: {
+    heartbeat: heartbeatrecord | undefined;
+    now: number;
+    window: number;
+}): boolean;
+/** Loads the user configured heartbeat staleness window without a hard cap: an absent setting keeps the documented roadmap window while every configured value stays the user's choice. */
+export declare function heartbeatwindowof(settings: runsettings | undefined): number;
+/** Lists the running runs whose heartbeat is stale: every run past its staleness window names a zombie candidate the reaper may reap. */
+export declare function zombiecheck(input: {
+    runs: runrecord[];
+    heartbeats: Record<string, heartbeatrecord>;
+    now: number;
+    window: number;
+}): runrecord[];
+/** Transitions one zombie run to failed and records its reap audit event: the reaped run keeps its record for the audit trail while it never executes again. */
+export declare function reaprun(run: runrecord, now: number): {
+    run: runrecord;
+    event: auditevent;
+};
+/** Lists the mutating steps a run already executed: every executed step that is not read only names a side effect the rollback must compensate. */
+export declare function sideeffects(steps: toolstep[], executedstepids: string[]): toolstep[];
+/** Builds the compensating steps of a failed run for its executed side effects; read only steps carry no compensation at all because they changed nothing. */
+export declare function rollbackrun(input: {
+    runid: string;
+    steps: toolstep[];
+    executedstepids: string[];
+    origin: string;
+    now: number;
+}): rollbackitem[];
+/** Moves one run to cancelled and returns the rollback choice the cancel pairs with: the cancel itself never executes a compensation without the explicit user choice. */
+export declare function cancelrunrecord(run: runrecord, now: number): runrecord;
+/** Pairs one cancellation with its optional rollback execution: the choice rollback builds the compensating steps while the choice none stops the run with its state frozen for the audit trail. */
+export declare function cancelrollback(input: {
+    run: runrecord;
+    steps: toolstep[];
+    executedstepids: string[];
+    origin: string;
+    choice: "rollback" | "none";
+    now: number;
+}): {
+    run: runrecord;
+    compensations: rollbackitem[];
+    reason: string;
+};
+/** Transitions one run to failed and freezes its progress snapshot so the failure keeps exactly the state it failed at. */
+export declare function runfail(input: {
+    run: runrecord;
+    progress?: planprogress;
+    now: number;
+}): {
+    run: runrecord;
+    frozen?: planprogress;
+};
+/** Transitions one run to completed only when iscomplete reports the plan finished; an unfinished run never completes. */
+export declare function runcomplete(input: {
+    run: runrecord;
+    plan: agentplan;
+    progress?: planprogress;
+    now: number;
+}): runrecord;
+/** Rebuilds one runrecord after a service worker restart: the persisted plan restores its run with its original timestamps while an expired or unapproved plan rebuilds as failed because it never resumes. */
+export declare function runfromplan(plan: agentplan, sessionid: string, now: number): runrecord;
+/** Returns the summary of one run: its state, its step counts against its plan, its checkpoint position and its last update. */
+export declare function runsummaryof(input: {
+    run: runrecord;
+    plan: agentplan;
+    progress?: planprogress;
+    checkpoint?: checkpointrecord;
+}): {
+    runid: string;
+    state: runstate;
+    steps: number;
+    completed: number;
+    checkpointstep?: string;
+    updatedat: number;
+};
+import type { agentsession, lockrecord, runtimelineevent, tabstate, urlvisit } from "./types.js";
+/**
+ * Run history logic of the 1.1.71 state depth family.
+ * Every run keeps its own urlhistory and timeline: urlvisit entries append per navigation with consecutive duplicates folded, the runtimeline merges step results, audit events and url visits into one ordered stream with phase buckets, tabisolate namespaces the memory keys per tab so runs never share state, and the sessionlock serializes concurrent runs on one session while it names its holder and expires its abandoned locks.
+ * No window stays hardcoded: the lock expiry window reads the user setting with no code ceiling, urlhistory stays scoped per run and never merges runs, and no lock, visit or timeline path ever bypasses the review.
+ */
+/** The documented lock expiry window the roadmap names while the configured window stays the user's choice with no code ceiling. */
+export declare const roadmaplockwindow = 120000;
+/** Builds one urlvisit of a navigation inside a run: the url, the page title, the time and the run it belongs to. */
+export declare function visitof(input: {
+    url: string;
+    title?: string;
+    runid: string;
+    now: number;
+}): urlvisit;
+/** Appends one urlvisit to the urlhistory of a run: consecutive visits to the same url fold into one entry so the history reads as the real route, and the visits of one run never merge with another run. */
+export declare function appendvisit(visits: urlvisit[], visit: urlvisit): urlvisit[];
+/** Builds one runtimeline event of a step result: the step identity, its outcome summary and its timestamp inside the run. */
+export declare function stepeventof(input: {
+    runid: string;
+    stepid: string;
+    summary: string;
+    ok: boolean;
+    now: number;
+}): runtimelineevent;
+/** Builds one runtimeline event of an audit event so the timeline carries the audit trail beside the steps. */
+export declare function auditeventof(event: auditevent): runtimelineevent;
+/** Builds one runtimeline event of a url visit so the timeline carries the route beside the steps. */
+export declare function visiteventof(visit: urlvisit): runtimelineevent;
+/** Merges step results, audit events and url visits into one ordered runtimeline stream: every event sorts by its timestamp, the audit events carry their kind and the visits carry their route. */
+export declare function runtimelineof(input: {
+    steps: runtimelineevent[];
+    audits: runtimelineevent[];
+    visits: urlvisit[];
+    runid: string;
+}): runtimelineevent[];
+/** Buckets one runtimeline stream by phase for the timeline view: every event lands in the phase its timestamp names while the order inside a phase stays the stream order. */
+export declare function buckettimeline(events: runtimelineevent[]): Array<{
+    phase: string;
+    events: runtimelineevent[];
+}>;
+/** Derives the isolated namespace id of one tab: every memory key of the run lives under its tab namespace so runs never share state. */
+export declare function tabnamespace(tabid: number): string;
+/** Names one memory key inside the isolated namespace of its tab; the shared key stays readable beside the namespace copy. */
+export declare function tabkey(tabid: number, key: string): string;
+/** Copies the shared config into the tab namespace on demand: the tabstate carries its namespace id, its isolated run id and the copied config snapshot. */
+export declare function tabisolate(input: {
+    tabid: number;
+    config: Record<string, unknown>;
+    runid?: string;
+    now: number;
+}): tabstate;
+/** Acquires one lockrecord for a run on a session: the holder names the run, the acquisition time stamps it and the expiry window stays the user choice. */
+export declare function acquiresessionlock(input: {
+    runid: string;
+    sessionid: string;
+    window: number;
+    now: number;
+}): lockrecord;
+/** Reads whether one lock blocks a run: a lock of the same run never blocks itself, a live foreign lock blocks and names its holder while an expired lock blocks nothing because its window passed. */
+export declare function lockblocks(lock: lockrecord | undefined, runid: string, now: number): {
+    blocked: boolean;
+    reason: string;
+};
+/** Reads whether one lock belongs to a run so the release path only clears its own lock. */
+export declare function lockheldby(lock: lockrecord | undefined, runid: string): boolean;
+/** Releases the lock of a completed, failed or cancelled run: the sessionlock clears so the next reviewed run may acquire it. */
+export declare function releasesessionlock(lock: lockrecord | undefined, runid: string): boolean;
+/** Loads the user configured lock expiry window without a hard cap: an absent setting keeps the documented roadmap window while every configured value stays the user's choice. */
+export declare function lockwindowof(settings: runsettings | undefined): number;
+/** Lists the locks whose expiry window passed: every abandoned lock names an expiry candidate the startup pass clears before the zombiecheck runs. */
+export declare function stalelocks(locks: lockrecord[], now: number): lockrecord[];
+/** Attaches the acquired lockid to one agentsession so concurrent run protection travels with the session record. */
+export declare function sessionwithlock(session: agentsession, lockid: string | undefined): agentsession;
+/** Summarizes the urlhistory of one run: the visit count, its distinct origins and its first and last visit times; a run without visits carries none. */
+export declare function visitsummary(visits: urlvisit[]): {
+    count: number;
+    origins: string[];
+    first?: number;
+    last?: number;
+};
+/** Reads the final url of a completed navigation step result so the urlhistory records the url the redirect chain landed on; a result without a final url reports the planned url unchanged. */
+export declare function finalurlof(input: {
+    plannedurl: string;
+    finalurl?: string;
+}): string;
+/** Lists the navigation steps of a plan in their reviewed order: the urlhistory records one urlvisit for each completed navigation step. */
+export declare function navigationsteps(steps: toolstep[]): toolstep[];
+/** Reads the runrecord of a run with its visits attached so the record carries its urlhistory beside its lifecycle state. */
+export declare function runwithvisits(run: runrecord, visits: urlvisit[]): runrecord;
+import type { consolediff, consoleentry, errorrecord, exchangerecord, loglevel, loglevelset, longtaskentry, netfailureentry, rejectionrecord, rotationrule, spamrule, stackframe, timelineentry, timelinesource } from "./types.js";
+/**
+ * Run timeline logics for the 1.1.45 debugging family.
+ * Every correlated rule for console capture with reviewed depth bounds and secret redaction, stack frame parsing, error, rejection and resource failure capture, long task attribution windows, the timeline binding to one run and its step ids, spam collapse with reviewed thresholds, log rotation without entry loss, level and source filters, the blocking duration per step window and the console diff between two runs lives in this file.
+ * Console, error and task watching derives from page-injected listeners installed through the scripting api and the performance buffers, so no debugger permission exists anywhere in the manifest; redaction runs before any entry leaves the page bridge and captured text never carries reviewed secret patterns.
+ */
+/** The debugging kinds, listed among the available capabilities of every proposal request. */
+export declare const timelinekinds: string[];
+/** The reviewed level set, ordered from the most severe to the most verbose level. */
+export declare const loglevels: loglevel[];
+/** The reviewed timeline source grammar: page console output, script errors, promise rejections, resource failures, long tasks, failed network requests and instrumented devtools protocol events. */
+export declare const timelinesources: timelinesource[];
+/** Ranks one level inside the reviewed level set; lower ranks are more severe. */
+export declare function levelrank(level: loglevel): number;
+/** Redacts reviewed secret patterns from console text before any entry leaves the page bridge; matched patterns never survive into a stored entry. */
+export declare function redactconsoletext(text: string, patterns: string[]): string;
+/** Classifies the kind tag of one console argument for the consoleentry argument kinds. */
+export declare function argkind(value: unknown): string;
+/** Serializes one console argument through the reviewed depth bound; deeper objects collapse to their constructor tag so the bound stays a user choice with no code ceiling. */
+export declare function serializearg(value: unknown, depth: number): string;
+/** Builds one captured console entry from a forwarded console call: the level, the redacted text of every serialized argument and the argument kinds, with redaction applied before the entry exists. */
+export declare function consolecapture(input: {
+    level: loglevel;
+    args: unknown[];
+    depth: number;
+    redact: string[];
+}): consoleentry;
+/** Parses one stack trace text into stack frames with function names, urls, lines and columns; unparseable lines are skipped instead of crashing capture. */
+export declare function stackframes(stacktext: string): stackframe[];
+/** Builds one captured javascript error record body from an error event: the redacted message, the parsed stack frames, the source url and the line. */
+export declare function errorcapture(input: {
+    message: string;
+    sourceurl: string;
+    line: number;
+    stacktext?: string;
+    redact: string[];
+}): Pick<errorrecord, "message" | "frames" | "sourceurl" | "line">;
+/** Builds one captured unhandled rejection record body from the rejection reason text and its stack frames, with the reason redacted before capture. */
+export declare function rejectioncapture(input: {
+    reason: string;
+    stacktext?: string;
+    redact: string[];
+}): Pick<rejectionrecord, "reason" | "frames">;
+/** Builds the long task entry bodies of one watch window from performance longtask entries with their attribution names; the reviewed threshold filters entries below the user configured duration. */
+export declare function longtaskcapture(input: {
+    entries: Array<{
+        starttime: number;
+        duration: number;
+        attributions: string[];
+    }>;
+    threshold: number;
+}): Array<Pick<longtaskentry, "duration" | "starttime" | "attributions">>;
+/** One run timeline bound to its run and step ids. */
+export interface timeline {
+    runid: string;
+    origin: string;
+    stepids: string[];
+    attachedat: number;
+    entries: timelineentry[];
+}
+/** Binds one timeline to the run and its step ids; capture stays scoped to that run and every entry carries the run correlation id of its step. */
+export declare function attachtimeline(input: {
+    runid: string;
+    origin: string;
+    stepids: string[];
+    now: number;
+}): timeline;
+/** Applies the reviewed level set to timeline entries: per step level floors drop entries more verbose than the floor and source filters drop entries from unreviewed sources. */
+export declare function filterentries(entries: timelineentry[], levelset: loglevelset): timelineentry[];
+/** Collapses repeated identical messages inside the reviewed spam window into counts and flags the patterns that exceed the reviewed collapse threshold. */
+export declare function spamdetect(entries: timelineentry[], rule: spamrule): {
+    entries: Array<timelineentry & {
+        repeat: number;
+    }>;
+    flagged: Array<{
+        message: string;
+        count: number;
+    }>;
+};
+/** Rotates the timeline of one run: the newest entries stay inside the reviewed max entries window while every overflow entry moves to the rotation target store without data loss. */
+export declare function rotatelogs(entries: timelineentry[], rule: rotationrule): {
+    kept: timelineentry[];
+    overflow: timelineentry[];
+};
+/** Counts the timeline entries per level for the response envelope timeline block. */
+export declare function timelinecounts(entries: timelineentry[]): Record<string, number>;
+/** Sums the blocking duration of long task entries inside one step window; the window stays a reviewed value with no code ceiling. */
+export declare function blockingduration(tasks: Array<{
+    starttime: number;
+    duration: number;
+}>, stepid: string, window: {
+    startedat: number;
+    endedat: number;
+}): {
+    stepid: string;
+    blocking: number;
+    tasks: number;
+};
+/** Marks one failed request of the run in the timeline from its observed exchange: the url, status, error class and correlation id. */
+export declare function netfailureentryof(input: {
+    id: string;
+    exchange: exchangerecord;
+    at: number;
+}): netfailureentry | null;
+/** Decides whether a watcher detached early because the run tab navigated inside its watch window: navigation timestamps inside the window detach the watcher at the navigation time. */
+export declare function watcherdetached(input: {
+    startedat: number;
+    lifetime: number;
+    navigations: number[];
+}): {
+    detached: boolean;
+    at?: number;
+};
+/** Compares the console output of two runs and classifies every line as added, removed or repeated; repeated lines carry their repeat counts. */
+export declare function consolediff(input: {
+    baseid: string;
+    targetid: string;
+    baselines: string[];
+    targetlines: string[];
+    now: number;
+}): consolediff;
+import type { budgetalert, runbudgetrecord, timeoutcancelevent, timeoutcancelpolicy } from "./types.js";
+/**
+ * Runbudget logic of the 1.1.69 family.
+ * Every run tracks its step usage against the user chosen step budget and its memory pressure through the worker telemetry, the budgetalerts fire at the user chosen thresholds with their severity levels while the critical threshold pauses the run pending a user choice instead of refusing it, and the timeoutcancel aborts a slow step at the user chosen bound with the cancel event recorded in the immutable log beside the step outcome.
+ * Every budget, threshold and bound stays a user choice: the tracker measures and never caps, and the pause waits for the user instead of dropping work.
+ */
+/** Builds one runbudget record of a run: the step usage against the user chosen step budget beside the memory pressure the worker telemetry reported. */
+export declare function runbudgetof(input: {
+    runid: string;
+    steps: number;
+    stepbudget?: number;
+    pressure: number;
+    memorybudget?: number;
+    now: number;
+}): runbudgetrecord;
+/** Reads the budgetalerts of one runbudget record: the warning threshold fires its warning while the critical threshold fires its critical alert that pauses the run pending a user choice; an absent threshold keeps the alert informational only. */
+export declare function budgetalertstate(input: {
+    budget: runbudgetrecord;
+    thresholds?: {
+        warning?: number;
+        critical?: number;
+    };
+}): budgetalert[];
+/** Reads whether one run pauses for its budgetalerts: only a critical alert pauses the run pending a user choice while every warning stays informational. */
+export declare function runpausesforalerts(alerts: budgetalert[]): boolean;
+/** Reads the timeoutcancel decision of one step: the step aborts at the user chosen bound while an absent bound never aborts a step because the bound stays a user choice. */
+export declare function timeoutcanceldecision(input: {
+    elapsed: number;
+    bound?: number;
+}): {
+    abort: boolean;
+    reason: string;
+};
+/** Builds one timeoutcancel event: the aborted step, its bound, its elapsed time and the immutable log entry the cancel wrote beside the step outcome. */
+export declare function timeoutcanceleventof(input: {
+    runid: string;
+    stepid: string;
+    bound: number;
+    elapsed: number;
+    now: number;
+    logged: boolean;
+}): timeoutcancelevent;
+/** Reads the timeoutcancel policies of one plan: one policy per step carrying the user chosen bound, and an absent bound keeps every policy unbounded. */
+export declare function timeoutcancelpolicies(input: {
+    steps: string[];
+    bound?: number;
+}): timeoutcancelpolicy[];
+import type { navdedupeentry, resumepoint, runcacheentry, stepprefetchhint } from "./types.js";
+/**
+ * Runresume logic of the 1.1.69 family.
+ * The efficientresume checkpoints every step boundary with its cursor and its page digest, skips the completed steps after a restart and revalidates the page fingerprint before it resumes, the navdedupe skips navigations to the already active url and folds repeated planned visits into one navigation, the runcache stores fetched resources per run keyed by their digest, serves the repeat fetches of the same run and clears at the run end unless the user pins the profile cache, and the stepprefetch derives its likely next pages and likely next selectors from the plan structure alone.
+ * The resume, the dedupe and the prefetch optimize the run only: they never skip a review and never fetch a page the reviewed plan never named.
+ */
+/** Builds one efficientresume checkpoint: the step boundary with its cursor and the digest of the page fingerprint the resume revalidates. */
+export declare function resumepointof(input: {
+    runid: string;
+    stepid: string;
+    cursor: number;
+    digest: string;
+    now: number;
+}): resumepoint;
+/** Reads the skip plan after a restart: the steps with a checkpoint skip while the resume continues at the first step without one. */
+export declare function skipcompletedsteps(input: {
+    checkpoints: resumepoint[];
+    steps: string[];
+}): {
+    skip: string[];
+    resumeat?: string;
+};
+/** Revalidates the page fingerprint before one resume: a matching digest resumes while a changed fingerprint refuses so the resume never continues against a different page. */
+export declare function revalidatefingerprint(input: {
+    checkpoint: resumepoint;
+    fingerprint: string;
+}): {
+    ok: boolean;
+    reason: string;
+};
+/** Reads the navdedupe verdict of one planned navigation: a navigation to the already active url skips while every other navigation runs. */
+export declare function navdedupeverdict(input: {
+    url: string;
+    activeurl: string;
+}): {
+    skip: boolean;
+    reason: string;
+};
+/** Folds repeated planned visits into one navigation per url: every step that plans the same url merges into one navdedupe entry. */
+export declare function foldplannedvisits(steps: Array<{
+    id: string;
+    url?: string;
+}>): navdedupeentry[];
+/** Reads the digest key of one fetched resource within one run so the runcache stores and serves it by digest. */
+export declare function runcachedigest(input: {
+    runid: string;
+    resource: string;
+}): string;
+/** Serves one repeat fetch from the runcache: a stored entry of the same run and the same resource answers the fetch while no stored entry keeps the fetch running. */
+export declare function runcachehit(entries: runcacheentry[], input: {
+    runid: string;
+    resource: string;
+}): runcacheentry | undefined;
+/** Reads the runcache sweep of one run end: the entries clear at the run end while the pinned entries of the user profile cache survive. */
+export declare function runcachesweep(entries: runcacheentry[], input: {
+    runid: string;
+    pin: boolean;
+}): {
+    kept: runcacheentry[];
+    cleared: number;
+};
+/** Derives the stepprefetch hints from the plan structure alone: every step names its likely next page from the next planned navigation and its likely next selectors from the targets of the steps that follow, so the warming never reaches a page the reviewed plan never named. */
+export declare function stepprefetchhints(plan: {
+    steps: Array<{
+        id: string;
+        kind: string;
+        value?: string;
+        target?: string;
+    }>;
+}): stepprefetchhint[];
+import type { immutablelogentry, runreplaysession, runreplaystep } from "./types.js";
+/** Builds one replay step of a log entry with its gate resolutions: the step annotates the gate the run waited at when the entry carries one. */
+export declare function replaystepof(entry: immutablelogentry, index: number, gates: Array<{
+    gateid: string;
+    kind: string;
+    resolution: string;
+    at: number;
+}>): runreplaystep;
+/** Builds one runreplay session of a sealed run: one replay step per verified log entry in order, the cursor starts before the first step and the viewer actions start empty. */
+export declare function runreplaysessionof(input: {
+    runid: string;
+    entries: immutablelogentry[];
+    gates?: Array<{
+        gateid: string;
+        kind: string;
+        resolution: string;
+        at: number;
+    }>;
+    now: number;
+}): runreplaysession;
+/** Moves the replay cursor one step forward or backward; the cursor stays inside the step list because a replay walks its recorded chain only. */
+export declare function replaymove(session: runreplaysession, direction: "forward" | "backward", now: number): runreplaysession;
+/** Jumps the replay cursor to one chosen step of the recorded chain; a step outside the chain refuses the jump. */
+export declare function replayjump(session: runreplaysession, stepid: string, now: number): runreplaysession;
+/** Toggles the replay play state: playing advances the viewer through the recorded steps while the pause holds the cursor exactly where it stands. */
+export declare function replayplay(session: runreplaysession, playing: boolean, now: number): runreplaysession;
+/** Records one viewer action of the replay session for the audit trail: every play, pause, step and jump keeps its time. */
+export declare function replayviewaction(session: runreplaysession, action: {
+    kind: "play" | "pause" | "step" | "jump";
+    stepid?: string;
+    at: number;
+}): runreplaysession;
+/** Reads the restored view of the replayed step: the log summary it stands on beside the observation and the capture the step restored from the stored captures of the run. */
+export declare function replayrestoredview(step: runreplaystep): {
+    stepid: string;
+    index: number;
+    summary: string;
+    observationversion?: number;
+    captureid?: string;
+    gateresolutions: Array<{
+        gateid: string;
+        kind: string;
+        resolution: string;
+        at: number;
+    }>;
+};
+/** Reads the replay cursor of one viewed run the memory keeps per run, so a reopened replay stands where the viewer left it. */
+export declare function replaycursorof(session: runreplaysession): {
+    runid: string;
+    cursor: number;
+    playing: boolean;
+};
+import type { readparallelgroup, sessionreusegrant, warmselectorrecord } from "./types.js";
+/**
+ * Runparallel logic of the 1.1.69 family.
+ * The readparallel groups the independent page reads of one run into parallel lanes and joins the lanes before the dependent steps, the warmselectors carry the validated selectors between adjacent steps and revalidate on a fingerprint change only, and the sessionreuse attaches an authenticated profile to a run on its explicit per profile consent while it isolates the cookies per task through separate containers.
+ * The parallel lanes, the carried selectors and the reused sessions optimize the run only: every read, every resolution and every attached profile stays inside the reviewed plan and its consent gates.
+ */
+/** Groups the independent page reads of one run into parallel lanes: every read runs in its own lane while the user chosen lane ceiling keeps the waves bounded, and an absent ceiling keeps every lane open. */
+export declare function readparallelgroupof(input: {
+    runid: string;
+    reads: Array<{
+        stepid: string;
+        origin: string;
+    }>;
+    lanes?: number;
+}): readparallelgroup;
+/** Joins one readparallel group before its dependent steps: every lane completes before the dependent step runs. */
+export declare function joinlanes(group: readparallelgroup): readparallelgroup;
+/** Reads the lanes of one readparallel group that still run, so the join waits on the open lanes alone. */
+export declare function openlanes(group: readparallelgroup): Array<{
+    stepid: string;
+    origin: string;
+}>;
+/** Carries one validated selector to the adjacent step: the record holds the resolution and the page fingerprint the resolution stays valid under. */
+export declare function carrywarmselector(input: {
+    selector: string;
+    resolution: string;
+    fingerprint: string;
+    from: string;
+}): warmselectorrecord;
+/** Reads whether one carried selector stays valid: the carry holds while the page fingerprint stays unchanged, and only a fingerprint change revalidates the selector. */
+export declare function warmselectorcarryvalid(input: {
+    record: warmselectorrecord;
+    fingerprint: string;
+}): {
+    carry: boolean;
+    reason: string;
+};
+/** Builds one sessionreuse grant: the authenticated profile attaches to a run only through its explicit per profile consent prompt. */
+export declare function sessionreusegrantof(input: {
+    profile: string;
+    container: string;
+    promptid: string;
+    consentedat: number;
+    runid?: string;
+}): sessionreusegrant;
+/** Reads the container name of one task under one profile so the sessionreuse isolates the cookies per task through separate containers. */
+export declare function sessioncontainerof(input: {
+    profile: string;
+    taskid: string;
+}): string;
+import type { backgroundqueueentry } from "./types.js";
+/**
+ * Background run queue logic of the 1.1.66 family.
+ * The queue that keeps workflows executing with no open surface lives here: each entry holds one reviewed workflow the user queued, the queue hands the entries to the executor one at a time in their queued order, a running entry holds the keepalive signal of 1.1.60 for its whole duration, the interrupted entries of a restart requeue for the recovery, and every state transition feeds the attentionfeed through the statusbadge.
+ * The queue never starts an unreviewed workflow: a queued entry needs its approved review state exactly like a foreground run.
+ */
+/** Builds one background queue entry: the workflow stays queued until the executor picks it while no keepalive signal is held yet. */
+export declare function backgroundqueueentryof(input: {
+    workflowid: string;
+    summary: string;
+    now: number;
+}): backgroundqueueentry;
+/** Enqueues one workflow for a background run: the queue keeps its order and one workflow may wait more than once. */
+export declare function enqueuebackgroundrun(input: {
+    queue: backgroundqueueentry[];
+    workflowid: string;
+    summary: string;
+    now: number;
+}): backgroundqueueentry[];
+/** Reads the next queued entry of the queue in its queued order; an empty queue returns undefined. */
+export declare function nextbackgroundrun(queue: backgroundqueueentry[]): backgroundqueueentry | undefined;
+/** Begins one background run: the entry moves to running and holds the keepalive signal for its whole duration behind the background run gate. */
+export declare function beginbackgroundrun(entry: backgroundqueueentry, now: number, reviewed: boolean): {
+    entry: backgroundqueueentry;
+    gate: {
+        allowed: boolean;
+        reason: string;
+    };
+};
+/** Finishes one background run: the entry reaches its terminal state and releases the keepalive hold it carried. */
+export declare function finishbackgroundrun(entry: backgroundqueueentry, state: "done" | "failed", now: number): backgroundqueueentry;
+/** Reads the restart recovery state of the queue: every running entry of an interrupted worker requeues while the terminal entries keep their state for the audit. */
+export declare function resumebackgroundqueue(queue: backgroundqueueentry[], now: number): {
+    queue: backgroundqueueentry[];
+    requeued: string[];
+};
+/** Reads the attention descriptor of one background queue entry: a failed entry feeds the attentionfeed while a queued entry defers until the executor turn frees. */
+export declare function backgroundrunattention(entry: backgroundqueueentry, origin: string): {
+    cause: "failure" | "deferral";
+    runid: string;
+    origin: string;
+    summary: string;
+} | undefined;
+/** Reads the dashboard view of the background queue: one row per entry with its state and its progress by the workflow step count. */
+export declare function backgroundrunsview(queue: backgroundqueueentry[]): Array<{
+    id: string;
+    workflowid: string;
+    state: string;
+    keepaliveheld: boolean;
+    queuedat: number;
+    startedat?: number;
+    endedat?: number;
+    summary: string;
+    progress: string;
+}>;
+/** Reads the recenttray rows of the finished background runs: the tray grows its background section from the terminal entries of the queue. */
+export declare function backgroundtrayrows(queue: backgroundqueueentry[], origin: string): Array<{
+    runid: string;
+    origin: string;
+    outcome: "running" | "completed" | "halted" | "failed";
+    title: string;
+    at: number;
+    resumable: boolean;
+    reopenable: boolean;
+}>;
+/** Cancels one queued entry of the background queue: a running entry keeps its executor path and only a queued entry leaves through the queue. */
+export declare function cancelbackgroundentry(queue: backgroundqueueentry[], id: string): {
+    queue: backgroundqueueentry[];
+    cancelled: string[];
+};
+//# sourceMappingURL=run.d.ts.map