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

package/dist/src/carrier-attention.js

@@ -0,0 +1,44 @@
+export function createCarrierAttentionRegistry(idFactory = () => crypto.randomUUID()) {
+    const byTab = new Map();
+    return Object.freeze({
+        derive(input) {
+            const current = byTab.get(input.tabId);
+            if (current?.contentInstanceId === input.contentInstanceId &&
+                current.url === input.url &&
+                current.permissionFingerprint === input.permissionFingerprint) {
+                const refreshed = { ...current, ...input };
+                byTab.set(input.tabId, refreshed);
+                return refreshed;
+            }
+            const occurrenceRef = idFactory();
+            const attention = {
+                ...input,
+                occurrenceRef,
+                attentionRef: `carrier-attention:${input.tabId}:${occurrenceRef}`,
+            };
+            byTab.set(input.tabId, attention);
+            return attention;
+        },
+        find(attentionRef) {
+            for (const attention of byTab.values())
+                if (attention.attentionRef === attentionRef)
+                    return attention;
+            return null;
+        },
+        current(tabId) {
+            return byTab.get(tabId) ?? null;
+        },
+        values() {
+            return [...byTab.values()];
+        },
+        delete(attentionRef) {
+            for (const [tabId, attention] of byTab)
+                if (attention.attentionRef === attentionRef)
+                    return byTab.delete(tabId);
+            return false;
+        },
+        removeTab(tabId) {
+            return byTab.delete(tabId);
+        },
+    });
+}

package/dist/src/carrier-continuation-control.d.ts

@@ -0,0 +1,44 @@
+export type CarrierContinuationDenial = {
+    attentionRef: string;
+    tabId: number;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+    url: string;
+    contentInstanceId: string;
+    permissionFingerprint: string;
+};
+export type CarrierRecoveryObservation = {
+    tabId: number;
+    url: string;
+    contentInstanceId?: string;
+    pageState: "IDLE" | "BUSY" | "BLOCKED" | "UNKNOWN";
+    blockerFacts?: {
+        fingerprint: string;
+    };
+};
+export type CarrierPermissionDenialContext = {
+    tabId: number;
+    contentInstanceId: string;
+    url: string;
+    permissionFingerprint: string;
+    taskId: string | null;
+    roleRef: string | null;
+    workerRef: string | null;
+};
+export type CarrierDispatchDenialContext = {
+    taskId: string;
+    roleRef: string;
+    workerRef: string;
+    conversationLocator: string | null;
+};
+export declare function createCarrierContinuationControl(initial?: unknown): Readonly<{
+    beginDenied(denial: CarrierContinuationDenial): void;
+    cancelDenied(attentionRef: string): boolean;
+    hasMatchingPermissionDenial(context: CarrierPermissionDenialContext): boolean;
+    hasMatchingDispatchDenial(context: CarrierDispatchDenialContext): boolean;
+    consumeRecovery(previous: CarrierRecoveryObservation | undefined, current: CarrierRecoveryObservation): CarrierContinuationDenial | null;
+    suppressRecovery(previous: CarrierRecoveryObservation | undefined, current: CarrierRecoveryObservation): boolean;
+    snapshot(): CarrierContinuationDenial[];
+    load: (value: unknown) => boolean;
+}>;

package/dist/src/carrier-continuation-control.js

