@wenathlan/extension 1.1.37 → 1.1.39

package/README.md

@@ -2,18 +2,20 @@
 
 Devthink is a **consent-first browser-agent bridge** distributed as a TypeScript library and a Chromium Manifest V3 extension. It turns a user-provided browser objective into a bounded, reviewable plan. The user must start the active-tab session and approve the plan before any page action reaches the browser.
 
-Version: **1.1.37**. License: **GPL-3.0-only**. The repository is `wenathlan/extension`; the npm-compatible scoped package identifier is `@wenathlan/extension`.
+Version: **1.1.39**. License: **GPL-3.0-only**. The repository is `wenathlan/extension`; the npm-compatible scoped package identifier is `@wenathlan/extension`.
 
 ## What it does
 
-| Capability | Behavior in 1.1.37 |
+| Capability | Behavior in 1.1.39 |
 | --- | --- |
 | Active-tab session | The user starts a short-lived session for one HTTPS tab and one origin; the session records its origin grants. |
 | Page observation | The extension captures the complete semantic inventory: every interactive element, every form control, every select option and the full page text. |
 | Plan proposal | A local plan can be created immediately; an optional user-configured HTTPS endpoint can return a typed plan proposal of any length. |
 | Review gate | Every remote proposal starts in `pending`; it cannot reach the page bridge before explicit approval. |
-| Browser tools | Reviewed plans cover two hundred one action kinds: pointer paths and coordinate clicks, text, aria, name, xpath, index and point target resolution, timed typing, key holds, sliders, dates, colors, shadow dom piercing, iframe entry, dialog answering, retry rules, a complete read vocabulary with clickable maps and verification reads, page mutation under review, and browser-level tab, window, zoom, snapshot and download commands. |
+| Browser tools | Reviewed plans cover two hundred thirty one action kinds: pointer paths and coordinate clicks, text, aria, name, xpath, index and point target resolution, timed typing, key holds, sliders, dates, colors, shadow dom piercing, iframe entry, dialog answering, retry rules, a complete read vocabulary with clickable maps and verification reads, page mutation under review, and browser-level tab, window, zoom, snapshot and download commands. |
 | Forms and data | The agent fills forms with review: `fillform` fills from a structured record of field matches, kinds and values, `filllabel` and `fillplaceholder` match controls by label, placeholder or aria label, `detectfields` reports the form map with field kinds, `generatevalues` seeds locale aware values per field kind while real looking card numbers and personal identifiers are refused, `saveprofiles` stores profiles behind origin grants, `asksubmit` opens the submission prompt with the values diff, `submitform` submits only under an approved consent ref, `readerrors` associates inline validation messages with fields, `retryform` retries with reviewed backoff windows, `runwizard`, `selectchain`, `picktypeahead` and `pickdate` drive wizards, dependent selects, typeaheads and calendars, `attachfile` attaches run store artifacts, `fillcard`, `fillcode` and `consentpassword` handle payment and secret fields behind explicit consent, `skiphoneypot` skips trap fields, `detectlogin` and `detecttemplate` flag login, signup and checkout shapes, and `handoffcaptcha` pauses the plan and hands control back to the user. |
+| Files and downloads | The agent moves bytes with review: `batchdownload` downloads reviewed url lists in waves under a user configured concurrent window with per file states and sequence suffixes for filename conflicts, `pausedownload` and `resumedownload` walk the queue through the downloads api, `verifydownload` compares state, size and checksum against reviewed expectations, `interceptmime` arms include, exclude and deny default mime filters that reroute matching downloads into quarantine, `exportnetlog` exports the step correlated network log with every header value redacted, `readclipboard` needs an approved single use consent prompt per read and never persists the payload text, `writeclipboard` writes reviewed text through the page bridge with payload hashes for audit, `copyscreen` copies the visible tab to the clipboard, `quarantinedownload` and `scanvirus` keep files outside the downloads folder until a clean scan verdict releases them, `namecaptures` stamps task, step and sequence filenames with per task counters, and `cleanupartifacts` sweeps artifacts by reviewed age and kind rules while keeping open review references. |
+| Datasets and exports | The agent turns pages into data with audit: `scrapetable` reads tables into normalized column keys with rowspan and colspan expansion and nested child datasets, `paginateextract` follows next controls while waiting for fresh rows, `mergepages` aligns columns across pages, `transformvalues` applies reviewed expressions with per rule error surfacing, `deduperows` deduplicates by reviewed keys, `stamplerows` stamps every row with its source url, timestamp and step ref, `previewgrid` previews the grid before export, `importcsv` parses quoted csv with column mappings for fill loops, `looprows` interpolates `{{column}}` row variables into the wrapped inner step, `exportcsv`, `exportjson` and `exportexcel` write checksummed artifacts into the task artifact store with provenance records, `copytable` uses the clipboard under the optional clipboardWrite capability, `pushsheets` pushes only to a reviewed HTTPS endpoint behind its origin grant and the explicit reviewed flag, `streamdisk` streams chunk by chunk with backpressure and a persisted resume state, `resumeextract` continues an interrupted extraction from its stored cursor, and `logprovenance` logs provenance for audit; exports refuse to leave local memory while the session origin grants do not cover the active origin. |
 | Tabs and windows command | The agent commands the whole browser surface with review: `querytabs` resolves reviewed url, title, id and pattern matchers against the live tab set, `closepattern` closes matching tabs only under the explicit reviewed flag, `pintab`, `mutetab`, `movetab`, `movetabwindow`, `duplicatetab`, `reloadtabs`, `discardtab`, `zoomin`, `zoomout` and `switchtab` mutate tabs, `grouptabs`, `colorgroup` and `collapsegroup` keep group registries, `savelayout` and `restorelayout` save and restore named tab layouts with window bounds, `snapshotsession` and `reopenrun` capture and reopen whole runs, `watchtab` observes title, activation and closure events, `findclones`, `searchtabs` and `listaudio` enumerate the surface read only, `badgetab` and `attachmeta` route task state per tab, and `maximizewindow`, `minimizewindow`, `restorewindow`, `focuswindow`, `scratchwindow` and `incognitowindow` command windows with incognito separated from grant inheritance. |
 | Navigation mastery | The agent moves anywhere with review: `openlink`, `openprivate`, `reopentab`, `deeplink` and `openclipboard` open reviewed targets in resolved containers, `followlink`, `spanav`, `spawait`, `waitload` and `waiturl` navigate pages and single page app routes, `rewritequery` and `setfragment` edit the current url, `navlist` walks a reviewed url list with per entry progress, `navprofile` applies per site wait profiles, `checksafe` verifies urls before unreviewed origins open, `batchopen` opens curated lists with per url safety states, `navrate` enforces per domain rate limits with user configured windows and ceilings, and the navigation trail, redirect chains and final urls stay recorded for audit. |
 | Observation depth | The agent sees the whole page read only: the accessibility tree beside the dom snapshot, reader views, visible text, outlines, selections, open graph and embedded json state, plus detected lists, tables, pagination, infinite scroll, virtualization, lazy images, sticky overlays and scroll locks offered as plan suggestions. |
