@wenathlan/devthink 2.0.14 → 2.0.19

package/dist/perf.d.ts

@@ -1,481 +0,0 @@
-/**
- * The perf module of the 1.1.90 consolidation: every correlated variation of the hot path measurement and bounding logic interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the hot path family: perfrecords holds the perf record stream every meter writes into (the worker backpressure, the queue depth samples, the snapshot request dedupe, the capture plan schedule and the pruning of the record window); snapshotdelta fingerprints the snapshot regions so unchanged ones skip recomputation; dombatch coalesces the dom bursts into debounced batches with their query plans; stepmeter measures the steps (the durationmeter that writes its samples into the perf records, the selectorprofile with its failure rates, the steptrace spans, the startupmeter of the cold start and the slowmo replay); resourceaware bounds the same hot paths against the device (the tab suspend plan, the artifact compression, the log pruning and the battery aware network backoff); batchscheduling paces the queues with the domain lanes, the polite delay, the adaptive poll and the request coalescing under backpressure; and lazyload keeps the heavy modules out of the first paint path inside the user startup budget.
- * No window, budget, factor or threshold is ever hardcoded: every bound stays the user's choice with no engine cap, and the meters measure and never refuse.
- */
-import type { perfrecord, queuedepthsample, incrsnapshotdelta, snapshotchange, batchqueryplan, debouncedbatch, debounceprofile, durationsample, selectorstats, slowmosession, startupsample, steptracespan, artifactcompressrecord, batteryawarestate, logprunerule, networkretryrule, tabsuspendstate, adaptivepollwindow, backpressuresignal, cadencecontrol, coalescedrequest, domainlane, lazyloadrecord, lazymoddescriptor, startupbudget } from "./types.js";
-/**
- * Perfrecords logic of the 1.1.68 family.
- * Every step records its perf data beside its outcome: the duration, the query count, the cache hits and the delta flag with the provenance attached, the worker queue gains backpressure that defers parse tasks past the user configured depth instead of refusing them, the queue depth records over time for tuning, and the run summary charts the step durations.
- * No budget ever refuses work: the deferral, the priority and the depth stay the user's choices, and the records stay advisory instruments of measurement.
- */
-/** Records one perf record of an executed step: the duration, the query count and the cache hits the step cost beside the delta flag and the provenance every record attaches. */
-export declare function perfrecordof(input: {
-    runid: string;
-    stepid: string;
-    duration: number;
-    queries: number;
-    cachehits: number;
-    delta: boolean;
-    now: number;
-    provenance?: {
-        origin?: string;
-        environment?: string;
-        task?: string;
-    };
-}): perfrecord;
-/** Reads the backpressure verdict of one worker queue: parse tasks past the user configured depth defer and never refuse, and an absent depth keeps the queue unbounded. */
-export declare function workerbackpressure(input: {
-    depth: number;
-    pending: number;
-    configured?: number;
-}): {
-    deferred: number;
-    admitted: number;
-    unbounded: boolean;
-};
-/** Builds one worker queue depth sample for the tuning record: the pending parse count and the deferred count the backpressure held at one moment. */
-export declare function queuedepthsampleof(input: {
-    depth: number;
-    deferred: number;
-    now: number;
-}): queuedepthsample;
-/** Reads the tuning view of the recorded queue depth samples: the peak depth, the deferred total and the span the samples cover. */
-export declare function queuedepthview(samples: queuedepthsample[]): {
-    peak: number;
-    deferred: number;
-    samples: number;
-};
-/** Builds the snapshot request key of one run so the executor deduplicates identical snapshot requests within the run: the same run, base ref and fingerprint answer from the same recomputation. */
-export declare function snapshotrequestkey(input: {
-    runid: string;
-    stepid: string;
-    fingerprint: string;
-}): string;
-/** Deduplicates identical snapshot requests within one run: the first request computes and the repeats answer from the first result while the executor records the hit count. */
-export declare function dedupesnapshotrequests(input: {
-    runid: string;
-    requests: Array<{
-        stepid: string;
-        fingerprint: string;
-    }>;
-}): {
-    distinct: Array<{
-        stepid: string;
-        fingerprint: string;
-    }>;
-    duplicates: number;
-};
-/** Reads the capture schedule behind the user priority choice: speed defers the heavy capture work to the run end while evidence keeps every capture beside its step; the choice optimizes the order and never drops a capture. */
-export declare function captureplanschedule(input: {
-    priority?: "speed" | "evidence";
-    heavy: string[];
-}): {
-    beside: string[];
-    deferred: string[];
-    note: string;
-};
-/** Reads the abandoned parse task ids of one halted run so the executor cancels them: a task belongs to the halted run and never started inside the worker pool. */
-export declare function abandonedparsetasks(input: {
-    halted: boolean;
-    runid: string;
-    pending: Array<{
-        id: string;
-        runid: string;
-        started: boolean;
-    }>;
-}): {
-    cancelled: string[];
-    kept: string[];
-};
-/** Builds the perf summary of one recent run the dashboardpage renders: the step count, the total and average duration, the query count and the cache hit ratio beside the delta share. */
-export declare function perfsummary(records: perfrecord[]): {
-    steps: number;
-    duration: number;
-    average: number;
-    queries: number;
-    cachehits: number;
-    hitratio: number;
-    deltashare: number;
-};
-/** Charts the step durations of one run over its steps: one point per step in execution order with the step id, the duration and the environment provenance. */
-export declare function stepdurationchart(records: perfrecord[]): Array<{
-    stepid: string;
-    duration: number;
-    delta: boolean;
-}>;
-/** Builds the perf audit bundle of one run: every record with its provenance beside the summary, exported as one bundle the user reads. */
-export declare function perfbundle(input: {
-    runid: string;
-    records: perfrecord[];
-}): {
-    runid: string;
-    summary: ReturnType<typeof perfsummary>;
-    records: perfrecord[];
-};
-/** Prunes the perf records past the user configured retention window; an absent window keeps every record while the audit bundle always rebuilds from the survivors. */
-export declare function pruneperfrecords(records: perfrecord[], retention: number | undefined, now: number): {
-    kept: perfrecord[];
-    pruned: number;
-};
-/**
- * Snapshotdelta logic of the 1.1.68 family.
- * The snapshot builder computes deltas against the previous snapshot of the same run: every region keeps a stable fingerprint, the delta emits only the changed regions with their fingerprints, and the full snapshot returns on the user configured cadence while an empty delta lets the executor skip the recomputation in full.
- * The base snapshot ref must come from the same run: a delta against another run or against no base at all refuses, and the cadence stays the user's choice with no engine default.
- */
-/** One region of a snapshot the delta engine compares: the region name and its content. */
-export type snapshotregion = {
-    region: string;
-    content: string;
-};
-/** Stable local fingerprint of one region content so the delta engine recognizes unchanged regions without recomputation; the hash stays deterministic without a network dependency. */
-export declare function regionfingerprint(region: string, content: string): string;
-/** Computes one incrsnapshot delta against the base snapshot of the same run: only the added, changed and removed regions enter the change set, and the full snapshot returns once the user configured cadence of deltas elapsed. */
-export declare function snapshotdeltaof(input: {
-    baseref: string;
-    runid: string;
-    base: snapshotregion[];
-    current: snapshotregion[];
-    deltasince?: number;
-    cadence?: number;
-    now: number;
-}): incrsnapshotdelta;
-/** Reads whether one incrsnapshot delta is empty: an empty delta with no full snapshot lets the executor skip the whole recomputation because nothing changed. */
-export declare function isemptydelta(delta: incrsnapshotdelta): boolean;
-/** Reads whether the executor skips the recomputation of one step: an empty delta against the same run base means the snapshot builder emits nothing and the step reuses the base observation. */
-export declare function skipsrecomputation(delta: incrsnapshotdelta): boolean;
-/** Reads the fingerprint of the change set one delta carries beside its base ref, so the executor deduplicates identical snapshot requests within a run. */
-export declare function deltarequestkey(delta: incrsnapshotdelta): string;
-/** Builds the base snapshot ref record of one run the memory keeps for its deltas: the ref, the run it belongs to and the time the run set it. */
-export declare function snapshotbaserecord(input: {
-    runid: string;
-    ref: string;
-    now: number;
-}): {
-    id: string;
-    runid: string;
-    ref: string;
-    at: number;
-};
-/** Reads the regions one delta touched, in the incrsnapshot change format the progress records reuse beside the step outcomes. */
-export declare function deltachangesof(delta: incrsnapshotdelta): snapshotchange[];
-/**
- * Dombatch logic of the 1.1.68 family.
- * The dom observer debounces rapid mutation bursts into one batch, debouncedom coalesces scroll, input and resize storms per window, and the snapshot builder batches every dom query into one pass: the batchquery plan folds repeated selectors so one snapshot costs one query pass, and the grouped selectors execute together inside one offscreen worker task.
- * Every window stays the user's choice: an absent window passes events through uncoalesced, and no engine default ever caps a storm.
- */
-/** Builds the debounce profiles of the user configured windows: only the event kinds with a window coalesce while the kinds without one pass every event through. */
-export declare function debounceprofilesof(windows: Partial<Record<debounceprofile["kind"], number>>): debounceprofile[];
-/** Coalesces one dom event storm into per kind batches: every event inside the window of its kind folds into the open batch, and a batch closes once the window since its first event elapsed. */
-export declare function coalescedombursts(input: {
-    events: Array<{
-        kind: debounceprofile["kind"];
-        at: number;
-    }>;
-    profiles: debounceprofile[];
-    now: number;
-}): debouncedbatch[];
-/** Debounces one rapid mutation burst of the dom observer into a single batch: every mutation inside the user window folds into one batch the observer delivers once. */
-export declare function mutationbatchof(input: {
-    mutations: Array<{
-        at: number;
-        fingerprint?: string;
-    }>;
-    window?: number;
-    now: number;
-}): debouncedbatch;
-/** Builds one batchquery plan from the selector list a snapshot needs: repeated selectors fold away so the plan carries every distinct selector exactly once and the snapshot costs one query pass. */
-export declare function batchqueryplanof(selectors: string[]): batchqueryplan;
-/** Executes one batchquery plan in a single pass: the resolver runs once per distinct selector and every repeated selector shares the resolution of its first occurrence. */
-export declare function runbatchquery(input: {
-    plan: batchqueryplan;
-    resolver: (selector: string) => string;
-}): {
-    resolutions: Record<string, string>;
-    queries: number;
-};
-/** Shapes one batchquery plan into the offscreen worker task payload the worker pool executes: the grouped selectors travel together so one worker task answers the whole pass. */
-export declare function batchquerytaskof(input: {
-    plan: batchqueryplan;
-    runid: string;
-    stepid: string;
-}): {
-    task: "batchquery";
-    runid: string;
-    stepid: string;
-    selectors: string[];
-    folded: number;
-};
-/** Reads the query savings of one batchquery pass: the folded duplicate count beside the distinct queries the pass ran. */
-export declare function batchquerysavings(plan: batchqueryplan): {
-    distinct: number;
-    folded: number;
-    saved: number;
-};
-/**
- * Stepmeter logic of the 1.1.69 family.
- * The durationmeter measures every step with monotonic clocks and writes its samples into the perf records of the 1.1.68 family, the selectorprofile counts the resolution time and the failure rate per selector and flags the selectors above the user latency threshold, the steptrace spans nest per step and per worker task and export one trace file for the timeline view, the startupmeter measures the cold start from the startup event to ready with the lazymods budget it spent, the coldstart keeps the ready path under the user target with the heavy modules out of the first paint path, and the slowmo replays a recorded run at the user chosen speed factor with its pauses linked to their steptrace spans.
- * Every threshold, target and factor stays a user choice: the meters measure and never refuse.
- */
-/** Builds one durationmeter sample from a monotonic clock pair: the step start and end clocks with the duration it measured. */
-export declare function durationsampleof(input: {
-    stepid: string;
-    start: number;
-    end: number;
-    monotonic?: boolean;
-}): durationsample;
-/** Writes one durationmeter sample into the perf records of the 1.1.68 family: the sample becomes one perf record with its provenance attached. */
-export declare function durationsampletoperf(input: {
-    runid: string;
-    sample: durationsample;
-    queries: number;
-    cachehits: number;
-    delta: boolean;
-    now: number;
-    provenance?: {
-        origin?: string;
-        environment?: string;
-        task?: string;
-    };
-}): perfrecord;
-/** Reads the selectorprofile stats of one selector: the resolution count, the total and average resolution time and the failure rate, with the flag the selectors above the user latency threshold carry. */
-export declare function selectorprofileof(input: {
-    selector: string;
-    samples: Array<{
-        duration: number;
-        ok: boolean;
-    }>;
-    threshold?: number;
-}): selectorstats;
-/** Updates one selectorprofile stat with a fresh resolution sample beside its prior stats: the count, the total duration and the failure rate grow while the flag follows the user latency threshold. */
-export declare function selectorstatsupdate(prior: selectorstats | undefined, input: {
-    selector: string;
-    duration: number;
-    ok: boolean;
-    threshold?: number;
-}): selectorstats;
-/** Builds one steptrace span: the step or the worker task it covers with its start and end clocks, its cause and its optional parent span. */
-export declare function steptracespanof(input: {
-    runid: string;
-    stepid?: string;
-    task?: string;
-    start: number;
-    end: number;
-    cause: string;
-    parent?: string;
-}): steptracespan;
-/** Reads the child spans of one steptrace span so the trace nests per step and per worker task. */
-export declare function spanchildren(spans: steptracespan[], parentid: string): steptracespan[];
-/** Exports one trace file of a run for the timeline view: every span in start order with its event count. */
-export declare function steptracefile(input: {
-    runid: string;
-    spans: steptracespan[];
-}): {
-    runid: string;
-    format: "devthink-steptrace";
-    events: number;
-    spans: steptracespan[];
-};
-/** Builds one startupmeter sample: the cold start duration from the startup event to ready with the lazymods budget it spent, reported against the user target without ever refusing a load. */
-export declare function startupsampleof(input: {
-    startedat: number;
-    readyat: number;
-    spent: number;
-    target?: number;
-}): startupsample;
-/** Reads the coldstart verdict of one startup sample: the ready path stays under the user target while the heavy modules stay out of the first paint path; an absent target keeps the verdict informational only. */
-export declare function coldstartverdict(input: {
-    sample: startupsample;
-    heavy: string[];
-    firstpaint: string[];
-}): {
-    withintarget: boolean;
-    heavyinfirstpaint: string[];
-    reason: string;
-};
-/** Opens one slowmo replay session of a recorded run at the user chosen speed factor; an absent factor keeps the replay at its recorded speed. */
-export declare function slomosessionof(input: {
-    runid: string;
-    factor?: number;
-    now: number;
-}): slowmosession;
-/** Reads the pause window between two slowmo steps: the recorded duration divided by the user factor, so a factor of one half doubles every pause. */
-export declare function slomostepdelay(input: {
-    factor: number;
-    duration: number;
-}): number;
-/** Pauses one slowmo replay between steps for inspection and links the pause to its steptrace span. */
-export declare function slomopause(input: {
-    session: slowmosession;
-    stepid: string;
-    spanid: string;
-}): slowmosession;
-/** Resumes one slowmo replay from its inspection pause; the replay keeps its factor and its run. */
-export declare function slomoresume(session: slowmosession): slowmosession;
-/**
- * Resourceaware logic of the 1.1.69 family.
- * The tabsuspend discards idle tabs only during the waits longer than the user window, restores a tab before the next step that needs it and preserves the run state across the suspend and restore, the artifactcompress compresses captures and logs at rest and decompresses them lazily on read, the logprune removes the sealed logs past the user retention window while it prunes whole sealed runs only so the chain stays verifiable, the batteryaware scheduler defers non urgent scheduled runs on low battery and surfaces the deferrals in the attentionfeed, and the networkaware retry policies adapt their backoff to the failure kind while they honor the server signals when present.
- * Every window, rule and floor stays a user choice: the deferrals, the codecs and the backoffs optimize the resource use and never refuse the work.
- */
-/** Reads the tabsuspend plan of one wait: the tab suspends only during a wait longer than the user window while an absent window or a shorter wait never suspends the tab. */
-export declare function suspendplan(input: {
-    waitduration: number;
-    window?: number;
-}): {
-    suspend: boolean;
-    reason: string;
-};
-/** Builds one tabsuspend state: the suspended tab with its run, its restore url and the discard flag, so the run state survives the suspend and the restore. */
-export declare function tabsuspendstateof(input: {
-    tabid: number;
-    runid: string;
-    restoreurl: string;
-    discarded: boolean;
-    now: number;
-}): tabsuspendstate;
-/** Reads the restore plan of one suspended tab: the tab restores before the next step that needs it while a discarded tab reloads its restore url and an undiscarded tab keeps its page state. */
-export declare function tabsuspendrestoreplan(input: {
-    state: tabsuspendstate;
-    nextneedsurl: string;
-}): {
-    restore: boolean;
-    reload: boolean;
-    reason: string;
-};
-/** Builds one artifactcompress record: the stored artifact with its codec and its lazy read flag, so the capture and log bytes compress at rest and decompress on read. */
-export declare function artifactcompressof(input: {
-    artifactid: string;
-    codec?: "deflate" | "store";
-    lazy?: boolean;
-    now: number;
-}): artifactcompressrecord;
-/** Reads the read plan of one stored artifact: a deflate artifact decompresses lazily on read while a stored artifact reads its plain bytes directly. */
-export declare function artifactreadplan(record: artifactcompressrecord): {
-    decode: "immediate" | "lazy";
-    reason: string;
-};
-/** Reads the logprune plan of one sealed log chain: the prune removes whole sealed runs past the user retention or size window while an unsealed run never prunes so the chain stays verifiable. */
-export declare function logpruneplan(input: {
-    sealed: Array<{
-        runid: string;
-        sealedat: number;
-        bytes: number;
-        sealed: boolean;
-    }>;
-    rule: logprunerule;
-    now: number;
-}): {
-    prune: string[];
-    keep: string[];
-    refused: string[];
-};
-/** Reads the batteryaware scheduling state: the non urgent scheduled runs defer while the battery stays under the user floor and never charges; the deferral never cancels a run. */
-export declare function batteryawarestateof(input: {
-    level: number;
-    charging: boolean;
-    floor?: number;
-    scheduled: string[];
-    now: number;
-}): batteryawarestate;
-/** Reads the networkaware backoff of one retry: the policy of the failure kind sets the backoff window while a present server signal overrides it. */
-export declare function networkbackoff(input: {
-    failurekind: string;
-    rules: networkretryrule[];
-    serversignal?: number;
-}): number;
-/**
- * Batchscheduling logic of the 1.1.69 family.
- * Batch run queues pace themselves against the sites they address: the queue pauses its enqueueing when the downstream steps fall behind past the user window and never drops a queued step, every domain runs inside its user chosen concurrency slots with the overflow queued per lane, batch requests space themselves through the politedelay profile with its jitter and its per domain floors, the adaptivepoll window widens while observations stay unchanged and narrows the moment changes resume, identical pending queries merge into one dispatch whose single result fans out to every waiter, and the snapshot cadence widens under memory pressure and restores when the pressure clears.
- * Every window, limit and factor stays a user choice: the scheduler optimizes the pacing and never caps the work, and no budget ever bypasses the review.
- */
-/** Reads the backpressure signal of one batch run queue: the queue pauses its enqueueing when the completed outcomes fall behind the enqueued steps past the user window, and the pause never drops a queued step. */
-export declare function batchbackpressuresignal(input: {
-    runid: string;
-    enqueued: number;
-    completed: number;
-    window?: number;
-    now: number;
-}): backpressuresignal;
-/** Plans the domain lanes of one batch run: every domain runs at most its user chosen slots concurrently while the overflow steps queue per lane; a domain without a user limit stays unbounded. */
-export declare function domainlanesfor(input: {
-    steps: Array<{
-        id: string;
-        domain: string;
-    }>;
-    limits: Record<string, number>;
-}): domainlane[];
-/** Moves the queued overflow of one domain lane into its running set as its slots free; the lane never runs more steps than the user chosen slots. */
-export declare function advancelane(lane: domainlane, freed: number): domainlane;
-/** Reads the politedelay of one domain: the base delay with the jitter window folded over it through the roll, never below the per domain floor the siteprofiles carry. */
-export declare function politedelayfor(input: {
-    domain: string;
-    base: number;
-    floor?: number;
-    jitter?: number;
-    roll: number;
-}): number;
-/** Reads the next adaptivepoll interval: the window widens by the growth factor while observations stay unchanged and narrows the moment changes resume, always inside the floor and the ceiling the user chose. */
-export declare function adaptivepollnext(input: {
-    interval: number;
-    window: adaptivepollwindow;
-    changed: boolean;
-}): number;
-/** Merges identical pending queries into one dispatch: every request with the same key folds into one coalesced entry whose waiters list carries every waiter the single result fans out to. */
-export declare function coalescequeries(input: {
-    requests: Array<{
-        key: string;
-        waiter: string;
-    }>;
-}): coalescedrequest[];
-/** Fans the single result of one coalesced dispatch out to every waiter that merged into it. */
-export declare function coalescefanout<T>(entry: coalescedrequest, result: T): Array<{
-    waiter: string;
-    result: T;
-}>;
-/** Reads the snapshot cadence under memory pressure: the interval widens by the user chosen widening factor while the pressure stays high and restores to the base interval the moment the pressure clears. */
-export declare function cadenceunderpressure(input: {
-    control: cadencecontrol;
-    pressure: boolean;
-    widening?: number;
-}): cadencecontrol;
-/**
- * Lazyload logic of the 1.1.68 family.
- * The heavy modules stay out of the startup path: every lazy module declares its id, its load reason and its capability requirements ahead of load, the loader resolves a module on first use while the capability checks stay exactly the checks the eager path runs, the prewarm hook warms the user chosen set on startup, and every resolution records load telemetry for startup analysis.
- * Lazy loading never hides a capability: a module whose declared capability stays ungranted never resolves, and no budget ever refuses a load because every budget stays the user's choice.
- */
-/** The catalog of lazy modules: the heavy parsers and the capture, compare and export families load lazily behind their first command while the startup path stays free of them. */
-export declare function lazymodcatalog(): lazymoddescriptor[];
-/** Reads one lazy module descriptor by id; an unknown id returns undefined so the caller keeps its eager fallback. */
-export declare function lazymodof(id: string): lazymoddescriptor | undefined;
-/** Resolves one lazy module on first use: the declared capabilities must all stay granted or the resolution records its refusal, and the load telemetry records the duration and the provenance of the first use. */
-export declare function resolvelazymod(input: {
-    id: string;
-    granted: string[];
-    firstuse: boolean;
-    duration: number;
-    now: number;
-    provenance?: {
-        runid?: string;
-        stepid?: string;
-        surface?: string;
-    };
-}): lazyloadrecord;
-/** Prewarms the user chosen lazy module set on startup: every prewarmed module resolves immediately with its telemetry recorded while the modules outside the set stay out of the startup path. */
-export declare function prewarmmodules(input: {
-    prewarmset: string[];
-    granted: string[];
-    now: number;
-    duration?: number;
-}): lazyloadrecord[];
-/** Builds the startup module budget view: the prewarmed modules lead the startup path, the lazy rest stays out of it, and the user configured budget reports over or under without ever refusing a load. */
-export declare function startupbudgetof(input: {
-    prewarmset: string[];
-    budget?: number;
-}): startupbudget;
-/** Reads the startup cost the prewarm set adds: the module count the startup path carries beside the lazy rest, reported to the user with no engine ceiling. */
-export declare function startupcostof(budget: startupbudget): {
-    startupmodules: number;
-    lazy: number;
-    note: string;
-};
-//# sourceMappingURL=perf.d.ts.map