@@ -0,0 +1,114 @@
+function parseDenials(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.length > 128)
+        return null;
+    const parsed = [];
+    for (const item of value) {
+        if (typeof item !== "object" || item === null || Array.isArray(item))
+            return null;
+        const attentionRef = Reflect.get(item, "attentionRef");
+        const tabId = Reflect.get(item, "tabId");
+        const taskId = Reflect.get(item, "taskId");
+        const roleRef = Reflect.get(item, "roleRef");
+        const workerRef = Reflect.get(item, "workerRef");
+        const url = Reflect.get(item, "url");
+        const contentInstanceId = Reflect.get(item, "contentInstanceId");
+        const permissionFingerprint = Reflect.get(item, "permissionFingerprint");
+        if (typeof attentionRef !== "string" ||
+            !Number.isInteger(tabId) ||
+            (taskId !== null && typeof taskId !== "string") ||
+            (roleRef !== null && typeof roleRef !== "string") ||
+            (workerRef !== null && typeof workerRef !== "string") ||
+            typeof url !== "string" ||
+            typeof contentInstanceId !== "string" ||
+            typeof permissionFingerprint !== "string")
+            return null;
+        parsed.push({
+            attentionRef,
+            tabId: tabId,
+            taskId,
+            roleRef,
+            workerRef,
+            url,
+            contentInstanceId,
+            permissionFingerprint,
+        });
+    }
+    return parsed;
+}
+export function createCarrierContinuationControl(initial) {
+    const byTab = new Map();
+    const load = (value) => {
+        const denials = parseDenials(value);
+        byTab.clear();
+        if (!denials)
+            return false;
+        for (const denial of denials)
+            byTab.set(denial.tabId, denial);
+        return true;
+    };
+    if (initial !== undefined)
+        load(initial);
+    return Object.freeze({
+        beginDenied(denial) {
+            byTab.set(denial.tabId, { ...denial });
+        },
+        cancelDenied(attentionRef) {
+            for (const [tabId, denial] of byTab)
+                if (denial.attentionRef === attentionRef)
+                    return byTab.delete(tabId);
+            return false;
+        },
+        hasMatchingPermissionDenial(context) {
+            const denial = byTab.get(context.tabId);
+            return (denial?.contentInstanceId === context.contentInstanceId &&
+                denial.url === context.url &&
+                denial.permissionFingerprint === context.permissionFingerprint &&
+                denial.taskId === context.taskId &&
+                denial.roleRef === context.roleRef &&
+                denial.workerRef === context.workerRef);
+        },
+        hasMatchingDispatchDenial(context) {
+            if (context.conversationLocator === null)
+                return false;
+            for (const denial of byTab.values())
+                if (denial.taskId === context.taskId &&
+                    denial.roleRef === context.roleRef &&
+                    denial.workerRef === context.workerRef &&
+                    denial.url === context.conversationLocator)
+                    return true;
+            return false;
+        },
+        consumeRecovery(previous, current) {
+            const denial = byTab.get(current.tabId);
+            if (!denial)
+                return null;
+            if (denial.url !== current.url ||
+                denial.contentInstanceId !== current.contentInstanceId) {
+                byTab.delete(current.tabId);
+                return null;
+            }
+            if (current.pageState !== "IDLE")
+                return null;
+            if (previous &&
+                (previous.tabId !== denial.tabId ||
+                    previous.url !== denial.url ||
+                    previous.contentInstanceId !== denial.contentInstanceId ||
+                    previous.pageState !== "BLOCKED" ||
+                    previous.blockerFacts?.fingerprint !== denial.permissionFingerprint)) {
+                byTab.delete(current.tabId);
+                return null;
+            }
+            byTab.delete(current.tabId);
+            return { ...denial };
+        },
+        suppressRecovery(previous, current) {
+            return this.consumeRecovery(previous, current) !== null;
+        },
+        snapshot() {
+            return [...byTab.values()].map((denial) => ({ ...denial }));
+        },
+        load,
+    });
+}

package/dist/src/carrier-permission-attempt.d.ts

@@ -0,0 +1,18 @@
+export type CarrierPermissionAttemptSnapshot = ReadonlyArray<{
+    tabId: number;
+    key: string;
+}>;
+/**
+ * Tracks only automatic actions whose post-click reality is not yet known.
+ * A confirmed release removes the entry, so a later identical permission is a
+ * new occurrence; an MV3 service-worker restart reloads the bounded snapshot
+ * and therefore cannot blindly repeat an uncertain click.
+ */
+export declare function createCarrierPermissionAttemptRegistry(initial?: unknown): Readonly<{
+    has(tabId: number, key: string): boolean;
+    begin(tabId: number, key: string): void;
+    release(tabId: number, key: string): boolean;
+    observe(tabId: number, currentKey: string | null): boolean;
+    load(value: unknown): boolean;
+    snapshot(): CarrierPermissionAttemptSnapshot;
+}>;

package/dist/src/carrier-permission-attempt.js

