@wenathlan/devthink 2.0.13 → 2.0.15

package/dist/data.d.ts

@@ -0,0 +1,330 @@
+/** The data module of the 1.1.90 consolidation: every correlated variation of the dataset records, the streaming pipelines and the chunked parsing logic interned in this one file, so the module family carries one surface without duplicate variations. */
+import type { artifactrecord, chunkextractcursor, chunkextractwindowresult, columnspec, dataset, datasetrow, dedupekey, exportedartifact, extractbatch, extractpipeline, extractrow, extractsession, gridcolumn, provlogentry, provenancerecord, samplepolicy, sourcestamprecord, streamcursor, streamstate, streamparsechunk, toolstep, transformrule } from "./types.js";
+/**
+ * Dataset command logics for the background executors.
+ * Every correlated rule for dataset records, artifact exports with checksums, chunked streaming with backpressure, extraction cursors, loop row variables, provenance records and artifact retention lives in this file.
+ */
+/** Builds one dataset record from a scraped grid result. */
+export declare function builddataset(id: string, name: string, grid: {
+    columns: columnspec[];
+    rows: datasetrow[];
+    children?: Array<{
+        parentrow: number;
+        selector: string;
+        columns: columnspec[];
+        rows: datasetrow[];
+    }>;
+}, at: number): dataset;
+/** Computes the deterministic checksum of an exported artifact's content. */
+export declare function checksum(value: string): string;
+/** Serializes one dataset into the reviewed export format. */
+export declare function exportcontent(datasetvalue: dataset, format: "csv" | "json" | "excel", delimiter?: string): string;
+/** Builds one exported artifact record with its content and checksum for the task artifact store. */
+export declare function exportartifact(id: string, datasetvalue: dataset, format: "csv" | "json" | "excel", stepid: string, content: string, at: number): exportedartifact;
+/** Converts one exported artifact into the artifact record shape the run store keeps. */
+export declare function artifactrecordof(artifact: exportedartifact): artifactrecord;
+/** Plans the chunk boundaries of a streaming export from a user configured chunk size with no code ceiling. */
+export declare function chunkplan(rows: number, chunk: number): Array<{
+    index: number;
+    from: number;
+    to: number;
+}>;
+/** True when the stream writer must wait for acknowledgements: pending writes reached the in-flight budget of one. */
+export declare function backpressure(written: number, acknowledged: number): boolean;
+/** Advances one stream state by one acknowledged chunk of rows. */
+export declare function advancestream(state: streamstate, chunk: {
+    index: number;
+    to: number;
+}, at: number, done: boolean): streamstate;
+/** Returns the first unwritten row index of a stream, starting a fresh stream at zero. */
+export declare function streamfrom(state: streamstate | undefined, rows: number): number;
+/** Builds the initial stream state of one dataset. */
+export declare function newstream(datasetvalue: dataset, chunks: number, at: number): streamstate;
+/** Advances one extraction session by one extracted page with its row count. */
+export declare function advancecursor(sessionvalue: extractsession, page: string, rows: number, at: number, done: boolean): extractsession;
+/** Builds the initial extraction session of one dataset extraction. */
+export declare function newextractsession(id: string, datasetid: string, name: string, target: string, next: string, planned: number, at: number): extractsession;
+/** Returns the pages an interrupted extraction still owes after its stored cursor. */
+export declare function remainingpages(sessionvalue: extractsession, planned: number): number;
+/** Builds one provenance record of an exported artifact with its source url, step ref, row range and checksum. */
+export declare function provenancefor(artifact: {
+    id: string;
+    name: string;
+    rowcount: number;
+    checksum: string;
+}, url: string, stepid: string, at: number): provenancerecord;
+/** Applies the user configured artifact retention to exported artifacts; an absent setting keeps everything. */
+export declare function retainedexports<T>(records: T[], retention: number | undefined): T[];
+/** Interpolates one text through the {{column}} tokens of a dataset row; only the row's own string values answer a token because an inherited property never leaks object internals into a step payload. The token walk is a single linear scan: a brace expression over library input answers attacker paced backtracking, so the scanner resolves each token with plain index arithmetic instead. */
+export declare function interpolate(text: string, row: datasetrow): string;
+/** Substitutes the row variables of one looprows iteration into the target, value and options of the inner step. */
+export declare function loopstep(step: toolstep, row: datasetrow): toolstep;
+/** Exposes one dataset row as the step variables of a looprows iteration. */
+export declare function loopvariables(row: datasetrow): datasetrow;
+/** Builds the grid preview of a dataset with its column order, total rows and sampled rows. */
+export declare function gridpreview(datasetvalue: dataset, sample: number): {
+    datasetid: string;
+    columns: string[];
+    rows: number;
+    sample: datasetrow[];
+};
+/** Sorts dataset rows by one column key in the reviewed direction with a stable fallback for equal values. */
+export declare function sortrows(rows: datasetrow[], key: string, direction: "asc" | "desc"): datasetrow[];
+/** Builds the sheet push payload of one dataset for a reviewed sheet endpoint. */
+export declare function sheetpayload(datasetvalue: dataset, sheet: string): {
+    sheet: string;
+    columns: string[];
+    rows: datasetrow[];
+};
+/** Merges reviewed transform rules and dedupe keys into the task rules record of one task. */
+export declare function mergetaskrules(existing: {
+    taskid: string;
+    transforms: transformrule[];
+    dedupekeys: string[];
+} | undefined, taskid: string, transforms: transformrule[], dedupekeys: string[], at: number): {
+    taskid: string;
+    transforms: transformrule[];
+    dedupekeys: string[];
+    at: number;
+};
+/** Streams the rows of one extract to its sink chunk by chunk: only the active chunk rides the write at a time, every chunk reports the rows and the bytes it persisted, the streamcursor records the last written position after each chunk so the checkpoint call sees every boundary, and an absent chunk size streams the whole extract as one chunk because the chunk bound stays a user choice with no code default. */
+export declare function streamdisk(input: {
+    pipeline: extractpipeline;
+    rows: extractrow[];
+    write: (chunk: extractrow[]) => number;
+    cursor?: streamcursor;
+    chunk?: number;
+    checkpoint?: (cursor: streamcursor) => void;
+    now: number;
+}): {
+    cursor: streamcursor;
+    rowswritten: number;
+    byteswritten: number;
+    chunks: number;
+    reason: string;
+};
+/** Continues one interrupted pipeline from its streamcursor: the rows the cursor offset and the persisted row keys already cover skip so nothing writes twice, the resume marks the pipeline in the provlog, and a pipeline of another plan or another origin refuses loudly because a resume continues exactly the extraction it came from. */
+export declare function resumeextract(input: {
+    pipeline: extractpipeline;
+    rows: extractrow[];
+    cursor?: streamcursor;
+    persistedkeys?: string[];
+    logid?: string;
+    now: number;
+}): {
+    pipeline: extractpipeline;
+    rows: extractrow[];
+    skipped: number;
+    cursor: streamcursor;
+    entry: provlogentry;
+};
+/** Applies the reviewed transform rules between extraction and export: every rule reshapes exactly its field through its reviewed operation — trim folds the whitespace, case folds the letters, number strips the non numeric shapes and date normalizes to ISO 8601 — the raw value stays beside the transformed value so the audit reads both sides, and a transform never drops a row: an operation that cannot apply keeps the raw value and names its refusal while every row survives the pass. */
+export declare function transformvalues(input: {
+    rows: extractrow[];
+    rules: transformrule[];
+}): {
+    rows: extractrow[];
+    applied: number;
+    refusals: string[];
+};
+/** Deduplicates the rows of one pipeline by its configured key: the key columns join into one comparison value under the configured normalization — whitespace folding, case folding, both or none — with every column part JSON quoted so a cell value that embeds the join separator never collides two distinct rows, the first occurrence of every key stays, the dropped rows report by count and by key, and an empty key list refuses loudly because a dedupe without its columns would compare whole rows the user never configured. */
+export declare function deduperows(input: {
+    rows: extractrow[];
+    key: dedupekey;
+}): {
+    kept: extractrow[];
+    dropped: number;
+    droppedkeys: string[];
+    reason: string;
+};
+/** Selects the preview subset of one extract by its sample policy: the first strategy takes the leading rows, the random strategy shuffles deterministically under the seeded generator the policy names, the stratified strategy spreads the pick evenly across the ordered extract, and the full extract never mutates — the subset copies its rows so the stored batch keeps exactly what it held. */
+export declare function samplerows(input: {
+    rows: extractrow[];
+    policy: samplepolicy;
+    seed?: number;
+}): {
+    rows: extractrow[];
+    strategy: samplepolicy["strategy"];
+    reason: string;
+};
+/** Stamps the rows of one extraction pass with their source: the url, the step id and the capture time build one sourcestamprecord, every row of the pass carries the stamp, every cell links to the stamp id so each value answers which page and step captured it, and a row that already carries the same stamp keeps it once because a stamped timestamp never rewrites. */
+export declare function sourcestamp(input: {
+    rows: extractrow[];
+    stampid: string;
+    url: string;
+    stepid: string;
+    now: number;
+}): {
+    rows: extractrow[];
+    stamp: sourcestamprecord;
+};
+/** Projects the rows of one extract into a read only grid model: the columns build from the observed fields with their kinds inferred from the sampled values and their widths derived from the content, the sort orders by any column without touching the stored extract, the filter keeps the rows whose cells carry the query, and every projected row carries its marks — stamped when its stamps exist, transformed for the fields whose raw values survive beside them, deduplicated for the rows a dedupe pass kept. */
+export declare function pipelinegridpreview(input: {
+    rows: extractrow[];
+    sort?: {
+        column: string;
+        direction: "ascending" | "descending";
+    };
+    filter?: string;
+    dedupekeys?: string[];
+}): {
+    columns: gridcolumn[];
+    rows: Array<{
+        key: string;
+        values: Record<string, string>;
+        stamped: boolean;
+        transformed: string[];
+        deduplicated: boolean;
+    }>;
+    total: number;
+};
+/** Appends one provenance log entry for one extraction operation: every stream, transform, dedupe, sample and resume pass lands exactly one entry with the row keys it touched and its redacted summary, the log refuses an entry whose id already sits in it because the provlog stays append only for the audit integrity, and the secret shaped values mask before the entry ever lands. */
+export declare function provlog(input: {
+    entries: provlogentry[];
+    id: string;
+    pipelineid: string;
+    runid: string;
+    operation: provlogentry["operation"];
+    rowkeys: string[];
+    summary: string;
+    now: number;
+}): {
+    entries: provlogentry[];
+    entry: provlogentry;
+};
+/** Answers the provenance query of one row key: every provlog entry that touches the row returns in order so the reader walks exactly the operations the row rode — the stream that persisted it, the transforms that reshaped it, the dedupe that kept or dropped it, the sample that previewed it and the resume that continued it. */
+export declare function provlogquery(entries: provlogentry[], rowkey: string): provlogentry[];
+/** Tracks the live state of the pipelines of the workspace: the running, paused and finished counts roll per run so the popup and the sidepanel read exactly how many extracts stream, wait and finished, and the counts derive from the stored pipelines without ever writing one. */
+export declare function pipelinestate(input: {
+    pipelines: extractpipeline[];
+}): {
+    running: number;
+    paused: number;
+    finished: number;
+    perrun: Array<{
+        runid: string;
+        running: number;
+        paused: number;
+        finished: number;
+    }>;
+};
+/** Builds one extract batch of a finished pass: the rows and their streamcursor bundle under the pipeline identity so the preview and the resume read exactly the same rows. */
+export declare function extractbatchof(input: {
+    id: string;
+    pipeline: extractpipeline;
+    rows: extractrow[];
+    cursor: streamcursor;
+    now: number;
+}): extractbatch;
+/**
+ * Streamparse logic of the 1.1.68 family.
+ * Pages too large for one pass parse in chunks inside a worker: the stream tokenizer walks the page text window by window, yields observations progressively as each chunk completes and never holds the full page text in memory, while every chunk passes through the same schemastrict validation the one pass parser runs.
+ * Big tables extract through chunkextract: the cursor carries the table fingerprint, slices big tables into resumable row windows, emits each window as a partial extraction result, resumes from its cursor after an interruption and merges the windows into the datagrid incrementally.
+ */
+/** The byte bound of one streamparse chunk the caller supplies: the bound stays the user's choice, and the parser never holds more than the current chunk. */
+export type streamparseoptions = {
+    chunkbytes: number;
+};
+/** Splits one large page into chunk windows without holding the full text: the splitter returns the chunk count and the byte range of each chunk while the caller feeds one chunk at a time. */
+export declare function streamparsewindows(input: {
+    bytes: number;
+    chunkbytes: number;
+}): {
+    chunks: number;
+    windows: Array<{
+        index: number;
+        start: number;
+        end: number;
+    }>;
+};
+/** Tokenizes one chunk of a large page: the tokenizer walks the chunk text, splits text, element and attribute tokens and keeps the chunk bytes bounded so the full page text never assembles in memory. */
+export declare function streamparsechunkof(input: {
+    index: number;
+    text: string;
+    chunkbytes: number;
+    last: boolean;
+}): streamparsechunk;
+/** Validates one streamparse chunk through the same schemastrict validation the one pass parser runs: a chunk outside the shape the parser accepts refuses the whole stream before any observation yields. */
+export declare function validatesetreamparsechunk(chunk: unknown, expectedindex: number): {
+    valid: boolean;
+    reason?: string;
+};
+/** Yields the observations of one streamparse chunk progressively: each chunk completes into its own observation batch while the stream never waits for the last chunk before yielding the earlier ones. */
+export declare function streamparseobservations(chunks: streamparsechunk[]): {
+    progressive: string[][];
+    total: number;
+};
+/** Builds the memory bound summary of one streamparse stream: the peak bytes stay at one chunk bound because the full page text never assembles in memory. */
+export declare function streamparsememorybound(input: {
+    chunkbytes: number;
+    chunks: number;
+}): {
+    peak: number;
+    fullpage: number;
+    saved: number;
+};
+/** Opens one chunkextract cursor at the head of a big table: the cursor carries the table fingerprint the resume verifies and the user configured row window. */
+export declare function openchunkextractcursor(input: {
+    tableid: string;
+    fingerprint: string;
+    rows: number;
+    window?: number;
+    now?: number;
+}): chunkextractcursor;
+/** Slices one window of rows out of a big table: the cursor advances by the window size, the window emits as one partial extraction result and the cursor completes once the row range ends. */
+export declare function chunkextractwindow(input: {
+    cursor: chunkextractcursor;
+    rows: Array<Record<string, string>>;
+}): chunkextractwindowresult;
+/** Resumes one chunkextract cursor after an interruption: the stored fingerprint must match the table the resume addresses or the resume refuses and the caller opens a fresh cursor. */
+export declare function resumechunkextract(input: {
+    cursor: chunkextractcursor;
+    tableid: string;
+    fingerprint: string;
+}): {
+    resumed: boolean;
+    reason: string;
+};
+/** Merges the windows of one chunkextract stream into the datagrid incrementally: every window appends its rows in arrival order while a repeated or out of order window never duplicates a row. */
+export declare function mergechunkwindows(windows: chunkextractwindowresult[]): {
+    rows: Array<Record<string, string>>;
+    duplicates: number;
+};
+/** Reads the progress line of one chunkextract stream the datagrid shows: the rows extracted so far beside the total the cursor covers. */
+export declare function chunkextractprogress(cursor: chunkextractcursor, totalrows: number): {
+    extracted: number;
+    total: number;
+    share: number;
+    complete: boolean;
+};
+/** Shapes one streamparse stream into the offscreen worker task payload: the chunked parse runs inside the worker pool the 1.1.60 family introduced, beside the chunkextract windows of big tables. */
+export declare function streamparsetaskof(input: {
+    runid: string;
+    stepid: string;
+    chunkbytes: number;
+    chunks: number;
+}): {
+    task: "streamparse";
+    runid: string;
+    stepid: string;
+    chunkbytes: number;
+    chunks: number;
+};
+/** Shapes one chunkextract window task into the offscreen worker payload: the worker slices one row window and returns the advanced cursor with its partial rows. */
+export declare function chunkextracttaskof(input: {
+    runid: string;
+    stepid: string;
+    tableid: string;
+    fingerprint: string;
+    rowindex: number;
+    window: number;
+}): {
+    task: "chunkextract";
+    runid: string;
+    stepid: string;
+    tableid: string;
+    fingerprint: string;
+    rowindex: number;
+    window: number;
+};
+//# sourceMappingURL=data.d.ts.map

