@wenathlan/devthink 2.0.13 → 2.0.15

package/dist/capture.d.ts

@@ -0,0 +1,595 @@
+/**
+ * The capture module of the 1.1.90 consolidation: every correlated variation of the media capture, vision and redaction logic interned in this one file, so the module family carries one surface without duplicate variations.
+ * The correlation is the capture pipeline of a run: capture holds the base geometry (the capture options with their formats and export targets, the stitch tiling with seam blending and fixed header skip, the element crop with the viewport fallback, the region container steps, the contact sheet grid, the annotation plan and the capture naming rule with the before and after state pairing); media holds the media capture part two (the derived pdf composition with reviewed paper sizes and pagination break points, the recording records with their frame intervals and clean stops, the image filter matching with url deduplication, the lapse frame ordering, the conversion and thumbnail geometry and the raw media, asset and stream normalization); vision holds the teaching to see (the ocr recognition with its word boxes merged into lines and paragraphs, the region, pdf and frame ocr passes, the vision descriptions, the crop geometry that reuses the capture rectangle rules, the redaction masks, the grounding and the dom pairing beside every screenshot); and redactshots holds the capture masking (the sensitive regions derived from the field shapes the recognizer masks or drawn by the user, covering viewport, element and stitched captures alike so the stored bytes never carry them).
+ * No paper size, fps, region count, retention, model choice or cache window is ever hardcoded anywhere in the family: every geometry and bound stays the user's or the reviewed step's choice, recognition payloads stay opaque reviewed text, and no capture path ever bypasses the review.
+ */
+import type { captureexport, captureformat, capturenaming, captureoptions, regionrect, sheetlayout, shotpair, shotrecord, stitchplan } from "./types.js";
+/**
+ * Media capture logics for the 1.1.40 family.
+ * Every correlated rule for the capture options defaults, the stitch tiling and seam blending, the fixed header skip, the pixel ratio scaling, the element crop and viewport fallback, the region container steps, the contact sheet grid, the annotation plan, the capture naming rule and the before and after state pairing lives in this file.
+ */
+/** Formats every capture kind may produce; the policy grammar refuses anything outside this set. */
+export declare const captureformats: captureformat[];
+/** Export targets a reviewed capture may route to; disk writes stay inside the reviewed download flow. */
+export declare const capturetargets: captureexport[];
+/** The capture kinds of the 1.1.40 family, listed among the available capabilities of every proposal request. */
+export declare const capturekinds: string[];
+/** Normalizes reviewed capture options with png, pixel ratio one and the memory export target as defaults. */
+export declare function captureoptionsof(value: unknown): captureoptions;
+/** Builds one shotrecord for a visible viewport capture with the reviewed geometry and byte size. */
+export declare function capturevisible(input: {
+    runid: string;
+    stepid: string;
+    options: captureoptions;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    dataurl: string;
+    at: number;
+    id: string;
+    name?: string;
+    target?: string;
+}): shotrecord;
+/** Builds one shotrecord for a stitched full page capture from the tile plan geometry. */
+export declare function capturestitched(input: {
+    runid: string;
+    stepid: string;
+    options: captureoptions;
+    plan: stitchplan;
+    dataurl: string;
+    at: number;
+    id: string;
+    name?: string;
+}): shotrecord;
+/** Builds one shotrecord for an element capture cropped to the pixel ratio scaled element bounds. */
+export declare function captureelement(input: {
+    runid: string;
+    stepid: string;
+    options: captureoptions;
+    rect: regionrect;
+    dataurl: string;
+    at: number;
+    id: string;
+    name?: string;
+    target?: string;
+}): shotrecord;
+/** Builds one shotrecord for a region capture of one reviewed rectangle or scrollable container. */
+export declare function captureregion(input: {
+    runid: string;
+    stepid: string;
+    options: captureoptions;
+    rect: regionrect;
+    dataurl: string;
+    at: number;
+    id: string;
+    name?: string;
+    target?: string;
+}): shotrecord;
+/** Links a before and an after shot into one shotpair with the action context and the dom snapshot id of the same moment; a missing after shot skips the pair. */
+export declare function pairstates(before: shotrecord | undefined, after: shotrecord | undefined, action: {
+    kind: string;
+    target?: string;
+    domsnapshotid?: string;
+}, at: number, id: string): {
+    pair?: shotpair;
+    skipped?: "before" | "after";
+    reason: string;
+};
+/** Applies the capture policy around one action: beforeafter pairs wrap the action, every other mode leaves the pair to the manual capture kinds. */
+export declare function capturestates(input: {
+    policy: string;
+    before?: shotrecord | undefined;
+    after?: shotrecord | undefined;
+    actionkind: string;
+    target?: string | undefined;
+    domsnapshotid?: string | undefined;
+    at: number;
+    id: string;
+}): {
+    pair?: shotpair;
+    skipped?: "before" | "after";
+    reason: string;
+};
+/** Builds the viewport tiling of one full page capture: a tile grid of scroll offsets with overlap rows; the last tile clamps to the page end. */
+export declare function buildstitchplan(input: {
+    scrollwidth: number;
+    scrollheight: number;
+    viewportwidth: number;
+    viewportheight: number;
+    overlap?: number;
+}): stitchplan;
+/** Linear cross fade weights across one overlap band: the first row keeps the existing content, the last row adopts the new tile. */
+export declare function seamweights(overlap: number): number[];
+/** Blends one overlap band of equal length row arrays with the linear seam weights so tile seams never hard cut. */
+export declare function blendrows(upper: number[], lower: number[]): number[];
+/** True when a tile band repeats the first tile band, so the stitcher skips it and fixed headers never repeat across tiles. */
+export declare function fixedheadermatch(band: number[], firstband: number[]): boolean;
+/** Scales one css pixel rectangle by the reviewed pixel ratio; ratios of one, two and three scale every edge. */
+export declare function scaledrect(rect: regionrect, pixelratio: number): regionrect;
+/** Clamps one rectangle to the visible part of the viewport, never returning negative geometry. */
+export declare function croprect(rect: regionrect, viewport: {
+    width: number;
+    height: number;
+}): regionrect;
+/** True when an element rectangle crosses any viewport edge and the capture falls back to tiled capture. */
+export declare function crossesviewport(rect: regionrect, viewport: {
+    width: number;
+    height: number;
+}): boolean;
+/** Scroll tops that walk a scrollable container in reviewed steps; every step clamps so the last window ends at the container end. */
+export declare function regionsteps(containerheight: number, viewportstep: number): number[];
+/** One placed cell of a contact sheet grid with its caption stamped from the reviewed label style. */
+export interface sheetcell {
+    index: number;
+    column: number;
+    row: number;
+    selector: string;
+    label: string;
+    caption: string;
+}
+/** Places the element captures of a contact sheet on a labeled grid; the cell count stays a user choice with no code ceiling. */
+export declare function buildsheet(cells: Array<{
+    selector: string;
+    label?: string;
+}>, layout: sheetlayout): {
+    columns: number;
+    rows: number;
+    cells: sheetcell[];
+};
+/** Builds one capture filename from the reviewed naming rule segments; the sequence counter keeps every name unique inside a run. */
+export declare function buildname(rule: capturenaming, parts: {
+    run: string;
+    step: string;
+    sequence: number;
+    kind: string;
+}, extension: string): string;
+/** One annotation plan for a captured image: the step number marker, the optional target outline and the footer with capture time and page url. */
+export interface annotationplan {
+    marker: {
+        x: number;
+        y: number;
+        number: number;
+    };
+    outline?: regionrect;
+    footer: string;
+}
+/** Plans the annotations of one capture: the step number marker position, the expanded target rect outline and the footer text with capture time and url. */
+export declare function annotationplanof(input: {
+    step: number;
+    width: number;
+    height: number;
+    rect?: regionrect;
+    url: string;
+    at: number;
+}): annotationplan;
+import type { assetrecord, convertdirective, imagefilter, imagedescriptor, mediadatum, pdfoptions, recordingoptions, recordingrecord, streamrecord, thumbdirective } from "./types.js";
+/**
+ * Media capture part two logics for the 1.1.41 family.
+ * Every correlated rule for the derived pdf composition with reviewed paper sizes, margins and pagination break points, the recording records with their frame intervals and clean stops, the image filter matching with url deduplication and counter names, the lapse frame ordering, the conversion and thumbnail geometry and the raw media, asset and stream normalization lives in this file.
+ */
+/** The media capture part two kinds, listed among the available capabilities of every proposal request. */
+export declare const mediakinds: string[];
+/** Normalizes reviewed pdf options with paper defaults; unknown fields stay ignored. */
+export declare function pdfoptionsof(value: unknown): pdfoptions;
+/** Resolves the pdf page size in points after the landscape swap. */
+export declare function pdfpagesize(options: pdfoptions): {
+    width: number;
+    height: number;
+};
+/** Wraps one text block into page lines for the reviewed geometry: word wrap at the average glyph width of the Helvetica body font. */
+export declare function pdftextlayout(text: string, options: pdfoptions): string[];
+/** Splits the scroll height into report page segments at reviewed break point offsets; absent break points walk the height in viewport steps. */
+export declare function pdfsegments(scrollheight: number, viewportheight: number, breaks: number[]): Array<{
+    top: number;
+    height: number;
+}>;
+/** Composes one derived pdf document from the page text blocks with the reviewed paper size, margins, scale and landscape orientation; the byte size is the latin one document length. */
+export declare function buildpdf(pages: string[], options: pdfoptions): {
+    document: string;
+    bytes: number;
+    pages: number;
+    pagewidth: number;
+    pageheight: number;
+};
+/** Normalizes reviewed recording options with the tab scope as the default. */
+export declare function recordingoptionsof(value: unknown): recordingoptions;
+/** Opens one recording record of user activity with the reviewed options applied. */
+export declare function newrecording(input: {
+    id: string;
+    runid: string;
+    stepid: string;
+    tabid: number;
+    kind: "screen" | "audio";
+    options: recordingoptions;
+    at: number;
+}): recordingrecord;
+/** Closes one recording cleanly at the given time and stamps the duration. */
+export declare function finishrecording(record: recordingrecord, endat: number): recordingrecord;
+/** Frame shoot interval in milliseconds of the reviewed fps; the fps itself carries no code ceiling. */
+export declare function frameinterval(fps: number): number;
+/** Normalizes a reviewed image filter; unknown fields stay ignored. */
+export declare function imagefilterof(value: unknown): imagefilter;
+/** True when one observed image passes the reviewed filter: minimum dimensions and the format list; absent bounds never refuse. */
+export declare function imagematches(image: imagedescriptor, filter: imagefilter): boolean;
+/** Deduplicates observed images by url before any download starts; the first observation of a url wins. */
+export declare function dedupeimages(images: imagedescriptor[]): imagedescriptor[];
+/** Stamps consistent image batch filenames from the reviewed naming rule with a per batch image counter. */
+export declare function imagenames(rule: capturenaming, run: string, step: string, count: number, extension: string): string[];
+/** Normalizes a reviewed lapse plan; an absent format keeps png. */
+export declare function lapseplanof(value: unknown): {
+    interval: number;
+    duration: number;
+    format: captureformat;
+} | undefined;
+/** Ordered lapse frame timestamps starting at zero and stepping the reviewed interval inside the reviewed duration. */
+export declare function lapseframes(plan: {
+    interval: number;
+    duration: number;
+}): number[];
+/** Normalizes a reviewed conversion directive; an absent payload leaves the step without a directive. */
+export declare function convertdirectiveof(value: unknown): convertdirective | undefined;
+/** Normalizes a reviewed thumbnail directive; an absent payload leaves the step without a directive. */
+export declare function thumbdirectiveof(value: unknown): thumbdirective | undefined;
+/** Nine argument draw geometry of one thumbnail: cover crops to the square and fits inside, contain letterboxes the whole source. */
+export declare function thumbgeometry(source: {
+    width: number;
+    height: number;
+}, directive: thumbdirective): {
+    sx: number;
+    sy: number;
+    sw: number;
+    sh: number;
+    dx: number;
+    dy: number;
+    dw: number;
+    dh: number;
+    width: number;
+    height: number;
+};
+/** Normalizes raw embedded media element entries into mediadatum records with duration, dimensions, codecs and track lists. */
+export declare function mediaentries(raw: Array<Record<string, unknown>>): mediadatum[];
+/** Normalizes raw page asset entries into favicon or logo asset shapes with their byte sizes and declared sizes. */
+export declare function assetentries(raw: Array<Record<string, unknown>>): Array<{
+    kind: assetrecord["kind"];
+    url: string;
+    bytes: number;
+    sizes?: string;
+}>;
+/** Normalizes raw stream probe entries into stream summaries with track counts, labels, live states and track details. */
+export declare function streamsummaries(raw: Array<Record<string, unknown>>): Array<Omit<streamrecord, "id" | "runid" | "stepid" | "at">>;
+import type { framereference, groundingresult, ocrline, ocrregion, ocrresult, ocrword, redactionmask, screenshotpair, streamcursor, visioncacheentry, visiondescription } from "./types.js";
+/**
+ * Vision and ocr logic of the 1.1.77 family.
+ * Every correlated rule for teaching the agent to see lives in this one module: the imageocr recognition that reads the words with their boxes and confidences off a captured image and merges the word boxes into lines and paragraphs; the regionocr recognition of one reviewed ocrregion of a screenshot with its bounds clamped into the viewport and its word boxes offset to absolute coordinates; the pdfocr pass that rasterizes one scanned pdf page at a time through a rasterize seam with the streamcursor checkpointing after every page; the frameocr read that refuses a playing video, seeks a paused video to its reviewed position and captures the frame; the visionshot description that carries the reviewed prompt with the image to the configured vision model and returns a visiondescription with labeled regions; the cropshot geometry that crops a screenshot to element bounds scaled with device pixel ratio awareness; the redactshot masking that applies a redactionmask before any sharing, fills the masked regions and proposes masks for the common sensitive regions by field type; the groundshot grounding that scores candidate elements by text and geometry match and returns ranked selectors; the pairshot pairing that captures a dom snapshot beside every screenshot, aligns the pair by capture time and viewport size and answers queries by searching text in both image and dom; the ocrtext normalization into searchable text; the visioncost counting of the model calls per run for the costshare ledger; and the visioncache that stores recognition results by image hash so a repeated read serves without a model call.
+ * The module extends the reviewed families instead of duplicating them: the crop and scale geometry composes the capture rectangle rules of the 1.1.40 family, the sensitive field shapes come from the maskinputs recognizer the redactshots family already uses, the streamcursor checkpoint grammar comes from the pipeline family of the 1.1.75 release, and the image hash rides the same bodyhashof shape identity the web api cache of the 1.1.76 family keys its entries with.
+ * Every impure move stays behind an injected seam — the ocr read, the vision model send, the pdf rasterize, the video state read, the frame grab and the mask fill resolve through functions the executor wires — while every recognition result, description text and labeled region stays opaque reviewed text; no recognition payload enters any audit summary built from these results, and every retention, budget and model choice stays the user's with no code default — an absent value never hides a hardcoded ceiling, and no vision path ever bypasses a review.
+ */
+/** Ocr read seam: one captured image with its optional region resolves to the recognized words with their boxes and confidences; the extension executor wires the configured vision model provider, tests wire plain fixtures. */
+export type ocrread = (image: string, region?: ocrregion) => Promise<ocrword[]>;
+/** The vision kinds of the 1.1.77 family, listed among the available capabilities of every proposal request. */
+export declare const visionkinds: string[];
+/** Vision model seam: one reviewed vision request with its image and prompt resolves to the description text and its labeled regions; the extension executor wires the configured model endpoint, tests wire plain fixtures. */
+export type visionsend = (request: {
+    imageid: string;
+    image: string;
+    prompt: string;
+}) => Promise<{
+    text: string;
+    regions: Array<{
+        label: string;
+        box: ocrregion;
+    }>;
+}>;
+/** Pdf rasterize seam: one stored pdf document with its one based page number resolves to the rasterized page image; the extension executor wires the renderer backend, tests wire plain fixtures. */
+export type pdfrasterize = (documentid: string, page: number) => Promise<string>;
+/** Video state seam: one video selector resolves to its paused flag with the playback position and duration in milliseconds; the executor wires the page bridge, tests wire plain fixtures. */
+export type videostateread = (selector: string) => Promise<{
+    paused: boolean;
+    positionms: number;
+    durationms: number;
+}>;
+/** Frame grab seam: one video selector at one reviewed position resolves to the captured frame image with its size; the executor wires the page bridge capture, tests wire plain fixtures. */
+export type framegrab = (selector: string, positionms: number) => Promise<{
+    image: string;
+    width: number;
+    height: number;
+}>;
+/** Mask fill seam: one image with the regions to cover resolves to the image with the opaque rectangles drawn; the executor wires the capture canvas, tests wire plain fixtures. */
+export type maskfill = (image: string, regions: ocrregion[]) => Promise<string>;
+/** Normalizes recognition output into searchable text: whitespace runs fold into single spaces, the ends trim, and the folded text feeds the pairshot queries and the observation vision block. */
+export declare function ocrtext(value: string): string;
+/**
+ * Merges the recognized word boxes into lines: two words join one line when their boxes share more than half of the shorter box's height, the line text joins the words left to right, the line box covers its words and the line confidence reports the lowest word confidence so a shaky word drags its line down instead of hiding inside an average — pure geometry with no configurable bound.
+ */
+export declare function mergelines(words: ocrword[]): ocrline[];
+/**
+ * Merges the recognized lines into paragraphs: two consecutive lines join one paragraph while the vertical gap between them stays inside the shorter line's height, and the paragraph text joins its line texts with single spaces — pure geometry again, so the paragraph breaks answer the page's own spacing.
+ */
+export declare function mergeparagraphs(lines: ocrline[]): string[];
+/**
+ * Runs the recognition of one captured image through the ocr read seam: the seam returns the words with their boxes and confidences, the words merge into lines and paragraphs by their own geometry, and the result carries the full normalized text beside the word level evidence.
+ */
+export declare function imageocr(input: {
+    record: {
+        runid: string;
+        stepid: string;
+        imageid: string;
+    };
+    image: string;
+    read: ocrread;
+    id?: string;
+    now: number;
+}): Promise<ocrresult>;
+/**
+ * Runs the recognition of one reviewed ocrregion of a screenshot: the region clamps into the viewport so a region drawn past the edges reads only the visible part, a region fully outside the surface refuses loudly instead of reading wrong pixels, the read rides the region through the ocr seam, and the recognized boxes offset by the region origin so every word box lands in absolute screenshot coordinates.
+ */
+export declare function regionocr(input: {
+    record: {
+        runid: string;
+        stepid: string;
+        imageid: string;
+    };
+    image: string;
+    region: ocrregion;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    read: ocrread;
+    id?: string;
+    now: number;
+}): Promise<ocrresult>;
+/**
+ * Reads one scanned pdf one page at a time through the rasterize and ocr seams: every page rasterizes, reads and lands its own ocrresult while the streamcursor checkpoints after each page, a cursor of another document refuses loudly because the pass continues exactly the document it came from, and the already read pages skip on a resume so nothing reads twice.
+ */
+export declare function pdfocr(input: {
+    record: {
+        runid: string;
+        stepid: string;
+        documentid: string;
+    };
+    pages: number;
+    rasterize: pdfrasterize;
+    read: ocrread;
+    cursor?: streamcursor;
+    checkpoint?: (cursor: streamcursor) => void;
+    now: number;
+    clock?: () => number;
+}): Promise<{
+    results: ocrresult[];
+    cursor: streamcursor;
+    pagesread: number;
+    skipped: number;
+}>;
+/**
+ * Reads one video frame through the video state and frame grab seams: a playing video refuses loudly because the frame of a moving picture answers no question, a paused video seeks to its reviewed position in milliseconds and captures the frame, and the read rides the captured image through the ocr seam while the framereference records the position the run read.
+ */
+export declare function frameocr(input: {
+    record: {
+        runid: string;
+        stepid: string;
+    };
+    frame: framereference;
+    state: videostateread;
+    grab: framegrab;
+    read: ocrread;
+    now: number;
+}): Promise<{
+    frame: framereference;
+    result: ocrresult;
+    image: string;
+}>;
+/**
+ * Sends one screenshot with its reviewed prompt to the configured vision model through the vision send seam: an empty prompt refuses loudly because the model answers exactly what the review asked, the seam returns the description text with its labeled regions, and the description carries the prompt it answered so the audit reads both sides.
+ */
+export declare function visionshot(input: {
+    record: {
+        runid: string;
+        stepid: string;
+        imageid: string;
+    };
+    image: string;
+    prompt: string;
+    send: visionsend;
+    id?: string;
+    now: number;
+}): Promise<visiondescription>;
+/**
+ * Computes the crop geometry of one element shot: the element bounds in css pixels scale by the device pixel ratio so the crop lands in image pixels, the scaled crop clamps into the captured image because an element past the edges crops only the visible part, and a bounds rectangle fully outside the image refuses loudly instead of cropping wrong pixels.
+ */
+export declare function cropshot(input: {
+    image: {
+        width: number;
+        height: number;
+    };
+    bounds: ocrregion;
+    pixelratio: number;
+}): {
+    cssbounds: ocrregion;
+    crop: ocrregion;
+    width: number;
+    height: number;
+    ratio: number;
+};
+/**
+ * Applies one redaction mask to a capture before any sharing through the mask fill seam: every region clamps into the capture so a mask past the edges covers only the real part, a mask whose every region falls outside the capture refuses loudly because a share that claims redaction while covering nothing leaks, the fill seam draws the opaque rectangles, and the returned summary records the mask in the audit trail with its reason.
+ */
+export declare function redactshot(input: {
+    image: string;
+    width: number;
+    height: number;
+    mask: redactionmask;
+    fill: maskfill;
+}): Promise<{
+    image: string;
+    regions: number;
+    reason: string;
+    summary: string;
+}>;
+/**
+ * Proposes redaction masks for the common sensitive regions by field type: every field whose name carries a sensitive field shape the maskinputs recognizer masks contributes one mask with its own reason, so the sidepanel offers exactly the masks the field types imply and the user edits them before any share.
+ */
+export declare function proposeredactionmasks(input: {
+    runid: string;
+    captureid: string;
+    fields: Array<{
+        name: string;
+        rect: ocrregion;
+    }>;
+    now: number;
+}): redactionmask[];
+/**
+ * Grounds the labeled regions of one vision description into ranked page selectors: every candidate element scores by its text match with the label (the shared significant words over the label's words) and its geometry match with the region box (the intersection over union after the image pixel ratio converts the box into css pixels), the two halves average, and the matches rank by score so the top selector grounds the label; a candidate that shares neither words nor geometry never joins the ranking.
+ */
+export declare function groundshot(input: {
+    description: visiondescription;
+    elements: Array<{
+        selector: string;
+        text: string;
+        rect: ocrregion;
+    }>;
+    pixelratio: number;
+    record: {
+        runid: string;
+        stepid: string;
+    };
+    id?: string;
+    now: number;
+}): groundingresult;
+/**
+ * Pairs one screenshot with the dom snapshot captured beside it: only snapshots of the same viewport size align, the nearest capture time wins because the pair answers one moment of the page, and an image with no same viewport snapshot stays unpaired and names its refusal instead of pairing wrong pixels with wrong dom.
+ */
+export declare function pairshot(input: {
+    runid: string;
+    stepid: string;
+    image: {
+        id: string;
+        capturetime: number;
+        viewport: {
+            width: number;
+            height: number;
+        };
+    };
+    snapshots: Array<{
+        id: string;
+        capturetime: number;
+        viewport: {
+            width: number;
+            height: number;
+        };
+    }>;
+    id?: string;
+    now: number;
+}): {
+    pair?: screenshotpair;
+    skipped?: "snapshot";
+    reason: string;
+};
+/**
+ * Answers one query by searching the text of both sides of a pair: the normalized ocr text of the image and the dom text both fold their whitespace and lowercase before the needle search, every matching side reports an excerpt around its hit, and the summary names exactly which sides matched so a visual claim answers its page side.
+ */
+export declare function pairquery(input: {
+    query: string;
+    ocrtextvalue: string;
+    domtext: string;
+}): {
+    matches: Array<{
+        source: "image" | "dom";
+        excerpt: string;
+    }>;
+    summary: string;
+};
+/**
+ * Counts the vision calls of one run for the costshare ledger: every call records whether it rode the configured model endpoint, only the model calls count units because the local passes spend nothing, and the description names the split so the ledger entry reads exactly what the vision family spent.
+ */
+export declare function visioncost(input: {
+    runid: string;
+    calls: Array<{
+        kind: string;
+        model: boolean;
+        at: number;
+    }>;
+}): {
+    calls: number;
+    modelcalls: number;
+    units: number;
+    description: string;
+};
+/** Reads the hash of one image payload for the visioncache keys: the same bodyhashof shape identity the web api cache keys its entries with, never the pixel values. */
+export declare function imagehashof(image: string): string;
+/**
+ * Stores one recognition or description in the visioncache by its image hash: a newer entry of the same hash replaces the older one, and the cache never grows a duplicate because one image hash answers one recognition.
+ */
+export declare function visioncacheput(input: {
+    entries: visioncacheentry[];
+    entry: visioncacheentry;
+}): visioncacheentry[];
+/**
+ * Serves one visioncache hit by the image hash and kind: entries older than the user retention window drop first because the expiry ties to the user choice with no code default, a live entry of the same hash and kind serves with its hit counter bumped so the repeated read never calls the model again, and the pass reports exactly what it expired.
+ */
+export declare function visioncacheserve(input: {
+    entries: visioncacheentry[];
+    hash: string;
+    kind: "ocr" | "vision";
+    now: number;
+    retention?: number;
+}): {
+    entry?: visioncacheentry;
+    entries: visioncacheentry[];
+    expired: number;
+};
+import type { capturesurface, redactregion, toolstep } from "./types.js";
+/**
+ * Redactshots logic of the 1.1.62 family.
+ * The capture masking rules live here: sensitive regions of the capture surface — derived from the field shapes the recognizer masks or drawn by the user — cover viewport, element and stitched captures alike, so the stored bytes never carry the sensitive regions while the record keeps the redaction evidence and the reason.
+ * The regions scope to one origin and one page template, and no geometry, region count or shape list is ever hardcoded: every region stays the user's knowledge, mirroring the maskinputs posture.
+ */
+/** Builds one redact region with its geometry in css pixels, its plain language reason and its source; the geometry stays finite and positive so the capture seam draws a real rectangle. */
+export declare function regionof(input: {
+    origin: string;
+    template: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    reason: string;
+    source: "fieldshape" | "userdrawn";
+    now: number;
+    id?: string;
+}): redactregion;
+/** Reads whether one region keeps finite, positive geometry the capture seam can draw. */
+export declare function regionvalid(region: redactregion): boolean;
+/** Reads the regions of one origin and page template: the regions bind to the page they were drawn on and never leak onto another origin or template. */
+export declare function regionsfor(regions: redactregion[], origin: string, template: string): redactregion[];
+/** Derives redact regions from the sensitive field shapes of one form layout: every field whose name matches a masked shape contributes its rectangle, so the capture masks exactly what the recognizer would mask. */
+export declare function fieldshaperegions(input: {
+    origin: string;
+    template: string;
+    fields: Array<{
+        name: string;
+        rect: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    }>;
+    now: number;
+}): redactregion[];
+/** Merges drawn regions into the stored set: a region of the same origin, template and geometry keeps its first record while a new geometry joins the list. */
+export declare function mergeregions(existing: redactregion[], added: redactregion[]): redactregion[];
+/** Maps one capture kind to its redactshots surface: viewport captures, element captures and stitched captures all carry the same region grammar. */
+export declare function capturesurfaceof(kind: string): capturesurface;
+/** Reads the template name of one capture step: the reviewed option template the user named, or the step kind itself as the page template baseline. */
+export declare function templateof(step: Pick<toolstep, "kind" | "options">): string;
+/** Applies the redact regions to one stored capture record: the record keeps the redaction evidence — the flag and the region count — while the capture seam draws the opaque rectangles before the bytes reach storage, across every capture kind. */
+export declare function redactedshot<T extends {
+    kind: string;
+}>(record: T, regions: redactregion[]): T & {
+    redacted?: boolean;
+    redactedregions?: number;
+};
+/** Builds the redaction evidence summary the audit trail records: the surface, the region count and the reason of every region. */
+export declare function redactionsummary(regions: redactregion[]): string;
+//# sourceMappingURL=capture.d.ts.map

package/dist/cjs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Cjs entry of the 1.1.81 family.
+ * The shared core for require based consumers: the build emits this entry as dist/index.cjs with every named export of the esm core behind one stable getter object, and the entry stamps its own mode so the library reports the bundle it runs from.
+ */
+export * from "./index.js";
+//# sourceMappingURL=cjs.d.ts.map

package/{cli.js → dist/cli.js}

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-/*! devthink 2.0.13 — consent-first browser agent library — GPL-3.0-only — https://github.com/wenathlan/devthink */
+/*! devthink 2.0.15 — consent-first browser agent library — GPL-3.0-only — https://github.com/wenathlan/devthink */
 
 // cli.ts
 import { createInterface } from "node:readline/promises";
@@ -569,7 +569,7 @@ function endcall(input) {
 }
 
 // version.ts
-var packageversion = "2.0.13";
+var packageversion = "2.0.15";
 var protocolmajor = 2;
 var protocolfloormajor = 2;