codex-chatgpt-control 0.5.0-alpha.1 → 0.5.1-alpha.2

package/dist/src/commands/files.js

@@ -6,11 +6,12 @@ import { downloadLatestArtifact, locatorCountWithTimeout } from "./artifacts.js"
 import { waitForDownloadFromClick } from "../browser/downloads.js";
 import { resultError, resultOk } from "../errors.js";
 import { addFilesButton, cssSelectors, requiredLocator } from "../dom/selectors.js";
-import { localeLabels } from "../dom/locale-labels.js";
-import { basenameForHostPath, isHostAbsolutePath, resolveForHostPath } from "../platform/local-paths.js";
+import { escapeRegExp, localeLabels } from "../dom/locale-labels.js";
+import { basenameForHostPath, currentHostPathPlatform, isHostAbsolutePath, resolveForHostPath } from "../platform/local-paths.js";
 import { contextFromPage } from "./context.js";
+import { createDeadline, remainingMs } from "./deadline.js";
 import { ensurePage } from "./session.js";
-import { localGuardTimeout } from "./timeouts.js";
+import { localGuardTimeout, withTimeout } from "./timeouts.js";
 const CODEX_UPLOAD_PERMISSION_FIX = "Codex Settings > Computer Use > Chrome > Permissions > Uploads: set to Always allow, or add chatgpt.com to the allowed upload domains.";
 const CHROME_FILE_URL_PERMISSION_FIX = "Chrome chrome://extensions > Codex extension > Details: enable Allow access to file URLs.";
 const DEFAULT_MAX_BYTES_PER_FILE = 512 * 1024 * 1024;