package/dist/database.d.ts

@@ -0,0 +1,24 @@
+/**
+ * database — prisma database client and persistence logic
+ * one file one responsibility — only db logic lives here
+ * uses prisma 7 with libsql adapter for serverless vercel netlify compat
+ * local dev uses gateway own sqlite at web/prisma/devthink.db
+ * production uses remote url from DATABASE_URL when it is libsql or http
+ * the client is LAZY: @prisma/client loads on the first database touch,
+ * never at import time (a fresh consumer can import the library and run
+ * the cli init before the generated client exists)
+ */
+import type { PrismaClient } from "@prisma/client";
+/** db — the shared prisma client singleton, lazy (the proxy instantiates
+ * the client — and loads @prisma/client — on the first database touch) */
+export declare const db: PrismaClient;
+/** savemsg — persist a chat message to the db never throws */
+export declare function savemsg(data: Record<string, unknown>): Promise<void>;
+/** getsession — retrieve or create a session by id */
+export declare function getsession(sessionid: string): Promise<{
+    sessionid: string;
+    messagecount: number;
+} | null>;
+/** getmessagessince — get messages for a session for context management */
+export declare function getsessionmessages(sessionid: string, limit?: number): Promise<unknown[]>;
+//# sourceMappingURL=database.d.ts.map

