@wenathlan/extension 1.1.64 → 1.1.65

package/dist/index.js

@@ -5259,6 +5259,68 @@ var sessionmemory = class {
   async addstepapproveresolution(resolution) {
     await this.adapter.set("stepapproveresolutions", [resolution, ...await this.getstepapproveresolutions()]);
   }
+  /**
+   * Interface surface stores of the 1.1.65 family live here, scoped per profile workspace: the siteprofiles with the per site interface preferences, the shortcutkeys bindings and the theme preference per profile, the recenttray entries with their configurable depth and the notification consent and preference per profile.
+   */
+  /** Returns the siteprofile of one origin; an absent profile keeps the global interface preferences. */
+  async getsiteprofile(origin) {
+    return this.adapter.get(`siteprofile:${origin}`);
+  }
+  /** Stores the siteprofile of one origin with its theme, shortcutkeys and default view; the profile never adjusts a policy gate. */
+  async setsiteprofile(profile) {
+    return this.adapter.set(`siteprofile:${profile.origin}`, profile);
+  }
+  /** Returns every stored siteprofile keyed by origin. */
+  async listsiteprofiles() {
+    const entries = Object.entries(await this.adapter.get("siteprofiles") ?? {});
+    return entries.map(([, profile]) => profile);
+  }
+  /** Stores every siteprofile keyed by origin so the list view reads them in one call. */
+  async setsiteprofiles(profiles) {
+    await this.adapter.set("siteprofiles", Object.fromEntries(profiles.map((profile) => [profile.origin, profile])));
+  }
+  /** Returns the stored shortcutkeys bindings of the profile; an absent set keeps the shipped editable defaults. */
+  async getshortcutbindings() {
+    return await this.adapter.get("shortcutbindings") ?? [];
+  }
+  /** Stores the shortcutkeys bindings the user edited in the optionspage. */
+  async setshortcutbindings(bindings) {
+    return this.adapter.set("shortcutbindings", bindings);
+  }
+  /** Returns the stored darklight theme preference of the profile; an absent preference follows the os preference alone. */
+  async getthemepreference() {
+    return this.adapter.get("themepreference");
+  }
+  /** Stores the darklight theme preference of the profile with its manual override. */
+  async setthemepreference(preference) {
+    return this.adapter.set("themepreference", preference);
+  }
+  /** Returns the recenttray entries, newest first, with their resume and reopen offers. */
+  async getrecenttray() {
+    return await this.adapter.get("recenttray") ?? [];
+  }
+  /** Adds one recenttray entry with the user configured depth; an absent depth keeps every run. */
+  async addrecenttrayentry(entry) {
+    const depth = (await this.getsettings())?.recenttraydepth;
+    const appended = [entry, ...(await this.getrecenttray()).filter((candidate) => candidate.runid !== entry.runid)];
+    await this.adapter.set("recenttray", depth !== void 0 && Number.isInteger(depth) && depth > 0 ? appended.slice(0, depth) : appended);
+  }
+  /** Returns the notification consent and preference of the profile; an absent record keeps the notifications content free and on. */
+  async getnotificationprefs() {
+    return this.adapter.get("notificationprefs");
+  }
+  /** Stores the notification consent and preference of the profile; the content consent gates every page content bearing body. */
+  async setnotificationprefs(prefs) {
+    return this.adapter.set("notificationprefs", prefs);
+  }
+  /** Returns the notification payloads the surface history keeps for the user to open after a do not disturb quiet. */
+  async getnotificationhistory() {
+    return await this.adapter.get("notificationhistory") ?? [];
+  }
+  /** Records one notification payload in the history so its deep link stays reachable while the notifications permission stays outside the manifest. */
+  async addnotificationhistory(payload) {
+    await this.adapter.set("notificationhistory", [payload, ...await this.getnotificationhistory()]);
+  }
 };
 function mediakindof(record2) {
   if ("pages" in record2) return "pdf";
@@ -11445,6 +11507,51 @@ function logstreamegressgate(input) {
   if (!input.verified) return { allowed: false, reason: "The logstream chain failed its live verification; the audit excerpt refuses the copy because only a verified range leaves the stream." };
   return { allowed: true, reason: `The logstream chain verifies across the ${input.entries} event${input.entries === 1 ? "" : "s"} of the range; the audit excerpt copies as one verified record.` };
 }
+function quickactiongate(input) {
+  if (input.action.origin.trim() === "") return { allowed: false, reason: `The ${input.action.command} quickaction needs the origin of the clicked tab; an originless entry never registers.` };
+  if (!input.granted.includes(input.action.origin)) return { allowed: false, reason: `The ${input.action.command} quickaction stays off the ${input.action.origin} tab because its origin holds no allowlist entry; only permitted actions surface.` };
+  if (input.action.session === true && !input.sessionactive) return { allowed: false, reason: `The ${input.action.command} quickaction needs an active browser session before it registers; the context menu never offers a run action without its session.` };
+  if (input.action.permission !== void 0 && !(input.capabilities ?? []).includes(input.action.permission)) return { allowed: false, reason: `The ${input.action.command} quickaction needs the ${input.action.permission} capability granted before it registers; the context menu never offers an action the current capability set refuses.` };
+  return { allowed: true, reason: `The ${input.action.command} quickaction rides the origin allowlist of the clicked ${input.action.origin} tab and registers.` };
+}
+function omniboxtaskgate(input) {
+  if (input.direct) return { allowed: false, reason: "The omnibox keyword never executes a goal directly; every keyword goal routes through the same proposal and review flow as the api and becomes a reviewed plan first." };
+  if (input.text.trim() === "") return { allowed: false, reason: "The omnibox task needs its natural language goal after the keyword; an empty goal never reaches the proposal flow." };
+  if (input.origin.trim() === "") return { allowed: false, reason: "The omnibox task needs its active origin scope; a goal without an origin never reaches the proposal flow." };
+  return { allowed: true, reason: `The omnibox goal for ${input.origin} rides the same proposal flow as the api: the observation, the capabilities and the plan review all recheck it.` };
+}
+function shortcutkeygate(input) {
+  if (!input.palettecommands.includes(input.command)) return { allowed: false, reason: `The ${input.command} shortcut binds no commandpalette command; a shortcut may only trigger a command the palette catalog knows.` };
+  if (input.action?.permission !== void 0 && !input.granted.includes(input.action.permission)) return { allowed: false, reason: `The ${input.command} shortcut needs the ${input.action.permission} capability granted before it dispatches; the shortcut never bypasses the palette action gate.` };
+  if (input.action?.session === true && !input.sessionactive) return { allowed: false, reason: `The ${input.command} shortcut needs an active browser session before it dispatches; the shortcut never bypasses the palette action gate.` };
+  return { allowed: true, reason: `The ${input.command} shortcut dispatches through the same palette action gate the commandpalette rides; its gates stay intact.` };
+}
+function notificationcontentgate(input) {
+  if (!input.content) return { allowed: true, reason: "The notification body carries no page content, so no content consent is needed and it shows." };
+  if (!input.consent) return { allowed: false, reason: "The notification body carries page content and no content consent exists; a content bearing notification never shows without its consent." };
+  return { allowed: true, reason: "The notification body carries page content and its consent exists, so it shows with the content the user agreed to." };
+}
+function pickeroverlaygate(input) {
+  if (input.origin.trim() === "") return { allowed: false, reason: "The pickeroverlay session needs its origin; an originless read never starts." };
+  if (!input.granted.includes(input.origin)) return { allowed: false, reason: `The pickeroverlay reads no element candidate of ${input.origin} because the origin holds no allowlist entry; picker reads stay inside the granted origins.` };
+  return { allowed: true, reason: `The pickeroverlay lists the element candidates of the granted origin ${input.origin} with their stability scored selectors.` };
+}
+function shotpanelgate(input) {
+  if (input.captureorigin.trim() === "") return { allowed: false, reason: "The shotpanel view needs the origin of its capture; an originless capture never opens." };
+  if (!input.granted.includes(input.captureorigin)) return { allowed: false, reason: `The shotpanel opens no capture of ${input.captureorigin} because the origin holds no allowlist entry; capture views stay inside the granted origins.` };
+  return { allowed: true, reason: `The shotpanel previews the capture of the granted origin ${input.captureorigin} with its redaction verdicts.` };
+}
+function siteprofilegate(input) {
+  const origin = input.origin.trim();
+  if (origin === "") return { allowed: false, reason: "The siteprofile needs its origin; an originless profile never stores." };
+  if (!origin.startsWith("https://") || origin.length <= "https://".length) return { allowed: false, reason: `The siteprofile stores per site interface preferences of https origins only; ${origin} holds no https origin shape.` };
+  return { allowed: true, reason: `The siteprofile of ${origin} stores its theme, shortcutkeys and default view beside the originprofiles policy preferences; no profile ever adjusts a policy gate.` };
+}
+function importexportgate(input) {
+  if (input.containssecrets) return { allowed: false, reason: "The importexport bundle carries a secretvault value shape; secret values never leave the browser under any flag, so the bundle refuses in full." };
+  if (input.unmaskedlogs) return { allowed: false, reason: "The importexport bundle carries unmasked log entries; only masked summaries ever move between profiles, so the bundle refuses in full." };
+  return { allowed: true, reason: "The importexport bundle carries no secretvault value and no unmasked log; the originprofiles, the siteprofiles, the notes and the preferences move with their honest exclusion list." };
+}
 
 // llm.ts
 var defaultrefusalmarkers = ["i cannot", "i can't", "i'm unable", "refusal:", "cannot comply"];
@@ -11805,7 +11912,7 @@ function budgetcheck(input) {
 }
 
 // version.ts
-var packageversion = "1.1.64";
+var packageversion = "1.1.65";
 
 // types.ts
 var protocolversion = packageversion;
@@ -13418,6 +13525,566 @@ function busrouteaction(action, input) {
   return { dispatched: true, gate: "commandbus", reason: `The ${action.command} action of the ${action.surface} routed through its policy gates and dispatches.` };
 }
 
+// datagrid.ts
+function infercolumntype(values) {
+  const present = values.filter((value) => value.trim() !== "");
+  if (present.length === 0) return "empty";
+  if (present.every((value) => /^-?\d+(?:\.\d+)?$/.test(value.trim()))) return "number";
+  if (present.every((value) => value.trim() === "true" || value.trim() === "false")) return "boolean";
+  if (present.every((value) => !Number.isNaN(Date.parse(value.trim())) && /\d{4}-\d{2}-\d{2}/.test(value.trim()))) return "date";
+  return "text";
+}
+function datagridcolumnsof(rows) {
+  const fields = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  return fields.map((field) => ({ field, label: field, type: infercolumntype(rows.map((row) => row[field] ?? "")), inferred: true }));
+}
+function datagridof(input) {
+  if (input.title.trim() === "") throw new Error("The datagrid view needs its title.");
+  if (input.origin.trim() === "") throw new Error("The datagrid view needs its origin.");
+  if (input.rows.length === 0) throw new Error("The datagrid view needs at least one extracted row.");
+  const columns = datagridcolumnsof(input.rows);
+  const rows = input.rows.map((row, index) => ({ index, values: Object.fromEntries(columns.map((column) => [column.field, row[column.field] ?? ""])) }));
+  return { id: randomid(), title: input.title.trim(), origin: input.origin.trim(), runid: input.runid, columns, rows, at: input.at };
+}
+function sortdatagridrows(view, input) {
+  const column = view.columns.find((candidate) => candidate.field === input.field);
+  if (column === void 0) throw new Error(`The datagrid knows no ${input.field} column to sort.`);
+  const rows = [...view.rows].sort((left, right) => {
+    const leftvalue = left.values[input.field] ?? "";
+    const rightvalue = right.values[input.field] ?? "";
+    let compared = 0;
+    if (column.type === "number") compared = Number(leftvalue) - Number(rightvalue);
+    else if (column.type === "boolean") compared = (leftvalue === "true" ? 1 : 0) - (rightvalue === "true" ? 1 : 0);
+    else if (column.type === "date") compared = Date.parse(leftvalue) - Date.parse(rightvalue);
+    else compared = leftvalue.localeCompare(rightvalue);
+    return input.direction === "descending" ? -compared : compared;
+  }).map((row, index) => ({ ...row, index }));
+  return { ...view, rows };
+}
+function filterdatagridrows(view, text2) {
+  const query = text2.trim().toLowerCase();
+  if (query === "") return view;
+  const rows = view.rows.filter((row) => Object.values(row.values).some((value) => value.toLowerCase().includes(query)));
+  return { ...view, rows };
+}
+function selectrowrange(view, from, to) {
+  if (from < 0 || to < from || to >= view.rows.length) throw new Error(`The row range ${from} to ${to} names no inclusive slice of the ${view.rows.length} row${view.rows.length === 1 ? "" : "s"}.`);
+  const rows = view.rows.map((row) => ({ ...row, selected: row.index >= from && row.index <= to }));
+  return { ...view, rows };
+}
+function exportrowsof(view, scope) {
+  if (scope === "selection") {
+    const selected = view.rows.filter((row) => row.selected === true);
+    if (selected.length === 0) throw new Error("The selection export needs its selected row range; select rows before the export.");
+    return selected;
+  }
+  return view.rows;
+}
+function exportmenudescriptors() {
+  return ["csv", "json", "clipboard"].flatMap((format) => ["selection", "step", "run"].map((scope) => ({ format, scope, destination: format === "clipboard" ? "clipboard" : "download" })));
+}
+function maskedvalueof(value, field, maskverdicts) {
+  const verdict = maskverdicts[field];
+  if (verdict === void 0) return { value, masked: false };
+  return { value: `${"\u2022".repeat(Math.min(value.length, 8))} (${value.length} characters, masked)`, masked: true };
+}
+function csvfield(value) {
+  if (/[",\n]/.test(value)) return `"${value.replaceAll('"', '""')}"`;
+  return value;
+}
+function exportdatagrid(view, descriptor, maskverdicts = {}) {
+  const rows = exportrowsof(view, descriptor.scope);
+  const maskedfields = [...new Set(rows.flatMap((row) => Object.keys(row.values)).filter((field) => maskverdicts[field] !== void 0))];
+  if (descriptor.format === "json") {
+    const records = rows.map((row) => Object.fromEntries(view.columns.map((column) => {
+      const masked = maskedvalueof(row.values[column.field] ?? "", column.field, maskverdicts);
+      return [column.field, column.type === "number" && !masked.masked ? Number(masked.value) : column.type === "boolean" && !masked.masked ? masked.value === "true" : masked.value];
+    })));
+    return { format: descriptor.format, scope: descriptor.scope, destination: descriptor.destination, text: JSON.stringify({ view: view.title, origin: view.origin, runid: view.runid, columns: view.columns.map((column) => ({ field: column.field, type: column.type })), rows: records }, null, 2), rows: records.length, maskedfields };
+  }
+  const header = view.columns.map((column) => csvfield(column.label)).join(",");
+  const lines = rows.map((row) => view.columns.map((column) => csvfield(maskedvalueof(row.values[column.field] ?? "", column.field, maskverdicts).value)).join(","));
+  return { format: descriptor.format, scope: descriptor.scope, destination: descriptor.destination, text: [header, ...lines].join("\n"), rows: rows.length, maskedfields };
+}
+
+// quickactions.ts
+function quickactioncatalog() {
+  return [
+    { id: "extractpage", label: "Extract page data", command: "starttask", surface: "sidepanel", session: true },
+    { id: "captureshot", label: "Capture a shot", command: "starttask", surface: "sidepanel", permission: "downloads", session: true },
+    { id: "runrecent", label: "Run the recent task", command: "starttask", surface: "popup", session: true },
+    { id: "opendashboardpage", label: "Open the dashboard", command: "opendashboardpage", surface: "dashboardpage" }
+  ];
+}
+function quickactionsfor(catalog, input) {
+  const capabilities = input.grantedcapabilities ?? ["activeTab", "storage", "scripting", "sidePanel"];
+  const grantedcapabilities = capabilities;
+  return catalog.filter((action) => quickactiongate({ action: { command: action.command, origin: input.origin, ...action.permission !== void 0 ? { permission: action.permission } : {}, ...action.session !== void 0 ? { session: action.session } : {} }, granted: input.granted, sessionactive: input.sessionactive, capabilities: grantedcapabilities }).allowed);
+}
+function shortcutdefaults() {
+  return [
+    { command: "starttask", key: "Enter", modifiers: [], editable: true, surface: "popup" },
+    { command: "pauserun", key: "p", modifiers: ["ctrl", "shift"], editable: true, surface: "sidepanel" },
+    { command: "resumerun", key: "r", modifiers: ["ctrl", "shift"], editable: true, surface: "sidepanel" },
+    { command: "cancelrun", key: "x", modifiers: ["ctrl", "shift"], editable: true, surface: "sidepanel" },
+    { command: "commandpalette", key: ".", modifiers: ["ctrl"], editable: true, surface: "popup" }
+  ];
+}
+function parseshortcut(text2) {
+  const parts = text2.trim().toLowerCase().split("+").map((part) => part.trim()).filter((part) => part !== "");
+  if (parts.length === 0) throw new Error("The shortcut binding needs its key.");
+  const modifiers = ["ctrl", "alt", "shift", "meta"];
+  const key = parts.filter((part) => !modifiers.includes(part))[0];
+  if (key === void 0 || key === "") throw new Error("The shortcut binding needs its key beside its modifiers.");
+  return { key, modifiers: parts.filter((part) => modifiers.includes(part)) };
+}
+function shortcuttext(binding) {
+  return [...binding.modifiers, binding.key].join("+");
+}
+function shortcutbindingafter(bindings, command, text2) {
+  const existing = bindings.find((binding) => binding.command === command);
+  if (existing === void 0) throw new Error(`The shortcutkeys know no ${command} command to edit.`);
+  const parsed = parseshortcut(text2);
+  return bindings.map((binding) => binding.command === command ? { ...binding, key: parsed.key, modifiers: parsed.modifiers } : binding);
+}
+function shortcutcommandof(bindings, input) {
+  const pressed = [...input.modifiers].map((modifier) => modifier.toLowerCase()).sort();
+  return bindings.find((binding) => binding.key.toLowerCase() === input.key.toLowerCase() && [...binding.modifiers].sort().join("+") === pressed.join("+") && (binding.command === "commandpalette" || binding.surface === input.surface))?.command;
+}
+function shortcutdispatchable(command, entries, input) {
+  const entry = entries.find((candidate) => candidate.action.command === command);
+  if (entry === void 0) return command === "commandpalette";
+  return paletteactiongate({ action: { command: entry.action.command, ...entry.action.permission !== void 0 ? { permission: entry.action.permission } : {}, ...entry.action.session !== void 0 ? { session: entry.action.session } : {} }, granted: input.granted, sessionactive: input.sessionactive }).allowed;
+}
+function parseomniboxtask(input) {
+  const text2 = input.text.trim();
+  if (text2 === "") throw new Error("The omnibox task needs its natural language goal after the keyword.");
+  if (input.origin.trim() === "") throw new Error("The omnibox task needs its active origin scope.");
+  return { id: randomid(), text: text2, origin: input.origin.trim(), surface: "omnibox", at: input.at };
+}
+function omniboxtasktotaskinput(submission) {
+  return { id: submission.id, text: submission.text, context: "", origin: submission.origin, surface: "omnibox", at: submission.at };
+}
+
+// statusviews.ts
+function statusbadgeof(input) {
+  if (input.planstate === void 0) return { state: "idle", waitingcount: 0 };
+  if (input.waitingcount > 0) return { state: "attention", waitingcount: input.waitingcount, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+  if (input.planstate === "approved") return { state: "running", waitingcount: 0, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+  if (input.planstate === "pending") return { state: "waiting", waitingcount: 0, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+  return { state: "idle", waitingcount: 0, ...input.runid !== void 0 ? { runid: input.runid } : {} };
+}
+function badgetextof(state) {
+  if (state.state === "attention") return String(state.waitingcount);
+  if (state.state === "running") return "run";
+  if (state.state === "waiting") return "wait";
+  return "";
+}
+function badgecolorof(state) {
+  if (state.state === "attention") return "#b3261e";
+  if (state.state === "running") return "#1a73e8";
+  if (state.state === "waiting") return "#e37400";
+  return "#5f6368";
+}
+function notifydoneof(input) {
+  if (input.runid.trim() === "") throw new Error("The done notification needs its run id.");
+  return { id: randomid(), kind: "done", title: "The run completed", body: input.summary.trim() === "" ? `The run of ${input.origin} completed; the runsummary holds every step outcome.` : input.summary, deeplink: `#run-${input.runid}`, runid: input.runid, content: false, at: input.at };
+}
+function notifyattentionof(input) {
+  if (input.stepid.trim() === "") throw new Error("The attention notification needs its waiting step.");
+  const gate = notificationcontentgate({ content: input.content === true, consent: input.consent === true });
+  if (!gate.allowed) throw new Error(gate.reason ?? "The attention notification refuses its page content.");
+  return { id: randomid(), kind: "attention", title: input.cause === "gatewait" ? "The run waits for review" : input.cause === "phishguard" ? "The phishguard blocked a step" : "The run deferred a step", body: input.reason, deeplink: `#step-${input.stepid}`, runid: input.runid, stepid: input.stepid, content: input.content === true, at: input.at };
+}
+function notificationrespectsdnd(payload, dnd) {
+  if (dnd) return { show: false, reason: `The os stays in do not disturb, so the ${payload.kind} notification holds its deep link ${payload.deeplink} in the history instead of showing.` };
+  return { show: true, reason: `The ${payload.kind} notification shows with its deep link ${payload.deeplink}.` };
+}
+function recenttrayentryof(input) {
+  if (input.runid.trim() === "") throw new Error("The recenttray entry needs its run id.");
+  return { runid: input.runid, origin: input.origin, outcome: input.outcome, title: input.title, at: input.at, resumable: input.outcome === "halted", reopenable: input.outcome === "completed" || input.outcome === "failed" };
+}
+function recenttrayafter(entries, entry, depth) {
+  const appended = [entry, ...entries.filter((candidate) => candidate.runid !== entry.runid)];
+  if (depth === void 0) return appended;
+  if (!Number.isInteger(depth) || depth <= 0) return appended;
+  return appended.slice(0, depth);
+}
+function recenttrayactions(entry) {
+  const actions = [];
+  if (entry.resumable) actions.push("resume");
+  if (entry.reopenable) actions.push("reopen");
+  return actions;
+}
+function stetoastof(input) {
+  if (input.stepid.trim() === "") throw new Error("The stetoast needs its step.");
+  return { id: randomid(), stepid: input.stepid, kind: input.kind, durationms: input.durationms, at: input.at };
+}
+function stetoaststackafter(toasts, toast, livecount) {
+  const history = [...toasts, toast];
+  if (livecount === void 0 || !Number.isInteger(livecount) || livecount <= 0) return { live: history, history };
+  return { live: history.slice(-livecount), history };
+}
+function stetoasthistory(toasts) {
+  return [...toasts].reverse();
+}
+
+// pickerviews.ts
+function stabilityscoreof(input) {
+  let score = 0;
+  if (input.hasid) score += 40;
+  if (input.hasstableattributes) score += 25;
+  if (input.hasrole) score += 15;
+  if (input.textunique) score += 10;
+  if (input.selector.trim() === "") score -= 20;
+  else if (input.selector.includes(":nth-child") || input.selector.includes(":nth-of-type")) score -= 15;
+  return Math.max(0, Math.min(100, score));
+}
+function pickercandidateof(input) {
+  const score = stabilityscoreof(input);
+  const reasons = [];
+  if (input.hasid) reasons.push("the id anchors the selector");
+  if (input.hasstableattributes) reasons.push("stable attributes back the selector");
+  if (input.hasrole) reasons.push("the aria role names the element");
+  if (input.textunique) reasons.push("the text stays unique on the page");
+  if (reasons.length === 0) reasons.push("only the positional shape anchors the selector");
+  return { selector: input.selector, ...input.text !== void 0 && input.text !== "" ? { text: input.text } : {}, ...input.role !== void 0 && input.role !== "" ? { role: input.role } : {}, stabilityscore: score, reason: `The stability score of ${score} stands because ${reasons.join(", ")}.` };
+}
+function pickersessionstart(input) {
+  const gate = pickeroverlaygate({ origin: input.origin, granted: input.granted });
+  if (!gate.allowed) throw new Error(gate.reason);
+  return { id: randomid(), origin: input.origin, candidates: rankcandidates(input.candidates), startedat: input.at };
+}
+function rankcandidates(candidates) {
+  return [...candidates].sort((left, right) => right.stabilityscore - left.stabilityscore);
+}
+function lockcandidate(session, candidateindex, stepid) {
+  const candidate = session.candidates[candidateindex];
+  if (candidate === void 0) throw new Error(`The picker session knows no candidate ${candidateindex} to lock.`);
+  if (session.lockedstepid !== void 0) throw new Error(`The picker session already locks its candidate for the step ${session.lockedstepid}; one session locks one candidate.`);
+  return { ...session, lockedstepid: stepid, lockedselector: candidate.selector };
+}
+function haloof(input) {
+  if (input.selector.trim() === "") throw new Error("The targethalo needs its target selector.");
+  return { stepid: input.stepid, selector: input.selector, rect: input.rect, state: input.state };
+}
+function halocolorof(state) {
+  if (state === "running") return "#1a73e8";
+  if (state === "waiting") return "#e37400";
+  if (state === "done") return "#188038";
+  if (state === "failed") return "#b3261e";
+  if (state === "halted") return "#3c4043";
+  return "#5f6368";
+}
+function guidedtips() {
+  return [
+    { id: "selectorstability", surface: "sidepanel", title: "Selector stability", body: "Devthink scores every candidate selector by its stability: an id anchor, stable attributes, an aria role and a unique text each lift the score while a positional shape lowers it, so the proposed step binds to the selector least likely to break.", pickerstep: "candidatepick" },
+    { id: "candidatelock", surface: "sidepanel", title: "Locking a candidate", body: "Lock one candidate to bind it to the proposed step; one picker session locks one candidate and the locked selector rides the step for its review.", pickerstep: "candidatelock" },
+    { id: "haloreadout", surface: "sidepanel", title: "The halo read out", body: "During a run the targethalo outlines the active target element and its color follows the step state: gray while pending, blue while running, amber at a gate, green when done, red on failure and dark when halted.", pickerstep: "halotracking" }
+  ];
+}
+function guidedtipdismiss(tips, dismissed, tipid) {
+  const tip = tips.find((candidate) => candidate.id === tipid);
+  if (tip === void 0) throw new Error(`The guidedtips know no ${tipid} tip.`);
+  return [.../* @__PURE__ */ new Set([...dismissed, tipid])];
+}
+function guidedtiprecall(dismissed) {
+  return [];
+}
+function pagechipof(input) {
+  if (input.stepid.trim() === "") throw new Error("The pagechip needs its step.");
+  if (input.selector.trim() === "") throw new Error("The pagechip needs its anchor selector.");
+  return { id: randomid(), stepid: input.stepid, selector: input.selector, origin: input.origin, at: input.at };
+}
+function pagechipresolve(chip, resolution, surface, at) {
+  if (surface === "background") throw new Error("The pagechip resolution needs its distinct human action from a surface; the background never resolves a review on its own.");
+  const resolved = { ...chip, resolution, resolvedat: at };
+  return {
+    chip: resolved,
+    logevent: { kind: "review", stepid: chip.stepid, summary: `The user ${resolution === "approve" ? "approved" : "rejected"} the step ${chip.stepid} of ${chip.origin} from the pagechip anchored to ${chip.selector} on the ${surface}; one distinct human action resolved the step alone.` }
+  };
+}
+
+// evidenceviews.ts
+function shotpanelof(input) {
+  const gate = shotpanelgate({ captureorigin: input.origin, granted: input.granted });
+  if (!gate.allowed) throw new Error(gate.reason);
+  if (input.stepid.trim() === "") throw new Error("The shotpanel view needs its step.");
+  return { id: randomid(), stepid: input.stepid, runid: input.runid, captureid: input.captureid, provenance: input.provenance, origin: input.origin, redactions: input.redactions ?? [], zoom: 1, pan: { x: 0, y: 0 }, at: input.at };
+}
+function shotpanelzoom(view, factor) {
+  if (!(factor > 0)) throw new Error("The shotpanel zoom factor stays a positive number.");
+  return { ...view, zoom: view.zoom * factor };
+}
+function shotpanelpan(view, offset) {
+  return { ...view, pan: { x: view.pan.x + offset.x, y: view.pan.y + offset.y } };
+}
+function comparepairof(input) {
+  if (input.stepid.trim() === "") throw new Error("The compareviewer pair needs its step.");
+  if (input.beforecaptureid === input.aftercaptureid) throw new Error("The compareviewer pair needs its distinct before and after captures.");
+  return { id: randomid(), stepid: input.stepid, beforecaptureid: input.beforecaptureid, aftercaptureid: input.aftercaptureid, slidervalue: 50 };
+}
+function overlayslider(pair, value) {
+  if (!Number.isFinite(value) || value < 0 || value > 100) throw new Error("The compareviewer slider stays between zero and one hundred.");
+  return { ...pair, slidervalue: value };
+}
+function comparepairsforsteps(steps, captures) {
+  const pairs = [];
+  for (const step of steps) {
+    if (!step.writeexecuted) continue;
+    const capture = captures[step.stepid];
+    if (capture?.beforecaptureid === void 0 || capture?.aftercaptureid === void 0) continue;
+    pairs.push(comparepairof({ stepid: step.stepid, beforecaptureid: capture.beforecaptureid, aftercaptureid: capture.aftercaptureid }));
+  }
+  return pairs;
+}
+
+// siteprefs.ts
+function siteprofileof(input) {
+  const gate = siteprofilegate({ origin: input.origin });
+  if (!gate.allowed) throw new Error(gate.reason);
+  return { origin: input.origin, ...input.theme !== void 0 ? { theme: input.theme } : {}, ...input.shortcuts !== void 0 ? { shortcuts: input.shortcuts } : {}, ...input.defaultview !== void 0 ? { defaultview: input.defaultview } : {}, updatedat: input.at };
+}
+function siteprofileactive(profile, origin) {
+  return profile.origin === origin;
+}
+function siteprofilefor(profiles, origin) {
+  return profiles.find((profile) => siteprofileactive(profile, origin));
+}
+function darklighttokensof(mode) {
+  const tokens = mode === "dark" ? { surface: "#1f1f1f", elevated: "#2b2b2b", text: "#e3e3e3", muted: "#9aa0a6", accent: "#8ab4f8", border: "#3c4043", focus: "#aecbfa", error: "#f28b82", success: "#81c995", warning: "#fdd663" } : { surface: "#ffffff", elevated: "#f8f9fa", text: "#202124", muted: "#5f6368", accent: "#1a73e8", border: "#dadce0", focus: "#174ea6", error: "#b3261e", success: "#188038", warning: "#e37400" };
+  return { mode, tokens };
+}
+function resolveappearance(input) {
+  if (input.siteprofile?.theme !== void 0 && input.siteprofile.theme !== "system") return { ...darklighttokensof(input.siteprofile.theme), source: "site" };
+  if (input.useroverride !== void 0 && input.useroverride !== "system") return { ...darklighttokensof(input.useroverride), source: "user" };
+  return { ...darklighttokensof(input.ospreference), source: "os" };
+}
+function applytheme(documentroot, tokens) {
+  for (const [name, value] of Object.entries(tokens.tokens)) documentroot.style.setProperty(`--theme-${name}`, value);
+  documentroot.style.setProperty("color-scheme", tokens.mode);
+}
+function localebundles() {
+  return [
+    {
+      language: "en",
+      strings: {
+        "popup.title": "Devthink",
+        "popup.taskinput.placeholder": "Describe the goal for the active tab",
+        "popup.taskinput.submit": "Propose the plan",
+        "popup.palette.open": "Open the commandpalette",
+        "popup.recent.title": "Recent runs",
+        "popup.recent.resume": "Resume",
+        "popup.recent.reopen": "Reopen",
+        "sidepanel.tab.plan": "Plan",
+        "sidepanel.tab.run": "Run",
+        "sidepanel.tab.review": "Review",
+        "sidepanel.data.export": "Export",
+        "dashboard.title": "Dashboard",
+        "options.title": "Options",
+        "options.theme.label": "Theme",
+        "options.theme.dark": "Dark",
+        "options.theme.light": "Light",
+        "options.theme.system": "Follow the system",
+        "options.locale.label": "Language",
+        "options.shortcuts.label": "Shortcutkeys",
+        "options.notifications.label": "Notifications",
+        "options.importexport.label": "Import and export",
+        "options.tour.label": "Feature tour",
+        "stepapprove.approve": "Approve",
+        "stepapprove.reject": "Reject",
+        "stepapprove.edit": "Edit",
+        "pagechip.approve": "Approve",
+        "pagechip.reject": "Reject",
+        "grid.empty": "No extracted rows yet",
+        "toast.stepdone": "Step completed"
+      }
+    },
+    {
+      language: "pt",
+      strings: {
+        "popup.title": "Devthink",
+        "popup.taskinput.placeholder": "Descreva o objetivo para a aba ativa",
+        "popup.taskinput.submit": "Propor o plano",
+        "popup.palette.open": "Abrir a paleta de comandos",
+        "popup.recent.title": "Execu\xE7\xF5es recentes",
+        "popup.recent.resume": "Retomar",
+        "popup.recent.reopen": "Reabrir",
+        "sidepanel.tab.plan": "Plano",
+        "sidepanel.tab.run": "Execu\xE7\xE3o",
+        "sidepanel.tab.review": "Revis\xE3o",
+        "sidepanel.data.export": "Exportar",
+        "dashboard.title": "Painel",
+        "options.title": "Op\xE7\xF5es",
+        "options.theme.label": "Tema",
+        "options.theme.dark": "Escuro",
+        "options.theme.light": "Claro",
+        "options.theme.system": "Seguir o sistema",
+        "options.locale.label": "Idioma",
+        "options.shortcuts.label": "Atalhos",
+        "options.notifications.label": "Notifica\xE7\xF5es",
+        "options.importexport.label": "Importar e exportar",
+        "options.tour.label": "Tour de recursos",
+        "stepapprove.approve": "Aprovar",
+        "stepapprove.reject": "Rejeitar",
+        "stepapprove.edit": "Editar",
+        "pagechip.approve": "Aprovar",
+        "pagechip.reject": "Rejeitar",
+        "grid.empty": "Nenhuma linha extra\xEDda ainda",
+        "toast.stepdone": "Etapa conclu\xEDda"
+      }
+    }
+  ];
+}
+function localestring(bundles, language, key) {
+  const requested = bundles.find((bundle) => bundle.language === language);
+  const english = bundles.find((bundle) => bundle.language === "en");
+  return requested?.strings[key] ?? english?.strings[key] ?? key;
+}
+function supportedlanguages(bundles) {
+  return bundles.map((bundle) => bundle.language);
+}
+function localeformat(input) {
+  if (input.kind === "date") {
+    const date = new Date(input.value);
+    const year = date.getUTCFullYear();
+    const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+    const day = String(date.getUTCDate()).padStart(2, "0");
+    const hours = String(date.getUTCHours()).padStart(2, "0");
+    const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+    return input.language === "pt" ? `${day}/${month}/${year} ${hours}:${minutes}` : `${year}-${month}-${day} ${hours}:${minutes}`;
+  }
+  if (input.kind === "duration") {
+    const seconds = Math.round(input.value / 1e3);
+    const minutes = Math.floor(seconds / 60);
+    const rest = seconds % 60;
+    return input.language === "pt" ? `${minutes} min ${rest} s` : `${minutes}m ${rest}s`;
+  }
+  const text2 = String(input.value);
+  const parts = text2.split(".");
+  const whole = parts[0] ?? "0";
+  const fraction = parts[1];
+  const grouped = whole.replace(/\B(?=(\d{3})+(?!\d))/g, input.language === "pt" ? "." : ",");
+  return fraction !== void 0 ? `${grouped}${input.language === "pt" ? "," : "."}${fraction}` : grouped;
+}
+
+// portability.ts
+function importexportpayloadof(input) {
+  if (input.profile.trim() === "") throw new Error("The importexport payload needs its profile name.");
+  const secrets = [...input.originprofiles, ...input.siteprofiles, ...input.notes, ...Object.values(input.preferences)].find((record2) => secretcarrying(record2)) !== void 0;
+  const gate = importexportgate({ containssecrets: secrets, unmaskedlogs: false });
+  if (!gate.allowed) throw new Error(gate.reason);
+  return { version: 1, kind: "settings", profile: input.profile.trim(), exportedat: input.at, contents: { originprofiles: input.originprofiles, siteprofiles: input.siteprofiles, notes: input.notes, preferences: input.preferences }, exclusions: ["secretvault values", "unmasked logs"] };
+}
+function secretcarrying(record2) {
+  if (record2 === null || typeof record2 !== "object") return false;
+  const entries = Object.entries(record2);
+  const secretkeys = ["secret", "token", "password", "apikey", "authorization"];
+  return entries.some(([key, value]) => secretkeys.some((shape) => key.toLowerCase().includes(shape)) && typeof value === "string" && value.trim() !== "");
+}
+function importexportvalidate(payload) {
+  const records = [...payload.contents.originprofiles, ...payload.contents.siteprofiles, ...payload.contents.notes, ...Object.values(payload.contents.preferences)];
+  const preferencessecrets = Object.entries(payload.contents.preferences).some(([key, value]) => secretcarrying({ [key]: value }));
+  const gate = importexportgate({ containssecrets: records.some((record2) => secretcarrying(record2)) || preferencessecrets, unmaskedlogs: payload.contents.unmaskedlogs !== void 0 });
+  if (!gate.allowed) return { ok: false, reason: gate.reason ?? "The importexport bundle refuses." };
+  if (payload.profile.trim() === "") return { ok: false, reason: "The importexport bundle needs its profile name." };
+  return { ok: true, reason: `The importexport bundle of the profile ${payload.profile} validates with ${payload.contents.originprofiles.length} origin profile${payload.contents.originprofiles.length === 1 ? "" : "s"}, ${payload.contents.siteprofiles.length} site profile${payload.contents.siteprofiles.length === 1 ? "" : "s"} and ${payload.contents.notes.length} note${payload.contents.notes.length === 1 ? "" : "s"}; ${payload.exclusions.join(" and ")} never enter any bundle.` };
+}
+function applyimport(payload, current) {
+  const validation = importexportvalidate(payload);
+  if (!validation.ok) throw new Error(validation.reason);
+  const applied = Object.keys(payload.contents.preferences);
+  return { preferences: { ...current, ...payload.contents.preferences }, applied };
+}
+function detectfilekind(filename, head) {
+  const extension = filename.toLowerCase().split(".").pop() ?? "";
+  if (extension === "csv") return "csv";
+  if (extension === "json") {
+    const trimmed = head.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) return trimmed.includes('"steps"') ? "workflow" : "json";
+    return "json";
+  }
+  if (extension === "yaml" || extension === "yml") return "workflow";
+  return void 0;
+}
+function dropimportof(input) {
+  if (input.filename.trim() === "") throw new Error("The dropimport session needs its filename.");
+  const kind = detectfilekind(input.filename, input.head);
+  if (kind === void 0) throw new Error(`The dropimport detects no csv, json or workflow kind in ${input.filename}; the import path refuses the file.`);
+  return { id: `${input.filename}:${input.at}`, filename: input.filename, kind, bytes: input.bytes, accepted: true, at: input.at };
+}
+
+// tourviews.ts
+function featuretourstops() {
+  return [
+    { id: "origingrants", surface: "popup", focus: "#allowlist", title: "Origin grants", body: "Devthink denies automation by default; grant one exact origin at a time and every run stays inside the granted origins.", order: 1 },
+    { id: "planreview", surface: "sidepanel", focus: "#plancards", title: "Plan review", body: "Every task becomes a plan of reviewed steps; read the plancards of each risk class and approve, reject or edit one step at a time.", order: 2 },
+    { id: "runcontrol", surface: "sidepanel", focus: "#timeline", title: "Run control", body: "Runs start, pause, resume and cancel under your hand while the stepstimeline follows every transition.", order: 3 },
+    { id: "logaudit", surface: "dashboardpage", focus: "#sessiongrid", title: "Log audit", body: "The immutable log chains every step transition with masked values; verify the chain and copy a verified range as an audit excerpt.", order: 4 },
+    { id: "datagrid", surface: "sidepanel", focus: "#datagrid", title: "The datagrid", body: "Extraction results render as a grid with inferred column types; sort and filter locally, select a row range and export csv, json or clipboard with masked values only.", order: 5 },
+    { id: "compareviewer", surface: "sidepanel", focus: "#compareviewer", title: "The compareviewer", body: "Every executed write step pairs its before and after captures; the slider overlays the two so you see exactly what the step changed.", order: 6 },
+    { id: "pickeroverlay", surface: "sidepanel", focus: "#picker", title: "The pickeroverlay", body: "Start a picker session to list the element candidates of the granted origin with stability scored selectors; lock one candidate for the proposed step.", order: 7 }
+  ];
+}
+function featuretourordered(stops) {
+  return [...stops].sort((left, right) => left.order - right.order);
+}
+function featuretourstopat(stops, position) {
+  return featuretourordered(stops)[position];
+}
+function a11ylabelof(input) {
+  if (input.control.trim() === "") throw new Error("The a11ylabel needs its control.");
+  if (input.name.trim() === "") throw new Error("The a11ylabel needs its accessible name.");
+  return { control: input.control, role: input.role, name: input.name, ...input.state !== void 0 ? { state: input.state } : {}, ...input.value !== void 0 ? { value: input.value } : {} };
+}
+function a11ylabelsfor(surface) {
+  const labels = {
+    popup: [
+      a11ylabelof({ control: "taskinput", role: "textbox", name: "popup.taskinput.placeholder", state: "idle" }),
+      a11ylabelof({ control: "submit", role: "button", name: "popup.taskinput.submit" }),
+      a11ylabelof({ control: "palette", role: "button", name: "popup.palette.open" }),
+      a11ylabelof({ control: "recenttray", role: "list", name: "popup.recent.title", value: "0 runs" })
+    ],
+    sidepanel: [
+      a11ylabelof({ control: "plantab", role: "tab", name: "sidepanel.tab.plan", state: "selected" }),
+      a11ylabelof({ control: "runtab", role: "tab", name: "sidepanel.tab.run", state: "unselected" }),
+      a11ylabelof({ control: "reviewtab", role: "tab", name: "sidepanel.tab.review", state: "unselected" }),
+      a11ylabelof({ control: "datagrid", role: "table", name: "grid.empty" }),
+      a11ylabelof({ control: "compareviewer", role: "slider", name: "sidepanel.data.compare", value: "50" }),
+      a11ylabelof({ control: "picker", role: "button", name: "sidepanel.data.picker" })
+    ],
+    dashboardpage: [
+      a11ylabelof({ control: "sessiongrid", role: "table", name: "dashboard.title", value: "0 runs" }),
+      a11ylabelof({ control: "historysearch", role: "search", name: "dashboard.history" }),
+      a11ylabelof({ control: "dropzone", role: "region", name: "options.importexport.label" })
+    ],
+    optionspage: [
+      a11ylabelof({ control: "theme", role: "radiogroup", name: "options.theme.label", value: "system" }),
+      a11ylabelof({ control: "locale", role: "combobox", name: "options.locale.label", value: "en" }),
+      a11ylabelof({ control: "shortcuts", role: "group", name: "options.shortcuts.label" }),
+      a11ylabelof({ control: "notifications", role: "switch", name: "options.notifications.label", state: "off" }),
+      a11ylabelof({ control: "importexport", role: "region", name: "options.importexport.label" }),
+      a11ylabelof({ control: "tour", role: "button", name: "options.tour.label" })
+    ],
+    onboarding: [
+      a11ylabelof({ control: "onboarding", role: "dialog", name: "options.tour.label", state: "open" })
+    ],
+    omnibox: [
+      a11ylabelof({ control: "omnibox", role: "textbox", name: "popup.taskinput.placeholder" })
+    ],
+    page: [
+      a11ylabelof({ control: "pagechip", role: "group", name: "pagechip.approve", state: "pending" })
+    ]
+  };
+  return labels[surface];
+}
+function a11ylabellocalized(label, bundles, language) {
+  return { ...label, name: localestring(bundles, language, label.name) };
+}
+function a11ylabelslocalizedfor(surface, bundles, language) {
+  return a11ylabelsfor(surface).map((label) => a11ylabellocalized(label, bundles, language));
+}
+
 // taskqueue.ts
 function emptyqueue(input = {}) {
   return { lanes: input.lanes ?? [], priorities: input.priorities ?? [], completionpolicy: input.completionpolicy ?? "all", items: [], claims: [] };
@@ -14374,6 +15041,9 @@ function transparencyreport(input) {
 function surfacesnapshot(input) {
   return { version: protocolversion, surface: input.surface, palette: input.palette, timeline: input.timeline, logstream: input.logstream, plancards: input.plancards, ...input.onboarding !== void 0 ? { onboarding: input.onboarding } : {} };
 }
+function interfaceviews(input) {
+  return { version: protocolversion, ...input.datagrid !== void 0 ? { datagrid: input.datagrid } : {}, exportmenu: input.exportmenu, badge: input.badge, recenttray: input.recenttray, toasts: input.toasts, appearance: input.appearance };
+}
 
 // workfloweditor.ts
 var palettecategories = ["actions", "controlflow", "waits", "variables", "triggers"];
@@ -15079,6 +15749,10 @@ function yamlscalarvalue(text2) {
   return text2;
 }
 export {
+  a11ylabellocalized,
+  a11ylabelof,
+  a11ylabelsfor,
+  a11ylabelslocalizedfor,
   acceptrenderresult,
   acceptworkerresponse,
   ackreview,
@@ -15114,11 +15788,13 @@ export {
   appendlogstreamevent,
   applycooldown,
   applyheaderules,
+  applyimport,
   applylayer,
   applyoverride,
   applyretry,
   applyreview,
   applyruntimeout,
+  applytheme,
   applytimeout,
   approvalframes,
   approvalprompt,
@@ -15139,6 +15815,8 @@ export {
   autointervalof,
   automationallowlistgate,
   backoffdelay,
+  badgecolorof,
+  badgetextof,
   batchreport,
   beatrun,
   bindlocalhost,
@@ -15235,6 +15913,8 @@ export {
   collectresults,
   commandguard,
   compareoutputs,
+  comparepairof,
+  comparepairsforsteps,
   complete,
   composeworkflow,
   conditionof,
@@ -15282,6 +15962,9 @@ export {
   croprect,
   crossesviewport,
   cursorfrom,
+  darklighttokensof,
+  datagridcolumnsof,
+  datagridof,
   datasetresponse,
   debuggate,
   debuggerconsentcovers,
@@ -15310,6 +15993,7 @@ export {
   denydefaultposture,
   actionrisk as deriveactionrisk,
   detachcdpsession,
+  detectfilekind,
   devicepresetof,
   diffpreviewgate,
   diffpreviewof,
@@ -15325,6 +16009,7 @@ export {
   downloadreport,
   draftplan,
   drainqueue,
+  dropimportof,
   dryrunprojection,
   dryrunreport,
   dryrunworkflow,
@@ -15383,8 +16068,11 @@ export {
   expiretokens,
   expirnotes,
   exportcontentreview,
+  exportdatagrid,
   exportlogchain,
+  exportmenudescriptors,
   exportpresetlibrary,
+  exportrowsof,
   exportrunstate,
   exportsessionfile,
   exportworkflow,
@@ -15396,10 +16084,14 @@ export {
   failureclass,
   fallbackroute,
   familyofkind,
+  featuretourordered,
+  featuretourstopat,
+  featuretourstops,
   fetchoptionsof,
   fetchrequestof,
   fieldshapekind,
   fieldshaperegions,
+  filterdatagridrows,
   filteredsessions,
   filterentries,
   filterexchanges,
@@ -15427,6 +16119,11 @@ export {
   growthtrend,
   guardoutput,
   guardverdictgate,
+  guidedtipdismiss,
+  guidedtiprecall,
+  guidedtips,
+  halocolorof,
+  haloof,
   haltedstepsof,
   handleframe,
   handoffframe,
@@ -15451,13 +16148,18 @@ export {
   imagefilterof,
   imagematches,
   imagenames,
+  importexportgate,
+  importexportpayloadof,
+  importexportvalidate,
   importpresetlibrary,
   importsessionfile,
   importworkflow,
+  infercolumntype,
   inflightreport,
   inheritconsent,
   initialize,
   inmemoryvault,
+  interfaceviews,
   interleavetimeline,
   iscdpkind,
   iscontrolflowkind,
@@ -15499,12 +16201,16 @@ export {
   listtools,
   livebufferof,
   loadworkflow,
+  localebundles,
+  localeformat,
+  localestring,
   localhostbind,
   localsensitivegrade,
   locationconsentcovers,
   locationconsentgate,
   locationpresetof,
   locationrangevalid,
+  lockcandidate,
   lockkey,
   logbufferboundvalid,
   logchainreport,
@@ -15527,6 +16233,7 @@ export {
   markpending,
   markprovider,
   markuprenderstep,
+  maskedvalueof,
   maskexport,
   maskfield,
   maskformstate,
@@ -15585,6 +16292,10 @@ export {
   normalizeendpoint,
   notebodyof,
   notehistoryentry,
+  notificationcontentgate,
+  notificationrespectsdnd,
+  notifyattentionof,
+  notifydoneof,
   oauthflowof,
   observationmodeof,
   observationresponse,
@@ -15592,6 +16303,8 @@ export {
   offfamilyof,
   offloadkinds,
   offscreencapabilitygate,
+  omniboxtaskgate,
+  omniboxtasktotaskinput,
   onboardingcomplete,
   onboardingconsentgate,
   onboardingstart,
@@ -15613,8 +16326,11 @@ export {
   originprofilegate,
   originprofileof,
   outcomeresponse,
+  overlayslider,
   overrideinputof,
   overridematches,
+  pagechipof,
+  pagechipresolve,
   pairclient,
   pairexchange,
   pairingframes,
@@ -15630,8 +16346,10 @@ export {
   parsecompletion,
   parseframe,
   parsehtmlbody,
+  parseomniboxtask,
   parseoutput,
   parseproposal,
+  parseshortcut,
   parsessetext,
   parsestream,
   parsetokens,
@@ -15664,6 +16382,9 @@ export {
   phishthresholdgate,
   phishthresholdvalid,
   phishverdictof,
+  pickercandidateof,
+  pickeroverlaygate,
+  pickersessionstart,
   ping,
   planallowlist,
   plancardgroups,
@@ -15705,8 +16426,12 @@ export {
   queuecomplete,
   queuefire,
   queuelanesvalid,
+  quickactioncatalog,
+  quickactiongate,
+  quickactionsfor,
   randomid,
   rankapis,
+  rankcandidates,
   rankrecall,
   ratelimitboundsvalid,
   ratelimitbudgetallowed,
@@ -15722,6 +16447,9 @@ export {
   recallentryof,
   receivemessage,
   receivemessages,
+  recenttrayactions,
+  recenttrayafter,
+  recenttrayentryof,
   reconnectwaits,
   recordagentusage,
   recordenvironment,
@@ -15775,6 +16503,7 @@ export {
   resolutionhistoryafter,
   resolutionlogeventof,
   resolutionverdict,
+  resolveappearance,
   resolveapproval,
   resolvedrisk,
   resolveescalation,
@@ -15877,6 +16606,7 @@ export {
   securityreport,
   seededrandom,
   selectorresponse,
+  selectrowrange,
   semanticrecallscopegate,
   sendcdpcommand,
   sendfetch,
@@ -15910,26 +16640,43 @@ export {
   sharelesson,
   shareworkflow,
   shiftentryof,
+  shortcutbindingafter,
+  shortcutcommandof,
+  shortcutdefaults,
+  shortcutdispatchable,
+  shortcutkeygate,
+  shortcuttext,
+  shotpanelgate,
+  shotpanelof,
+  shotpanelpan,
+  shotpanelzoom,
   signalsreport,
   sitenoteof,
   sitenotesreadgate,
   sitenoteswritegate,
+  siteprofileactive,
+  siteprofilefor,
+  siteprofilegate,
+  siteprofileof,
   snapnode,
   snapshotplanof,
   snapshotretentionwindow,
   snapshotsections,
   socketgate,
   socketkinds,
+  sortdatagridrows,
   sourcemapconsentcovers,
   spamdetect,
   spamruleof,
   spawn,
   spawngrade,
   sserequestheaders,
+  stabilityscoreof,
   stackedcount,
   stackframes,
   stackgate,
   starttls,
+  statusbadgeof,
   statusclassof,
   steal,
   stepapprovegate,
@@ -15939,6 +16686,9 @@ export {
   stepstimelinenodes,
   steptemplateof,
   stepwindows,
+  stetoasthistory,
+  stetoastof,
+  stetoaststackafter,
   stopone,
   streamchunkframe,
   streamdelta,
@@ -15954,6 +16704,7 @@ export {
   summaryhistoryentry,
   summaryrequestof,
   summarywindowvalid,
+  supportedlanguages,
   surfacepalette,
   surfacesnapshot,
   swarmcosts,