@@ -51,7 +53,7 @@ The endpoint field intentionally has no default URL. Enter a URL such as `https:
 
 ```json
 {
-  "version": "1.1.37",
+  "version": "1.1.39",
   "objective": "User supplied objective",
   "session": { "id": "uuid", "tabid": 1, "origin": "https://example.com" },
   "observation": { "schemaversion": 3, "url": "https://example.com/path", "interactive": [] },

package/dist/index.js

@@ -520,21 +520,235 @@ var sessionmemory = class {
   async getcodevalue() {
     return this.adapter.get("codevalue");
   }
+  /** Stores one dataset with its column specs and rows, replacing the previous record of that id. */
+  async setdataset(value) {
+    await this.adapter.set(`dataset${value.id}`, value);
+    const ids = (await this.adapter.get("datasets") ?? []).filter((id) => id !== value.id);
+    await this.adapter.set("datasets", [value.id, ...ids]);
+  }
+  /** Returns one stored dataset by its id with its column specs and row count. */
+  async getdataset(id) {
+    return this.adapter.get(`dataset${id}`);
+  }
+  /** Returns every stored dataset id, newest first. */
+  async getdatasets() {
+    const ids = await this.adapter.get("datasets") ?? [];
+    const records = [];
+    for (const id of ids) {
+      const record2 = await this.adapter.get(`dataset${id}`);
+      if (record2) records.push(record2);
+    }
+    return records;
+  }
+  /** Stores one imported csv dataset for fill loops beside the dataset store. */
+  async addimport(value) {
+    await this.setdataset(value);
+    const ids = (await this.adapter.get("imports") ?? []).filter((id) => id !== value.id);
+    await this.adapter.set("imports", [value.id, ...ids]);
+  }
+  /** Returns every imported csv dataset for fill loops, newest first. */
+  async getimports() {
+    const ids = await this.adapter.get("imports") ?? [];
+    const records = [];
+    for (const id of ids) {
+      const record2 = await this.adapter.get(`dataset${id}`);
+      if (record2) records.push(record2);
+    }
+    return records;
+  }
+  /** Stores one extraction session with its cursor and page history, replacing the previous session of that id. */
+  async setextractsession(value) {
+    await this.adapter.set(`extract${value.id}`, value);
+    const ids = (await this.adapter.get("extracts") ?? []).filter((id) => id !== value.id);
+    await this.adapter.set("extracts", [value.id, ...ids]);
+  }
+  /** Returns every extraction session with its cursor and page history, newest first. */
+  async getextractsessions() {
+    const ids = await this.adapter.get("extracts") ?? [];
+    const records = [];
+    for (const id of ids) {
+      const record2 = await this.adapter.get(`extract${id}`);
+      if (record2) records.push(record2);
+    }
+    return records;
+  }
+  /** Records one provenance record of an exported artifact. */
+  async addprovenance(record2) {
+    const records = await this.getprovenances();
+    await this.adapter.set("provenances", [record2, ...records]);
+  }
+  /** Returns every provenance record per exported artifact, newest first. */
+  async getprovenances() {
+    return await this.adapter.get("provenances") ?? [];
+  }
+  /** Stores the transform rules and dedupe keys of one task, replacing the previous record of that task. */
+  async settaskrules(value) {
+    const records = (await this.adapter.get("taskrules") ?? []).filter((item) => item.taskid !== value.taskid);
+    await this.adapter.set("taskrules", [value, ...records]);
+  }
+  /** Returns the transform rules and dedupe keys per task, newest first. */
+  async gettaskrules() {
+    return await this.adapter.get("taskrules") ?? [];
+  }
+  /** Stores one stream chunk state for resume, replacing the previous state of that dataset. */
+  async setstream(state) {
+    const records = (await this.adapter.get("streams") ?? []).filter((item) => item.datasetid !== state.datasetid);
+    await this.adapter.set("streams", [state, ...records]);
+  }
+  /** Returns every stream chunk state persisted for resume, newest first. */
+  async getstreams() {
+    return await this.adapter.get("streams") ?? [];
+  }
+  /** Stores one reviewed sheet endpoint config behind its origin grant, replacing the previous config of that origin. */
+  async setsheetendpoint(config) {
+    const records = (await this.adapter.get("sheetendpoints") ?? []).filter((item) => item.origin !== config.origin);
+    await this.adapter.set("sheetendpoints", [config, ...records]);
+  }
+  /** Returns every reviewed sheet endpoint config, newest first. */
+  async getsheetendpoints() {
+    return await this.adapter.get("sheetendpoints") ?? [];
+  }
+  /** Records one exported data artifact; artifact retention is a user setting and an absent setting keeps every artifact. */
+  async addexport(artifact) {
+    const records = await this.getexports();
+    const combined = [artifact, ...records.filter((item) => item.id !== artifact.id)];
+    const retention = (await this.getsettings())?.artifactretention;
+    await this.adapter.set("exports", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns every exported data artifact with its content and checksum, newest first. */
+  async getexports() {
+    return await this.adapter.get("exports") ?? [];
+  }
+  /** Removes one exported data artifact by id and reports whether it existed. */
+  async removeexport(id) {
+    const records = await this.getexports();
+    const remaining = records.filter((item) => item.id !== id);
+    await this.adapter.set("exports", remaining);
+    return remaining.length !== records.length;
+  }
+  /** Removes one run store artifact by id and reports whether it existed. */
+  async removeartifact(id) {
+    const records = await this.getartifacts();
+    const remaining = records.filter((item) => item.id !== id);
+    await this.adapter.set("artifacts", remaining);
+    return remaining.length !== records.length;
+  }
+  /** Stores one batch download file record with its state, path and checksum, replacing the previous record of that id. */
+  async setdownload(record2) {
+    const records = (await this.adapter.get("downloads") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("downloads", [record2, ...records]);
+  }
+  /** Returns every batch download file record with its state, path and checksum, newest first. */
+  async getdownloads() {
+    return await this.adapter.get("downloads") ?? [];
+  }
+  /** Records one captured network log record; netlog retention is a user setting and an absent value keeps every record. */
+  async addnetlog(record2) {
+    const records = await this.getnetlog();
+    const combined = [record2, ...records];
+    const retention = (await this.getsettings())?.netlogretention;
+    await this.adapter.set("netlog", retention === void 0 ? combined : combined.slice(0, retention));
+  }
+  /** Returns the captured network log of the run with its step correlation, newest first. */
+  async getnetlog() {
+    return await this.adapter.get("netlog") ?? [];
+  }
+  /** Stores one clipboard consent record with its prompt and origin, replacing the previous record of that id. */
+  async setclipconsent(record2) {
+    const records = (await this.adapter.get("clipconsents") ?? []).filter((item) => item.id !== record2.id);
+    await this.adapter.set("clipconsents", [record2, ...records]);
+  }
+  /** Returns every clipboard consent record with its prompt and origin, newest first. */
+  async getclipconsents() {
+    return await this.adapter.get("clipconsents") ?? [];
+  }
+  /** Records one clipboard entry hash with its origin provenance; the payload text itself never persists. */
+  async addclip(entry) {
+    const records = await this.getclips();
+    await this.adapter.set("clips", [entry, ...records]);
+  }
+  /** Returns every clipboard entry hash with its kind and origin provenance, newest first. */
+  async getclips() {
+    return await this.adapter.get("clips") ?? [];
+  }
+  /** Stores one quarantine entry with its scan verdict, replacing the previous entry of that id. */
+  async setquarantine(entry) {
+    const records = (await this.adapter.get("quarantines") ?? []).filter((item) => item.id !== entry.id);
+    await this.adapter.set("quarantines", [entry, ...records]);
+  }
+  /** Returns every quarantine entry with its scan verdict and release ref, newest first. */
+  async getquarantines() {
+    return await this.adapter.get("quarantines") ?? [];
+  }
+  /** Stores the reviewed cleanup rule set of the run, replacing the previous set. */
+  async setcleanuprules(rules) {
+    return this.adapter.set("cleanuprules", rules);
+  }
+  /** Returns the reviewed cleanup rule set of the run. */
+  async getcleanuprules() {
+    return await this.adapter.get("cleanuprules") ?? [];
+  }
+  /** Records one cleanup run in the run history. */
+  async addcleanuprun(run) {
+    const records = await this.getcleanupruns();
+    await this.adapter.set("cleanupruns", [run, ...records]);
+  }
+  /** Returns every cleanup run history record with removed and kept counts, newest first. */
+  async getcleanupruns() {
+    return await this.adapter.get("cleanupruns") ?? [];
+  }
+  /** Stores the capture naming counters of one task, replacing the previous counters of that task. */
+  async setcapturecounter(counter) {
+    const records = (await this.adapter.get("capturecounters") ?? []).filter((item) => item.taskid !== counter.taskid);
+    await this.adapter.set("capturecounters", [counter, ...records]);
+  }
+  /** Returns every stored capture naming counter per task, newest first. */
+  async getcapturecounters() {
+    return await this.adapter.get("capturecounters") ?? [];
+  }
+  /** Replaces the artifact inventory the cleanup sweeper plans against. */
+  async setinventory(entries) {
+    return this.adapter.set("inventory", entries);
+  }
+  /** Returns the artifact inventory with sizes and ages for the cleanup sweeper. */
+  async getinventory() {
+    return await this.adapter.get("inventory") ?? [];
+  }
+  /** Stores one user configured virus scanning hook, replacing the previous hook of that scanner name. */
+  async setscanhook(config) {
+    const records = (await this.adapter.get("scanhooks") ?? []).filter((item) => item.scanner !== config.scanner);
+    await this.adapter.set("scanhooks", [config, ...records]);
+  }
+  /** Returns every configured virus scanning hook, newest first. */
+  async getscanhooks() {
+    return await this.adapter.get("scanhooks") ?? [];
+  }
+  /** Stores the armed mime interception filters of the run, newest first. */
+  async setmimefilters(filters) {
+    return this.adapter.set("mimefilters", filters);
+  }
+  /** Returns the armed mime interception filters of the run, newest first. */
+  async getmimefilters() {
+    return await this.adapter.get("mimefilters") ?? [];
+  }
 };
 function randomid() {
   return crypto.randomUUID();
 }
 
 // policy.ts
-var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword"]);
+var sensitiveactions = /* @__PURE__ */ new Set(["click", "type", "navigate", "select", "presskey", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "reload", "back", "forward", "writestorage", "setattribute", "removeattribute", "evaluate", "tabcreate", "tabactivate", "tabclose", "tabreload", "windowcreate", "windowclose", "windowresize", "downloadfile", "clickpoint", "shiftclick", "dismissdialog", "enterframe", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "openlink", "openprivate", "reloadcache", "stopnav", "followlink", "spanav", "rewritequery", "setfragment", "navlist", "navprofile", "handleauth", "printpdf", "prefetch", "preconnect", "deeplink", "reopentab", "pausenav", "navrate", "openclipboard", "batchopen", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "restorelayout", "reopenrun", "badgetab", "fillform", "filllabel", "fillplaceholder", "submitform", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcard", "fillcode", "consentpassword", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk", "paginateextract", "resumeextract", "batchdownload", "pausedownload", "resumedownload", "interceptmime", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "cleanupartifacts"]);
 var interactionactions = /* @__PURE__ */ new Set(["focus", "scroll", "hover", "clickdeep", "rightclick", "doubleclick", "scrollpage", "scrollby", "scrollend", "scrolltop", "fullscreen", "zoomset", "movepointer", "clicktext", "clickaria", "clickname", "expanddetails", "pierceshadow", "retryaction"]);
-var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha"]);
+var readactions = /* @__PURE__ */ new Set(["observe", "inspect", "extract", "wait", "waitfor", "waittext", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "readlinks", "readimages", "readmeta", "readforms", "readstorage", "highlight", "tablist", "windowlist", "tabsnapshot", "mapclicks", "verifyvisible", "verifyenabled", "resolvexpath", "a11ytree", "readvisible", "readertree", "detectlists", "detecttables", "readjson", "watchmutate", "waitquiet", "watchbanner", "detectinfinitescroll", "detectvirtual", "detectlazy", "readscrollpos", "readlang", "readoutline", "countpages", "listshadow", "listframes", "classifypage", "fingerprintsection", "diffsnapshots", "readselection", "watchfocus", "detectsticky", "detectscrolllock", "readopengraph", "detectlanguage", "deriveselector", "waitload", "waiturl", "spawait", "detecthttp", "readredirects", "readfinalurl", "trailaudit", "navintent", "checksafe", "querytabs", "watchtab", "findclones", "searchtabs", "listaudio", "snapshotsession", "savelayout", "attachmeta", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "readerrors", "skiphoneypot", "detectlogin", "detecttemplate", "handoffcaptcha", "scrapetable", "importcsv", "looprows", "transformvalues", "deduperows", "mergepages", "stamplerows", "previewgrid", "logprovenance", "verifydownload", "exportnetlog", "namecaptures"]);
 var allowedactions = /* @__PURE__ */ new Set([...sensitiveactions, ...interactionactions, ...readactions]);
 var watchactions = /* @__PURE__ */ new Set(["watchmutate", "watchbanner", "watchfocus", "watchtab"]);
-var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword"]);
-var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword"]);
+var targetactions = /* @__PURE__ */ new Set(["inspect", "focus", "click", "type", "scroll", "select", "hover", "clickdeep", "rightclick", "doubleclick", "drag", "drop", "upload", "clear", "check", "uncheck", "toggle", "submit", "readattribute", "readstyle", "readgeometry", "readvalue", "readtext", "readhtml", "countelements", "readtable", "highlight", "setattribute", "removeattribute", "waitfor", "shiftclick", "typetime", "appendtext", "setvalue", "typeedit", "submitsearch", "selectmulti", "chooseradio", "setslider", "setdate", "setcolor", "expanddetails", "verifyvisible", "verifyenabled", "pierceshadow", "deriveselector", "fingerprintsection", "submitform", "retryform", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "scrapetable", "paginateextract"]);
+var valueactions = /* @__PURE__ */ new Set(["presskey", "drag", "drop", "upload", "readattribute", "removeattribute", "waittext", "evaluate", "zoomset", "tabactivate", "tabclose", "tabreload", "windowclose", "windowresize", "tabcreate", "windowcreate", "downloadfile", "typetime", "appendtext", "setvalue", "typeedit", "keyhold", "keyrelease", "chooseradio", "setslider", "setdate", "setcolor", "followlink", "setfragment", "handleauth", "navintent", "openclipboard", "checksafe", "reopentab", "spanav", "duplicatetab", "pintab", "mutetab", "movetab", "movetabwindow", "searchtabs", "badgetab", "attachmeta", "focuswindow", "maximizewindow", "minimizewindow", "restorewindow", "incognitowindow", "asksubmit", "selectchain", "picktypeahead", "pickdate", "attachfile", "fillcode", "consentpassword", "pausedownload", "resumedownload", "verifydownload", "writeclipboard", "quarantinedownload", "scanvirus"]);
 var tabscommandactions = /* @__PURE__ */ new Set(["querytabs", "duplicatetab", "closepattern", "pintab", "mutetab", "movetab", "movetabwindow", "grouptabs", "colorgroup", "collapsegroup", "discardtab", "reloadtabs", "zoomin", "zoomout", "watchtab", "switchtab", "maximizewindow", "minimizewindow", "restorewindow", "focuswindow", "scratchwindow", "incognitowindow", "restoretab", "savelayout", "restorelayout", "findclones", "searchtabs", "badgetab", "attachmeta", "listaudio", "reopenrun", "snapshotsession"]);
 var formactions = /* @__PURE__ */ new Set(["fillform", "filllabel", "fillplaceholder", "detectfields", "generatevalues", "saveprofiles", "asksubmit", "submitform", "readerrors", "retryform", "runwizard", "selectchain", "picktypeahead", "pickdate", "attachfile", "handoffcaptcha", "fillcard", "fillcode", "consentpassword", "skiphoneypot", "detectlogin", "detecttemplate"]);
+var datasetactions = /* @__PURE__ */ new Set(["scrapetable", "exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "importcsv", "looprows", "transformvalues", "deduperows", "paginateextract", "mergepages", "stamplerows", "previewgrid", "streamdisk", "resumeextract", "logprovenance"]);
+var exportactions = /* @__PURE__ */ new Set(["exportcsv", "exportjson", "exportexcel", "copytable", "pushsheets", "streamdisk"]);
+var filesactions = /* @__PURE__ */ new Set(["batchdownload", "pausedownload", "resumedownload", "verifydownload", "interceptmime", "exportnetlog", "readclipboard", "writeclipboard", "copyscreen", "quarantinedownload", "scanvirus", "namecaptures", "cleanupartifacts"]);
 var fieldkinds = ["text", "email", "phone", "date", "number", "select", "check", "radio", "file", "password", "card", "code"];
 var layoutmutationactions = /* @__PURE__ */ new Set(["grouptabs", "colorgroup", "collapsegroup", "savelayout", "restorelayout"]);
 var groupcolors = ["grey", "blue", "red", "yellow", "green", "pink", "purple", "cyan", "orange"];
@@ -582,6 +796,19 @@ function islayoutkind(kind) {
 function isformkind(kind) {
   return formactions.has(kind);
 }
+function isdatasetkind(kind) {
+  return datasetactions.has(kind);
+}
+function isexportkind(kind) {
+  return exportactions.has(kind);
+}
+function isfileskind(kind) {
+  return filesactions.has(kind);
+}
+function exportgranted(session, origin) {
+  if (!origingranted(session, origin)) return { allowed: false, reason: `The export of extracted data from ${origin} needs the session origin grants before it leaves local memory.` };
+  return { allowed: true };
+}
 function validatefieldmatch(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed field match is required in options." };
   const match = value;
@@ -679,6 +906,164 @@ function validateformgrammar(step, options) {
   if (kind === "consentpassword" && !isnonempty(options.consentref)) return { allowed: false, reason: "A reviewed consent ref is required in options before any password is filled." };
   return { allowed: true };
 }
+function validatetransformrule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed transform rule with an expression, sources and a target is required in options." };
+  const rule = value;
+  const expression = rule.expression;
+  if (typeof expression !== "string" || !/^(trim|upper|lower|number|prefix|suffix|replace)(?::.+)?$/.test(expression)) return { allowed: false, reason: "The reviewed transform expression must be trim, upper, lower, number, prefix, suffix or replace with an optional argument." };
+  if (expression.startsWith("replace") && !expression.slice("replace".length).includes("=>")) return { allowed: false, reason: "The reviewed replace expression needs the from=>to separator." };
+  if (expression.startsWith("replace") && expression.slice("replace:".length).split("=>")[0] === "") return { allowed: false, reason: "The reviewed replace expression needs a non-empty from part." };
+  if (!Array.isArray(rule.sources) || rule.sources.length === 0 || !rule.sources.every((source) => isnonempty(source))) return { allowed: false, reason: "Every reviewed transform rule needs a non-empty list of source columns." };
+  if (!isnonempty(rule.target)) return { allowed: false, reason: "Every reviewed transform rule needs a non-empty target column." };
+  return { allowed: true };
+}
+function validatedatasetids(options, key) {
+  const ids = options[key];
+  if (!Array.isArray(ids) || ids.length === 0 || !ids.every((id) => isnonempty(id))) return { allowed: false, reason: `A reviewed non-empty list of dataset ids is required in options as ${key}.` };
+  return { allowed: true };
+}
+function validatedatagrammar(step, options, origin) {
+  const kind = step.kind;
+  if (kind === "scrapetable") {
+    if (options.name !== void 0 && !isnonempty(options.name)) return { allowed: false, reason: "The reviewed dataset name must be a non-empty string." };
+    if (options.rowlimit !== void 0 && (typeof options.rowlimit !== "number" || !Number.isInteger(options.rowlimit) || options.rowlimit < 1)) return { allowed: false, reason: "The reviewed row limit must be a positive integer with no code ceiling." };
+  }
+  if (kind === "paginateextract") {
+    if (!isnonempty(options.next)) return { allowed: false, reason: "A reviewed next control selector is required in options." };
+    if (options.pages !== void 0 && (typeof options.pages !== "number" || !Number.isInteger(options.pages) || options.pages < 1)) return { allowed: false, reason: "The reviewed page count must be a positive integer with no code ceiling." };
+    if (!nonnegativeoption(options, "wait")) return { allowed: false, reason: "The reviewed row freshness wait must be zero or a positive number of milliseconds." };
+  }
+  if (kind === "exportcsv" || kind === "exportjson" || kind === "exportexcel" || kind === "copytable" || kind === "streamdisk") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    if (options.name !== void 0 && !isnonempty(options.name)) return { allowed: false, reason: "The reviewed artifact name must be a non-empty string." };
+  }
+  if (kind === "exportcsv" && options.delimiter !== void 0 && (typeof options.delimiter !== "string" || options.delimiter.length !== 1)) return { allowed: false, reason: "The reviewed csv delimiter must be a single character." };
+  if (kind === "streamdisk" && (typeof options.chunk !== "number" || !Number.isInteger(options.chunk) || options.chunk < 1)) return { allowed: false, reason: "The reviewed streaming chunk size must be a positive integer with no code ceiling." };
+  if (kind === "pushsheets") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    if (!isnonempty(options.sheet)) return { allowed: false, reason: "A reviewed sheet endpoint url is required in options." };
+    if (!ishttpsurl(options.sheet)) return { allowed: false, reason: "The reviewed sheet endpoint url must use HTTPS." };
+    if (options.reviewed !== true) return { allowed: false, reason: "The sheet push needs the explicit reviewed flag before any data leaves local memory." };
+  }
+  if (kind === "importcsv") {
+    if (typeof options.csv !== "string" || !options.csv.trim()) return { allowed: false, reason: "Reviewed csv content is required in options." };
+    if (options.name !== void 0 && !isnonempty(options.name)) return { allowed: false, reason: "The reviewed dataset name must be a non-empty string." };
+    if (options.mapping !== void 0) {
+      const mapping = options.mapping;
+      if (!mapping || typeof mapping !== "object" || Array.isArray(mapping) || !Object.values(mapping).every((item) => typeof item === "string")) return { allowed: false, reason: "The reviewed csv column mapping must be an object of string values." };
+    }
+  }
+  if (kind === "looprows") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    if (options.variable !== void 0 && !isnonempty(options.variable)) return { allowed: false, reason: "The reviewed row variable name must be a non-empty string." };
+    const inner = validateinnerstep(options, origin);
+    if (!inner.allowed) return inner;
+  }
+  if (kind === "transformvalues") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    const rules = options.rules;
+    if (!Array.isArray(rules) || rules.length === 0) return { allowed: false, reason: "A reviewed non-empty list of transform rules is required in options." };
+    for (const item of rules) {
+      const rulecheck = validatetransformrule(item);
+      if (!rulecheck.allowed) return rulecheck;
+    }
+  }
+  if (kind === "deduperows") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    const keys = options.keys;
+    if (!Array.isArray(keys) || keys.length === 0 || !keys.every((key) => isnonempty(key))) return { allowed: false, reason: "A reviewed non-empty list of dedupe column keys is required in options." };
+  }
+  if (kind === "mergepages") {
+    const listcheck = validatedatasetids(options, "datasets");
+    if (!listcheck.allowed) return listcheck;
+  }
+  if (kind === "stamplerows") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    if (options.url !== void 0 && !ishttpsurl(options.url)) return { allowed: false, reason: "The reviewed source url must use HTTPS." };
+  }
+  if (kind === "previewgrid") {
+    if (!isnonempty(options.dataset)) return { allowed: false, reason: "A reviewed dataset id is required in options." };
+    if (options.sample !== void 0 && (typeof options.sample !== "number" || !Number.isInteger(options.sample) || options.sample < 1)) return { allowed: false, reason: "The reviewed sample row count must be a positive integer with no code ceiling." };
+  }
+  if (kind === "resumeextract" && !isnonempty(options.session)) return { allowed: false, reason: "A reviewed extract session id is required in options." };
+  if (kind === "logprovenance" && !isnonempty(options.artifact)) return { allowed: false, reason: "A reviewed artifact id or name is required in options." };
+  return { allowed: true };
+}
+function validatedownloadspec(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed downloadspec with a url list is required in options." };
+  const spec = value;
+  if (!Array.isArray(spec.urls) || spec.urls.length === 0 || !spec.urls.every((url) => ishttpsurl(url))) return { allowed: false, reason: "The reviewed downloadspec needs a non-empty list of HTTPS urls." };
+  if (spec.filename !== void 0 && !isnonempty(spec.filename)) return { allowed: false, reason: "The reviewed downloadspec filename rule must be a non-empty string." };
+  if (spec.complete !== void 0 && spec.complete !== "size" && spec.complete !== "checksum") return { allowed: false, reason: "The reviewed downloadspec completion criterion must be size or checksum." };
+  return { allowed: true };
+}
+function validatemimefilter(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed mimefilter with include and exclude patterns is required in options." };
+  const filter = value;
+  if (!Array.isArray(filter.include) || filter.include.length === 0 || !filter.include.every((pattern) => isnonempty(pattern))) return { allowed: false, reason: "The reviewed mimefilter needs a non-empty list of include patterns." };
+  if (filter.exclude !== void 0 && (!Array.isArray(filter.exclude) || !filter.exclude.every((pattern) => isnonempty(pattern)))) return { allowed: false, reason: "The reviewed mimefilter exclude patterns must be a list of non-empty strings." };
+  if (filter.default !== "deny" && filter.default !== "allow") return { allowed: false, reason: "The reviewed mimefilter needs the deny or allow default for unlisted mime types." };
+  return { allowed: true };
+}
+function validatecleanuprule(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return { allowed: false, reason: "A reviewed cleanuprule with an age, a kind and a keep policy is required." };
+  const rule = value;
+  if (typeof rule.age !== "number" || !Number.isFinite(rule.age) || rule.age <= 0) return { allowed: false, reason: "The reviewed cleanup age window must be a positive number of milliseconds with no code ceiling." };
+  if (!isnonempty(rule.kind)) return { allowed: false, reason: "The reviewed cleanup rule needs a non-empty artifact kind, or any to match every kind." };
+  if (rule.keep !== "none" && rule.keep !== "latest" && rule.keep !== "all") return { allowed: false, reason: "The reviewed cleanup keep policy must be none, latest or all." };
+  return { allowed: true };
+}
+function validatefilesgrammar(step, options) {
+  const kind = step.kind;
+  if (kind === "batchdownload") {
+    const speccheck = validatedownloadspec(options.downloadspec);
+    if (!speccheck.allowed) return speccheck;
+    if (options.concurrent !== void 0 && (typeof options.concurrent !== "number" || !Number.isInteger(options.concurrent) || options.concurrent < 1)) return { allowed: false, reason: "The reviewed concurrent download window must be a positive integer with no code ceiling." };
+  }
+  if (kind === "pausedownload" || kind === "resumedownload" || kind === "verifydownload" || kind === "quarantinedownload" || kind === "scanvirus") {
+    if (!isnonempty(step.value)) return { allowed: false, reason: "A reviewed download or quarantine reference is required." };
+    if (kind === "verifydownload") {
+      if (options.checksum !== void 0 && !isnonempty(options.checksum)) return { allowed: false, reason: "The reviewed expected checksum must be a non-empty string." };
+      if (options.bytes !== void 0 && (typeof options.bytes !== "number" || !Number.isFinite(options.bytes) || options.bytes < 0)) return { allowed: false, reason: "The reviewed expected size must be zero or a positive number of bytes." };
+    }
+    if (kind === "scanvirus" && options.scanner !== void 0 && !isnonempty(options.scanner)) return { allowed: false, reason: "The reviewed scanner name must be a non-empty string." };
+    if (kind === "quarantinedownload" && options.reason !== void 0 && !isnonempty(options.reason)) return { allowed: false, reason: "The reviewed quarantine reason must be a non-empty string." };
+  }
+  if (kind === "interceptmime") {
+    const filtercheck = validatemimefilter(options.mimefilter);
+    if (!filtercheck.allowed) return filtercheck;
+  }
+  if (kind === "readclipboard") {
+    if (!isnonempty(options.consentref)) return { allowed: false, reason: "A clipboard read requires a reviewed consent ref of an approved consent prompt in options." };
+    if (options.prompt !== void 0 && !isnonempty(options.prompt)) return { allowed: false, reason: "The reviewed clipboard consent prompt must be a non-empty string." };
+  }
+  if (kind === "exportnetlog" && options.stepid !== void 0 && !isnonempty(options.stepid)) return { allowed: false, reason: "The reviewed netlog step filter must be a non-empty step id." };
+  if (kind === "namecaptures") {
+    if (!isnonempty(options.task)) return { allowed: false, reason: "A reviewed task id is required in options for capture naming." };
+    if (options.steps !== void 0 && (!Array.isArray(options.steps) || options.steps.length === 0 || !options.steps.every((item) => isnonempty(item)))) return { allowed: false, reason: "The reviewed capture steps must be a non-empty list of step ids when present." };
+    if (options.extension !== void 0 && !isnonempty(options.extension)) return { allowed: false, reason: "The reviewed capture extension must be a non-empty string." };
+  }
+  if (kind === "cleanupartifacts" && options.rules !== void 0) {
+    const rules = options.rules;
+    if (!Array.isArray(rules) || rules.length === 0) return { allowed: false, reason: "The reviewed cleanup rules must be a non-empty list when present." };
+    for (const item of rules) {
+      const rulecheck = validatecleanuprule(item);
+      if (!rulecheck.allowed) return rulecheck;
+    }
+  }
+  return { allowed: true };
+}
+function clipboardconsentgranted(step) {
+  let options = {};
+  try {
+    options = parseoptions(step);
+  } catch {
+    options = {};
+  }
+  const consentref = options.consentref;
+  if (typeof consentref !== "string" || !consentref.trim()) return { allowed: false, reason: "A clipboard read requires a reviewed consent ref in options." };
+  return { allowed: true };
+}
 function submitreviewgranted(steps, submitid) {
   const position = steps.findIndex((candidate) => candidate.id === submitid);
   const asked = steps.some((candidate, index) => candidate.kind === "asksubmit" && (position === -1 || index < position));
@@ -813,7 +1198,7 @@ function validateinnerstep(options, origin) {
     return { allowed: true };
   }
   if (typeof kind !== "string" || !kind.trim()) return { allowed: false, reason: "A reviewed step id or inline step kind is required in options." };
-  if (kind === "retryaction" || kind === "enterframe") return { allowed: false, reason: "The reviewed inner step cannot be another wrapper kind." };
+  if (kind === "retryaction" || kind === "enterframe" || kind === "looprows") return { allowed: false, reason: "The reviewed inner step cannot be another wrapper kind." };
   if (!allowedactions.has(kind)) return { allowed: false, reason: "The reviewed inner step kind is unsupported." };
   const inneroptions = options.options;
   if (inneroptions !== void 0 && (!inneroptions || typeof inneroptions !== "object" || Array.isArray(inneroptions))) return { allowed: false, reason: "The reviewed inner step options must be an object." };
@@ -1197,6 +1582,14 @@ function validatestep(step, origin) {
     const formcheck = validateformgrammar(step, options);
     if (!formcheck.allowed) return formcheck;
   }
+  if (isdatasetkind(step.kind)) {
+    const datacheck = validatedatagrammar(step, options, origin);
+    if (!datacheck.allowed) return datacheck;
+  }
+  if (isfileskind(step.kind)) {
+    const filescheck = validatefilesgrammar(step, options);
+    if (!filescheck.allowed) return filescheck;
+  }
   if (step.kind === "tabcreate") {
     if (options.background !== void 0 && typeof options.background !== "boolean") return { allowed: false, reason: "The reviewed background flag must be a boolean." };
     if (options.window !== void 0 && (typeof options.window !== "number" || !Number.isInteger(options.window) || options.window < 0)) return { allowed: false, reason: "The reviewed target window id must be a non-negative integer." };
@@ -1224,6 +1617,10 @@ function canexecute(input) {
   if (input.plan.expiresat <= now) return { allowed: false, reason: "The approved plan has expired." };
   if ((input.step.kind === "pierceshadow" || input.step.kind === "enterframe") && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The shadow or frame step is outside the session origin grants." };
   if (input.step.kind === "readjson" && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The json state read is outside the session origin grants." };
+  if (isexportkind(input.step.kind)) {
+    const exportgate = exportgranted(input.session, input.origin);
+    if (!exportgate.allowed) return exportgate;
+  }
   if (input.step.kind === "navlist") {
     let options = {};
     try {
@@ -1247,6 +1644,11 @@ function canexecute(input) {
     const consentgate = passwordconsentgranted(input.step);
     if (!consentgate.allowed) return consentgate;
   }
+  if (input.step.kind === "readclipboard") {
+    const clipgate = clipboardconsentgranted(input.step);
+    if (!clipgate.allowed) return clipgate;
+  }
+  if (input.step.kind === "interceptmime" && !origingranted(input.session, input.origin)) return { allowed: false, reason: "The download interception is outside the session origin grants." };
   if (input.step.kind === "openlink" || input.step.kind === "openprivate" || input.step.kind === "batchopen" || input.step.kind === "prefetch" || input.step.kind === "deeplink" || input.step.kind === "reopentab") {
     let options = {};
     try {
@@ -1268,7 +1670,7 @@ function canexecute(input) {
 }
 
 // version.ts
-var packageversion = "1.1.37";
+var packageversion = "1.1.39";
 
 // types.ts
 var protocolversion = packageversion;
@@ -1305,9 +1707,9 @@ function parseproposal(value, origin) {
     return step;
   });
   for (const step of steps) {
-    if (step.kind !== "retryaction" && step.kind !== "enterframe") continue;
+    if (step.kind !== "retryaction" && step.kind !== "enterframe" && step.kind !== "looprows") continue;
     const options = parseoptions(step);
-    if (typeof options.stepid === "string" && !steps.some((candidate) => candidate.id === options.stepid)) throw new Error("A retry or frame wrapper references an unknown step id.");
+    if (typeof options.stepid === "string" && !steps.some((candidate) => candidate.id === options.stepid)) throw new Error("A retry, frame or loop wrapper references an unknown step id.");
   }
   for (const step of steps) {
     if (step.kind !== "submitform" && step.kind !== "retryform") continue;
@@ -1386,12 +1788,38 @@ function errorreportresponse(input) {
 function wizardreport(input) {
   return { version: protocolversion, ...input.sessionid ? { sessionid: input.sessionid } : {}, wizards: input.wizards, picks: input.picks };
 }
+function datasetresponse(input) {
+  const sample = Math.max(0, Math.floor(input.sample ?? 10));
+  const payload = { ...input.dataset, rows: input.dataset.rows.slice(0, sample), totalrows: input.dataset.rows.length };
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, dataset: payload });
+}
+function extractionreport(input) {
+  return { version: protocolversion, sessions: input.sessions };
+}
+function provenancereport(input) {
+  return { version: protocolversion, records: input.records };
+}
+function transformgrammar(rules) {
+  return JSON.stringify({ rules: rules.map((rule) => ({ expression: rule.expression, sources: rule.sources, target: rule.target })) });
+}
+function downloadreport(input) {
+  return JSON.stringify({ version: protocolversion, planid: input.plan.id, planstate: input.plan.state, downloads: input.downloads });
+}
+function netlogreport(input) {
+  return { version: protocolversion, records: input.records };
+}
+function quarantinereport(input) {
+  return { version: protocolversion, entries: input.entries };
+}
 export {
   canexecute,
+  datasetresponse,
   actionrisk as deriveactionrisk,
   diffresponse,
+  downloadreport,
   errorreportresponse,
   eventresponse,
+  extractionreport,
   formreportresponse,
   generatedvalueallowed,
   heldkeysreport,
@@ -1401,6 +1829,7 @@ export {
   layoutreport,
   mapresponse,
   navstateresponse,
+  netlogreport,
   normalizeendpoint,
   observationmodeof,
   observationresponse,
@@ -1409,6 +1838,8 @@ export {
   passwordconsentgranted,
   profilegrantgranted,
   protocolversion,
+  provenancereport,
+  quarantinereport,
   randomid,
   requestbody,
   resolutionverdict,
@@ -1419,6 +1850,7 @@ export {
   submitreviewgranted,
   tabreportresponse,
   trailreport,
+  transformgrammar,
   validatefieldmatch,
   validateformrecord,
   validatestep,