package/dist/debug.d.ts

@@ -0,0 +1,270 @@
+/** The debug module of the 1.1.90 consolidation: every correlated variation of the cdp instrumentation and the profilers interned in this one file, so the module family carries one surface without duplicate variations. */
+import type { attachtarget, breakpointspec, cdpallowlist, cdpcommand, cdpeventrule, cdpsession, cpuprofile, flowmetric, flowspec, growsample, heaprecord, memorytrend, pausestate, scriptoverride, shiftentry, sourcemapref, stackframe, stepmode, teardownplan, traceannotation, tracerecord, watchexpression } from "./types.js";
+/**
+ * Devtools protocol bus for the 1.1.46 debugging family.
+ * Every correlated rule for the reviewed instrumented devtools session lives in this file: the domain grammar, the attach and detach lifecycle with the honest derivation note, the raw command records with duration and error class, the per session command serialization in send order, the domain event rules with match filters and per domain event counts, the breakpoint input grammar, the pause state capture with call frames, the step mode grammar, the watch expression values per pause, the script override url patterns and the teardown plan that reverts every breakpoint and override and decides the resume policy when the user detaches the debugger.
+ * The chrome devtools protocol is unavailable without the debugger permission, which the manifest gate forbids, so every command routes through the page-instrumented harness injected through the scripting api; the derivation is recorded on every session instead of hidden.
+ */
+/** The debugging kinds of the devtools family, listed among the available capabilities of every proposal request. */
+export declare const cdpkinds: string[];
+/** The reviewed devtools domain grammar: runtime evaluation, log capture, debugger state, dom snapshots, network facts and page lifecycle; the enabled subset stays a user choice bounded by this grammar only. */
+export declare const cdpdomains: string[];
+/** Resolves the domain of one devtools method name of the form Domain.method; malformed methods resolve to undefined. */
+export declare function methoddomain(method: string): string | undefined;
+/** Normalizes one reviewed devtools domain allowlist: the enabled domains bounded by the reviewed domain grammar and the optional method gates inside the enabled domains; a gate list that names no method of the enabled domains is refused. */
+export declare function cdpallowlistof(value: unknown): cdpallowlist | undefined;
+/** True when the allowlist covers one method: the method domain must be enabled and a present method gate list must name the method. */
+export declare function allowlistcovers(allowlist: cdpallowlist, method: string): boolean;
+/** Attaches one instrumented devtools session to the run tab with the reviewed enabled domains and the honest debugger derivation note. */
+export declare function attachcdpsession(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    tabid: number;
+    origin: string;
+    domains: string[];
+    now: number;
+    debuggerversion: string;
+}): cdpsession;
+/** Detaches one session cleanly: the detach time stamps the record and the domains stay auditable after the detach. */
+export declare function detachcdpsession(session: cdpsession, at: number, userdetached?: boolean): cdpsession;
+/** Builds one raw protocol command record with its method, params, domain, dotted result path, duration and error class. */
+export declare function sendcdpcommand(input: {
+    id: string;
+    sessionid: string;
+    runid: string;
+    stepid: string;
+    method: string;
+    params?: Record<string, unknown>;
+    resultpath?: string;
+    duration: number;
+    errorclass?: string;
+    at: number;
+}): cdpcommand;
+/** Appends one command to the per session send queue so concurrent commands serialize in send order. */
+export declare function serializecdpcommand(queue: cdpcommand[], command: cdpcommand): cdpcommand[];
+/** Normalizes one reviewed domain event rule: the domain of the reviewed grammar, the event name and the optional payload match filter. */
+export declare function cdpeventruleof(value: unknown): Pick<cdpeventrule, "domain" | "event" | "match"> | undefined;
+/** Matches observed domain events against the reviewed rules and counts the matched events per domain; the match filter must appear in the payload before an event forwards. */
+export declare function watchcdpevents(rules: cdpeventrule[], events: Array<{
+    domain: string;
+    event: string;
+    payload?: string;
+}>): {
+    matched: Array<{
+        ruleid: string;
+        domain: string;
+        event: string;
+        payload?: string;
+    }>;
+    counts: Record<string, number>;
+};
+/** Normalizes one reviewed breakpoint input: the script url, the zero based line, the optional column and the condition of the reviewed expression grammar. */
+export declare function breakpointinputof(value: unknown): Pick<breakpointspec, "url" | "line" | "column" | "condition"> | undefined;
+/** Captures one pause state from the instrumented pause: the reason, the call frames, the hit breakpoint and the dom snapshot reference of the page bridge capture. */
+export declare function capturepause(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    reason: string;
+    callframes: stackframe[];
+    hitbreakpoint?: string;
+    domsnapshotid?: string;
+    at: number;
+}): pausestate;
+/** Normalizes one reviewed step mode of the instrumented debugger: stepover, stepinto, stepout or resume. */
+export declare function stepmodeof(value: unknown): stepmode | undefined;
+/** Normalizes one reviewed watch expression input: the expression text and the pause scope it evaluates in. */
+export declare function watchexpressionof(value: unknown): Pick<watchexpression, "expression" | "scope"> | undefined;
+/** Records one watch value captured at a pause with the pause scope correlation. */
+export declare function recordwatchvalue(expression: watchexpression, pauseid: string, value: string, at: number): watchexpression;
+/** Normalizes one reviewed script override input: the url pattern that names its origin explicitly and the full fixture source. */
+export declare function overrideinputof(value: unknown): Pick<scriptoverride, "urlpattern" | "source"> | undefined;
+/** Matches one script url against a reviewed override pattern of an explicit https origin with single star segments and double star subtrees. */
+export declare function overridematches(urlpattern: string, url: string): boolean;
+/** Normalizes one reviewed teardown plan: the revert steps and the resume policy of resume, pause or ask. */
+export declare function teardownplanof(value: unknown): teardownplan | undefined;
+/** The teardown outcome of one session: every breakpoint and override reverts, the resume policy decides the continuation and a user detach keeps the session record alive for review while the run pauses. */
+export interface teardowndecision {
+    session: cdpsession;
+    revertedbreakpoints: string[];
+    revertedoverrides: string[];
+    resumepolicy: teardownplan["resumepolicy"];
+    paused: boolean;
+    keepsalive: boolean;
+}
+/** Tears one session down safely: the revert steps of the reviewed teardown plan revert every active breakpoint and override in order, the session detaches, and a user detach keeps the session record alive while the run pauses for review before continuing. */
+export declare function teardowncdpsession(input: {
+    session: cdpsession;
+    breakpoints: breakpointspec[];
+    overrides: scriptoverride[];
+    plan: teardownplan | undefined;
+    userdetached: boolean;
+    at: number;
+}): teardowndecision;
+/**
+ * Profilers for the 1.1.47 debugging part three family.
+ * Every correlated rule for the reviewed flow, heap, cpu, trace and source map instruments lives in this file: the flow metric grammar with per step mark windows and blocking sums, the on demand heap snapshot records with the user chosen interval, the growth trend slopes with the flagged steps, the cpu profile records with hot functions, the layout shift entries with impacted selectors, the trace records with the reviewed category list and step annotations, the offline replay of a captured trace file, and the source map references with stack rewriting.
+ * The chrome devtools protocol needs the debugger permission, which the manifest gate forbids, so every measurement derives from the performance timeline buffers, the injected instrumentation probes of the page harness and the existing page seams; the derivation stays recorded on every record instead of hidden.
+ */
+/** The profiling kinds of the debugging part three family, listed among the available capabilities of every proposal request. */
+export declare const profilerkinds: string[];
+/** The reviewed flow metric set: navigation, paint and largest contentful paint timings, first input delay and interaction timings, and the blocking time sums per step window. */
+export declare const flowmetricnames: string[];
+/** The reviewed trace category list applied to every recorded trace; the enabled subset stays a user choice bounded by this grammar only. */
+export declare const tracecategories: string[];
+/** Normalizes one reviewed profiling attach target: the target kind of page, iframe, worker or service worker with an explicit https url. */
+export declare function attachtargetof(value: unknown): attachtarget | undefined;
+/** Normalizes one reviewed flow spec: a non-empty mark prefix, a non-empty step window and a metric list of the reviewed metric set. */
+export declare function flowspecof(value: unknown): flowspec | undefined;
+/** One flattened performance entry of the page buffers: the name, the entry type, the start time and the duration. */
+export interface perfentry {
+    name: string;
+    type: string;
+    start: number;
+    duration: number;
+}
+/** Resolves the reviewed step windows of a flow spec from the performance marks of the prefix: every step id of the window gains its start and end from the marks of the measured page. */
+export declare function stepwindows(spec: flowspec, marks: perfentry[]): Array<{
+    stepid: string;
+    start: number;
+    end: number;
+}>;
+/** Measures one reviewed flow from the performance buffers of the page: every metric of the reviewed set carries its window start and end, its duration and the step ids it spans, navigation, paint and largest contentful paint timings come from the navigation and paint buffers, first input delay and interaction timings from the event buffers and the blocking time is summed per step window from the long task entries over the fifty millisecond threshold. */
+export declare function measure(input: {
+    runid: string;
+    stepid: string;
+    spec: flowspec;
+    entries: perfentry[];
+    now: number;
+}): flowmetric[];
+/** True when the user chosen heap interval allows a new on demand snapshot: the frequency bound stays a user choice only and an absent interval always allows the capture. */
+export declare function heapintervalallowed(lastcapturedat: number | undefined, interval: number | undefined, now: number): boolean;
+/** Captures one on demand heap snapshot record with its byte size, node count and capture time; the counts derive from the page performance memory buffer and the dom node count because no heap profiler exists without the debugger permission. */
+export declare function heapsnap(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    origin: string;
+    usedbytes: number;
+    limitbytes: number;
+    nodecount: number;
+    now: number;
+}): heaprecord;
+/** Records one heap growth sample taken beside a step with the used and limit bytes of the page memory buffer. */
+export declare function growsampleof(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    usedbytes: number;
+    limitbytes: number;
+    now: number;
+}): growsample;
+/** Computes the growth trend of the heap samples: the slope in bytes per millisecond from the first to the last sample, the sample count and the flagged steps whose per step growth exceeds the reviewed slope. */
+export declare function growthtrend(input: {
+    runid: string;
+    samples: growsample[];
+    slope: number;
+    now: number;
+}): memorytrend;
+/** One cpu sample of the profiled window: the observed function name and the sampled time in milliseconds. */
+export interface cpusample {
+    name: string;
+    time: number;
+}
+/** Captures one cpu profile record around the step window: the profiled duration, the sample count and the hot functions ranked by their accumulated sampled time; the samples derive from the long task attribution and event timing buffers because no sampling profiler exists without the debugger permission. */
+export declare function cpusnap(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    origin: string;
+    duration: number;
+    samples: cpusample[];
+    now: number;
+}): cpuprofile;
+/** Normalizes one observed layout shift entry: the shift score, the start time and the impacted element selectors derived from the shift sources of the page observer. */
+export declare function shiftentryof(value: unknown): shiftentry | undefined;
+/** Starts one trace record of the flow with the reviewed category list; the record stops at the reviewed window end and the exported file derives from the performance timeline buffers. */
+export declare function tracestart(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    origin: string;
+    categories: string[];
+    now: number;
+}): tracerecord;
+/** One derived trace event of the recorded window: the name, the reviewed category and the time offset from the trace start. */
+export interface traceevent {
+    name: string;
+    category: string;
+    offset: number;
+}
+/** Serializes the recorded trace into its exportable file content: the honest derived format of the performance timeline events with the reviewed categories and the step annotations, never the devtools trace binary format. */
+export declare function tracetofile(trace: tracerecord, events: traceevent[]): {
+    content: string;
+    bytesize: number;
+    events: number;
+};
+/** Normalizes one reviewed trace annotation input: the step id, the label and the time offset from the trace start. */
+export declare function annotationof(value: unknown): traceannotation | undefined;
+/** Writes the reviewed step ids and labels into the trace metadata: every annotation aligns with the run timeline entry of its step so the replay view shows the trace beside the reviewed steps; exported traces without step annotations are refused upstream. */
+export declare function annotatetrace(input: {
+    trace: tracerecord;
+    annotations: traceannotation[];
+    timeline: Array<{
+        stepid: string;
+        time: number;
+    }>;
+    now: number;
+}): tracerecord;
+/** The offline replay of one captured trace file: the events, the category counts and the step annotations of the file render without a live browser. */
+export declare function replaytrace(content: string): {
+    traceid: string;
+    runid: string;
+    categories: Record<string, number>;
+    events: Array<{
+        name: string;
+        category: string;
+        offset: number;
+        stepid?: string;
+    }>;
+    annotations: traceannotation[];
+};
+/** Resolves the sourceMappingURL declaration of one script source: the map url resolves against the script url and scripts without a declaration have no map to capture. */
+export declare function mapurlof(scripturl: string, source: string): string | undefined;
+/** Builds the source map reference drafts of the loaded scripts: every script with a sourceMappingURL declaration gains its map url while the parsed state is decided by the capture. */
+export declare function capturesourcemaps(input: {
+    runid: string;
+    stepid: string;
+    origin: string;
+    scripts: Array<{
+        url: string;
+        source: string;
+    }>;
+    now: number;
+}): sourcemapref[];
+/** Rewrites one stack location through a parsed source map: the minimal mapping lookup decodes the mappings field, walks the generated lines and resolves the original source file and line of the generated position; unparsed maps leave the location untouched. */
+export declare function rewritesourcelocation(input: {
+    url: string;
+    line: number;
+    column?: number;
+}, map: {
+    sources?: string[];
+    mappings?: string;
+}): {
+    url: string;
+    line: number;
+} | undefined;
+/** Expires the heavy profile bytes after the user configured retention window: the snapshot bytes, sample payloads and trace file bytes drop while the byte and node counts, the sample counts, hot functions, category lists and step annotations survive. */
+export declare function expireprofilerecords(input: {
+    heaps: heaprecord[];
+    profiles: cpuprofile[];
+    traces: tracerecord[];
+    retention: number | undefined;
+    now: number;
+}): {
+    heaps: heaprecord[];
+    profiles: cpuprofile[];
+    traces: tracerecord[];
+};
+//# sourceMappingURL=debug.d.ts.map