@tomflow/proflow-execution-browser-extension 0.1.37 → 0.1.39

package/dist/extension/content.js

@@ -1,5 +1,251 @@
 "use strict";
 (() => {
+  // packages/execution-browser-extension/src/carrier-permission.ts
+  var actionLabels = [
+    [/^(始终允许|always allow)$/i, "allowAlways"],
+    [/^(允许一次|allow once)$/i, "allowOnce"],
+    [/^(拒绝|deny)$/i, "deny"]
+  ];
+  function permissionSemanticAction(label) {
+    const normalized = label.trim();
+    for (const [pattern, action] of actionLabels)
+      if (pattern.test(normalized)) return action;
+    return null;
+  }
+  function normalizedText(value) {
+    return value.replace(/\s+/g, " ").trim().slice(0, 4096);
+  }
+  function hashFingerprint(value) {
+    let hash = 2166136261;
+    for (let index = 0; index < value.length; index += 1) {
+      hash ^= value.charCodeAt(index);
+      hash = Math.imul(hash, 16777619);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }
+  function targetHost(text) {
+    const url = text.match(/https?:\/\/([a-z0-9.-]+)(?=[/:\s"'”]|$)/i)?.[1];
+    if (url) return url.toLowerCase();
+    const hosts = text.match(/[a-z0-9][a-z0-9-]*(?:\.[a-z0-9-]+){2,}/gi) ?? [];
+    return hosts.find((value) => value.includes("devtunnels.ms"))?.toLowerCase() ?? hosts[0]?.toLowerCase() ?? null;
+  }
+  function operationId(text) {
+    return text.match(
+      /(?:工具调用|tool call)\s*[：:]\s*[^\s.]+(?:\.[^\s.]+)*\.([A-Za-z][A-Za-z0-9_]*)/i
+    )?.[1] ?? null;
+  }
+  function taskId(text) {
+    return text.match(/\btask-[A-Za-z0-9-]+\b/)?.[0] ?? null;
+  }
+  function detectActionPermission(candidates) {
+    for (const candidate of candidates) {
+      const actions = candidate.buttonLabels.map(permissionSemanticAction).filter((value) => value !== null);
+      if (!actions.includes("deny") || !actions.includes("allowAlways") && !actions.includes("allowOnce"))
+        continue;
+      const text = normalizedText(candidate.text);
+      const operation = operationId(text);
+      if (!operation) continue;
+      return {
+        kind: "ACTION_PERMISSION",
+        targetHost: targetHost(text),
+        operationId: operation,
+        taskId: taskId(text),
+        actions,
+        fingerprint: `permission:v1:${hashFingerprint(`${text}|${actions.join(",")}`)}`
+      };
+    }
+    return null;
+  }
+  function permissionActionAllowed(facts, expectedFingerprint, action) {
+    return facts.fingerprint === expectedFingerprint && facts.actions.includes(action);
+  }
+
+  // packages/execution-browser-extension/src/composer-submit.ts
+  async function submitAfterComposerCommit(port, expectedValue, maxFrames = 180) {
+    let stableFrames = 0;
+    for (let frame = 0; frame < maxFrames; frame += 1) {
+      await port.nextFrame();
+      if (port.readValue() === expectedValue && port.submitReady()) {
+        stableFrames += 1;
+        if (stableFrames >= 2) {
+          port.clickSubmit();
+          return;
+        }
+      } else {
+        stableFrames = 0;
+      }
+    }
+    throw new Error("COMPOSER_SUBMIT_NOT_READY");
+  }
+  async function submitControlledComposer(port, expectedValue, maxFrames = 180) {
+    port.write(expectedValue);
+    port.dispatchInput(expectedValue);
+    await submitAfterComposerCommit(port, expectedValue, maxFrames);
+  }
+
+  // packages/execution-browser-extension/src/chatgpt-runtime-adapter.ts
+  function classifyChatGptPageSignals(input) {
+    if (input.permission)
+      return {
+        pageState: "BLOCKED",
+        activityKind: "ACTION_PERMISSION",
+        blockerFacts: input.permission
+      };
+    if (input.hasDialog)
+      return { pageState: "BLOCKED", activityKind: "WAITING_HUMAN" };
+    if (input.isGenerating)
+      return { pageState: "BUSY", activityKind: "GENERATING" };
+    if (input.hasComposer) return { pageState: "IDLE", activityKind: null };
+    return { pageState: "UNKNOWN", activityKind: null };
+  }
+  var composerSelector = '#prompt-textarea, textarea, [contenteditable="true"]';
+  var sendSelector = 'button[data-testid="send-button"], button[aria-label*="Send"], button[aria-label*="\u53D1\u9001"]';
+  function buttonLabel(button) {
+    return (button.textContent ?? "").replace(/\s+/g, " ").trim();
+  }
+  function actionPermissionDom(document2) {
+    const view = document2.defaultView;
+    if (!view) return null;
+    const semanticButtons = [...document2.querySelectorAll("button")].filter(
+      (button) => button instanceof view.HTMLButtonElement && permissionSemanticAction(buttonLabel(button)) !== null
+    );
+    for (const seed of semanticButtons) {
+      let root = seed.parentElement;
+      for (let depth = 0; root && depth < 8; depth += 1, root = root.parentElement) {
+        const buttons = [...root.querySelectorAll("button")].filter(
+          (button) => button instanceof view.HTMLButtonElement
+        );
+        const facts = detectActionPermission([
+          {
+            text: root.textContent ?? "",
+            buttonLabels: buttons.map(buttonLabel)
+          }
+        ]);
+        if (!facts) continue;
+        const mapped = /* @__PURE__ */ new Map();
+        for (const button of buttons) {
+          const action = permissionSemanticAction(buttonLabel(button));
+          if (action && !mapped.has(action)) mapped.set(action, button);
+        }
+        return { facts, buttons: mapped };
+      }
+    }
+    return null;
+  }
+  function observeChatGptPage(document2) {
+    const permission = actionPermissionDom(document2);
+    return classifyChatGptPageSignals({
+      permission: permission?.facts ?? null,
+      hasDialog: document2.querySelector('[role="dialog"]') !== null,
+      isGenerating: document2.querySelector(
+        '[data-testid="stop-button"], button[aria-label*="Stop"], button[aria-label*="\u505C\u6B62"]'
+      ) !== null,
+      hasComposer: document2.querySelector(composerSelector) !== null
+    });
+  }
+  function performChatGptPermissionAction(document2, expectedFingerprint, action) {
+    const permission = actionPermissionDom(document2);
+    if (!permission) throw new Error("ACTION_PERMISSION_NOT_FOUND");
+    if (!permissionActionAllowed(permission.facts, expectedFingerprint, action))
+      throw new Error("STALE_PERMISSION");
+    const button = permission.buttons.get(action);
+    if (!button || button.disabled || button.getAttribute("aria-disabled") === "true")
+      throw new Error("PERMISSION_ACTION_NOT_READY");
+    button.click();
+    return permission.facts;
+  }
+  function composerElement(document2) {
+    const view = document2.defaultView;
+    const element = document2.querySelector(composerSelector);
+    if (!view || !(element instanceof view.HTMLElement))
+      throw new Error("COMPOSER_NOT_FOUND");
+    return element;
+  }
+  function readElementValue(element) {
+    const view = element.ownerDocument.defaultView;
+    if (!view) return "";
+    if (element instanceof view.HTMLTextAreaElement || element instanceof view.HTMLInputElement)
+      return element.value;
+    return element.textContent ?? "";
+  }
+  function nativeWrite(element, value) {
+    const view = element.ownerDocument.defaultView;
+    if (!view) throw new Error("DOM_WINDOW_NOT_READY");
+    if (element instanceof view.HTMLTextAreaElement || element instanceof view.HTMLInputElement) {
+      const prototype = element instanceof view.HTMLTextAreaElement ? view.HTMLTextAreaElement.prototype : view.HTMLInputElement.prototype;
+      const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+      if (!setter) throw new Error("COMPOSER_NATIVE_SETTER_MISSING");
+      setter.call(element, value);
+      return;
+    }
+    element.textContent = value;
+  }
+  function dispatchComposerInput(element, value) {
+    const view = element.ownerDocument.defaultView;
+    if (!view) throw new Error("DOM_WINDOW_NOT_READY");
+    element.dispatchEvent(
+      new view.InputEvent("input", {
+        bubbles: true,
+        inputType: "insertText",
+        data: value
+      })
+    );
+  }
+  function nextComposerFrame(document2) {
+    const view = document2.defaultView;
+    if (!view) return Promise.reject(new Error("DOM_WINDOW_NOT_READY"));
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = () => {
+        if (settled) return;
+        settled = true;
+        resolve();
+      };
+      view.requestAnimationFrame(finish);
+      view.setTimeout(finish, 50);
+    });
+  }
+  function sendButton(document2) {
+    const view = document2.defaultView;
+    const element = document2.querySelector(sendSelector);
+    return view && element instanceof view.HTMLButtonElement ? element : null;
+  }
+  async function submitChatGptComposer(document2, value) {
+    const composer = composerElement(document2);
+    composer.focus();
+    await submitControlledComposer(
+      {
+        write: (next) => nativeWrite(composer, next),
+        dispatchInput: (next) => dispatchComposerInput(composer, next),
+        readValue: () => readElementValue(composer),
+        submitReady: () => {
+          const button = sendButton(document2);
+          return Boolean(
+            button && !button.disabled && button.getAttribute("aria-disabled") !== "true"
+          );
+        },
+        nextFrame: () => nextComposerFrame(document2),
+        clickSubmit: () => {
+          const button = sendButton(document2);
+          if (!button || button.disabled || button.getAttribute("aria-disabled") === "true")
+            throw new Error("COMPOSER_SUBMIT_NOT_READY");
+          button.click();
+        }
+      },
+      value
+    );
+  }
+  function writeChatGptInput(document2, selector, value) {
+    if (!selector || selector.length > 512) throw new Error("SELECTOR_INVALID");
+    const view = document2.defaultView;
+    const element = document2.querySelector(selector);
+    if (!view || !(element instanceof view.HTMLElement))
+      throw new Error("ELEMENT_NOT_FOUND");
+    element.focus();
+    nativeWrite(element, value);
+    dispatchComposerInput(element, value);
+  }
+
   // packages/execution-browser-extension/src/submitted-message.ts
   function containsSubmittedFingerprint(candidates, fingerprint) {
     if (!fingerprint) return false;
@@ -13,17 +259,7 @@
   // packages/execution-browser-extension/extension/content.ts
   var contentInstanceId = `content:${crypto.randomUUID()}`;
   function pageState() {
-    if (document.querySelector('[role="dialog"]'))
-      return { pageState: "BLOCKED", activityKind: "ACTION_PERMISSION" };
-    if (document.querySelector(
-      '[data-testid="stop-button"], button[aria-label*="Stop"]'
-    ))
-      return { pageState: "BUSY", activityKind: "GENERATING" };
-    if (document.querySelector(
-      '#prompt-textarea, textarea, [contenteditable="true"]'
-    ))
-      return { pageState: "IDLE", activityKind: null };
-    return { pageState: "UNKNOWN", activityKind: null };
+    return observeChatGptPage(document);
   }
   function observation() {
     return {
@@ -52,6 +288,7 @@
   }
   chrome.runtime.onMessage.addListener((command, _sender, sendResponse) => {
     void (async () => {
+      if (command.type === "PROFLOW_PAGE_SNAPSHOT_REQUEST") return observation();
       if (command.type !== "PROFLOW_PAGE_COMMAND" || command.contentInstanceId !== contentInstanceId || command.expectedUrl !== location.href)
         throw new Error("STALE_CONTENT_SESSION");
       if (command.operation === "observe") return observation();
@@ -60,30 +297,32 @@
           ...observation(),
           verified: hasFingerprint(command.fingerprint)
         };
-      if (pageState().pageState === "BLOCKED")
-        throw new Error("PAGE_PERMISSION_REQUIRES_HUMAN");
+      if (command.operation === "permissionAction") {
+        if (!command.permissionFingerprint || !command.permissionAction)
+          throw new Error("PERMISSION_ACTION_INVALID");
+        performChatGptPermissionAction(
+          document,
+          command.permissionFingerprint,
+          command.permissionAction
+        );
+        return observation();
+      }
+      if (pageState().pageState === "BLOCKED") throw new Error("PAGE_BLOCKED");
       if (command.operation === "click") {
         safeElement(command.selector).click();
         return observation();
       }
-      const input = safeElement(command.selector ?? "#prompt-textarea");
       if (command.value === void 0 || command.value.length > 4096)
         throw new Error("INPUT_BUDGET_EXCEEDED");
-      input.focus();
-      if (input instanceof HTMLTextAreaElement || input instanceof HTMLInputElement)
-        input.value = command.value;
-      else input.textContent = command.value;
-      input.dispatchEvent(
-        new InputEvent("input", {
-          bubbles: true,
-          inputType: "insertText",
-          data: command.value
-        })
+      if (command.operation === "submit") {
+        await submitChatGptComposer(document, command.value);
+        return observation();
+      }
+      writeChatGptInput(
+        document,
+        command.selector ?? "#prompt-textarea",
+        command.value
       );
-      if (command.operation === "submit")
-        safeElement(
-          'button[data-testid="send-button"], button[aria-label*="Send"]'
-        ).click();
       return observation();
     })().then(
       (value) => sendResponse({ ok: true, value }),

package/dist/extension/tasks.js

@@ -1,5 +1,5 @@
-export {};
-const extensionRuntime = typeof chrome !== "undefined" && chrome.runtime ? chrome.runtime : null;
+import { parseCarrierAttentionViews } from "../src/carrier-attention-view.js";
+const extensionRuntime = typeof chrome === "undefined" ? null : chrome.runtime;
 function element(selector) {
     const value = document.querySelector(selector);
     if (!value)
@@ -17,6 +17,7 @@ const startButton = element("#start-task");
 const ensureWorkersButton = element("#ensure-workers");
 const newTaskForm = element("#new-task-form");
 const approvalsTarget = element("#approvals");
+const carrierAttentionsTarget = element("#carrier-attentions");
 const systemAssessmentTarget = element("#system-assessment");
 let selected = null;
 function requestId(prefix) {
@@ -68,6 +69,73 @@ async function approvalApplication(operation, input) {
             : "APPROVAL_APPLICATION_FAILED");
     return response.value;
 }
+async function carrierAttentionAction(attentionRef, action) {
+    if (!extensionRuntime) {
+        const response = await fetch("/tasks/api/carrier-attention", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ attentionRef, action }),
+        });
+        const body = record(await response.json());
+        if (!response.ok || body.ok !== true)
+            throw new Error(typeof body.error === "string"
+                ? body.error
+                : "CARRIER_ATTENTION_ACTION_FAILED");
+        return;
+    }
+    const raw = await extensionRuntime.sendMessage({
+        type: "PROFLOW_CARRIER_ATTENTION_ACTION",
+        input: { attentionRef, action },
+    });
+    const response = record(raw);
+    if (response.ok !== true)
+        throw new Error(typeof response.error === "string"
+            ? response.error
+            : "CARRIER_ATTENTION_ACTION_FAILED");
+}
+function renderCarrierAttentions(snapshot) {
+    const attentions = parseCarrierAttentionViews(snapshot.carrierAttentions);
+    carrierAttentionsTarget.replaceChildren();
+    if (attentions.length === 0) {
+        carrierAttentionsTarget.textContent = "No carrier attention.";
+        return;
+    }
+    for (const attention of attentions) {
+        const row = document.createElement("div");
+        row.className = "task";
+        const label = document.createElement("div");
+        label.textContent = `${attention.operationId} · ${attention.targetHost ?? "unknown target"}`;
+        const detail = document.createElement("div");
+        detail.className = "meta";
+        detail.textContent = [
+            attention.reason,
+            attention.taskId ? `task ${attention.taskId}` : "task unknown",
+            attention.roleRef ? `role ${attention.roleRef}` : "role unknown",
+        ].join(" · ");
+        row.append(label, detail);
+        if (attention.actions.includes("allowOnce")) {
+            const allow = document.createElement("button");
+            allow.type = "button";
+            allow.textContent = "Allow once";
+            allow.addEventListener("click", () => void run(async () => {
+                await carrierAttentionAction(attention.attentionRef, "allowOnce");
+                await refreshBrowserStatus();
+            }));
+            row.append(allow);
+        }
+        if (attention.actions.includes("deny")) {
+            const deny = document.createElement("button");
+            deny.type = "button";
+            deny.textContent = "Deny";
+            deny.addEventListener("click", () => void run(async () => {
+                await carrierAttentionAction(attention.attentionRef, "deny");
+                await refreshBrowserStatus();
+            }));
+            row.append(deny);
+        }
+        carrierAttentionsTarget.append(row);
+    }
+}
 async function refreshApprovals() {
     const value = record(await approvalApplication("approval.list", { status: "PENDING" }));
     const approvals = Array.isArray(value.approvals)
@@ -170,7 +238,9 @@ async function refreshTasks() {
 }
 async function pageStatus() {
     if (extensionRuntime)
-        return record(await extensionRuntime.sendMessage({ type: "PROFLOW_SIDE_PANEL_SNAPSHOT" }));
+        return record(await extensionRuntime.sendMessage({
+            type: "PROFLOW_SIDE_PANEL_SNAPSHOT",
+        }));
     const response = await fetch("/tasks/api/status", { cache: "no-store" });
     const body = record(await response.json());
     if (!response.ok || body.ok !== true)
@@ -179,6 +249,7 @@ async function pageStatus() {
 }
 async function refreshBrowserStatus() {
     const snapshot = await pageStatus();
+    renderCarrierAttentions(snapshot);
     connection.textContent =
         snapshot.taskApplicationConfigured === true &&
             snapshot.approvalApplicationConfigured === true

package/dist/src/bridge.js

@@ -1,5 +1,6 @@
 import { randomUUID, timingSafeEqual } from "node:crypto";
 import { createServer, } from "node:http";
+import { parseCarrierAttentionViews, } from "./carrier-attention-view.js";
 export class BrowserRealityBridgeError extends Error {
     code;
     constructor(code, message) {
@@ -121,6 +122,8 @@ export async function createBrowserRealityBridgeServer(options) {
     let lastCommandConsumerAt = null;
     let closed = false;
     let endpoint = "";
+    let carrierAttentions = [];
+    let requestCommand = () => Promise.reject(new BrowserRealityBridgeError("BRIDGE_OFFLINE", "extension command consumer is not ready"));
     const taskBootstrap = new Map();
     const taskSessions = new Map();
     const taskCookie = "proflow_tasks_session";
@@ -162,7 +165,9 @@ export async function createBrowserRealityBridgeServer(options) {
     const server = createServer(async (request, response) => {
         try {
             const url = new URL(request.url ?? "/", "http://127.0.0.1");
-            if (options.taskWeb && request.method === "GET" && url.pathname.startsWith("/tasks/bootstrap/")) {
+            if (options.taskWeb &&
+                request.method === "GET" &&
+                url.pathname.startsWith("/tasks/bootstrap/")) {
                 pruneTaskWebState();
                 const bootstrap = decodeURIComponent(url.pathname.slice("/tasks/bootstrap/".length));
                 if (!taskBootstrap.has(bootstrap)) {
@@ -200,6 +205,7 @@ export async function createBrowserRealityBridgeServer(options) {
                             taskApplicationConfigured: true,
                             approvalApplicationConfigured: true,
                             systemObserver: null,
+                            carrierAttentions,
                             browserCarrier: {
                                 online: commandConsumerReady(),
                                 sessionOnline: sessionOnline(),
@@ -215,13 +221,41 @@ export async function createBrowserRealityBridgeServer(options) {
                     });
                     return;
                 }
-                if (request.method === "POST" && (url.pathname === "/tasks/api/task" || url.pathname === "/tasks/api/approval")) {
+                if (request.method === "POST" &&
+                    url.pathname === "/tasks/api/carrier-attention") {
                     if (request.headers.origin !== endpoint) {
                         send(response, 403, { error: "TASK_WEB_ORIGIN_INVALID" });
                         return;
                     }
                     const body = await readJson(request);
-                    if (!isRecord(body) || typeof body.operation !== "string" || !isRecord(body.input))
+                    if (!isRecord(body))
+                        throw new BrowserRealityBridgeError("BRIDGE_INPUT_INVALID", "carrier attention action must be an object");
+                    const attentionRef = stringField(body, "attentionRef");
+                    const action = body.action;
+                    if (action !== "allowOnce" && action !== "deny")
+                        throw new BrowserRealityBridgeError("BRIDGE_INPUT_INVALID", "carrier attention action is invalid");
+                    const attention = carrierAttentions.find((candidate) => candidate.attentionRef === attentionRef);
+                    if (!attention?.actions.includes(action))
+                        throw new BrowserRealityBridgeError("BRIDGE_INPUT_INVALID", "carrier attention reference is stale or denied");
+                    const value = await requestCommand({
+                        type: "CARRIER_ATTENTION_ACTION",
+                        attentionRef,
+                        action,
+                    });
+                    send(response, 200, { ok: true, value });
+                    return;
+                }
+                if (request.method === "POST" &&
+                    (url.pathname === "/tasks/api/task" ||
+                        url.pathname === "/tasks/api/approval")) {
+                    if (request.headers.origin !== endpoint) {
+                        send(response, 403, { error: "TASK_WEB_ORIGIN_INVALID" });
+                        return;
+                    }
+                    const body = await readJson(request);
+                    if (!isRecord(body) ||
+                        typeof body.operation !== "string" ||
+                        !isRecord(body.input))
                         throw new BrowserRealityBridgeError("BRIDGE_INPUT_INVALID", "task web request is invalid");
                     const value = url.pathname.endsWith("/task")
                         ? await options.taskWeb.invokeTask(body.operation, body.input)
@@ -242,11 +276,15 @@ export async function createBrowserRealityBridgeServer(options) {
                 return;
             }
             authenticate(request);
-            if (options.taskWeb && request.method === "POST" && url.pathname === "/v1/tasks/session") {
+            if (options.taskWeb &&
+                request.method === "POST" &&
+                url.pathname === "/v1/tasks/session") {
                 pruneTaskWebState();
                 const bootstrap = idFactory();
                 taskBootstrap.set(bootstrap, now().getTime() + taskBootstrapTtlMs);
-                send(response, 200, { url: `${endpoint}/tasks/bootstrap/${encodeURIComponent(bootstrap)}` });
+                send(response, 200, {
+                    url: `${endpoint}/tasks/bootstrap/${encodeURIComponent(bootstrap)}`,
+                });
                 return;
             }
             if (request.method === "POST" && url.pathname === "/v1/session/hello") {
@@ -289,6 +327,20 @@ export async function createBrowserRealityBridgeServer(options) {
                 send(response, 200, { accepted: true });
                 return;
             }
+            if (request.method === "POST" &&
+                url.pathname === "/v1/carrier/attentions") {
+                requireExtensionOrigin(request);
+                const body = await readJson(request);
+                if (!isRecord(body) || !Array.isArray(body.carrierAttentions))
+                    throw new BrowserRealityBridgeError("BRIDGE_INPUT_INVALID", "carrier attentions must be an array");
+                const parsed = parseCarrierAttentionViews(body.carrierAttentions);
+                if (body.carrierAttentions.length > 128 ||
+                    parsed.length !== body.carrierAttentions.length)
+                    throw new BrowserRealityBridgeError("BRIDGE_INPUT_INVALID", "carrier attentions contain invalid entries");
+                carrierAttentions = parsed;
+                send(response, 200, { accepted: true });
+                return;
+            }
             if (request.method === "GET" && url.pathname === "/v1/commands/next") {
                 const stamp = now();
                 session.lastHeartbeatAt = stamp.getTime();
@@ -349,7 +401,7 @@ export async function createBrowserRealityBridgeServer(options) {
     if (!address || typeof address === "string")
         throw new Error("bridge address missing");
     endpoint = `http://127.0.0.1:${address.port}`;
-    const requestCommand = (command) => {
+    requestCommand = (command) => {
         if (!online())
             return Promise.reject(new BrowserRealityBridgeError("BRIDGE_OFFLINE", "extension command consumer is not ready"));
         const commandId = `browser-command:${idFactory()}`;
@@ -435,6 +487,7 @@ export async function createBrowserRealityBridgeServer(options) {
         },
         async close() {
             closed = true;
+            carrierAttentions = [];
             for (const item of pending.values()) {
                 clearTimeout(item.timer);
                 item.reject(new BrowserRealityBridgeError("BRIDGE_OFFLINE", "bridge server closed"));

package/dist/src/carrier-attention-view.d.ts

@@ -0,0 +1,13 @@
+export type CarrierAttentionView = {
+    attentionRef: string;
+    occurrenceRef: string;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+    targetHost: string | null;
+    operationId: string;
+    reason: string;
+    actions: Array<"allowOnce" | "deny">;
+    observedAt: string;
+};
+export declare function parseCarrierAttentionViews(value: unknown): CarrierAttentionView[];

package/dist/src/carrier-attention-view.js

@@ -0,0 +1,54 @@
+function nullableString(value) {
+    return value === null || typeof value === "string";
+}
+function parseCarrierAttentionView(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const attentionRef = Reflect.get(value, "attentionRef");
+    const occurrenceRef = Reflect.get(value, "occurrenceRef");
+    const taskId = Reflect.get(value, "taskId");
+    const roleRef = Reflect.get(value, "roleRef");
+    const workerRef = Reflect.get(value, "workerRef");
+    const targetHost = Reflect.get(value, "targetHost");
+    const operationId = Reflect.get(value, "operationId");
+    const reason = Reflect.get(value, "reason");
+    const actions = Reflect.get(value, "actions");
+    const observedAt = Reflect.get(value, "observedAt");
+    if (typeof attentionRef !== "string" ||
+        attentionRef.length === 0 ||
+        typeof occurrenceRef !== "string" ||
+        occurrenceRef.length === 0 ||
+        !nullableString(taskId) ||
+        !nullableString(roleRef) ||
+        !nullableString(workerRef) ||
+        !nullableString(targetHost) ||
+        typeof operationId !== "string" ||
+        operationId.length === 0 ||
+        typeof reason !== "string" ||
+        reason.length === 0 ||
+        !Array.isArray(actions) ||
+        actions.some((action) => action !== "allowOnce" && action !== "deny") ||
+        typeof observedAt !== "string" ||
+        observedAt.length === 0)
+        return null;
+    return {
+        attentionRef,
+        occurrenceRef,
+        taskId,
+        roleRef,
+        workerRef,
+        targetHost,
+        operationId,
+        reason,
+        actions: [...actions],
+        observedAt,
+    };
+}
+export function parseCarrierAttentionViews(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value
+        .slice(0, 128)
+        .map(parseCarrierAttentionView)
+        .filter((item) => item !== null);
+}

package/dist/src/carrier-attention.d.ts

@@ -0,0 +1,26 @@
+export type CarrierAttentionAction = "allowOnce" | "deny";
+export type CarrierAttention = {
+    attentionRef: string;
+    occurrenceRef: string;
+    tabId: number;
+    contentInstanceId: string;
+    url: string;
+    permissionFingerprint: string;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+    targetHost: string | null;
+    operationId: string;
+    reason: string;
+    actions: CarrierAttentionAction[];
+    observedAt: string;
+};
+export type CarrierAttentionInput = Omit<CarrierAttention, "attentionRef" | "occurrenceRef">;
+export declare function createCarrierAttentionRegistry(idFactory?: () => string): Readonly<{
+    derive(input: CarrierAttentionInput): CarrierAttention;
+    find(attentionRef: string): CarrierAttention | null;
+    current(tabId: number): CarrierAttention | null;
+    values(): CarrierAttention[];
+    delete(attentionRef: string): boolean;
+    removeTab(tabId: number): boolean;
+}>;