@@ -132,6 +133,7 @@ export async function preflightFiles(env, args) {
     return resultOk({ files, totalBytes }, filePreflightContext(env), warnings);
 }
 export async function attachFiles(env, args) {
+    const deadline = createDeadline(Math.max(1, args.timeoutMs ?? 30_000));
     const preflightArgs = { paths: args.paths };
     if (args.includeDiagnostics === true && args.includeHashes !== undefined) {
         preflightArgs.includeHashes = args.includeHashes;
@@ -140,52 +142,42 @@ export async function attachFiles(env, args) {
     if (!preflight.ok || preflight.data === undefined) {
         return preflight;
     }
-    const boot = await ensurePage(env);
+    let boot;
+    try {
+        boot = await withinAttachmentDeadline(deadline, () => ensurePage(env, { minimalContext: true }), "ChatGPT page verification");
+    }
+    catch (error) {
+        if (error instanceof AttachmentDeadlineError || remainingMs(deadline) <= 0) {
+            return attachmentDeadlineResult(error);
+        }
+        return resultError(error instanceof Error ? error : new Error(String(error)));
+    }
     if (!boot.ok) {
         return boot;
     }
     const page = env.page;
+    const mutationState = { handoffStarted: false };
     try {
         const files = preflight.data.files.map(file => ({
             path: file.path,
             name: file.name,
             bytes: file.bytes
         }));
-        await uploadFiles(page, files, args.timeoutMs ?? 30000);
+        const rawBaseline = await withinNativeAttachmentDeadline(deadline, timeoutMs => readAttachmentEvidenceBaseline(page, timeoutMs), "Pre-upload attachment baseline", 2_000).catch(() => ({ supported: false, inputFiles: [], attachmentLabels: [] }));
+        const baseline = rawBaseline !== null
+            && typeof rawBaseline === "object"
+            && Array.isArray(rawBaseline.inputFiles)
+            && Array.isArray(rawBaseline.attachmentLabels)
+            ? rawBaseline
+            : { supported: false, inputFiles: [], attachmentLabels: [] };
+        await uploadFiles(page, files, deadline, mutationState);
         const browserInput = args.includeDiagnostics === true
-            ? await readBrowserInputDiagnostic(page).catch(() => undefined)
+            ? await withinNativeAttachmentDeadline(deadline, timeoutMs => readBrowserInputDiagnostic(page, timeoutMs), "Browser input diagnostic", 2_000).catch(() => undefined)
             : undefined;
-        await page.waitForTimeout?.(args.timeoutMs === undefined ? 1000 : Math.min(args.timeoutMs, 3000));
-        const readiness = await waitForAttachedFilesReady(page, files, args.timeoutMs ?? 30000);
+        await attachmentDelay(page, deadline, Math.min(250, Math.max(1, Math.floor(remainingMs(deadline) / 4))));
+        const readiness = await waitForAttachedFilesReady(page, files, baseline, deadline);
         if (!readiness.ready) {
-            const blocker = {
-                kind: "upload_failed",
-                code: "attachment_processing",
-                message: "ChatGPT still appears to be processing the attached file, so the prompt was not submitted.",
-                remediation: [
-                    {
-                        label: "Wait for upload",
-                        instruction: "Wait until the visible attachment finishes uploading or processing, then retry the askWithFiles call.",
-                        userActionRequired: false
-                    },
-                    {
-                        label: "Retry smaller file",
-                        instruction: "If processing never finishes, retry with a smaller file or a different supported file type.",
-                        userActionRequired: true
-                    }
-                ],
-                resumable: true
-            };
-            if (readiness.processingText !== undefined) {
-                blocker.visibleText = readiness.processingText;
-            }
-            return {
-                ok: false,
-                status: "blocked",
-                warnings: [],
-                blocker,
-                context: await contextFromPage(page)
-            };
+            return attachmentOutcomeIndeterminate(files, [], await attachmentContext(page, deadline), readiness.processingText);
         }
         const data = { files };
         if (args.includeDiagnostics === true) {
@@ -194,10 +186,44 @@ export async function attachFiles(env, args) {
                 data.diagnostics.browserInput = browserInput;
             }
         }
-        return resultOk(data, await contextFromPage(page), preflight.warnings);
+        return resultOk(data, await attachmentContext(page, deadline), preflight.warnings);
     }
     catch (error) {
-        if (isUploadBridgeBlocker(error)) {
+        if (mutationState.handoffStarted) {
+            const permissionFailure = isUploadPermissionBlocker(error);
+            return attachmentOutcomeIndeterminate(preflight.data.files, [error instanceof Error ? error.message : String(error)], await attachmentContext(page, deadline), permissionFailure ? uploadPermissionDetails(error) : undefined, permissionFailure ? uploadPermissionRemediation() : undefined);
+        }
+        if (error instanceof AttachmentDeadlineError || remainingMs(deadline) <= 0) {
+            return attachmentDeadlineResult(error);
+        }
+        if (isUploadTransportFailure(error)) {
+            return {
+                ok: false,
+                status: "blocked",
+                warnings: [],
+                blocker: {
+                    kind: "browser_bridge_unavailable",
+                    code: "upload_transport_failed",
+                    message: "The Codex Chrome bridge disconnected while handing files to ChatGPT's visible composer. File attachment did not complete, so callers must not submit the prompt.",
+                    visibleText: error instanceof Error ? error.message : String(error),
+                    remediation: [
+                        {
+                            label: "Retry live attachment",
+                            instruction: "Retry the attachment from the live Codex Chrome runtime; the operation is safe to resume because file attachment did not complete.",
+                            userActionRequired: false
+                        },
+                        {
+                            label: "Restart bridge if repeated",
+                            instruction: "If the bridge disconnects again, restart Chrome or Codex before retrying. Do not change upload permissions unless Chrome explicitly reports a permission denial.",
+                            userActionRequired: true
+                        }
+                    ],
+                    resumable: true
+                },
+                context: await attachmentContext(page, deadline)
+            };
+        }
+        if (isUploadPermissionBlocker(error)) {
             return {
                 ok: false,
                 status: "blocked",
@@ -210,12 +236,70 @@ export async function attachFiles(env, args) {
                     remediation: uploadPermissionRemediation(),
                     resumable: true
                 },
-                context: await contextFromPage(page)
+                context: await attachmentContext(page, deadline)
             };
         }
-        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+        if (isUploadPathFailure(error)) {
+            return {
+                ok: false,
+                status: "blocked",
+                warnings: [],
+                blocker: {
+                    kind: "upload_failed",
+                    code: "upload_path_unavailable",
+                    message: "None of the browser's supported ChatGPT file-attachment paths completed. Callers must not submit the prompt.",
+                    visibleText: error instanceof Error ? error.message : String(error),
+                    remediation: [
+                        {
+                            label: "Retry live attachment",
+                            instruction: "Retry from the live Codex Chrome runtime after confirming the ChatGPT composer is visible. Do not change upload permissions unless Chrome explicitly reports a permission denial.",
+                            userActionRequired: false
+                        }
+                    ],
+                    resumable: true
+                },
+                context: await attachmentContext(page, deadline)
+            };
+        }
+        return resultError(error instanceof Error ? error : new Error(String(error)), await attachmentContext(page, deadline));
     }
 }
+function attachmentDeadlineResult(error) {
+    return {
+        ok: false,
+        status: "timeout",
+        warnings: error === undefined ? [] : [error instanceof Error ? error.message : String(error)],
+        blocker: {
+            kind: "upload_failed",
+            code: "attachment_deadline_exhausted",
+            message: "ChatGPT file attachment did not complete before the caller's single operation deadline. The prompt was not submitted.",
+            resumable: true
+        },
+        context: { timestamp: new Date().toISOString() }
+    };
+}
+function attachmentOutcomeIndeterminate(files, warnings, context, visibleText, remediation) {
+    const blocker = {
+        kind: "upload_failed",
+        code: "attachment_outcome_indeterminate",
+        message: "The native file handoff started, but its outcome could not be verified. The browser request is no longer in flight, though the file may already be present. Inspect the current composer; do not submit or retry automatically.",
+        resumable: false
+    };
+    if (visibleText !== undefined)
+        blocker.visibleText = visibleText;
+    if (remediation !== undefined)
+        blocker.remediation = remediation;
+    return {
+        ok: false,
+        status: "partial",
+        data: {
+            files: files.map(file => ({ path: file.path, name: file.name, bytes: file.bytes }))
+        },
+        warnings,
+        blocker,
+        context
+    };
+}
 function filePreflightBlocker(args) {
     return {
         ok: false,
@@ -251,7 +335,7 @@ async function fileMetadata(absolute, bytes, includeHash = false) {
     return metadata;
 }
 function extensionForHostPath(value) {
-    return process.platform === "win32"
+    return currentHostPathPlatform() === "win32"
         ? path.win32.extname(value).toLowerCase()
         : path.posix.extname(value).toLowerCase();
 }
@@ -328,44 +412,131 @@ function guessFileType(extension) {
 function isNodeError(error) {
     return error instanceof Error && "code" in error;
 }
-async function waitForAttachedFilesReady(page, files, timeoutMs) {
-    const started = Date.now();
+async function readAttachmentEvidenceBaseline(page, timeoutMs) {
+    if (typeof page.evaluate !== "function") {
+        return { supported: false, inputFiles: [], attachmentLabels: [] };
+    }
+    return page.evaluate(() => {
+        const visible = (element) => {
+            if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const style = window.getComputedStyle(element);
+            if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0")
+                return false;
+            const rect = element.getBoundingClientRect();
+            return rect.width > 0 || rect.height > 0;
+        };
+        const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+        const composers = [...new Set(textboxes
+                .map(textbox => textbox.closest("form")
+                ?? textbox.closest("[data-testid*='composer' i]")
+                ?? textbox.closest("[aria-label*='composer' i]")
+                ?? textbox.closest("[class*='composer' i]"))
+                .filter((value) => value !== null))];
+        if (composers.length !== 1) {
+            return { supported: false, inputFiles: [], attachmentLabels: [] };
+        }
+        const composer = composers[0];
+        const allInputs = Array.from(composer.querySelectorAll("input[type='file']"))
+            .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
+        const preferred = allInputs.filter(input => input.id === "upload-files");
+        const nonImage = allInputs.filter(input => input.getAttribute("accept") !== "image/*");
+        const inputs = preferred.length > 0 ? preferred : nonImage.length > 0 ? nonImage : allInputs;
+        if (inputs.length !== 1) {
+            return { supported: false, inputFiles: [], attachmentLabels: [] };
+        }
+        const attachmentSelector = [
+            "[data-testid*='attachment' i]",
+            "[data-testid*='file' i]",
+            "[aria-label*='attachment' i]",
+            "[aria-label*='upload' i]",
+            "[aria-label*='file' i]",
+            "[class*='attachment' i]",
+            "[class*='upload' i]",
+            "[class*='file' i]",
+            "[role='progressbar']"
+        ].join(", ");
+        const labels = Array.from(composer.querySelectorAll(attachmentSelector))
+            .filter(visible)
+            .map(element => [
+            element.textContent ?? "",
+            element.getAttribute("aria-label") ?? "",
+            element.getAttribute("title") ?? ""
+        ].join(" ").replace(/\s+/g, " ").trim().toLocaleLowerCase())
+            .filter(Boolean);
+        return {
+            supported: true,
+            inputFiles: Array.from(inputs[0].files ?? []).map(file => `${file.name.toLocaleLowerCase()}\u0000${file.size}`),
+            attachmentLabels: labels
+        };
+    }, undefined, { timeoutMs });
+}
+async function waitForAttachedFilesReady(page, files, baseline, deadline) {
     let lastProcessingText;
-    while (Date.now() - started < timeoutMs) {
-        const snapshot = await readAttachmentReadiness(page, files).catch(() => undefined);
-        if (snapshot === undefined) {
-            return { ready: true };
+    let sawProcessing = false;
+    while (remainingMs(deadline) > 0) {
+        const snapshot = await withinNativeAttachmentDeadline(deadline, timeoutMs => readAttachmentReadiness(page, files, baseline, timeoutMs), "Attachment readiness inspection", 2_000).catch(() => undefined);
+        if (snapshot === undefined || snapshot.supported === false) {
+            return { ready: false, reason: "unverified" };
         }
-        const allNamesVisible = snapshot.files.length > 0 && snapshot.files.every(file => file.visible);
+        const allNamesVisible = snapshot.files.length === files.length && snapshot.files.every(file => file.visible);
         if (!snapshot.processing && allNamesVisible) {
             return { ready: true };
         }
-        if (!snapshot.processing && Date.now() - started >= Math.min(timeoutMs, 1000)) {
-            return { ready: true };
-        }
+        sawProcessing ||= snapshot.processing;
         if (snapshot.processingText !== undefined) {
             lastProcessingText = snapshot.processingText;
         }
-        await page.waitForTimeout?.(250);
+        const pollBudget = remainingMs(deadline);
+        if (pollBudget <= 10)
+            break;
+        await attachmentDelay(page, deadline, Math.min(250, pollBudget - 10));
     }
-    const blocked = { ready: false };
+    const blocked = {
+        ready: false,
+        reason: sawProcessing ? "processing" : "unverified"
+    };
     if (lastProcessingText !== undefined) {
         blocked.processingText = lastProcessingText;
     }
     return blocked;
 }
-async function readAttachmentReadiness(page, files) {
+async function readAttachmentReadiness(page, files, baseline, timeoutMs) {
     if (typeof page.evaluate !== "function") {
         return undefined;
     }
-    return page.evaluate((fileNames) => {
-        const visibleText = document.body?.innerText ?? "";
+    return page.evaluate((args) => {
+        const expectedFiles = args.expectedFiles;
         const normalize = (value) => value.toLocaleLowerCase();
-        const normalizedVisibleText = normalize(visibleText);
-        const files = fileNames.map(name => ({
-            name,
-            visible: normalizedVisibleText.includes(normalize(name))
-        }));
+        const visible = (element) => {
+            if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const style = window.getComputedStyle(element);
+            if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0")
+                return false;
+            const rect = element.getBoundingClientRect();
+            return rect.width > 0 || rect.height > 0;
+        };
+        const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+        const composers = [...new Set(textboxes
+                .map(textbox => textbox.closest("form")
+                ?? textbox.closest("[data-testid*='composer' i]")
+                ?? textbox.closest("[aria-label*='composer' i]")
+                ?? textbox.closest("[class*='composer' i]"))
+                .filter((value) => value !== null))];
+        if (composers.length !== 1) {
+            return { supported: false, files: expectedFiles.map(file => ({ name: file.name, visible: false })), processing: false };
+        }
+        const composer = composers[0];
+        const allInputs = Array.from(composer.querySelectorAll("input[type='file']"))
+            .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
+        const preferred = allInputs.filter(input => input.id === "upload-files");
+        const nonImage = allInputs.filter(input => input.getAttribute("accept") !== "image/*");
+        const inputs = preferred.length > 0 ? preferred : nonImage.length > 0 ? nonImage : allInputs;
+        if (inputs.length !== 1) {
+            return { supported: false, files: expectedFiles.map(file => ({ name: file.name, visible: false })), processing: false };
+        }
+        const input = inputs[0];
         const attachmentSelectors = [
             "[data-testid*='attachment' i]",
             "[data-testid*='file' i]",
@@ -377,92 +548,169 @@ async function readAttachmentReadiness(page, files) {
             "[class*='file' i]",
             "[role='progressbar']"
         ].join(", ");
-        const attachmentText = Array.from(document.querySelectorAll(attachmentSelectors))
+        const attachmentElements = Array.from(composer.querySelectorAll(attachmentSelectors)).filter(visible);
+        const attachmentText = attachmentElements
             .map(element => [
             element.textContent ?? "",
             element.getAttribute("aria-label") ?? "",
             element.getAttribute("title") ?? ""
         ].join(" "))
             .join(" ");
-        const relevantText = attachmentText.length > 0 ? attachmentText : visibleText;
-        const processingMatch = /\b(uploading|processing|attaching|preparing|reading|scanning|analyzing)\b/i.exec(relevantText);
+        const inputFiles = Array.from(input.files ?? []).map(file => ({
+            name: normalize(file.name),
+            size: file.size,
+            signature: `${normalize(file.name)}\u0000${file.size}`
+        }));
+        const attachmentLabels = attachmentElements.map(element => normalize([
+            element.textContent ?? "",
+            element.getAttribute("aria-label") ?? "",
+            element.getAttribute("title") ?? ""
+        ].join(" ")));
+        const occurrence = (values, index) => values.slice(0, index + 1).filter(value => value === values[index]).length;
+        const inputSignatures = inputFiles.map(file => file.signature);
+        const newInputIndices = new Set(inputSignatures
+            .map((signature, index) => occurrence(inputSignatures, index)
+            > args.baseline.inputFiles.filter(value => value === signature).length ? index : -1)
+            .filter(index => index >= 0));
+        const newLabelIndices = new Set(attachmentLabels
+            .map((label, index) => args.baseline.supported
+            && occurrence(attachmentLabels, index)
+                > args.baseline.attachmentLabels.filter(value => value === label).length ? index : -1)
+            .filter(index => index >= 0));
+        const usedInputs = new Set();
+        const usedLabels = new Set();
+        const visibleFiles = expectedFiles.map(expected => {
+            const expectedName = normalize(expected.name);
+            const inputIndex = inputFiles.findIndex((candidate, index) => !usedInputs.has(index)
+                && newInputIndices.has(index)
+                && candidate.name === expectedName
+                && candidate.size === expected.bytes);
+            if (inputIndex >= 0) {
+                usedInputs.add(inputIndex);
+                return { name: expected.name, visible: true };
+            }
+            const labelIndex = attachmentLabels.findIndex((label, index) => !usedLabels.has(index) && newLabelIndices.has(index) && label.includes(expectedName));
+            if (labelIndex >= 0)
+                usedLabels.add(labelIndex);
+            return { name: expected.name, visible: labelIndex >= 0 };
+        });
+        const processingMatch = /\b(uploading|processing|attaching|preparing|reading|scanning|analyzing)\b/i.exec(attachmentText);
         const snapshot = {
-            files,
+            supported: true,
+            files: visibleFiles,
             processing: processingMatch !== null
         };
         if (processingMatch !== null) {
-            snapshot.processingText = relevantText.slice(0, 500);
+            snapshot.processingText = attachmentText.slice(0, 500);
         }
         return snapshot;
-    }, files.map(file => file.name));
+    }, {
+        expectedFiles: files.map(file => ({ name: file.name, bytes: file.bytes })),
+        baseline
+    }, { timeoutMs });
 }
-async function uploadFiles(page, files, timeoutMs) {
+async function uploadFiles(page, files, deadline, mutationState) {
     const paths = files.map(file => file.path);
     const errors = [];
-    const attempts = [
-        {
+    let activeComposerInput;
+    try {
+        activeComposerInput = await resolveUniqueActiveComposerFileInput(page, deadline);
+    }
+    catch (error) {
+        errors.push(`active-composer-input: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const attempts = [];
+    if (activeComposerInput !== undefined) {
+        const resolvedInput = activeComposerInput;
+        attempts.push({
             name: "visible-chatgpt-file-input",
             run: async () => {
-                await clickFileChooserTarget(page, "#upload-files", paths, timeoutMs, { requireVisible: true });
-            }
-        },
-        {
-            name: "add-photos-files-menu-item",
-            run: async () => {
-                await clickChatGPTAddPhotosMenuItem(page, paths, timeoutMs);
-            }
-        },
-        {
-            name: "generic-add-files-button",
-            run: async () => {
-                await clickFileChooserLocator(page, addFilesButton(page), paths, timeoutMs);
+                if (!await locatorIsRendered(resolvedInput, deadline)) {
+                    throw new Error("The active-composer upload target is hidden.");
+                }
+                await clickFileChooserLocator(page, resolvedInput, paths, deadline, mutationState);
             }
-        },
-        {
+        });
+    }
+    attempts.push({
+        name: "add-photos-files-menu-item",
+        run: async () => {
+            await clickChatGPTAddPhotosMenuItem(page, paths, deadline, mutationState);
+        }
+    }, {
+        name: "generic-add-files-button",
+        run: async () => {
+            const control = addFilesButton(page);
+            await assertControlInUniqueActiveComposer(control, deadline, "Generic Add files control");
+            await clickFileChooserLocator(page, control, paths, deadline, mutationState);
+        }
+    }, {
+        name: "cdp-file-input-chooser",
+        run: async () => {
+            await clickHiddenFileInputWithCdp(page, paths, deadline, mutationState);
+        }
+    });
+    if (activeComposerInput !== undefined) {
+        const resolvedInput = activeComposerInput;
+        attempts.push({
             name: "direct-file-input-set",
             run: async () => {
-                await setHiddenFileInput(page, files);
+                await setResolvedFileInput(resolvedInput, files, deadline, mutationState);
             }
-        }
-    ];
+        });
+    }
     for (const attempt of attempts) {
+        if (remainingMs(deadline) <= 0) {
+            errors.push(`${attempt.name}: skipped because the single attachment deadline was exhausted`);
+            break;
+        }
         try {
             await attempt.run();
             return;
         }
         catch (error) {
+            if (mutationState.handoffStarted) {
+                throw error;
+            }
+            if (isUploadPermissionBlocker(error) || isUploadTransportFailure(error)) {
+                throw error;
+            }
             errors.push(`${attempt.name}: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
     throw new Error(`No ChatGPT upload path completed.\n${errors.join("\n")}`);
 }
-async function clickChatGPTAddPhotosMenuItem(page, paths, timeoutMs) {
+async function clickChatGPTAddPhotosMenuItem(page, paths, deadline, mutationState) {
     // The `#composer-plus-btn` id is the language-agnostic primary; the aria-label and the
     // menu-item text are locale-sensitive (menu text sourced from the locale registry).
-    const addPhotosFilesText = localeLabels.addPhotosFilesMenuItem[0];
-    const menuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: addPhotosFilesText });
-    if (await locatorCount(menuItem) !== 1) {
+    const addPhotosFilesLabels = localeLabels.addPhotosFilesMenuItem;
+    let menuItem = await findChatGPTUploadMenuItem(page, addPhotosFilesLabels, deadline);
+    if (menuItem === undefined) {
         const plusButton = requiredLocator(page, "#composer-plus-btn, button[aria-label='Add files and more']");
-        if (await locatorCount(plusButton) !== 1) {
+        if (await locatorCount(plusButton, deadline) !== 1) {
             throw new Error("ChatGPT Add files button was not uniquely available.");
         }
-        await plusButton.click?.({ timeoutMs: Math.min(timeoutMs, 10000) });
-        await page.waitForTimeout?.(250);
+        await assertControlInUniqueActiveComposer(plusButton, deadline, "ChatGPT Add files control");
+        if (plusButton.click === undefined)
+            throw new Error("ChatGPT Add files button does not expose click().");
+        await withinNativeAttachmentDeadline(deadline, timeoutMs => plusButton.click({ timeoutMs }), "ChatGPT Add files control click", 10_000);
+        await attachmentDelay(page, deadline, 250);
     }
-    const refreshedMenuItem = requiredLocator(page, "div[role='menuitem']").filter?.({ hasText: addPhotosFilesText });
-    await clickFileChooserLocator(page, refreshedMenuItem, paths, timeoutMs);
-}
-async function clickFileChooserTarget(page, selector, paths, timeoutMs, options = {}) {
-    const locator = requiredLocator(page, selector);
-    if (await locatorCount(locator) !== 1) {
-        throw new Error(`Upload target was not uniquely available: ${selector}`);
+    menuItem = await findChatGPTUploadMenuItem(page, addPhotosFilesLabels, deadline);
+    if (menuItem === undefined) {
+        throw new Error("ChatGPT's visible Add photos & files upload row was not uniquely available.");
     }
-    if (options.requireVisible === true && locator.isVisible !== undefined && !await locator.isVisible({ timeoutMs: 1000 })) {
-        throw new Error(`Upload target is hidden: ${selector}`);
-    }
-    await clickFileChooserLocator(page, locator, paths, timeoutMs);
+    const refreshedMenuItem = menuItem;
+    await clickFileChooserLocator(page, refreshedMenuItem, paths, deadline, mutationState);
+}
+async function findChatGPTUploadMenuItem(page, addPhotosFilesLabels, deadline) {
+    // Current Chat renders the command palette upload action as a focusable row
+    // with tabindex=0 and no ARIA menuitem role.
+    const pattern = new RegExp(addPhotosFilesLabels.map(escapeRegExp).join("|"), "i");
+    const candidate = requiredLocator(page, "div[tabindex='0']").filter?.({ hasText: pattern });
+    return await locatorCount(candidate, deadline) === 1 ? candidate : undefined;
 }
-async function clickFileChooserLocator(page, locator, paths, timeoutMs) {
+async function clickFileChooserLocator(page, locator, paths, deadline, mutationState) {
     if (locator === undefined) {
         throw new Error("Upload locator was not available.");
     }
@@ -472,28 +720,105 @@ async function clickFileChooserLocator(page, locator, paths, timeoutMs) {
     if (typeof locator.click !== "function") {
         throw new Error("Upload locator does not expose click().");
     }
-    const chooserPromise = waitForFileChooser(page, timeoutMs);
+    // Attach a rejection handler immediately. Browser bridges can reject the
+    // chooser wait before the visible click promise settles; leaving that
+    // rejection temporarily unobserved can terminate the host JavaScript
+    // runtime even though attachFiles has a surrounding error boundary.
+    const chooserPromise = waitForFileChooser(page, deadline).then(chooser => ({ ok: true, chooser }), error => ({ ok: false, error }));
     try {
-        await locator.click({ timeoutMs: Math.min(timeoutMs, 10000) });
+        await withinNativeAttachmentDeadline(deadline, timeoutMs => locator.click({ timeoutMs }), "ChatGPT upload-control click", 10_000);
     }
     catch (error) {
-        await chooserPromise.catch(() => undefined);
+        await chooserPromise;
         throw error;
     }
-    const chooser = await chooserPromise;
-    await validateChooserMultiplicity(chooser, paths);
+    const chooserResult = await chooserPromise;
+    if (!chooserResult.ok) {
+        throw chooserResult.error;
+    }
+    const chooser = chooserResult.chooser;
+    await validateChooserTarget(chooser, deadline, "scoped-composer-trigger");
+    await withinAttachmentDeadline(deadline, () => validateChooserMultiplicity(chooser, paths), "File-chooser multiplicity validation");
     try {
-        await chooser.setFiles(paths);
+        mutationState.handoffStarted = true;
+        await withinNativeAttachmentDeadline(deadline, timeoutMs => chooser.setFiles(paths, { timeoutMs }), "File-chooser handoff", 15_000);
     }
     catch (error) {
         throw new Error(`fileChooser.setFiles failed. ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-async function waitForFileChooser(page, timeoutMs) {
-    const rawChooser = await page.waitForEvent?.("filechooser", {
-        timeout: timeoutMs,
-        timeoutMs
-    });
+async function clickHiddenFileInputWithCdp(page, paths, deadline, mutationState) {
+    // Codex Chrome exposes page.evaluate as read-only and intentionally omits
+    // locator.setInputFiles. CDP supplies only the trusted user gesture here;
+    // the sanctioned file-chooser object still performs the local handoff.
+    if (typeof page.waitForEvent !== "function") {
+        throw new Error("The active browser page does not expose file chooser events.");
+    }
+    const rawCapability = await withinAttachmentDeadline(deadline, () => Promise.resolve(page.capabilities?.get?.("cdp")), "Scoped CDP upload capability resolution");
+    const cdp = rawCapability;
+    if (typeof cdp?.send !== "function") {
+        throw new Error("The active browser page does not expose the scoped CDP capability needed to click a hidden file input.");
+    }
+    const chooserPromise = waitForFileChooser(page, deadline).then(chooser => ({ ok: true, chooser }), error => ({ ok: false, error }));
+    try {
+        const evaluation = await withinNativeAttachmentDeadline(deadline, timeoutMs => Promise.resolve(cdp.send("Runtime.evaluate", {
+            expression: `(() => {
+        const visible = element => {
+          if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']")) return false;
+          const style = getComputedStyle(element);
+          const rect = element.getBoundingClientRect();
+          return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
+            && (rect.width > 0 || rect.height > 0);
+        };
+        const textboxes = [...document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")].filter(visible);
+        const composers = [...new Set(textboxes.map(textbox =>
+          textbox.closest("form")
+            ?? textbox.closest("[data-testid*='composer' i]")
+            ?? textbox.closest("[aria-label*='composer' i]")
+            ?? textbox.closest("[class*='composer' i]")
+        ).filter(Boolean))];
+        if (composers.length !== 1) return { ok: false, reason: "active composer was not unique" };
+        const all = [...composers[0].querySelectorAll("input[type='file']")]
+          .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
+        const preferred = all.filter(input => input.id === "upload-files");
+        const nonImage = all.filter(input => input.getAttribute("accept") !== "image/*");
+        const candidates = preferred.length ? preferred : nonImage.length ? nonImage : all;
+        if (candidates.length !== 1) return { ok: false, reason: "active composer file input was not unique" };
+        candidates[0].click();
+        return { ok: true };
+      })()`,
+            userGesture: true,
+            awaitPromise: true,
+            returnByValue: true
+        }, {
+            timeoutMs
+        })), "Scoped CDP file-input click", 10_000);
+        const wrappedValue = evaluation?.result?.value;
+        const value = (wrappedValue ?? evaluation);
+        if (value?.ok !== true) {
+            throw new Error(`Scoped CDP file-input click was refused: ${value?.reason ?? "no success result"}.`);
+        }
+    }
+    catch (error) {
+        await chooserPromise;
+        throw error;
+    }
+    const chooserResult = await chooserPromise;
+    if (!chooserResult.ok) {
+        throw chooserResult.error;
+    }
+    await validateChooserTarget(chooserResult.chooser, deadline, "scoped-cdp-input");
+    await withinAttachmentDeadline(deadline, () => validateChooserMultiplicity(chooserResult.chooser, paths), "File-chooser multiplicity validation");
+    try {
+        mutationState.handoffStarted = true;
+        await withinNativeAttachmentDeadline(deadline, timeoutMs => chooserResult.chooser.setFiles(paths, { timeoutMs }), "File-chooser handoff", 15_000);
+    }
+    catch (error) {
+        throw new Error(`fileChooser.setFiles failed. ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function waitForFileChooser(page, deadline) {
+    const rawChooser = await withinNativeAttachmentDeadline(deadline, timeoutMs => Promise.resolve(page.waitForEvent?.("filechooser", { timeoutMs })), "File-chooser event wait");
     if (!isFileChooserLike(rawChooser)) {
         throw new Error("File chooser event did not return a setFiles-capable chooser.");
     }
@@ -513,12 +838,132 @@ function isFileChooserLike(value) {
         && typeof value === "object"
         && typeof value.setFiles === "function";
 }
-async function locatorCount(locator) {
-    if (locator === undefined || typeof locator.count !== "function") {
+async function validateChooserTarget(chooser, deadline, _triggerProof) {
+    if (typeof chooser.element !== "function") {
+        // The Codex Chrome bridge deliberately exposes only isMultiple/setFiles.
+        // This function is reachable only after the initiating input/control has
+        // already been proven to belong to the unique active composer (or after
+        // the scoped CDP expression proved and clicked that exact input).
+        return;
+    }
+    const element = await withinAttachmentDeadline(deadline, () => Promise.resolve(chooser.element()), "File-chooser backing-input resolution");
+    if (typeof element?.evaluate !== "function") {
+        throw new Error("The file chooser backing input could not be inspected safely.");
+    }
+    const scoped = await withinNativeAttachmentDeadline(deadline, timeoutMs => element.evaluate((candidate) => {
+        const visible = (node) => {
+            if (node.hidden || node.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const style = window.getComputedStyle(node);
+            const rect = node.getBoundingClientRect();
+            return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
+                && style.pointerEvents !== "none" && (rect.width > 0 || rect.height > 0);
+        };
+        const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+        const composers = [...new Set(textboxes
+                .map(textbox => textbox.closest("form")
+                ?? textbox.closest("[data-testid*='composer' i]")
+                ?? textbox.closest("[aria-label*='composer' i]")
+                ?? textbox.closest("[class*='composer' i]"))
+                .filter((value) => value !== null))];
+        if (composers.length !== 1 || !composers[0].contains(candidate))
+            return false;
+        const all = Array.from(composers[0].querySelectorAll("input[type='file']"))
+            .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
+        const preferred = all.filter(input => input.id === "upload-files");
+        const nonImage = all.filter(input => input.getAttribute("accept") !== "image/*");
+        const resolved = preferred.length > 0 ? preferred : nonImage.length > 0 ? nonImage : all;
+        return resolved.length === 1 && resolved[0] === candidate;
+    }, undefined, { timeoutMs }), "File-chooser active-composer identity check", 2_000);
+    if (!scoped) {
+        throw new Error("The file chooser backing input was not the unique active-composer upload target.");
+    }
+}
+async function locatorCount(locator, deadline) {
+    if (locator === undefined) {
         return 0;
     }
+    if (deadline !== undefined && typeof locator.allTextContents === "function") {
+        const values = await withinNativeAttachmentDeadline(deadline, timeoutMs => locator.allTextContents({ timeoutMs }), "Locator enumeration", 2_000);
+        return values.length;
+    }
+    if (typeof locator.count !== "function")
+        return 0;
+    if (deadline !== undefined) {
+        return withinAttachmentDeadline(deadline, () => locator.count(), "Locator enumeration");
+    }
     return locator.count();
 }
+async function locatorIsRendered(locator, deadline) {
+    if (typeof locator.evaluate !== "function")
+        return false;
+    return withinNativeAttachmentDeadline(deadline, timeoutMs => locator.evaluate((element) => {
+        const node = element;
+        if (node.hidden || node.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+            return false;
+        const style = window.getComputedStyle(node);
+        const rect = node.getBoundingClientRect();
+        return style.display !== "none"
+            && style.visibility !== "hidden"
+            && style.opacity !== "0"
+            && style.pointerEvents !== "none"
+            && (rect.width > 0 || rect.height > 0);
+    }, undefined, { timeoutMs }), "Active-composer file-input visibility check", 1_000);
+}
+function attachmentBudget(deadline) {
+    const budget = remainingMs(deadline);
+    if (budget <= 0) {
+        throw new AttachmentDeadlineError("Attachment operation");
+    }
+    return budget;
+}
+class AttachmentDeadlineError extends Error {
+    constructor(label) {
+        super(`${label} exceeded the single attachment deadline.`);
+        this.name = "AttachmentDeadlineError";
+    }
+}
+async function withinAttachmentDeadline(deadline, operation, label) {
+    const budget = attachmentBudget(deadline);
+    try {
+        return await withTimeout(operation(), budget, `${label} exceeded the single attachment deadline.`);
+    }
+    catch (error) {
+        if (remainingMs(deadline) <= 0
+            || (error instanceof Error && error.message.includes("exceeded the single attachment deadline"))) {
+            throw new AttachmentDeadlineError(label);
+        }
+        throw error;
+    }
+}
+async function withinNativeAttachmentDeadline(deadline, operation, label, capMs = Number.POSITIVE_INFINITY) {
+    const timeoutMs = Math.min(capMs, attachmentBudget(deadline));
+    try {
+        // Browser-native timeoutMs is the cancellation boundary. Do not wrap this
+        // promise in Promise.race: abandoning a mutation promise lets it fire later.
+        return await operation(timeoutMs);
+    }
+    catch (error) {
+        if (remainingMs(deadline) <= 0) {
+            throw new AttachmentDeadlineError(label);
+        }
+        throw error;
+    }
+}
+async function attachmentDelay(_page, deadline, requestedMs) {
+    const budget = attachmentBudget(deadline);
+    const delayMs = Math.min(Math.max(0, requestedMs), Math.max(0, budget - 1));
+    if (delayMs <= 0) {
+        if (requestedMs > 0)
+            throw new AttachmentDeadlineError("Attachment settling delay");
+        return;
+    }
+    // A host timer cannot strand a browser request and is sufficient for polling.
+    await new Promise(resolve => setTimeout(resolve, delayMs));
+}
+async function attachmentContext(page, _deadline) {
+    return contextFromPage(page, {}, { minimal: true });
+}
 export async function downloadLatestFile(env, args) {
     const boot = await ensurePage(env);
     if (!boot.ok) {
@@ -526,6 +971,24 @@ export async function downloadLatestFile(env, args) {
     }
     const page = env.page;
     try {
+        const generatedFileDownload = await tryGeneratedFilePreviewDownload(page, args);
+        if (generatedFileDownload !== undefined) {
+            return generatedFileDownload;
+        }
+        if (args.filenamePattern !== undefined) {
+            return {
+                ok: false,
+                status: "unsupported",
+                warnings: [],
+                blocker: {
+                    kind: "download_unavailable",
+                    code: "download_filename_not_found",
+                    message: `No visible ChatGPT file affordance matched filenamePattern ${JSON.stringify(args.filenamePattern)}.`,
+                    resumable: true
+                },
+                context: await contextFromPage(page)
+            };
+        }
         const controls = requiredLocator(page, cssSelectors.downloadControls);
         let count;
         try {
@@ -571,28 +1034,297 @@ export async function downloadLatestFile(env, args) {
         return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
     }
 }
-async function setHiddenFileInput(page, files) {
-    if (page === undefined) {
-        throw new Error("No active page is available for file upload.");
+async function tryGeneratedFilePreviewDownload(page, args) {
+    const timeoutMs = args.timeoutMs ?? 120000;
+    const candidates = await inspectGeneratedFileAffordances(page, localGuardTimeout(timeoutMs, 5000));
+    const selected = selectGeneratedFileAffordance(candidates, args);
+    if (selected === undefined)
+        return undefined;
+    try {
+        const assistantMessages = requiredLocator(page, cssSelectors.assistantMessages);
+        const assistantCount = await locatorCountWithTimeout(assistantMessages, localGuardTimeout(timeoutMs, 5000), "generated_file_assistant_count_timeout");
+        if (selected.assistantIndex < 0 || selected.assistantIndex >= assistantCount) {
+            throw new Error("The selected generated-file assistant turn is no longer present.");
+        }
+        const assistant = assistantMessages.nth?.(selected.assistantIndex) ?? assistantMessages;
+        const role = selected.tag === "button" ? "button" : "link";
+        const controlLabel = selected.controlLabel ?? selected.filename;
+        const affordance = assistant.getByRole?.(role, { name: controlLabel, exact: true })
+            ?? assistant.locator?.(`${selected.tag}[aria-label="${escapeCssAttribute(controlLabel)}"]`);
+        const affordanceCount = await locatorCountWithTimeout(affordance, localGuardTimeout(timeoutMs, 5000), "generated_file_affordance_count_timeout");
+        if (affordance === undefined || affordanceCount !== 1 || typeof affordance.click !== "function") {
+            throw new Error(`Expected one clickable generated-file affordance for ${selected.filename}, found ${affordanceCount}.`);
+        }
+        if (selected.tag === "a") {
+            const downloaded = await waitForDownloadFromClick(page, () => affordance.click({ timeoutMs: localGuardTimeout(timeoutMs, 10000) }), args.destDir, timeoutMs, selected.filename);
+            return resultOk(downloaded, await contextFromPage(page));
+        }
+        await affordance.click({ timeoutMs: localGuardTimeout(timeoutMs, 10000) });
+        const labelledPreview = requiredLocator(page, `section[aria-label="${escapeCssAttribute(selected.filename)}"]`);
+        const workbookPreviews = requiredLocator(page, "section[data-testid^='popcorn-']");
+        const workbookPreview = workbookPreviews.filter?.({ hasText: selected.filename }) ?? workbookPreviews;
+        const download = await waitForPreviewDownloadControl(page, [labelledPreview, workbookPreview], timeoutMs);
+        if (download === undefined) {
+            throw new Error(`The artifact preview for ${selected.filename} did not expose a visible Download control.`);
+        }
+        const downloaded = await waitForDownloadFromClick(page, async () => download.click?.({ timeoutMs: localGuardTimeout(timeoutMs, 10000) }), args.destDir, timeoutMs, selected.filename);
+        return resultOk(downloaded, await contextFromPage(page));
+    }
+    catch (error) {
+        return resultError(error instanceof Error ? error : new Error(String(error)), await contextFromPage(page));
+    }
+}
+async function inspectGeneratedFileAffordances(page, timeoutMs) {
+    if (typeof page.evaluate === "function") {
+        const fromDom = await withTimeout(page.evaluate((downloadLabels) => {
+            const visible = (element) => {
+                let current = element;
+                while (current !== null) {
+                    const html = current;
+                    const style = window.getComputedStyle(html);
+                    const rect = html.getBoundingClientRect();
+                    if (style.display === "none" || style.visibility === "hidden" || Number(style.opacity || "1") <= 0)
+                        return false;
+                    if (current === element && (rect.width <= 0 || rect.height <= 0))
+                        return false;
+                    current = current.parentElement;
+                }
+                return true;
+            };
+            const fileLike = (value) => /^[^\\/\r\n]{1,255}\.[a-z0-9][a-z0-9._-]{0,15}$/i.test(value);
+            const normalizedFilename = (value) => {
+                const trimmed = value.trim();
+                const lowered = trimmed.toLocaleLowerCase();
+                const prefix = downloadLabels
+                    .map(label => label.trim())
+                    .filter(Boolean)
+                    .sort((left, right) => right.length - left.length)
+                    .find(label => lowered.startsWith(`${label.toLocaleLowerCase()} `));
+                return prefix === undefined ? trimmed : trimmed.slice(prefix.length).trim();
+            };
+            const assistants = Array.from(document.querySelectorAll("[data-message-author-role='assistant']"));
+            return assistants.flatMap((assistant, assistantIndex) => Array.from(assistant.querySelectorAll("button[aria-label], a[download], a[href*='/backend-api/files/']"))
+                .filter(visible)
+                .map(element => {
+                const controlLabel = (element.getAttribute("aria-label") ?? element.textContent ?? "").trim();
+                const text = (element.textContent ?? "").trim();
+                return {
+                    assistantIndex,
+                    filename: normalizedFilename(controlLabel),
+                    controlLabel,
+                    tag: element.tagName.toLocaleLowerCase(),
+                    textFilename: normalizedFilename(text)
+                };
+            })
+                .filter(item => (item.tag === "button" || item.tag === "a") && fileLike(item.filename) && item.filename === item.textFilename)
+                .map(({ assistantIndex: index, filename, controlLabel, tag }) => ({
+                assistantIndex: index,
+                filename,
+                ...(controlLabel === filename ? {} : { controlLabel }),
+                tag
+            })));
+        }, [...localeLabels.download]), timeoutMs, "Timed out while inspecting generated-file buttons.").catch(() => undefined);
+        if (Array.isArray(fromDom))
+            return fromDom;
+    }
+    if (typeof page.content !== "function")
+        return [];
+    const html = await withTimeout(page.content(), timeoutMs, "Timed out while reading generated-file button markup.").catch(() => "");
+    const candidates = [];
+    const buttonPattern = /<(button|a)\b[^>]*\baria-label=(['"])(.*?)\2[^>]*>([\s\S]*?)<\/\1>/gi;
+    let match;
+    while ((match = buttonPattern.exec(html)) !== null) {
+        const controlLabel = decodeBasicHtml(match[3] ?? "").trim();
+        const text = decodeBasicHtml((match[4] ?? "").replace(/<[^>]+>/g, " ")).replace(/\s+/g, " ").trim();
+        const filename = normalizeGeneratedFileControlLabel(controlLabel);
+        const textFilename = normalizeGeneratedFileControlLabel(text);
+        if (/^[^\\/\r\n]{1,255}\.[a-z0-9][a-z0-9._-]{0,15}$/i.test(filename) && filename === textFilename) {
+            candidates.push({
+                assistantIndex: 0,
+                filename,
+                ...(controlLabel === filename ? {} : { controlLabel }),
+                tag: (match[1] ?? "button").toLocaleLowerCase()
+            });
+        }
+    }
+    return candidates;
+}
+function normalizeGeneratedFileControlLabel(value) {
+    return stripLocalizedDownloadPrefix(value, localeLabels.download);
+}
+export function stripLocalizedDownloadPrefix(value, labels) {
+    const trimmed = value.trim();
+    const lowered = trimmed.toLocaleLowerCase();
+    const prefix = labels
+        .map(label => label.trim())
+        .filter(Boolean)
+        .sort((left, right) => right.length - left.length)
+        .find(label => lowered.startsWith(`${label.toLocaleLowerCase()} `));
+    return prefix === undefined ? trimmed : trimmed.slice(prefix.length).trim();
+}
+function selectGeneratedFileAffordance(candidates, args) {
+    let scoped = candidates;
+    const from = args.from;
+    if (typeof from === "object" && from !== null) {
+        scoped = scoped.filter(candidate => candidate.assistantIndex === from.assistantIndex);
+    }
+    else if (from !== "visible_conversation") {
+        const latestAssistant = Math.max(-1, ...scoped.map(candidate => candidate.assistantIndex));
+        scoped = scoped.filter(candidate => candidate.assistantIndex === latestAssistant);
+    }
+    if (args.filenamePattern !== undefined) {
+        scoped = scoped.filter(candidate => filenameMatches(candidate.filename, args.filenamePattern));
+    }
+    return scoped.at(-1);
+}
+function filenameMatches(filename, pattern) {
+    try {
+        return new RegExp(pattern, "i").test(filename);
+    }
+    catch {
+        return filename.toLocaleLowerCase().includes(pattern.toLocaleLowerCase());
+    }
+}
+async function waitForPreviewDownloadControl(page, previews, timeoutMs) {
+    const deadline = Date.now() + Math.min(timeoutMs, 60000);
+    while (Date.now() < deadline) {
+        for (const preview of previews) {
+            for (const label of localeLabels.download) {
+                const control = preview.getByRole?.("button", { name: label, exact: true })
+                    ?? preview.locator?.(`button[aria-label="${escapeCssAttribute(label)}"]`);
+                if (await locatorCountWithTimeout(control, localGuardTimeout(timeoutMs, 2000), "artifact_preview_download_count_timeout") === 1) {
+                    return control;
+                }
+            }
+        }
+        if (typeof page.waitForTimeout === "function") {
+            await page.waitForTimeout(100);
+        }
+        else {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+    return undefined;
+}
+function escapeCssAttribute(value) {
+    return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/[\r\n]/g, " ");
+}
+function decodeBasicHtml(value) {
+    return value
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;|&apos;/gi, "'")
+        .replace(/&lt;/gi, "<")
+        .replace(/&gt;/gi, ">")
+        .replace(/&amp;/gi, "&");
+}
+async function resolveUniqueActiveComposerFileInput(page, deadline) {
+    const candidates = requiredLocator(page, cssSelectors.hiddenFileInputs);
+    if (typeof candidates.count !== "function") {
+        throw new Error("ChatGPT file inputs could not be enumerated safely.");
+    }
+    const count = await locatorCount(candidates, deadline);
+    const eligible = [];
+    for (let index = 0; index < count; index += 1) {
+        const input = count === 1 ? candidates : candidates.nth?.(index);
+        if (input === undefined || typeof input.evaluate !== "function")
+            continue;
+        const scoped = await withinNativeAttachmentDeadline(deadline, timeoutMs => input.evaluate((element) => {
+            const candidate = element;
+            const visible = (node) => {
+                if (node.hidden || node.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                    return false;
+                const style = window.getComputedStyle(node);
+                const rect = node.getBoundingClientRect();
+                return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
+                    && (rect.width > 0 || rect.height > 0);
+            };
+            const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+            const composers = [...new Set(textboxes
+                    .map(textbox => textbox.closest("form")
+                    ?? textbox.closest("[data-testid*='composer' i]")
+                    ?? textbox.closest("[aria-label*='composer' i]")
+                    ?? textbox.closest("[class*='composer' i]"))
+                    .filter((value) => value !== null))];
+            if (composers.length !== 1 || !composers[0].contains(candidate))
+                return false;
+            const all = Array.from(composers[0].querySelectorAll("input[type='file']"))
+                .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
+            const preferred = all.filter(input => input.id === "upload-files");
+            const nonImage = all.filter(input => input.getAttribute("accept") !== "image/*");
+            const resolved = preferred.length > 0 ? preferred : nonImage.length > 0 ? nonImage : all;
+            return resolved.length === 1 && resolved[0] === candidate;
+        }, undefined, { timeoutMs }), `File-input ${index + 1} scope check`, 2_000);
+        if (scoped)
+            eligible.push(input);
+    }
+    if (eligible.length !== 1) {
+        throw new Error("The active browser exposes no sanctioned native file handoff because the active composer file input was not uniquely available.");
+    }
+    return eligible[0];
+}
+async function assertControlInUniqueActiveComposer(control, deadline, label) {
+    if (control === undefined || typeof control.evaluate !== "function") {
+        throw new Error(`${label} could not be scoped to the active composer.`);
     }
-    const input = requiredLocator(page, cssSelectors.hiddenFileInputs).last?.() ?? requiredLocator(page, cssSelectors.hiddenFileInputs);
+    const scoped = await withinNativeAttachmentDeadline(deadline, timeoutMs => control.evaluate((element) => {
+        const visible = (node) => {
+            if (node.hidden || node.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const style = window.getComputedStyle(node);
+            const rect = node.getBoundingClientRect();
+            return style.display !== "none" && style.visibility !== "hidden" && style.opacity !== "0"
+                && (rect.width > 0 || rect.height > 0);
+        };
+        const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+        const composers = [...new Set(textboxes
+                .map(textbox => textbox.closest("form")
+                ?? textbox.closest("[data-testid*='composer' i]")
+                ?? textbox.closest("[aria-label*='composer' i]")
+                ?? textbox.closest("[class*='composer' i]"))
+                .filter((value) => value !== null))];
+        return composers.length === 1 && composers[0].contains(element);
+    }, undefined, { timeoutMs }), `${label} scope check`, 2_000);
+    if (!scoped)
+        throw new Error(`${label} was outside the unique active composer.`);
+}
+async function setResolvedFileInput(input, files, deadline, mutationState) {
     if (typeof input.setInputFiles !== "function") {
-        await setFilesViaDomDataTransfer(page, files);
-        return;
+        throw new Error("The active browser exposes no sanctioned native file handoff for ChatGPT's file input.");
     }
-    await input.setInputFiles(files.map(file => file.path));
+    mutationState.handoffStarted = true;
+    await withinNativeAttachmentDeadline(deadline, timeoutMs => input.setInputFiles(files.map(file => file.path), { timeoutMs }), "Direct file-input handoff", 15_000);
 }
-async function readBrowserInputDiagnostic(page) {
+async function readBrowserInputDiagnostic(page, timeoutMs) {
     if (typeof page.evaluate !== "function") {
         return undefined;
     }
     return page.evaluate(() => {
-        const input = (document.querySelector("#upload-files")
-            || document.querySelector("input[type='file']:not([accept='image/*'])")
-            || document.querySelector("input[type='file']"));
-        if (!input) {
-            return { files: [] };
-        }
+        const visible = (element) => {
+            if (element.hidden || element.closest("[hidden], [inert], [aria-hidden='true']") !== null)
+                return false;
+            const style = window.getComputedStyle(element);
+            if (style.display === "none" || style.visibility === "hidden" || style.opacity === "0")
+                return false;
+            const rect = element.getBoundingClientRect();
+            return rect.width > 0 || rect.height > 0;
+        };
+        const textboxes = Array.from(document.querySelectorAll("textarea, [contenteditable='true'], [role='textbox']")).filter(visible);
+        const composers = [...new Set(textboxes
+                .map(textbox => textbox.closest("form")
+                ?? textbox.closest("[data-testid*='composer' i]")
+                ?? textbox.closest("[aria-label*='composer' i]")
+                ?? textbox.closest("[class*='composer' i]"))
+                .filter((value) => value !== null))];
+        if (composers.length !== 1)
+            return undefined;
+        const allInputs = Array.from(composers[0].querySelectorAll("input[type='file']"))
+            .filter(input => !input.disabled && input.getAttribute("aria-disabled") !== "true");
+        const preferred = allInputs.filter(input => input.id === "upload-files");
+        const nonImage = allInputs.filter(input => input.getAttribute("accept") !== "image/*");
+        const inputs = preferred.length > 0 ? preferred : nonImage.length > 0 ? nonImage : allInputs;
+        if (inputs.length !== 1)
+            return undefined;
+        const input = inputs[0];
         return {
             files: Array.from(input.files ?? []).map(file => {
                 const diagnostic = {
@@ -608,40 +1340,7 @@ async function readBrowserInputDiagnostic(page) {
                 return diagnostic;
             })
         };
-    });
-}
-async function setFilesViaDomDataTransfer(page, files) {
-    const totalBytes = files.reduce((sum, file) => sum + file.bytes, 0);
-    const maxInlineBytes = 25 * 1024 * 1024;
-    if (totalBytes > maxInlineBytes) {
-        throw new Error(`No file chooser or setInputFiles support is available for large uploads. ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`);
-    }
-    if (typeof page.evaluate !== "function") {
-        throw new Error(`No file chooser, setInputFiles, or page.evaluate support is available for file upload. ${CODEX_UPLOAD_PERMISSION_FIX} ${CHROME_FILE_URL_PERMISSION_FIX}`);
-    }
-    const payload = await Promise.all(files.map(async (file) => ({
-        name: file.name,
-        bytesBase64: (await readFile(file.path)).toString("base64"),
-        type: guessMimeType(file.name)
-    })));
-    await page.evaluate(async (payload) => {
-        const input = (document.querySelector("#upload-files") || document.querySelector("input[type='file']:not([accept='image/*'])") || document.querySelector("input[type='file']"));
-        if (!input) {
-            throw new Error("No ChatGPT file input found in the DOM.");
-        }
-        const dataTransfer = new DataTransfer();
-        for (const item of payload) {
-            const binary = atob(item.bytesBase64);
-            const bytes = new Uint8Array(binary.length);
-            for (let index = 0; index < binary.length; index += 1) {
-                bytes[index] = binary.charCodeAt(index);
-            }
-            dataTransfer.items.add(new File([bytes], item.name, { type: item.type }));
-        }
-        input.files = dataTransfer.files;
-        input.dispatchEvent(new Event("input", { bubbles: true }));
-        input.dispatchEvent(new Event("change", { bubbles: true }));
-    }, payload);
+    }, undefined, { timeoutMs });
 }
 function guessMimeType(name) {
     if (/\.txt$/i.test(name))
@@ -656,9 +1355,17 @@ function guessMimeType(name) {
         return "text/markdown";
     return "application/octet-stream";
 }
-function isUploadBridgeBlocker(error) {
+function isUploadPermissionBlocker(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /Allow access to file URLs|Codex Settings > Computer Use|Browser Use rejected|requested that files not be uploaded|permission denied|browser blocked|fileChooser\.setFiles failed[^\n]*(?:Not allowed|permission|denied|rejected)/i.test(message);
+}
+function isUploadTransportFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return /native pipe closed before response|browser bridge.*(?:closed|disconnect)|connection (?:was )?closed|target page, context or browser has been closed/i.test(message);
+}
+function isUploadPathFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
-    return /DataTransfer is not a constructor|No file chooser|setInputFiles|Allow access to file URLs|file upload|fileChooser\.setFiles failed|Not allowed|No ChatGPT upload path completed/i.test(message);
+    return /No ChatGPT upload path completed/i.test(message);
 }
 function uploadPermissionMessage(error) {
     const message = error instanceof Error ? error.message : String(error);