@@ -0,0 +1,68 @@
+function parsedAttempts(value) {
+    const result = new Map();
+    if (value === undefined)
+        return { attempts: result, valid: true };
+    if (!Array.isArray(value))
+        return { attempts: result, valid: false };
+    let valid = value.length <= 256;
+    for (const candidate of value.slice(0, 256)) {
+        if (typeof candidate !== "object" ||
+            candidate === null ||
+            Array.isArray(candidate)) {
+            valid = false;
+            continue;
+        }
+        const tabId = Reflect.get(candidate, "tabId");
+        const key = Reflect.get(candidate, "key");
+        if (!Number.isInteger(tabId) ||
+            tabId < 0 ||
+            typeof key !== "string" ||
+            key.length === 0 ||
+            key.length > 1_000) {
+            valid = false;
+            continue;
+        }
+        if (result.has(tabId))
+            valid = false;
+        result.set(tabId, key);
+    }
+    return { attempts: result, valid };
+}
+/**
+ * Tracks only automatic actions whose post-click reality is not yet known.
+ * A confirmed release removes the entry, so a later identical permission is a
+ * new occurrence; an MV3 service-worker restart reloads the bounded snapshot
+ * and therefore cannot blindly repeat an uncertain click.
+ */
+export function createCarrierPermissionAttemptRegistry(initial) {
+    const attempts = parsedAttempts(initial).attempts;
+    return Object.freeze({
+        has(tabId, key) {
+            return attempts.get(tabId) === key;
+        },
+        begin(tabId, key) {
+            attempts.set(tabId, key);
+        },
+        release(tabId, key) {
+            if (attempts.get(tabId) !== key)
+                return false;
+            return attempts.delete(tabId);
+        },
+        observe(tabId, currentKey) {
+            const attempted = attempts.get(tabId);
+            if (attempted === undefined || attempted === currentKey)
+                return false;
+            return attempts.delete(tabId);
+        },
+        load(value) {
+            const parsed = parsedAttempts(value);
+            attempts.clear();
+            for (const [tabId, key] of parsed.attempts)
+                attempts.set(tabId, key);
+            return parsed.valid;
+        },
+        snapshot() {
+            return [...attempts].map(([tabId, key]) => ({ tabId, key }));
+        },
+    });
+}

package/dist/src/carrier-permission-lifecycle.d.ts

@@ -0,0 +1,34 @@
+import type { ActionPermissionFacts, PermissionSemanticAction } from "./carrier-permission.ts";
+export type CarrierPermissionDecision = {
+    decision: "AUTO_ALLOW" | "DEFER" | "HUMAN_REQUIRED";
+    reason: string;
+};
+export type CarrierPermissionLifecycleResult = {
+    status: "RELEASED";
+    action: "allowAlways";
+} | {
+    status: "HUMAN_REQUIRED";
+    reason: string;
+} | {
+    status: "STALE";
+};
+export type CarrierPermissionLifecyclePort = {
+    classify(): Promise<CarrierPermissionDecision>;
+    revalidate(): boolean | Promise<boolean>;
+    waitBeforeReclassify?(): Promise<void>;
+    act(action: PermissionSemanticAction): Promise<void>;
+    released(): Promise<boolean>;
+};
+export declare function resolveRoutineCarrierPermission(input: {
+    facts: ActionPermissionFacts;
+    autoAlreadyAttempted: boolean;
+    maxClassifications?: number;
+    humanDenied?: () => boolean;
+    port: CarrierPermissionLifecyclePort;
+}): Promise<CarrierPermissionLifecycleResult>;
+export declare function resolveHumanCarrierPermission(input: {
+    action: "allowOnce" | "deny";
+    revalidate(): boolean | Promise<boolean>;
+    act(action: "allowOnce" | "deny"): Promise<void>;
+    released(): Promise<boolean>;
+}): Promise<"RELEASED">;

package/dist/src/carrier-permission-lifecycle.js

