@steipete/oracle 0.18.0 → 0.20.0

package/dist/src/browser/actions/attachmentContext.js

@@ -0,0 +1,239 @@
+import { withoutBrowserCancellation } from "../cancellation.js";
+import { randomUUID } from "node:crypto";
+import { BrowserAutomationError } from "../../oracle/errors.js";
+import { conversationIdFromUrl } from "./navigation.js";
+export async function captureComposerNavigationUrl(runtime) {
+    const result = await runtime.evaluate({
+        expression: "location.href",
+        returnByValue: true,
+    });
+    const url = result?.result?.value;
+    if (typeof url !== "string" || !url) {
+        throw new BrowserAutomationError("Oracle could not capture ChatGPT's page identity before attachment upload.", {
+            stage: "upload-attachment",
+            code: "attachment-navigation-identity-unavailable",
+        });
+    }
+    return url;
+}
+export async function assertComposerPlusStayedInPlace(runtime, startUrl) {
+    const result = await runtime.evaluate({
+        expression: buildComposerNavigationProbeExpression(),
+        returnByValue: true,
+    });
+    assertComposerNavigationSnapshot(startUrl, result?.result?.value);
+}
+export function buildComposerNavigationProbeExpression() {
+    return `(() => {
+      const normalize = value => String(value || '').replace(/\\s+/g, ' ').trim().toLowerCase();
+      const isWorkLabel = value => ['work', '工作'].includes(normalize(value));
+      const controlLabel = node => normalize(node.textContent || node.getAttribute('aria-label'));
+      const modeValue = node => normalize(node.getAttribute('data-mode') || node.getAttribute('data-value') || node.getAttribute('value'));
+      const visible = node => {
+        if (node.closest?.('[data-message-author-role], [data-testid^="conversation-turn-"], article[data-turn]')) return false;
+        const rect = node.getBoundingClientRect();
+        if (rect.width <= 0 || rect.height <= 0) return false;
+        for (let current = node; current && typeof current.getBoundingClientRect === 'function'; current = current.parentElement) {
+          const style = window.getComputedStyle(current);
+          if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0' || current.getAttribute?.('aria-hidden') === 'true') return false;
+        }
+        return true;
+      };
+      const selected = node =>
+        node?.getAttribute?.('aria-checked') === 'true' ||
+        node?.getAttribute?.('aria-selected') === 'true' ||
+        node?.getAttribute?.('aria-pressed') === 'true' ||
+        node?.getAttribute?.('data-state') === 'on' ||
+        node?.getAttribute?.('data-state') === 'active';
+      const prompt = document.querySelector('#prompt-textarea');
+      const fallbackPrompt = document.querySelector('textarea[name="prompt-textarea"]');
+      const composer = (prompt ?? fallbackPrompt)?.closest('form, [data-testid="composer"]');
+      const selectedControls = Array.from(
+        document.querySelectorAll('[aria-checked="true"],[aria-selected="true"],[aria-pressed="true"],[data-state="on"],[data-state="active"]'),
+      ).filter(visible).filter(selected);
+      const workToggleSelected = selectedControls.some(node => modeValue(node) === 'work' ||
+        composer?.contains(node) && node.matches('button[role="radio"],button[role="tab"],button[aria-pressed]') && isWorkLabel(controlLabel(node)));
+      // Labels outside the composer may name unrelated sidebar items or tabs.
+      const placeholder = normalize(
+        prompt?.getAttribute?.('data-placeholder') ||
+        prompt?.getAttribute?.('placeholder') ||
+        fallbackPrompt?.getAttribute?.('placeholder'),
+      );
+      return {
+        currentUrl: location.href,
+        workSelected: /(?:^|\\/)c\\/WEB(?::|%3a)/i.test(location.pathname) || workToggleSelected || placeholder === 'work on anything',
+        modeUnverified: false,
+      };
+    })()`;
+}
+export function assertComposerNavigationSnapshot(startUrl, snapshot) {
+    const value = snapshot;
+    const currentUrl = typeof value?.currentUrl === "string" ? value.currentUrl : "";
+    const startIdentity = composerNavigationIdentityFromUrl(startUrl);
+    const currentIdentity = composerNavigationIdentityFromUrl(currentUrl);
+    const unexpectedNavigation = !startIdentity ||
+        !currentIdentity ||
+        startIdentity.origin !== currentIdentity.origin ||
+        (startIdentity.conversationId !== null
+            ? currentIdentity.conversationId !== startIdentity.conversationId
+            : currentIdentity.conversationId !== null ||
+                currentIdentity.landingPath !== startIdentity.landingPath);
+    const workConversation = currentIdentity?.conversationId && /^WEB(?::|%3a)/i.test(currentIdentity.conversationId);
+    if (value?.workSelected || workConversation || unexpectedNavigation) {
+        throw new BrowserAutomationError("ChatGPT navigated to Work or another ChatGPT context during attachment preparation; upload/send was stopped before prompt submission.", {
+            stage: "upload-attachment",
+            code: "attachment-control-unexpected-navigation",
+            startUrl,
+            currentUrl,
+            workSelected: Boolean(value?.workSelected),
+            startNavigationIdentity: startIdentity,
+            currentNavigationIdentity: currentIdentity,
+        });
+    }
+    if (value?.modeUnverified) {
+        throw new BrowserAutomationError("ChatGPT mode could not be verified; attachment upload/send was stopped.", {
+            stage: "upload-attachment",
+            code: "attachment-control-mode-unverified",
+            startUrl,
+            currentUrl,
+        });
+    }
+}
+export function composerNavigationIdentityFromUrl(value) {
+    try {
+        const url = new URL(value);
+        const conversationId = conversationIdFromUrl(url.href);
+        return {
+            origin: url.origin.toLowerCase(),
+            conversationId,
+            landingPath: conversationId === null ? url.pathname.replace(/\/+$/, "") || "/" : null,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function buildComposerNavigationValidationExpression(startUrl) {
+    const expected = composerNavigationIdentityFromUrl(startUrl);
+    return `(() => {
+    const snapshot = ${buildComposerNavigationProbeExpression()};
+    const expected = ${JSON.stringify(expected)};
+    let contextMatches = false;
+    try {
+      const current = new URL(snapshot.currentUrl);
+      const id = current.pathname.match(/(?:^|\\/)c\\/([^/]+)/)?.[1] ?? null;
+      contextMatches = Boolean(expected) && !snapshot.workSelected && !snapshot.modeUnverified &&
+        current.origin.toLowerCase() === expected.origin &&
+        (expected.conversationId !== null ? id === expected.conversationId :
+          id === null && (current.pathname.replace(/\\/+$/, '') || '/') === expected.landingPath);
+    } catch {}
+    return { ...snapshot, contextMatches };
+  })()`;
+}
+/** Guards native file-selection events before application handlers can upload the bytes. */
+export function buildFileInputGuardExpression(inputExpression, startUrl) {
+    return `(() => {
+    const guardedInput = ${inputExpression};
+    let blocked = null;
+    let listening = false;
+    const cleanup = () => {
+      if (!listening) return;
+      window.removeEventListener('input', onEvent, true);
+      window.removeEventListener('change', onEvent, true);
+      listening = false;
+    };
+    const validate = (rollback = false) => {
+      try {
+        const snapshot = ${buildComposerNavigationValidationExpression(startUrl)};
+        if (!snapshot.contextMatches) blocked = snapshot;
+      } catch { blocked = { currentUrl: location.href, modeUnverified: true }; }
+      if (blocked && rollback && guardedInput) { try { guardedInput.value = ''; } catch {} }
+      return !blocked;
+    };
+    const onEvent = event => {
+      if (event.target !== guardedInput) return;
+      if (!validate(true)) { event.preventDefault(); event.stopImmediatePropagation(); }
+      if (event.type === 'change') cleanup();
+    };
+    if (validate()) {
+      window.addEventListener('input', onEvent, true);
+      window.addEventListener('change', onEvent, true);
+      listening = true;
+    }
+    return { get blocked() { return blocked; }, validate, cleanup };
+  })()`;
+}
+export async function withGuardedFileInput(runtime, selector, startUrl, assign) {
+    const id = randomUUID();
+    let result;
+    try {
+        const prepared = await runtime.evaluate({
+            expression: `(() => {
+    const input = document.querySelector(${JSON.stringify(selector)});
+    if (!(input instanceof HTMLInputElement) || input.type !== 'file') return { installed: false };
+    const guard = ${buildFileInputGuardExpression("input", startUrl)};
+    if (guard.blocked) { guard.cleanup(); return { blocked: guard.blocked }; }
+    const guards = window.__oracleAttachmentInputGuards ??= Object.create(null);
+    guards[${JSON.stringify(id)}] = guard;
+    return { installed: true };
+  })()`,
+            returnByValue: true,
+        });
+        const preparation = prepared.result?.value;
+        if (preparation?.blocked)
+            assertComposerNavigationSnapshot(startUrl, preparation.blocked);
+        if (!preparation?.installed)
+            throw new BrowserAutomationError("Attachment input changed before assignment.", {
+                stage: "upload-attachment",
+                code: "attachment-input-unavailable",
+            });
+        await assign();
+    }
+    finally {
+        const observed = await withoutBrowserCancellation(() => runtime
+            .evaluate({
+            expression: `(() => {
+      const guards = window.__oracleAttachmentInputGuards;
+      const guard = guards?.[${JSON.stringify(id)}];
+      if (!guard) return null;
+      guard.validate(true);
+      const summary = { blocked: guard.blocked };
+      guard.cleanup(); delete guards[${JSON.stringify(id)}]; return summary;
+    })()`,
+            returnByValue: true,
+        })
+            .catch(() => undefined));
+        result = observed?.result?.value;
+    }
+    if (!result)
+        throw new BrowserAutomationError("Attachment assignment could not be verified; do not retry automatically.", { stage: "upload-attachment", code: "attachment-assignment-ambiguous" });
+    if (result.blocked)
+        assertComposerNavigationSnapshot(startUrl, result.blocked);
+}
+async function mutateGuardedFileInput(runtime, selector, startUrl, events) {
+    const observed = await runtime.evaluate({
+        expression: `(() => {
+    const input = document.querySelector(${JSON.stringify(selector)});
+    if (!(input instanceof HTMLInputElement)) return { missing: true };
+    const guard = ${buildFileInputGuardExpression("input", startUrl)};
+    try {
+      if (!guard.blocked) {
+        ${events ? "input.dispatchEvent(new Event('input', { bubbles: true })); if (guard.validate()) input.dispatchEvent(new Event('change', { bubbles: true }));" : "input.value = '';"}
+        guard.validate(true);
+      }
+      return { blocked: guard.blocked };
+    } finally { guard.cleanup(); }
+  })()`,
+        returnByValue: true,
+    });
+    const value = observed.result?.value;
+    if (value?.blocked)
+        assertComposerNavigationSnapshot(startUrl, value.blocked);
+    if (!value || value.missing || observed.exceptionDetails)
+        throw new BrowserAutomationError("Attachment input changed during preparation.", {
+            stage: "upload-attachment",
+            code: "attachment-input-unavailable",
+        });
+}
+export const dispatchGuardedFileInputEvents = (runtime, selector, startUrl) => mutateGuardedFileInput(runtime, selector, startUrl, true);
+export const clearGuardedFileInput = (runtime, selector, startUrl) => mutateGuardedFileInput(runtime, selector, startUrl, false);

package/dist/src/browser/actions/attachmentDataTransfer.js

@@ -1,7 +1,8 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { assertComposerNavigationSnapshot, buildFileInputGuardExpression, } from "./attachmentContext.js";
 const MAX_DATA_TRANSFER_BYTES = 20 * 1024 * 1024;
-export async function transferAttachmentViaDataTransfer(runtime, attachment, selector) {
+export async function transferAttachmentViaDataTransfer(runtime, attachment, selector, navigationUrl) {
     const fileContent = await readFile(attachment.path);
     if (fileContent.length > MAX_DATA_TRANSFER_BYTES) {
         throw new Error(`Attachment ${path.basename(attachment.path)} is too large for data transfer (${fileContent.length} bytes). Maximum size is ${MAX_DATA_TRANSFER_BYTES} bytes.`);
@@ -22,6 +23,16 @@ export async function transferAttachmentViaDataTransfer(runtime, attachment, sel
       return { success: false, error: 'Found element is not a file input' };
     }
 
+    const guard = ${navigationUrl ? buildFileInputGuardExpression("fileInput", navigationUrl) : "null"};
+    if (guard?.blocked) { guard.cleanup(); return { success: false, navigationBlocked: guard.blocked }; }
+    let syntheticFiles = false;
+    const navigationFailure = () => {
+      if (syntheticFiles) delete fileInput.files;
+      fileInput.value = '';
+      return { success: false, navigationBlocked: guard.blocked };
+    };
+    try {
+
     const base64Data = ${JSON.stringify(base64Content)};
     const binaryString = atob(base64Data);
     const bytes = new Uint8Array(binaryString.length);
@@ -55,6 +66,7 @@ export async function transferAttachmentViaDataTransfer(runtime, attachment, sel
           configurable: true,
           get: () => dataTransfer.files,
         });
+        syntheticFiles = true;
         assigned = true;
       } catch {
         assigned = false;
@@ -72,8 +84,11 @@ export async function transferAttachmentViaDataTransfer(runtime, attachment, sel
       return { success: false, error: 'Unable to assign FileList to input' };
     }
 
+    if (guard && !guard.validate(true)) return navigationFailure();
     fileInput.dispatchEvent(new Event('change', { bubbles: true }));
+    if (guard && !guard.validate(true)) return navigationFailure();
     return { success: true, fileName: file.name, size: file.size };
+    } finally { guard?.cleanup(); }
   })()`;
     const evalResult = await runtime.evaluate({ expression, returnByValue: true });
     if (evalResult.exceptionDetails) {
@@ -86,6 +101,9 @@ export async function transferAttachmentViaDataTransfer(runtime, attachment, sel
         throw new Error("Failed to transfer file to browser: unexpected evaluation result");
     }
     const uploadResult = evalResult.result.value;
+    if (uploadResult.navigationBlocked && navigationUrl) {
+        assertComposerNavigationSnapshot(navigationUrl, uploadResult.navigationBlocked);
+    }
     if (!uploadResult.success) {
         throw new Error(`Failed to transfer file to browser: ${uploadResult.error || "Unknown error"}`);
     }

package/dist/src/browser/actions/attachmentEvidence.js

@@ -0,0 +1,78 @@
+import { randomUUID } from "node:crypto";
+import { INPUT_SELECTORS, SEND_BUTTON_SELECTORS } from "../constants.js";
+// Receipts live in the renderer: retaining the actual removal control, rather than
+// its label/count, lets every stage reject removed, replaced, or sent attachments.
+export function buildAttachmentEvidenceExpression(names, action = "read", id) {
+    return `(() => {
+    const names = ${JSON.stringify(names)}.map(name => String(name).toLowerCase().replace(/\\s+/g, ' ').trim());
+    const action = ${JSON.stringify(action)};
+    const id = ${JSON.stringify(id ?? "")};
+    const key = '__oracleAttachmentEvidence';
+    if (action === 'clear') { delete globalThis[key]; return true; }
+    const empty = names.map(() => false);
+    if (action === 'read' && !globalThis[key]) return empty;
+    const receipts = globalThis[key] ??= new Map();
+    const visible = node => node instanceof HTMLElement && node.getBoundingClientRect().width > 0 && node.getBoundingClientRect().height > 0;
+    const sendSelectors = ${JSON.stringify(SEND_BUTTON_SELECTORS)};
+    const prompt = ${JSON.stringify(INPUT_SELECTORS)}.flatMap(selector => Array.from(document.querySelectorAll(selector))).find(visible);
+    const send = sendSelectors.map(selector => document.querySelector(selector)).find(visible);
+    let composer = null;
+    let fallback = null;
+    for (let node = (prompt ?? send)?.parentElement; node && node !== document.body && node !== document.documentElement; node = node.parentElement) {
+      if (!sendSelectors.some(selector => node.querySelector(selector))) continue;
+      fallback ??= node;
+      if (node.querySelector('input[type="file"],[data-testid*="attachment"],[aria-label*="Remove" i]')) {
+        composer = node;
+        break;
+      }
+    }
+    composer ??= fallback;
+    if (!composer) return action === 'read' ? empty : false;
+    const controls = () => Array.from(composer.querySelectorAll('[aria-label*="Remove" i]')).filter(node => {
+      if (!visible(node) || node.closest('textarea,[contenteditable="true"]')) return false;
+      const label = (node.getAttribute('aria-label') ?? '').toLowerCase();
+      return /^remove (?:file|attachment|image|photo)(?: |$)/.test(label) || Boolean(node.closest('[data-testid*="chip"],[data-testid*="attachment"],[data-testid*="upload"]'));
+    });
+    const currentControls = controls();
+    const valid = receipt => receipt.composer === composer && receipt.control?.isConnected && currentControls.includes(receipt.control) && receipt.control.getAttribute('aria-label') === receipt.label;
+    for (const [receiptId, receipt] of receipts) {
+      if (receipt.composer !== composer || (receipt.control && !valid(receipt))) receipts.delete(receiptId);
+    }
+    if (action === 'begin') {
+      for (const [receiptId, receipt] of receipts) {
+        if (receipt.name === names[0]) receipts.delete(receiptId);
+      }
+      receipts.set(id, { name: names[0], composer, before: new Set(currentControls) });
+      return true;
+    }
+    if (action === 'confirm') {
+      const receipt = receipts.get(id);
+      if (!receipt || receipt.composer !== composer) return false;
+      if (valid(receipt)) return true;
+      const claimed = new Set(Array.from(receipts.values()).map(entry => entry.control).filter(Boolean));
+      const added = currentControls.filter(control => !receipt.before.has(control) && !claimed.has(control));
+      // Ambiguous additions cannot identify which file was accepted.
+      if (added.length !== 1) return false;
+      receipt.control = added[0];
+      receipt.label = added[0].getAttribute('aria-label');
+      receipt.before.clear();
+      return true;
+    }
+    return names.map(name => Array.from(receipts.values()).some(receipt => receipt.name === name && valid(receipt)));
+  })()`;
+}
+export async function beginAttachmentEvidence(runtime, name) {
+    const id = randomUUID();
+    await runtime.evaluate({
+        expression: buildAttachmentEvidenceExpression([name], "begin", id),
+        returnByValue: true,
+    });
+    return id;
+}
+export async function confirmAttachmentEvidence(runtime, id) {
+    const result = await runtime.evaluate({
+        expression: buildAttachmentEvidenceExpression([], "confirm", id),
+        returnByValue: true,
+    });
+    return result.result?.value === true;
+}

package/dist/src/browser/actions/attachmentProgress.js

@@ -0,0 +1,41 @@
+// Use the same composer-scoped signal at completion and immediately before send.
+export function buildAttachmentProgressExpression(composerExpression) {
+    return String.raw `(() => {
+    const root = ${composerExpression};
+    if (!root || root === document || root === document.body) return false;
+    // Text can name a file or describe a completed operation; only explicit state blocks sending.
+    const selectors = ['[data-state="loading"]', '[data-state="uploading"]', '[data-state="pending"]', '[aria-busy="true"]', '[role~="progressbar"]', 'progress'];
+    const candidates = new Set(selectors.flatMap(selector => Array.from(root.querySelectorAll(selector))));
+    if (selectors.some(selector => root.matches?.(selector))) candidates.add(root);
+    return Array.from(candidates).some(node => {
+      if (typeof node.getBoundingClientRect !== 'function') return false;
+      // Non-editable widgets inside rich-text editors own their upload controls.
+      const boundary = node.closest('textarea,[contenteditable=""],[contenteditable="true" i],[contenteditable="plaintext-only" i],[contenteditable="false" i]');
+      const editor = boundary?.matches('[contenteditable="false" i]') ? null : boundary;
+      if (editor && editor !== node) return false;
+      const state = node.getAttribute('data-state');
+      const pending = node.getAttribute('aria-busy') === 'true' || ['loading', 'uploading', 'pending'].includes(state);
+      // File inputs and backing editors may be hidden behind the visible composer.
+      if (pending && (node.matches('input[type="file"]') || editor === node)) return true;
+      const rect = node.getBoundingClientRect();
+      if (rect.width <= 0 || rect.height <= 0) return false;
+      for (let ancestor = node; ancestor && typeof ancestor.getBoundingClientRect === 'function'; ancestor = ancestor.parentElement) {
+        const style = typeof window === 'undefined' ? {} : window.getComputedStyle(ancestor);
+        if (style.display === 'none' || style.visibility === 'hidden' || Number.parseFloat(style.opacity) === 0) return false;
+        const clip = style.clip?.match(/^rect\((.*)\)$/)?.[1].split(/[,\s]+/).filter(Boolean).map(Number.parseFloat);
+        if (clip?.length === 4 && clip.every(Number.isFinite) && (clip[2] <= clip[0] || clip[1] <= clip[3])) return false;
+        if (style.clipPath === 'inset(50%)') return false;
+      }
+      if (pending) return true;
+      const nativeProgress = node.matches('progress');
+      if (nativeProgress || node.matches('[role~="progressbar"]')) {
+        const current = nativeProgress
+          ? (node.hasAttribute('value') ? node.value : NaN)
+          : Number.parseFloat(node.getAttribute('aria-valuenow'));
+        const maximum = nativeProgress ? node.max : Number.parseFloat(node.getAttribute('aria-valuemax') ?? '100');
+        return !Number.isFinite(current) || !Number.isFinite(maximum) || current < maximum;
+      }
+      return false;
+    });
+  })()`;
+}

package/dist/src/browser/actions/attachmentPrompt.js

@@ -0,0 +1,130 @@
+import { withoutBrowserCancellation } from "../cancellation.js";
+import { randomUUID } from "node:crypto";
+import { INPUT_SELECTORS } from "../constants.js";
+import { delay } from "../utils.js";
+import { BrowserAutomationError } from "../../oracle/errors.js";
+import { assertComposerNavigationSnapshot, buildComposerNavigationValidationExpression, } from "./attachmentContext.js";
+import { buildClickDispatcher } from "./domEvents.js";
+/** Bind editing commands and fallback writes to the original renderer and editor. */
+export async function stageAttachmentPrompt(runtime, prompt, navigationUrl) {
+    const id = randomUUID();
+    const requireSafe = (value) => {
+        if (value?.blocked)
+            assertComposerNavigationSnapshot(navigationUrl, value.blocked);
+        if (!value?.ready || value.blocked) {
+            throw new BrowserAutomationError("Attachment prompt focus or context changed; staging was stopped.", {
+                stage: "submit-prompt",
+                code: "attachment-prompt-not-ready",
+            });
+        }
+    };
+    try {
+        const prepared = await runtime.evaluate({
+            expression: `(() => {
+        ${buildClickDispatcher()}
+        const selectors = ${JSON.stringify(INPUT_SELECTORS)};
+        const visible = node => { const r = node?.getBoundingClientRect(); return r && r.width > 0 && r.height > 0; };
+        const resolveEditor = () => selectors.map(s => document.querySelector(s)).find(visible);
+        const editor = resolveEditor();
+        const read = () => editor instanceof HTMLTextAreaElement ? editor.value : editor?.innerText ?? '';
+        const write = value => { if (editor instanceof HTMLTextAreaElement) editor.value = value; else if (editor) editor.textContent = value; };
+        const guard = { blocked: null, beforeValue: '', sawInput: false };
+        const validate = (requireFocus = true) => {
+          try {
+            const state = ${buildComposerNavigationValidationExpression(navigationUrl)};
+            const focused = editor instanceof HTMLElement && editor.isConnected && resolveEditor() === editor &&
+              (!requireFocus || document.activeElement === editor || editor.contains(document.activeElement));
+            if (!state.contextMatches || !focused) guard.blocked = { ...state, focused };
+          } catch { guard.blocked = { currentUrl: location.href, modeUnverified: true }; }
+          return !guard.blocked;
+        };
+        const cancel = event => { event.preventDefault(); event.stopImmediatePropagation(); };
+        const onBeforeInput = event => {
+          if (!validate() || event.target !== editor) { guard.blocked ??= { currentUrl: location.href, focused: false }; cancel(event); return; }
+        };
+        const onInput = event => {
+          if (!validate() || event.target !== editor) {
+            if (event.target === editor) write(guard.beforeValue);
+            guard.blocked ??= { currentUrl: location.href, focused: false };
+            cancel(event); return;
+          }
+          guard.sawInput = true;
+        };
+        guard.cleanup = () => { window.removeEventListener('beforeinput', onBeforeInput, true); window.removeEventListener('input', onInput, true); };
+        guard.summary = () => {
+          const ready = validate();
+          if (!ready && guard.sawInput) write(guard.beforeValue);
+          return { ready, blocked: guard.blocked, length: read().length, sawInput: guard.sawInput };
+        };
+        guard.insert = text => {
+          if (!validate()) return;
+          guard.beforeValue = read();
+          const before = new InputEvent('beforeinput', { bubbles: true, cancelable: true, data: text, inputType: 'insertFromPaste' });
+          if (!editor.dispatchEvent(before) || !validate()) return;
+          try { document.execCommand('insertText', false, text); } catch {}
+        };
+        guard.fallback = text => {
+          if (!validate() || read().trim()) return;
+          const before = new InputEvent('beforeinput', { bubbles: true, cancelable: true, data: text, inputType: 'insertFromPaste' });
+          if (!editor.dispatchEvent(before) || !validate()) return;
+          write(text);
+          editor.dispatchEvent(new InputEvent('input', { bubbles: true, data: text, inputType: 'insertFromPaste' }));
+        };
+        (window.__oracleAttachmentPromptGuards ??= Object.create(null))[${JSON.stringify(id)}] = guard;
+        if (!validate(false)) return { ready: false, blocked: guard.blocked };
+        guard.beforeValue = read();
+        window.addEventListener('beforeinput', onBeforeInput, true);
+        window.addEventListener('input', onInput, true);
+        dispatchClickSequence(editor);
+        if (!validate(false)) return { ready: false, blocked: guard.blocked };
+        editor.focus();
+        if (!validate()) return { ready: false, blocked: guard.blocked };
+        const selection = document.getSelection();
+        if (selection && !(editor instanceof HTMLTextAreaElement)) {
+          const range = document.createRange(); range.selectNodeContents(editor); range.collapse(false);
+          selection.removeAllRanges(); selection.addRange(range);
+        }
+        return guard.summary();
+      })()`,
+            returnByValue: true,
+        });
+        requireSafe(prepared.result?.value);
+        // A renderer command cannot land in a replacement document after navigation.
+        const inserted = await runtime.evaluate({
+            expression: `(() => {
+        const guard = window.__oracleAttachmentPromptGuards?.[${JSON.stringify(id)}];
+        if (!guard) return { ready: false };
+        guard.insert(${JSON.stringify(prompt)});
+        return guard.summary();
+      })()`,
+            returnByValue: true,
+        });
+        requireSafe(inserted.result?.value);
+        await delay(500);
+        const staged = await runtime.evaluate({
+            expression: `(() => {
+        const guard = window.__oracleAttachmentPromptGuards?.[${JSON.stringify(id)}];
+        if (!guard) return { ready: false };
+        const before = guard.summary();
+        if (before.ready && !before.length) guard.fallback(${JSON.stringify(prompt)});
+        return guard.summary();
+      })()`,
+            returnByValue: true,
+        });
+        const value = staged.result?.value;
+        requireSafe(value);
+        if (!value?.sawInput)
+            throw new BrowserAutomationError("Attachment prompt input was not observed; do not retry automatically.", {
+                stage: "submit-prompt",
+                code: "attachment-prompt-ambiguous",
+            });
+        return value.length ?? 0;
+    }
+    finally {
+        await withoutBrowserCancellation(() => runtime
+            .evaluate({
+            expression: `(() => { const guards = window.__oracleAttachmentPromptGuards; const guard = guards?.[${JSON.stringify(id)}]; guard?.cleanup(); if (guards) delete guards[${JSON.stringify(id)}]; })()`,
+        })
+            .catch(() => undefined));
+    }
+}