package/dist/plan.d.ts

@@ -1,134 +0,0 @@
-/**
- * The plan module of the 1.1.90 consolidation: every correlated variation of the plan logic interned in this one file, so the module family carries one surface without duplicate variations.
- * The correlation is the life of a plan file: planlint reads the plan on disk and lints it against the same policy engine the extension runs (originprofile grading, sensitive class consents, portable capability gates, schemastrict unknown field refusal, explicit gate declarations, loop and retry bounds) so an error diagnostic refuses the file before any run starts; planreview renders the review half of the interface the same plan passes on its way to execution (plancards with their risk groups and correction memory matches, stepapprove resolutions with their immutable log events, diffpreviews of write class steps with mask verdicts, stepstimeline nodes derived from progress records with no new state, and the hash chained logstream the surface verifies live as entries arrive).
- * The linter never executes anything and the review surface never bypasses the human: every bound, window and buffer stays the user's choice with no engine cap.
- */
-import type { classconsent, originprofile, planfile, planfilestep, planlintdiagnostic, portableruleset, sensitiveclass } from "./types.js";
-/**
- * Planlint logic of the 1.1.67 family.
- * The plan file on disk lints against the same policy engine the extension runs: every step grades against the originprofile of the plan origin, every sensitive class needs the consent the extension would demand, every kind stays inside the portable capability set of the target runtime, unknown fields refuse under schemastrict, sensitive steps declare their gate explicitly, selectors that cannot resolve without a live page flag, and unbounded loops and missing retry bounds surface before any run starts.
- * The linter never executes anything and never touches a page: it reads the plan file and the compiled portable rule set only, and an error diagnostic refuses the file before flowrun ever sees it.
- */
-/** The step fields a plan file carries; any other field refuses under schemastrict with the path that names it. */
-export declare const planfilestepfields: readonly string[];
-/** The control flow kinds whose loop bound the linter reads; an absent bound flags as unbounded. */
-export declare const loopkinds: readonly string[];
-/** The retrying kinds whose attempts the linter reads; absent attempts flag as missing retry bounds. */
-export declare const retrykinds: readonly string[];
-/** Parses one plan file under schemastrict: the version, goal and origin are mandatory, every step maps onto the plan file step shape and unknown fields refuse with the path that names them. */
-export declare function parseplanfile(value: unknown): planfile;
-/** Reads the originprofile of one plan file: the profile builds from the declared kind grants exactly the way the extension builds it, so the lint and the runtime grade the same step the same way. */
-export declare function planoriginprofile(file: planfile, now: number): originprofile;
-/** Reads the derived risk of one plan file step: the same risk derivation the extension runs, so the lint and the runtime grade one step identically. The 1.1.80 cli family shares this grade with the risk summary planlint prints. */
-export declare function plansteprisk(step: planfilestep): "read" | "interaction" | "sensitive";
-/** Lints one plan file against the compiled portable rule set: every rule of the set runs, every diagnostic carries its code, path and severity, and an error diagnostic refuses the file before any run starts. */
-export declare function lintplanfile(input: {
-    file: planfile;
-    ruleset: portableruleset;
-    capabilities: string[];
-    consents?: classconsent[];
-    now: number;
-}): planlintdiagnostic[];
-/** Formats one diagnostic set for the terminal: the human format lists one line per diagnostic with its severity, path and message, and the json format carries the whole set as one json array. */
-export declare function formatdiagnostics(diagnostics: planlintdiagnostic[], format: "human" | "json"): string;
-/** Reads the exit code of one lint run: any error diagnostic exits non zero, while info and warn diagnostics keep the run green. */
-export declare function planlintexitcode(diagnostics: planlintdiagnostic[]): number;
-/** Reads the cache key of one compiled portable rule set: the version and the rule ids compose one deterministic key so repeat runs reuse the parsed rules until the set changes. */
-export declare function rulesetcachekey(ruleset: portableruleset): string;
-/** Reads the plan lint summary of one file for the audit trail: the diagnostic counts per severity beside the exit code the run carries. */
-export declare function planlintsummary(diagnostics: planlintdiagnostic[]): {
-    info: number;
-    warn: number;
-    error: number;
-    exitcode: number;
-    reason: string;
-};
-/** Reads the sensitive classes one plan file needs consent for, so the flowrun gate waits name the classes the terminal prompt shows. */
-export declare function plansensitiveclasses(file: planfile): sensitiveclass[];
-import type { agentplan, correctionentry, diffpreviewpayload, loglevel, logstreamevent, logstreamfilter, planprogress, plancard, plancardgroup, stepapproveresolution, stepstimelinenode, uisurface } from "./types.js";
-/**
- * Plan review surface logic of the 1.1.64 family, part one.
- * The review half of the interface lives here: plancards render one card per proposed step with its kind, risk class, environment and options and group by risk class with the sensitive classes expanded by default while the matching corrections of correctionmemory sit beside their steps; stepapprove resolves exactly one step per distinct human action with approve, reject and edit provenance that lands in the immutable log; diffpreview compares the observed before state with the predicted after state of write class steps only and highlights added, changed and removed fields with masked values carrying their mask verdicts; the stepstimeline derives its pending, running, waiting, done, failed and halted nodes from progress records with no new state, showing durations, environment badges and deep link anchors; and the logstream appends live events with level, source and step ref behind a hash chain the surface verifies as entries arrive while the bounded live window keeps the full history in memory.
- * No bound is ever hardcoded: the live buffer window stays the user's choice with no engine cap, and no review surface ever bypasses the human review.
- */
-/** Builds one plancard per proposed step: the kind, the risk class, the execution environment, the reviewed options, the summary, the matching corrections from correctionmemory and the edit before approve offer of a pending plan. */
-export declare function plancardsof(input: {
-    plan: agentplan;
-    corrections: correctionentry[];
-}): plancard[];
-/** Groups the plancards by risk class: the sensitive group expands by default while the read and interaction groups start folded. */
-export declare function plancardgroups(cards: plancard[]): plancardgroup[];
-/** Builds one stepapprove resolution: the step, the plan, the origin, the decision, the distinct human surface and the edited step shape an edit carries. */
-export declare function stepresolutionof(input: {
-    stepid: string;
-    planid: string;
-    origin: string;
-    resolution: "approve" | "reject" | "edit";
-    surface: uisurface;
-    edited?: string;
-    at: number;
-}): stepapproveresolution;
-/** Builds the immutable log event of one stepapprove resolution: the review kind entry the sealed chain keeps. */
-export declare function resolutionlogeventof(resolution: stepapproveresolution): {
-    kind: "review";
-    summary: string;
-    stepid: string;
-};
-/** Appends one stepapprove resolution to the per origin history: the review provenance stays queryable per origin. */
-export declare function resolutionhistoryafter(history: stepapproveresolution[], resolution: stepapproveresolution): stepapproveresolution[];
-/** Derives the mask verdicts of one state pair: every sensitive field shape carries its verdict reason while the rest stays unmasked. */
-export declare function maskverdictsof(state: Record<string, string>, sensitivefields: string[]): Record<string, string>;
-/** Compares the observed before state with the predicted after state of one write class step: added, changed and removed fields with the mask verdicts of masked values. */
-export declare function diffpreviewof(input: {
-    stepid: string;
-    before: Record<string, string>;
-    after: Record<string, string>;
-    maskverdicts?: Record<string, string>;
-    provenance: "inline" | "offscreenworker";
-}): diffpreviewpayload;
-/** Derives the stepstimeline nodes from the plan and its progress records with no new state: pending, running, waiting, done, failed and halted statuses, durations, environment badges, the active mark and the deep link anchors. */
-export declare function stepstimelinenodes(input: {
-    plan: agentplan;
-    progress?: planprogress;
-    now: number;
-}): stepstimelinenode[];
-/** Returns the deep link anchor of the active node the timeline scrolls to during a run. */
-export declare function activetimelineanchor(nodes: stepstimelinenode[]): string | undefined;
-/** The genesis hash the first logstream event chains to, mirroring the immutable log genesis. */
-export declare const logstreamgenesis: string;
-/** Builds one logstream event behind the hash chain: the level, the source, the origin, the summary, the optional step ref, the mask verdict of the source payload and the link to the previous event. */
-export declare function logstreameventof(input: {
-    level: loglevel;
-    source: string;
-    origin: string;
-    summary: string;
-    stepid?: string;
-    masked: boolean;
-    maskverdict: string;
-    previous: string;
-    at: number;
-}): Promise<logstreamevent>;
-/** Appends one logstream event to the in memory history: the history stays full while the live window reads its bounded slice. */
-export declare function appendlogstreamevent(events: logstreamevent[], event: logstreamevent): logstreamevent[];
-/** Filters the logstream events by level, origin and step ref: an absent filter keeps every event. */
-export declare function filterlogstream(events: logstreamevent[], filter: logstreamfilter): logstreamevent[];
-/** Returns the bounded live window of the logstream: the user configured bound keeps the newest events while the full history stays in memory; an absent bound keeps every event live. */
-export declare function livebufferof(events: logstreamevent[], bound: number | undefined): logstreamevent[];
-/** Verifies the logstream hash chain live as entries arrive: every event links to its predecessor and a broken link names its position. */
-export declare function verifylogstream(events: logstreamevent[]): Promise<{
-    valid: boolean;
-    brokenat?: number;
-    reason: string;
-}>;
-/** Copies one verified range of the logstream as an audit excerpt: an unverified chain refuses the copy while a verified range renders its entries with level, source and mask verdict. */
-export declare function auditexcerptof(events: logstreamevent[], input: {
-    from: number;
-    to: number;
-}): Promise<{
-    ok: boolean;
-    text: string;
-    reason: string;
-}>;
-/** Maps one audit kind onto the logstream level its event carries: errors stream as error, the refusal family streams as warn and the rest streams as info. */
-export declare function loglevelof(kind: string): loglevel;
-//# sourceMappingURL=plan.d.ts.map