@@ -0,0 +1,73 @@
+export async function resolveRoutineCarrierPermission(input) {
+    const denied = () => input.humanDenied?.()
+        ? { status: "HUMAN_REQUIRED", reason: "HUMAN_DENIED" }
+        : null;
+    const maxClassifications = Math.max(1, input.maxClassifications ?? 40);
+    let decision = null;
+    for (let attempt = 0; attempt < maxClassifications; attempt += 1) {
+        const beforeClassification = denied();
+        if (beforeClassification)
+            return beforeClassification;
+        try {
+            decision = await input.port.classify();
+        }
+        catch {
+            return {
+                status: "HUMAN_REQUIRED",
+                reason: "PERMISSION_CLASSIFICATION_FAILED",
+            };
+        }
+        const afterClassification = denied();
+        if (afterClassification)
+            return afterClassification;
+        if (decision.decision !== "DEFER")
+            break;
+        if (!(await input.port.revalidate()))
+            return { status: "STALE" };
+        if (attempt === maxClassifications - 1)
+            return {
+                status: "HUMAN_REQUIRED",
+                reason: "PERMISSION_CONTEXT_DEFER_TIMEOUT",
+            };
+        await input.port.waitBeforeReclassify?.();
+    }
+    if (!decision)
+        return {
+            status: "HUMAN_REQUIRED",
+            reason: "PERMISSION_CLASSIFICATION_FAILED",
+        };
+    if (decision.decision !== "AUTO_ALLOW")
+        return { status: "HUMAN_REQUIRED", reason: decision.reason };
+    if (!input.facts.actions.includes("allowAlways"))
+        return {
+            status: "HUMAN_REQUIRED",
+            reason: "AUTO_ALLOW_ACTION_UNAVAILABLE",
+        };
+    if (input.autoAlreadyAttempted)
+        return {
+            status: "HUMAN_REQUIRED",
+            reason: "AUTO_ALLOW_REALITY_UNCONFIRMED",
+        };
+    if (!(await input.port.revalidate()))
+        return { status: "STALE" };
+    const beforeAction = denied();
+    if (beforeAction)
+        return beforeAction;
+    try {
+        await input.port.act("allowAlways");
+    }
+    catch {
+        return { status: "HUMAN_REQUIRED", reason: "AUTO_ALLOW_FAILED" };
+    }
+    return (await input.port.released())
+        ? { status: "RELEASED", action: "allowAlways" }
+        : { status: "HUMAN_REQUIRED", reason: "AUTO_ALLOW_REALITY_UNCONFIRMED" };
+}
+export async function resolveHumanCarrierPermission(input) {
+    if (!(await input.revalidate()))
+        throw new Error("STALE_PERMISSION");
+    await input.act(input.action);
+    if (!(await input.released()))
+        throw new Error("PERMISSION_ACTION_REALITY_UNCONFIRMED");
+    return "RELEASED";
+}

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

@@ -0,0 +1,16 @@
+export type PermissionSemanticAction = "allowAlways" | "allowOnce" | "deny";
+export type ActionPermissionCandidate = {
+    text: string;
+    buttonLabels: readonly string[];
+};
+export type ActionPermissionFacts = {
+    kind: "ACTION_PERMISSION";
+    targetHost: string | null;
+    operationId: string;
+    taskId: string | null;
+    actions: PermissionSemanticAction[];
+    fingerprint: string;
+};
+export declare function permissionSemanticAction(label: string): PermissionSemanticAction | null;
+export declare function detectActionPermission(candidates: readonly ActionPermissionCandidate[]): ActionPermissionFacts | null;
+export declare function permissionActionAllowed(facts: ActionPermissionFacts, expectedFingerprint: string, action: string): action is PermissionSemanticAction;

package/dist/src/carrier-permission.js

@@ -0,0 +1,65 @@
+const actionLabels = [
+    [/^(始终允许|always allow)$/i, "allowAlways"],
+    [/^(允许一次|allow once)$/i, "allowOnce"],
+    [/^(拒绝|deny)$/i, "deny"],
+];
+export 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, 4_096);
+}
+function hashFingerprint(value) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < value.length; index += 1) {
+        hash ^= value.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    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;
+}
+export 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;
+}
+export function permissionActionAllowed(facts, expectedFingerprint, action) {
+    return (facts.fingerprint === expectedFingerprint &&
+        facts.actions.includes(action));
+}

package/dist/src/chatgpt-runtime-adapter.d.ts

@@ -0,0 +1,16 @@
+import { type ActionPermissionFacts, type PermissionSemanticAction } from "./carrier-permission.ts";
+export type ChatGptPageReality = {
+    pageState: "IDLE" | "BUSY" | "BLOCKED" | "UNKNOWN";
+    activityKind: "GENERATING" | "ACTION_PERMISSION" | "ACTION_RUNNING" | "WAITING_HUMAN" | null;
+    blockerFacts?: ActionPermissionFacts;
+};
+export declare function classifyChatGptPageSignals(input: {
+    permission: ActionPermissionFacts | null;
+    hasDialog: boolean;
+    isGenerating: boolean;
+    hasComposer: boolean;
+}): ChatGptPageReality;
+export declare function observeChatGptPage(document: Document): ChatGptPageReality;
+export declare function performChatGptPermissionAction(document: Document, expectedFingerprint: string, action: PermissionSemanticAction): ActionPermissionFacts;
+export declare function submitChatGptComposer(document: Document, value: string): Promise<void>;
+export declare function writeChatGptInput(document: Document, selector: string, value: string): void;

package/dist/src/chatgpt-runtime-adapter.js

@@ -0,0 +1,173 @@
+import { detectActionPermission, permissionActionAllowed, permissionSemanticAction, } from "./carrier-permission.js";
+import { submitControlledComposer } from "./composer-submit.js";
+export 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 };
+}
+const composerSelector = '#prompt-textarea, textarea, [contenteditable="true"]';
+const sendSelector = 'button[data-testid="send-button"], button[aria-label*="Send"], button[aria-label*="发送"]';
+function buttonLabel(button) {
+    return (button.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+function actionPermissionDom(document) {
+    const view = document.defaultView;
+    if (!view)
+        return null;
+    const semanticButtons = [...document.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 = 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;
+}
+export function observeChatGptPage(document) {
+    const permission = actionPermissionDom(document);
+    return classifyChatGptPageSignals({
+        permission: permission?.facts ?? null,
+        hasDialog: document.querySelector('[role="dialog"]') !== null,
+        isGenerating: document.querySelector('[data-testid="stop-button"], button[aria-label*="Stop"], button[aria-label*="停止"]') !== null,
+        hasComposer: document.querySelector(composerSelector) !== null,
+    });
+}
+export function performChatGptPermissionAction(document, expectedFingerprint, action) {
+    const permission = actionPermissionDom(document);
+    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(document) {
+    const view = document.defaultView;
+    const element = document.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(document) {
+    const view = document.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(document) {
+    const view = document.defaultView;
+    const element = document.querySelector(sendSelector);
+    return view && element instanceof view.HTMLButtonElement ? element : null;
+}
+export async function submitChatGptComposer(document, value) {
+    const composer = composerElement(document);
+    composer.focus();
+    await submitControlledComposer({
+        write: (next) => nativeWrite(composer, next),
+        dispatchInput: (next) => dispatchComposerInput(composer, next),
+        readValue: () => readElementValue(composer),
+        submitReady: () => {
+            const button = sendButton(document);
+            return Boolean(button &&
+                !button.disabled &&
+                button.getAttribute("aria-disabled") !== "true");
+        },
+        nextFrame: () => nextComposerFrame(document),
+        clickSubmit: () => {
+            const button = sendButton(document);
+            if (!button ||
+                button.disabled ||
+                button.getAttribute("aria-disabled") === "true")
+                throw new Error("COMPOSER_SUBMIT_NOT_READY");
+            button.click();
+        },
+    }, value);
+}
+export function writeChatGptInput(document, selector, value) {
+    if (!selector || selector.length > 512)
+        throw new Error("SELECTOR_INVALID");
+    const view = document.defaultView;
+    const element = document.querySelector(selector);
+    if (!view || !(element instanceof view.HTMLElement))
+        throw new Error("ELEMENT_NOT_FOUND");
+    element.focus();
+    nativeWrite(element, value);
+    dispatchComposerInput(element, value);
+}