diff --git a/README.md b/README.md
index 381bcbb..f04cb19 100644
--- a/README.md
+++ b/README.md
@@ -219,6 +219,8 @@ Firefox desktop is also a supported release target, but its support contract is
 different:
 
 - compile/run, Monaco, and extension-runtime flows are supported
+- programs that read `std::cin` use pre-supplied buffered stdin (up to 256 KiB);
+  live prompt-by-prompt stdin remains available on Chromium-family builds
 - file open/save and folder import use fallback browser flows rather than
   Chromium File System Access APIs
 - persistent folder write-back and directory-handle session restore may be
@@ -232,7 +234,7 @@ Full parity requires:
 - File System Access APIs (`showOpenFilePicker`, `showDirectoryPicker`,
   `showSaveFilePicker`)
 - Web Workers and WebAssembly
-- `SharedArrayBuffer` and `Atomics.waitAsync` for interactive stdin
+- `SharedArrayBuffer` and `Atomics.waitAsync` for Chromium live interactive stdin
 - Managed browser policies that allow local file read/write prompts
 
 ### Release-blocking checks
@@ -459,8 +461,8 @@ manual/GitHub-distributed channel.
 4. For self-distribution, verify that the protected release workflow produced a
    signed artifact under `release/firefox-unlisted/`.
 5. Install the signed XPI in Firefox and complete the manual QA checklist
-   below, paying special attention to the documented workspace-persistence
-   limitations.
+   in `docs/firefox-stdin-runtime-acceptance.md`, paying special attention to
+   buffered stdin and the documented workspace-persistence limitations.
 
 ### Manual release QA checklist
 
@@ -524,7 +526,9 @@ Copy the resulting `clang.js` and `clang.wasm` into `dist/clang/`.
   script" dialog.  The compiler runs in a dedicated Web Worker to avoid blocking
   the UI.
 - **Browser scope**: Full parity targets desktop Chrome, Edge, Brave, and
-  Chromium. Firefox and Safari are outside the current release target.
+  Chromium. Firefox is a compatible release target with buffered stdin and
+  workspace-persistence limitations; Safari is outside the current release
+  target.
 - **Managed browsers**: Enterprise policies that block File System Access prompts
   prevent full local workspace read/write support.
 
diff --git a/docs/firefox-stdin-runtime-acceptance.md b/docs/firefox-stdin-runtime-acceptance.md
new file mode 100644
index 0000000..561787b
--- /dev/null
+++ b/docs/firefox-stdin-runtime-acceptance.md
@@ -0,0 +1,88 @@
+# Firefox buffered stdin runtime acceptance
+
+Use this procedure to prove GitHub issue #53 is fixed in a real Firefox
+extension context. `npm run test:browser:firefox` validates packaging and
+manifest compatibility, but it does not execute a compiled program in Firefox.
+
+## Setup
+
+1. Run:
+
+   ```bash
+   npm run build
+   npm run test:browser:firefox
+   ```
+
+2. Open `about:debugging#/runtime/this-firefox` in Firefox.
+3. Choose **Load Temporary Add-on** and select `dist-firefox/manifest.json`.
+   For release validation, repeat with the signed XPI under
+   `release/firefox-unlisted/`.
+4. Open browser.cpp from the extension toolbar action.
+
+Record the Firefox version and the unpacked directory or signed XPI path used.
+
+## Test program
+
+Replace the editor contents with exactly:
+
+```cpp
+#include <iostream>
+#include <string>
+
+int main() {
+    std::string name;
+    int age = 0;
+
+    std::cout << "Name? ";
+    std::cin >> name;
+    std::cout << "Age? ";
+    std::cin >> age;
+
+    if (!std::cin) {
+        std::cerr << "input failed\n";
+        return 2;
+    }
+
+    std::cout << "\nHello " << name << ", next year " << (age + 1) << "\n";
+    return 0;
+}
+```
+
+Choose **Compile and Run**. In the **Pre-supplied stdin** dialog, enter exactly:
+
+```text
+Ada
+41
+```
+
+Keep the final newline after `41`, then choose **Run program**.
+
+## Expected result
+
+The process exits with code `0`, stderr is empty, and stdout is exactly:
+
+```text
+Name? Age?␠
+Hello Ada, next year 42
+```
+
+The `␠` marker represents the single trailing ASCII space emitted after
+`Age?`.
+
+The terminal and browser console must not contain any of these strings:
+
+```text
+Interactive stdin requires SharedArrayBuffer
+Cross-Origin-Opener-Policy
+Cross-Origin-Embedder-Policy
+```
+
+## PR evidence
+
+Paste the following into the pull request:
+
+- Firefox version
+- tested artifact path
+- observed stdout
+- confirmation that stderr was empty
+- confirmation that none of the old SharedArrayBuffer/COOP/COEP errors appeared
diff --git a/docs/release-playbook.md b/docs/release-playbook.md
index 3915296..8b4f5be 100644
--- a/docs/release-playbook.md
+++ b/docs/release-playbook.md
@@ -87,7 +87,8 @@ real Firefox desktop build:
 2. Confirm Monaco renders and the default sample appears without blocking
    console/runtime errors.
 3. Compile and run the default sample program.
-4. Run a program that reads stdin and confirm terminal interaction works.
+4. Complete `docs/firefox-stdin-runtime-acceptance.md` and confirm pre-supplied
+   buffered stdin works without the old SharedArrayBuffer/COOP/COEP error.
 5. Open a local source file with Firefox's fallback picker and save changes.
 6. Import a folder, compile a multi-file project, and confirm diagnostics appear
    in the expected file.
diff --git a/manifest.json b/manifest.json
index b3e4664..68946aa 100644
--- a/manifest.json
+++ b/manifest.json
@@ -3,7 +3,7 @@
   "name": "browser.cpp",
   "short_name": "browser.cpp",
   "description": "In-browser C++20 IDE powered by Monaco Editor and WASM Clang",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "minimum_chrome_version": "105",
   "icons": {
     "16": "icons/icon16.png",
diff --git a/package-lock.json b/package-lock.json
index 2b2a06c..dc9be4f 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "browser.cpp",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "browser.cpp",
-      "version": "0.3.2",
+      "version": "0.4.0",
       "dependencies": {
         "@xterm/addon-fit": "^0.11.0",
         "@xterm/addon-web-links": "^0.12.0",
diff --git a/package.json b/package.json
index fee44ec..47d8f83 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "browser.cpp",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "In-browser C++20 IDE with WASM Clang toolchain",
   "private": true,
   "scripts": {
@@ -10,7 +10,7 @@
     "lint": "eslint .",
     "build": "npm run build:webpack && npm run build:targets",
     "build:firefox": "npm run build",
-    "test:e2e": "node --experimental-detect-module --test scripts/e2e-session-persistence.test.mjs scripts/e2e-session-restore-choice.test.mjs scripts/e2e-multifile-build.test.mjs scripts/e2e-workspace-file-tracking.test.mjs scripts/e2e-terminal-mkdir.test.mjs scripts/e2e-terminal-stop.test.mjs scripts/e2e-terminal-git-removal.test.mjs scripts/e2e-terminal-stop-icon.test.mjs scripts/e2e-browser-compatibility.test.mjs scripts/e2e-firefox-compatibility.test.mjs scripts/e2e-wasi-shim.test.mjs scripts/e2e-release-packaging.test.mjs",
+    "test:e2e": "node --experimental-detect-module --test scripts/e2e-session-persistence.test.mjs scripts/e2e-session-restore-choice.test.mjs scripts/e2e-multifile-build.test.mjs scripts/e2e-workspace-file-tracking.test.mjs scripts/e2e-terminal-mkdir.test.mjs scripts/e2e-terminal-stop.test.mjs scripts/e2e-terminal-git-removal.test.mjs scripts/e2e-terminal-stop-icon.test.mjs scripts/e2e-buffered-stdin-ui.test.mjs scripts/e2e-browser-compatibility.test.mjs scripts/e2e-firefox-compatibility.test.mjs scripts/e2e-wasi-shim.test.mjs scripts/e2e-run-request.test.mjs scripts/e2e-release-packaging.test.mjs",
     "test:preflight-clang": "node scripts/preflight-clang-artifacts.js",
     "test:browser:chrome": "npm run test:preflight-clang && node scripts/smoke-browser.mjs chrome",
     "test:browser:edge": "npm run test:preflight-clang && node scripts/smoke-browser.mjs edge",
diff --git a/scripts/build-target-manifest.js b/scripts/build-target-manifest.js
index b8d5a13..ee19c67 100644
--- a/scripts/build-target-manifest.js
+++ b/scripts/build-target-manifest.js
@@ -42,6 +42,8 @@ function createChromiumManifest(baseManifest) {
 function createFirefoxManifest(baseManifest, firefoxOverlay) {
   const manifest = mergeObjects(baseManifest, firefoxOverlay);
   delete manifest.minimum_chrome_version;
+  delete manifest.cross_origin_opener_policy;
+  delete manifest.cross_origin_embedder_policy;
   manifest.background = {
     scripts: ['firefox-background.js'],
   };
diff --git a/scripts/e2e-browser-compatibility.test.mjs b/scripts/e2e-browser-compatibility.test.mjs
index b328d1e..a04fe2b 100644
--- a/scripts/e2e-browser-compatibility.test.mjs
+++ b/scripts/e2e-browser-compatibility.test.mjs
@@ -46,6 +46,8 @@ test('e2e: reports full Chromium-family capability support', () => {
   assert.deepEqual(report.limitations, []);
   assert.equal(report.capabilities.directoryPicker, true);
   assert.equal(report.capabilities.sharedArrayBuffer, true);
+  assert.equal(report.capabilities.interactiveStdin, true);
+  assert.equal(report.capabilities.stdinMode, 'interactive');
 });
 
 test('e2e: reports missing full-parity browser APIs', () => {
diff --git a/scripts/e2e-buffered-stdin-ui.test.mjs b/scripts/e2e-buffered-stdin-ui.test.mjs
new file mode 100644
index 0000000..ac89b73
--- /dev/null
+++ b/scripts/e2e-buffered-stdin-ui.test.mjs
@@ -0,0 +1,25 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { readFile } from 'node:fs/promises';
+
+test('e2e: buffered stdin dialog has accessible controls and status feedback', async () => {
+  const html = await readFile('src/ui/index.html', 'utf8');
+  const dialog = html.match(/<dialog id="buffered-stdin-dialog"[\s\S]*?<\/dialog>/)?.[0];
+
+  assert.ok(dialog, 'buffered stdin dialog markup should exist');
+  assert.match(dialog, /aria-labelledby="buffered-stdin-title"/);
+  assert.match(dialog, /<label for="buffered-stdin-input"/);
+  assert.match(dialog, /<textarea[\s\S]*id="buffered-stdin-input"[\s\S]*aria-describedby="buffered-stdin-feedback"/);
+  assert.match(dialog, /<textarea[\s\S]*maxlength="262144"/);
+  assert.match(dialog, /id="buffered-stdin-feedback"[\s\S]*aria-live="polite"/);
+  assert.match(dialog, /<button[^>]*id="buffered-stdin-cancel"/);
+  assert.match(dialog, /<button[^>]*id="buffered-stdin-run"/);
+});
+
+test('e2e: buffered stdin dialog styles remain usable in narrow extension windows', async () => {
+  const css = await readFile('src/ui/styles.css', 'utf8');
+
+  assert.match(css, /#buffered-stdin-dialog\s*\{[\s\S]*width:\s*min\(/);
+  assert.match(css, /#buffered-stdin-input\s*\{[\s\S]*resize:\s*vertical/);
+  assert.match(css, /buffered-stdin-feedback/);
+});
diff --git a/scripts/e2e-firefox-compatibility.test.mjs b/scripts/e2e-firefox-compatibility.test.mjs
index 5f2a215..2057491 100644
--- a/scripts/e2e-firefox-compatibility.test.mjs
+++ b/scripts/e2e-firefox-compatibility.test.mjs
@@ -35,9 +35,9 @@ function firefoxLikeRoot(overrides = {}) {
     },
     Worker() {},
     WebAssembly: { instantiate() {} },
-    SharedArrayBuffer() {},
-    Atomics: { waitAsync() {} },
-    crossOriginIsolated: true,
+    SharedArrayBuffer: undefined,
+    Atomics: {},
+    crossOriginIsolated: false,
     ...overrides,
   };
 }
@@ -54,8 +54,12 @@ test('e2e: Firefox compatibility report accepts supported fallback-based capabil
   assert.equal(report.ok, true);
   assert.equal(report.capabilities.browserFamily, 'firefox');
   assert.equal(report.capabilities.supportLevel, 'compatible');
+  assert.equal(report.capabilities.interactiveStdin, false);
+  assert.equal(report.capabilities.stdinMode, 'buffered');
   assert.deepEqual(report.missing, []);
+  assert.ok(report.limitations.some((item) => item.key === 'limitedInteractiveStdin'));
   assert.ok(report.limitations.some((item) => item.key === 'firefoxWorkspacePersistence'));
+  assert.ok(message.includes('pre-supplied buffered stdin'));
   assert.ok(message.includes('Persistent folder write-back'));
 });
 
@@ -70,6 +74,8 @@ test('e2e: target manifest generation creates a Firefox manifest without Chromiu
       service_worker: 'service-worker.js',
       type: 'module',
     },
+    cross_origin_opener_policy: { value: 'same-origin' },
+    cross_origin_embedder_policy: { value: 'require-corp' },
   });
   writeJson(path.join(repoRoot, 'manifest.firefox.json'), {
     browser_specific_settings: {
@@ -92,6 +98,16 @@ test('e2e: target manifest generation creates a Firefox manifest without Chromiu
 
   assert.equal(firefoxManifest.minimum_chrome_version, undefined);
   assert.equal(firefoxManifest.background.service_worker, undefined);
+  assert.equal(firefoxManifest.cross_origin_opener_policy, undefined);
+  assert.equal(firefoxManifest.cross_origin_embedder_policy, undefined);
+  assert.deepEqual(
+    result.chromiumManifest.cross_origin_opener_policy,
+    { value: 'same-origin' }
+  );
+  assert.deepEqual(
+    result.chromiumManifest.cross_origin_embedder_policy,
+    { value: 'require-corp' }
+  );
   assert.deepEqual(firefoxManifest.background.scripts, ['firefox-background.js']);
   assert.equal(firefoxManifest.browser_specific_settings.gecko.id, 'browser.cpp@example.test');
 });
@@ -105,6 +121,8 @@ test('e2e: createFirefoxManifest strips Chromium-specific background configurati
         type: 'module',
       },
       minimum_chrome_version: '105',
+      cross_origin_opener_policy: { value: 'same-origin' },
+      cross_origin_embedder_policy: { value: 'require-corp' },
     },
     {
       browser_specific_settings: {
@@ -117,5 +135,7 @@ test('e2e: createFirefoxManifest strips Chromium-specific background configurati
 
   assert.equal(manifest.minimum_chrome_version, undefined);
   assert.equal(manifest.background.service_worker, undefined);
+  assert.equal(manifest.cross_origin_opener_policy, undefined);
+  assert.equal(manifest.cross_origin_embedder_policy, undefined);
   assert.deepEqual(manifest.background.scripts, ['firefox-background.js']);
 });
diff --git a/scripts/e2e-run-request.test.mjs b/scripts/e2e-run-request.test.mjs
new file mode 100644
index 0000000..208119e
--- /dev/null
+++ b/scripts/e2e-run-request.test.mjs
@@ -0,0 +1,81 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  BUFFERED_STDIN_MAX_BYTES,
+  validateRunRequest,
+} from '../src/workers/run-request.mjs';
+
+function interactiveRequest(overrides = {}) {
+  return {
+    type: 'run',
+    stdinMode: 'interactive',
+    sharedBuffer: new SharedArrayBuffer(16),
+    vfsFiles: [{ path: 'input.txt', bytes: new Uint8Array([1, 2]) }],
+    binaryBytes: new Uint8Array([0, 97, 115, 109]),
+    ...overrides,
+  };
+}
+
+test('e2e: worker run contract accepts and normalizes all stdin modes', () => {
+  const interactive = validateRunRequest(interactiveRequest());
+  assert.equal(interactive.ok, true);
+  assert.equal(interactive.value.stdin.mode, 'interactive');
+
+  const buffered = validateRunRequest(interactiveRequest({
+    stdinMode: 'buffered',
+    sharedBuffer: undefined,
+    stdinBuffer: new TextEncoder().encode('Ada\n41\n').buffer,
+  }));
+  assert.equal(buffered.ok, true);
+  assert.equal(buffered.value.stdin.mode, 'buffered');
+  assert.deepEqual(
+    [...buffered.value.stdin.bytes],
+    [...new TextEncoder().encode('Ada\n41\n')]
+  );
+
+  const none = validateRunRequest(interactiveRequest({
+    stdinMode: 'none',
+    sharedBuffer: undefined,
+  }));
+  assert.equal(none.ok, true);
+  assert.deepEqual(none.value.stdin, { mode: 'none' });
+});
+
+test('e2e: worker run contract rejects mismatched stdin variants', () => {
+  const cases = [
+    interactiveRequest({ sharedBuffer: new ArrayBuffer(16) }),
+    interactiveRequest({ stdinMode: 'buffered', sharedBuffer: undefined, stdinBuffer: 'Ada' }),
+    interactiveRequest({ stdinMode: 'none', sharedBuffer: new SharedArrayBuffer(16) }),
+    interactiveRequest({ stdinMode: 'unknown' }),
+  ];
+
+  for (const request of cases) {
+    const result = validateRunRequest(request);
+    assert.equal(result.ok, false);
+    assert.match(result.error, /stdin/i);
+  }
+});
+
+test('e2e: worker run contract rejects buffered stdin above the shared size limit', () => {
+  const result = validateRunRequest(interactiveRequest({
+    stdinMode: 'buffered',
+    sharedBuffer: undefined,
+    stdinBuffer: new Uint8Array(BUFFERED_STDIN_MAX_BYTES + 1),
+  }));
+
+  assert.equal(result.ok, false);
+  assert.match(result.error, /256 KiB/);
+});
+
+test('e2e: worker run contract rejects invalid binary and VFS byte fields', () => {
+  const invalidBinary = validateRunRequest(interactiveRequest({ binaryBytes: 'wasm' }));
+  assert.equal(invalidBinary.ok, false);
+  assert.match(invalidBinary.error, /binaryBytes/);
+
+  const invalidVfs = validateRunRequest(interactiveRequest({
+    vfsFiles: [{ path: 'input.txt', bytes: [1, 2] }],
+  }));
+  assert.equal(invalidVfs.ok, false);
+  assert.match(invalidVfs.error, /vfsFiles/);
+});
diff --git a/scripts/e2e-terminal-stop.test.mjs b/scripts/e2e-terminal-stop.test.mjs
index e222978..1e7e932 100644
--- a/scripts/e2e-terminal-stop.test.mjs
+++ b/scripts/e2e-terminal-stop.test.mjs
@@ -6,6 +6,7 @@ import {
   __handleTerminalKeyForTesting,
   __setTerminalTestHarness,
   clearTerminal,
+  onRunStart,
   onRunResult,
   printInfo,
   showInitialPrompt,
@@ -13,9 +14,14 @@ import {
   stopRun,
 } from '../src/ui/terminal.js';
 
-function setupTerminalHarness() {
+function setupTerminalHarness({
+  supportsInteractiveStdin = true,
+  requestBufferedStdin = async () => '',
+  onRun,
+} = {}) {
   const writes = [];
   const runStateChanges = [];
+  const runPreparationChanges = [];
   const stopCalls = [];
   const runCalls = [];
   const fakeTerm = {
@@ -26,12 +32,15 @@ function setupTerminalHarness() {
   __setTerminalTestHarness({
     term: fakeTerm,
     lastBuiltArtifactPath: 'a.out',
-    onRun: (sharedBuffer) => runCalls.push(sharedBuffer),
+    onRun: onRun || ((request) => runCalls.push(request)),
     onStopRun: () => stopCalls.push('stop'),
     onRunStateChange: (running) => runStateChanges.push(running),
+    onRunPreparationStateChange: (preparing) => runPreparationChanges.push(preparing),
+    supportsInteractiveStdin: () => supportsInteractiveStdin,
+    requestBufferedStdin,
   });
 
-  return { writes, runStateChanges, stopCalls, runCalls };
+  return { writes, runStateChanges, runPreparationChanges, stopCalls, runCalls };
 }
 
 function ctrlCEvent() {
@@ -79,10 +88,11 @@ test('e2e: clearing during startup does not reveal the initial prompt early', ()
   assert.ok(output.indexOf('Clang WASM compiler loaded') < output.indexOf('browser.cpp'));
 });
 
-test('e2e: Ctrl+C while running stops the program once and restores the prompt', () => {
+test('e2e: Ctrl+C while running stops the program once and restores the prompt', async () => {
   const ctx = setupTerminalHarness();
 
-  startRun();
+  assert.equal(await startRun(), true);
+  onRunStart({ stdinMode: 'interactive' });
   __handleTerminalKeyForTesting('', ctrlCEvent());
   __handleTerminalKeyForTesting('', ctrlCEvent());
 
@@ -94,10 +104,11 @@ test('e2e: Ctrl+C while running stops the program once and restores the prompt',
   assert.ok(ctx.writes.join('').includes('Process interrupted.'));
 });
 
-test('e2e: stopRun is idempotent for repeated button presses during one run', () => {
+test('e2e: stopRun is idempotent for repeated button presses during one run', async () => {
   const ctx = setupTerminalHarness();
 
-  startRun();
+  assert.equal(await startRun(), true);
+  onRunStart({ stdinMode: 'interactive' });
   assert.equal(stopRun(), true);
   assert.equal(stopRun(), false);
 
@@ -112,16 +123,104 @@ test('e2e: Ctrl+C while idle keeps shell-line interrupt behavior', () => {
 
   assert.deepEqual(ctx.stopCalls, []);
   assert.deepEqual(ctx.runStateChanges, []);
+  assert.deepEqual(ctx.runPreparationChanges, []);
   assert.equal(__getTerminalStateForTesting().running, false);
   assert.ok(ctx.writes.join('').includes('^C'));
 });
 
-test('e2e: normal run completion reports not-running state', () => {
+test('e2e: normal run completion reports not-running state', async () => {
   const ctx = setupTerminalHarness();
 
-  startRun();
+  assert.equal(await startRun(), true);
+  onRunStart({ stdinMode: 'interactive' });
   onRunResult({ exitCode: 0 });
 
   assert.deepEqual(ctx.runStateChanges, [true, false]);
   assert.equal(__getTerminalStateForTesting().running, false);
 });
+
+test('e2e: non-SAB run posts UTF-8 buffered stdin before entering running state', async () => {
+  const ctx = setupTerminalHarness({
+    supportsInteractiveStdin: false,
+    requestBufferedStdin: async () => 'Grüße\n',
+  });
+
+  assert.equal(await startRun(), true);
+
+  assert.equal(ctx.runCalls.length, 1);
+  assert.equal(ctx.runCalls[0].stdinMode, 'buffered');
+  assert.deepEqual(
+    [...ctx.runCalls[0].stdinBuffer],
+    [...new TextEncoder().encode('Grüße\n')]
+  );
+  assert.deepEqual(ctx.runStateChanges, []);
+  assert.deepEqual(ctx.runPreparationChanges, [true]);
+  assert.equal(__getTerminalStateForTesting().preparingRun, true);
+
+  onRunStart({ stdinMode: 'buffered' });
+  assert.deepEqual(ctx.runStateChanges, [true]);
+  assert.deepEqual(ctx.runPreparationChanges, [true, false]);
+  assert.equal(__getTerminalStateForTesting().preparingRun, false);
+});
+
+test('e2e: canceling buffered stdin restores idle state and posts no run request', async () => {
+  const ctx = setupTerminalHarness({
+    supportsInteractiveStdin: false,
+    requestBufferedStdin: async () => null,
+  });
+
+  assert.equal(await startRun(), false);
+
+  assert.deepEqual(ctx.runCalls, []);
+  assert.deepEqual(ctx.runPreparationChanges, [true, false]);
+  assert.equal(__getTerminalStateForTesting().preparingRun, false);
+  assert.equal(__getTerminalStateForTesting().running, false);
+});
+
+test('e2e: duplicate run while buffered input is pending posts only one request', async () => {
+  let resolveInput;
+  const pendingInput = new Promise((resolve) => { resolveInput = resolve; });
+  const ctx = setupTerminalHarness({
+    supportsInteractiveStdin: false,
+    requestBufferedStdin: () => pendingInput,
+  });
+
+  const firstRun = startRun();
+  assert.equal(await startRun(), false);
+  resolveInput('Ada\n');
+  assert.equal(await firstRun, true);
+
+  assert.equal(ctx.runCalls.length, 1);
+  assert.equal(ctx.runCalls[0].stdinMode, 'buffered');
+});
+
+test('e2e: run callback failure restores idle state without run-start', async () => {
+  const writes = [];
+  __setTerminalTestHarness({
+    term: { clear() {}, write(text) { writes.push(text); } },
+    lastBuiltArtifactPath: 'a.out',
+    onRun: async () => { throw new Error('worker unavailable'); },
+    supportsInteractiveStdin: () => true,
+  });
+
+  assert.equal(await startRun(), false);
+
+  const state = __getTerminalStateForTesting();
+  assert.equal(state.preparingRun, false);
+  assert.equal(state.running, false);
+  assert.ok(writes.join('').includes('Could not start program'));
+});
+
+test('e2e: oversized buffered stdin restores idle state and posts no run request', async () => {
+  const ctx = setupTerminalHarness({
+    supportsInteractiveStdin: false,
+    requestBufferedStdin: async () => 'x'.repeat((256 * 1024) + 1),
+  });
+
+  assert.equal(await startRun(), false);
+
+  assert.deepEqual(ctx.runCalls, []);
+  assert.deepEqual(ctx.runPreparationChanges, [true, false]);
+  assert.equal(__getTerminalStateForTesting().preparingRun, false);
+  assert.ok(ctx.writes.join('').includes('256 KiB'));
+});
diff --git a/scripts/e2e-wasi-shim.test.mjs b/scripts/e2e-wasi-shim.test.mjs
index 64b6049..d80f8f0 100644
--- a/scripts/e2e-wasi-shim.test.mjs
+++ b/scripts/e2e-wasi-shim.test.mjs
@@ -3,11 +3,10 @@ import assert from 'node:assert/strict';
 
 import { createWasiRuntime } from '../src/workers/wasi-shim.mjs';
 
-function makeRuntime() {
-  const sharedBuffer = new SharedArrayBuffer(8 + 32);
+function makeRuntime(stdin = { mode: 'interactive', sharedBuffer: new SharedArrayBuffer(8 + 32) }) {
   const writes = [];
   const runtime = createWasiRuntime({
-    sharedBuffer,
+    stdin,
     onStdout: (text) => writes.push(['stdout', text]),
     onStderr: (text) => writes.push(['stderr', text]),
   });
@@ -16,12 +15,94 @@ function makeRuntime() {
   return { runtime, writes };
 }
 
+function configureRead(memory, spans, iovsPtr = 16, nreadPtr = 8) {
+  const dv = new DataView(memory.buffer);
+  spans.forEach(({ base, len }, index) => {
+    dv.setUint32(iovsPtr + (index * 8), base, true);
+    dv.setUint32(iovsPtr + (index * 8) + 4, len, true);
+  });
+  return { iovsPtr, nreadPtr, iovsLen: spans.length };
+}
+
+function readStdin(runtime, spans) {
+  const memory = runtime.getMemoryForTesting();
+  const request = configureRead(memory, spans);
+  const errno = runtime.wasi.fd_read(0, request.iovsPtr, request.iovsLen, request.nreadPtr);
+  const nread = new DataView(memory.buffer).getUint32(request.nreadPtr, true);
+  return { errno, nread, bytes: new Uint8Array(memory.buffer) };
+}
+
 function writeString(memory, ptr, text) {
   const bytes = new TextEncoder().encode(text);
   new Uint8Array(memory.buffer).set(bytes, ptr);
   return bytes.length;
 }
 
+test('e2e: wasi shim drains buffered stdin across iovecs and repeated reads', () => {
+  const input = new TextEncoder().encode('Ada\n41');
+  const { runtime } = makeRuntime({ mode: 'buffered', bytes: input });
+
+  const first = readStdin(runtime, [
+    { base: 128, len: 2 },
+    { base: 160, len: 3 },
+  ]);
+  assert.equal(first.errno, 0);
+  assert.equal(first.nread, 5);
+  assert.equal(new TextDecoder().decode(first.bytes.subarray(128, 130)), 'Ad');
+  assert.equal(new TextDecoder().decode(first.bytes.subarray(160, 163)), 'a\n4');
+
+  const second = readStdin(runtime, [{ base: 192, len: 8 }]);
+  assert.equal(second.errno, 0);
+  assert.equal(second.nread, 1);
+  assert.equal(new TextDecoder().decode(second.bytes.subarray(192, 193)), '1');
+
+  const eof = readStdin(runtime, [{ base: 224, len: 8 }]);
+  assert.equal(eof.errno, 0);
+  assert.equal(eof.nread, 0);
+});
+
+test('e2e: wasi shim preserves UTF-8 bytes and input without a trailing newline', () => {
+  const input = new TextEncoder().encode('Grüße');
+  const { runtime } = makeRuntime({ mode: 'buffered', bytes: input });
+
+  const result = readStdin(runtime, [{ base: 128, len: 32 }]);
+
+  assert.equal(result.errno, 0);
+  assert.equal(result.nread, input.length);
+  assert.deepEqual(
+    [...result.bytes.subarray(128, 128 + result.nread)],
+    [...input]
+  );
+});
+
+test('e2e: wasi shim returns immediate EOF for empty buffered and none stdin', () => {
+  for (const stdin of [
+    { mode: 'buffered', bytes: new Uint8Array() },
+    { mode: 'none' },
+  ]) {
+    const { runtime } = makeRuntime(stdin);
+    const result = readStdin(runtime, [{ base: 128, len: 8 }]);
+    assert.equal(result.errno, 0);
+    assert.equal(result.nread, 0);
+  }
+});
+
+test('e2e: wasi shim drains long buffered input without truncation', () => {
+  const input = new Uint8Array(32 * 1024);
+  input.forEach((_, index) => { input[index] = index % 251; });
+  const { runtime } = makeRuntime({ mode: 'buffered', bytes: input });
+  const memory = { buffer: new ArrayBuffer(64 * 1024) };
+  runtime.setMemory(memory);
+
+  const result = readStdin(runtime, [{ base: 1024, len: input.length }]);
+
+  assert.equal(result.nread, input.length);
+  assert.deepEqual(
+    result.bytes.subarray(1024, 1024 + input.length),
+    input
+  );
+});
+
 test('e2e: wasi shim exposes callable fd_fdstat_set_flags', () => {
   const { runtime } = makeRuntime();
   assert.equal(typeof runtime.wasi.fd_fdstat_set_flags, 'function');
diff --git a/scripts/smoke-firefox.mjs b/scripts/smoke-firefox.mjs
index 2720a14..f4885c0 100644
--- a/scripts/smoke-firefox.mjs
+++ b/scripts/smoke-firefox.mjs
@@ -20,6 +20,8 @@ function main() {
 
   assert.equal(manifest.background?.service_worker, undefined);
   assert.deepEqual(manifest.background?.scripts, ['firefox-background.js']);
+  assert.equal(manifest.cross_origin_opener_policy, undefined);
+  assert.equal(manifest.cross_origin_embedder_policy, undefined);
   assert.equal(manifest.browser_specific_settings?.gecko?.id, 'browser.cpp@kbuffardi.github.io');
 
   runWebExt([
@@ -42,7 +44,9 @@ function main() {
   assert.ok(builtArtifacts.length > 0, 'Expected web-ext build to emit a Firefox package.');
 
   console.log(`Firefox smoke validation passed with ${builtArtifacts[0]}.`);
-  console.log('Runtime compile/run verification remains part of the manual Firefox release QA checklist.');
+  console.log(
+    'Runtime compile/run verification remains required via docs/firefox-stdin-runtime-acceptance.md.'
+  );
 }
 
 main();
diff --git a/src/ui/app.js b/src/ui/app.js
index 8afcdf2..6e25944 100644
--- a/src/ui/app.js
+++ b/src/ui/app.js
@@ -63,10 +63,10 @@ window.addEventListener('DOMContentLoaded', async () => {
       });
       worker.postMessage({ type: 'compile', ...payload });
     },
-    onRun: async (sab) => {
+    onRun: async (runRequest) => {
       const vfsFiles = await fsAPI.readAllWorkspaceFiles();
       const binaryBytes = toolbarController?.getLastRunBinaryBytes?.() || null;
-      worker.postMessage({ type: 'run', sharedBuffer: sab, vfsFiles, binaryBytes });
+      worker.postMessage({ type: 'run', ...runRequest, vfsFiles, binaryBytes });
     },
     onStopRun: () => {
       worker.terminate();
@@ -76,6 +76,9 @@ window.addEventListener('DOMContentLoaded', async () => {
     onRunStateChange: (isRunning) => {
       setStopButtonRunning(isRunning);
     },
+    onRunPreparationStateChange: (isPreparing) => {
+      toolbarController?.setRunPreparing(isPreparing);
+    },
     onMkdir: async ({ path, parents }) => {
       const result = await fsAPI.createWorkspaceDirectory(path, { parents });
       if (result?.ok) {
diff --git a/src/ui/browser-capabilities.mjs b/src/ui/browser-capabilities.mjs
index bc28e8f..839449b 100644
--- a/src/ui/browser-capabilities.mjs
+++ b/src/ui/browser-capabilities.mjs
@@ -5,15 +5,23 @@ import { getExtensionAPI } from '../extension-api.mjs';
 const MINIMUM_CHROMIUM_MAJOR = 105;
 const MINIMUM_FIREFOX_MAJOR = 140;
 
-const CORE_REQUIRED_CAPABILITIES = [
+const BASE_REQUIRED_CAPABILITIES = [
   { key: 'extensionRuntime', label: 'Extension runtime API' },
   { key: 'extensionStorage', label: 'Extension storage API' },
   { key: 'worker', label: 'Web Worker' },
   { key: 'webAssembly', label: 'WebAssembly' },
+];
+
+const INTERACTIVE_STDIN_CAPABILITIES = [
   { key: 'sharedArrayBuffer', label: 'SharedArrayBuffer' },
   { key: 'atomicsWaitAsync', label: 'Atomics.waitAsync' },
 ];
 
+const CORE_REQUIRED_CAPABILITIES = [
+  ...BASE_REQUIRED_CAPABILITIES,
+  ...INTERACTIVE_STDIN_CAPABILITIES,
+];
+
 const CHROMIUM_FULL_PARITY_CAPABILITIES = [
   ...CORE_REQUIRED_CAPABILITIES,
   { key: 'fileOpenPicker', label: 'File open picker' },
@@ -72,6 +80,12 @@ export function collectBrowserCapabilities(root = globalThis) {
   const firefoxMajor = getFirefoxMajor(nav.userAgent);
   const profile = getBrowserProfile(nav.userAgent);
 
+  const sharedArrayBuffer = hasFunction(root.SharedArrayBuffer);
+  const atomicsWaitAsync = hasFunction(atomics.waitAsync);
+  const crossOriginIsolated = root.crossOriginIsolated === true;
+  const interactiveStdin =
+    sharedArrayBuffer && atomicsWaitAsync && crossOriginIsolated;
+
   return {
     userAgent: nav.userAgent ?? '',
     browserFamily: profile.family,
@@ -88,9 +102,11 @@ export function collectBrowserCapabilities(root = globalThis) {
     fileSavePicker: hasFunction(root.showSaveFilePicker),
     worker: hasFunction(root.Worker),
     webAssembly: !!root.WebAssembly?.instantiate,
-    sharedArrayBuffer: hasFunction(root.SharedArrayBuffer),
-    atomicsWaitAsync: hasFunction(atomics.waitAsync),
-    crossOriginIsolated: root.crossOriginIsolated === true,
+    sharedArrayBuffer,
+    atomicsWaitAsync,
+    crossOriginIsolated,
+    interactiveStdin,
+    stdinMode: interactiveStdin ? 'interactive' : 'buffered',
   };
 }
 
@@ -98,7 +114,9 @@ export function createBrowserCompatibilityReport(root = globalThis) {
   const capabilities = collectBrowserCapabilities(root);
   const requiredCapabilities = capabilities.browserFamily === 'chromium'
     ? CHROMIUM_FULL_PARITY_CAPABILITIES
-    : CORE_REQUIRED_CAPABILITIES;
+    : capabilities.browserFamily === 'firefox'
+      ? BASE_REQUIRED_CAPABILITIES
+      : CORE_REQUIRED_CAPABILITIES;
   const missing = requiredCapabilities
     .filter(({ key }) => !capabilities[key])
     .map(({ key, label }) => ({ key, label }));
@@ -126,13 +144,22 @@ export function createBrowserCompatibilityReport(root = globalThis) {
       label: `Firefox ${capabilities.minimumFirefoxMajor}+ is recommended for the supported browser.cpp Firefox release path`,
     });
   }
-  if (!capabilities.crossOriginIsolated) {
+  if (
+    capabilities.browserFamily !== 'firefox' &&
+    !capabilities.crossOriginIsolated
+  ) {
     warnings.push({
       key: 'crossOriginIsolated',
       label: 'Page is not cross-origin isolated; SharedArrayBuffer may be blocked by browser policy',
     });
   }
   if (capabilities.browserFamily === 'firefox') {
+    if (!capabilities.interactiveStdin) {
+      limitations.push({
+        key: 'limitedInteractiveStdin',
+        label: 'Firefox uses pre-supplied buffered stdin; live interactive terminal input is unavailable.',
+      });
+    }
     limitations.push({
       key: 'firefoxFileFallbacks',
       label: 'Firefox uses fallback file and folder flows instead of the Chromium File System Access APIs.',
diff --git a/src/ui/buffered-stdin-dialog.mjs b/src/ui/buffered-stdin-dialog.mjs
new file mode 100644
index 0000000..2c88904
--- /dev/null
+++ b/src/ui/buffered-stdin-dialog.mjs
@@ -0,0 +1,78 @@
+'use strict';
+
+import { BUFFERED_STDIN_MAX_BYTES } from '../workers/run-request.mjs';
+
+export function requestBufferedStdin() {
+  const dialog = document.getElementById('buffered-stdin-dialog');
+  const input = document.getElementById('buffered-stdin-input');
+  const feedback = document.getElementById('buffered-stdin-feedback');
+  const runButton = document.getElementById('buffered-stdin-run');
+  const cancelButton = document.getElementById('buffered-stdin-cancel');
+
+  if (!dialog || !input || !feedback || !runButton || !cancelButton) {
+    throw new Error('Buffered stdin dialog is unavailable.');
+  }
+
+  const previouslyFocused = document.activeElement;
+  input.value = '';
+  input.removeAttribute('aria-invalid');
+  feedback.classList.remove('is-error');
+
+  return new Promise((resolve) => {
+    let settled = false;
+
+    const updateFeedback = () => {
+      const byteLength = new TextEncoder().encode(input.value).byteLength;
+      feedback.textContent =
+        `${byteLength.toLocaleString()} / ${BUFFERED_STDIN_MAX_BYTES.toLocaleString()} bytes`;
+      feedback.classList.remove('is-error');
+      input.removeAttribute('aria-invalid');
+      return byteLength;
+    };
+
+    const cleanup = () => {
+      input.removeEventListener('input', updateFeedback);
+      runButton.removeEventListener('click', submit);
+      cancelButton.removeEventListener('click', cancel);
+      dialog.removeEventListener('cancel', cancel);
+      dialog.removeEventListener('close', cancel);
+    };
+
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      if (dialog.open) dialog.close();
+      previouslyFocused?.focus?.();
+      resolve(value);
+    };
+
+    const submit = () => {
+      const byteLength = updateFeedback();
+      if (byteLength > BUFFERED_STDIN_MAX_BYTES) {
+        feedback.textContent =
+          `Input is too large. Keep pre-supplied stdin at or below ${BUFFERED_STDIN_MAX_BYTES.toLocaleString()} bytes.`;
+        feedback.classList.add('is-error');
+        input.setAttribute('aria-invalid', 'true');
+        input.focus();
+        return;
+      }
+      finish(input.value);
+    };
+
+    const cancel = (event) => {
+      event?.preventDefault?.();
+      finish(null);
+    };
+
+    input.addEventListener('input', updateFeedback);
+    runButton.addEventListener('click', submit);
+    cancelButton.addEventListener('click', cancel);
+    dialog.addEventListener('cancel', cancel);
+    dialog.addEventListener('close', cancel);
+
+    updateFeedback();
+    dialog.showModal();
+    input.focus();
+  });
+}
diff --git a/src/ui/index.html b/src/ui/index.html
index 62d3a80..eca57cf 100644
--- a/src/ui/index.html
+++ b/src/ui/index.html
@@ -96,6 +96,30 @@
     </footer>
 
   </div>
+
+  <dialog id="buffered-stdin-dialog" aria-labelledby="buffered-stdin-title">
+    <div class="buffered-stdin-content">
+      <h2 id="buffered-stdin-title">Pre-supplied stdin</h2>
+      <p>
+        Live interactive input is unavailable in this browser. Enter all input
+        before the program starts; it will receive EOF after these bytes.
+      </p>
+      <label for="buffered-stdin-input">Program input</label>
+      <textarea
+        id="buffered-stdin-input"
+        rows="8"
+        maxlength="262144"
+        spellcheck="false"
+        aria-describedby="buffered-stdin-feedback"
+      ></textarea>
+      <div id="buffered-stdin-feedback" aria-live="polite">0 / 262,144 bytes</div>
+      <div class="buffered-stdin-actions">
+        <button type="button" id="buffered-stdin-cancel">Cancel</button>
+        <button type="button" id="buffered-stdin-run" class="btn-primary">Run program</button>
+      </div>
+    </div>
+  </dialog>
+
   <!-- bundle.js injected by HtmlWebpackPlugin -->
 </body>
 </html>
diff --git a/src/ui/styles.css b/src/ui/styles.css
index 972d423..e7d176a 100644
--- a/src/ui/styles.css
+++ b/src/ui/styles.css
@@ -561,3 +561,76 @@ body.is-resizing-horizontal * {
 .session-reload-actions .session-reload-primary:hover {
   filter: brightness(1.05);
 }
+
+/* ── Buffered stdin prompt ────────────────────────────────────────────────── */
+
+#buffered-stdin-dialog {
+  width: min(520px, calc(100vw - 32px));
+  max-height: calc(100vh - 32px);
+  margin: auto;
+  padding: 0;
+  overflow: auto;
+  color: var(--text);
+  background: var(--mantle);
+  border: 1px solid var(--surface1);
+  border-radius: 8px;
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.45);
+}
+
+#buffered-stdin-dialog::backdrop {
+  background: rgba(17, 17, 27, 0.72);
+}
+
+.buffered-stdin-content {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  padding: 20px;
+}
+
+.buffered-stdin-content h2 {
+  font-size: 15px;
+}
+
+.buffered-stdin-content p,
+#buffered-stdin-feedback {
+  color: var(--subtext0);
+  line-height: 1.45;
+}
+
+.buffered-stdin-content label {
+  font-weight: 600;
+}
+
+#buffered-stdin-input {
+  width: 100%;
+  min-height: 120px;
+  resize: vertical;
+  padding: 8px;
+  color: var(--text);
+  background: var(--crust);
+  border: 1px solid var(--surface1);
+  border-radius: 4px;
+  font: 13px/1.4 'JetBrains Mono', 'Fira Code', 'Cascadia Code', monospace;
+}
+
+#buffered-stdin-input:focus {
+  border-color: var(--blue);
+  outline: 1px solid var(--blue);
+}
+
+#buffered-stdin-feedback {
+  min-height: 18px;
+  font-size: 12px;
+  text-align: right;
+}
+
+#buffered-stdin-feedback.is-error {
+  color: var(--red);
+}
+
+.buffered-stdin-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
diff --git a/src/ui/terminal.js b/src/ui/terminal.js
index 4229f49..f01a9be 100644
--- a/src/ui/terminal.js
+++ b/src/ui/terminal.js
@@ -31,6 +31,8 @@ import {
   normalizeOverlayPath,
 } from './build-request.mjs';
 import { validateNewDirectoryPath, validateNewFilePath } from './workspace-fs.mjs';
+import { BUFFERED_STDIN_MAX_BYTES } from '../workers/run-request.mjs';
+import { requestBufferedStdin } from './buffered-stdin-dialog.mjs';
 
 function moduleExports(pkg) {
   return Object.prototype.hasOwnProperty.call(pkg, 'default') ? pkg['default'] : pkg;
@@ -87,6 +89,10 @@ let lastBuiltArtifactPath = null;
 
 /** True while a compiled program is executing – input is routed to stdin. */
 let running = false;
+/** True while a run request is collecting input or preparing workspace files. */
+let preparingRun = false;
+/** Stdin behavior for the active run. */
+let activeStdinMode = 'none';
 
 /** Resolve function set when waiting for run output to complete */
 let runDone = null;
@@ -192,7 +198,18 @@ let _onCompile = null;
 let _onRun     = null;
 let _onStopRun = null;
 let _onRunStateChange = null;
+let _onRunPreparationStateChange = null;
 let _getSource = null;  // () => string  – returns current editor source
+let _supportsInteractiveStdin = supportsInteractiveStdin;
+let _requestBufferedStdin = requestBufferedStdin;
+
+function supportsInteractiveStdin() {
+  return (
+    typeof SharedArrayBuffer !== 'undefined' &&
+    typeof globalThis.Atomics?.waitAsync === 'function' &&
+    globalThis.crossOriginIsolated === true
+  );
+}
 
 // ── Public API ────────────────────────────────────────────────────────────────
 
@@ -202,24 +219,38 @@ let _getSource = null;  // () => string  – returns current editor source
  * @param {HTMLElement} container
  * @param {{
  *   onCompile: (request:{sourcePaths:(string[]|null), flags:string[], std:string, outputName:(string|null), cwd:string}) => void,
- *   onRun:     (sharedBuffer:SharedArrayBuffer) => void,
+ *   onRun:     (request:{stdinMode:string,sharedBuffer?:SharedArrayBuffer,stdinBuffer?:Uint8Array}) => Promise<void>|void,
  *   onStopRun?: () => void,
  *   onRunStateChange?: (running:boolean) => void,
+ *   onRunPreparationStateChange?: (preparing:boolean) => void,
  *   getSource: () => string,
  *   readWorkspaceFile?: (path:string) => Promise<string|null>,
  *   onMkdir?: (request:{path:string, parents:boolean}) => Promise<object>,
  *   onTouch?: (request:{path:string}) => Promise<object>,
  * }} callbacks
  */
-export function createTerminal(container, { onCompile, onRun, onStopRun, onRunStateChange, getSource, readWorkspaceFile, onMkdir, onTouch }) {
+export function createTerminal(container, {
+  onCompile,
+  onRun,
+  onStopRun,
+  onRunStateChange,
+  onRunPreparationStateChange,
+  getSource,
+  readWorkspaceFile,
+  onMkdir,
+  onTouch,
+}) {
   _onCompile = onCompile;
   _onRun     = onRun;
   _onStopRun = onStopRun || null;
   _onRunStateChange = onRunStateChange || null;
+  _onRunPreparationStateChange = onRunPreparationStateChange || null;
   _getSource = getSource;
   _readWorkspaceFile = readWorkspaceFile || null;
   _onMkdir = onMkdir || null;
   _onTouch = onTouch || null;
+  _supportsInteractiveStdin = supportsInteractiveStdin;
+  _requestBufferedStdin = requestBufferedStdin;
   initialPromptShown = false;
   busy = true;
 
@@ -293,39 +324,71 @@ export function showInitialPrompt() {
 }
 
 /**
- * Start executing the last compiled binary with interactive stdin support.
+ * Start executing the last compiled binary.
  *
- * Creates a SharedArrayBuffer for stdin coordination, enters stdin-capture
- * mode, and dispatches the run request to the compiler worker via _onRun.
+ * Uses live SharedArrayBuffer stdin when cross-origin isolation is available,
+ * otherwise collects pre-supplied buffered stdin before dispatch.
  * Can be called from the terminal command line (`./a.out`) or directly from
  * the toolbar Run button.
+ *
+ * @returns {Promise<boolean>} whether a valid worker run request was posted
  */
-export function startRun() {
-  if (!term) return;
-  if (running) return; // already running
+export async function startRun() {
+  if (!term || running || preparingRun) return false;
 
   if (!lastBuiltArtifactPath) {
     term.write(`${C.red}No binary found. Compile first with:  g++ main.cpp${C.reset}${CRLF}`);
     writePrompt();
-    return;
+    return false;
   }
 
-  if (typeof SharedArrayBuffer === 'undefined') {
-    term.write(
-      `${C.red}Interactive stdin requires SharedArrayBuffer, which is unavailable ` +
-      `in this context.  The page must be served with Cross-Origin-Opener-Policy: ` +
-      `same-origin and Cross-Origin-Embedder-Policy: require-corp headers.${C.reset}${CRLF}`
-    );
+  setRunPreparationState(true);
+  busy = true;
+  inputBuffer = '';
+
+  try {
+    let request;
+    if (_supportsInteractiveStdin()) {
+      const sharedBuffer = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DATA_BYTES);
+      _initSAB(sharedBuffer);
+      request = { stdinMode: 'interactive', sharedBuffer };
+    } else {
+      const text = await _requestBufferedStdin();
+      if (text === null) {
+        setRunPreparationState(false);
+        busy = false;
+        writePrompt();
+        return false;
+      }
+
+      const stdinBuffer = new TextEncoder().encode(text);
+      if (stdinBuffer.byteLength > BUFFERED_STDIN_MAX_BYTES) {
+        throw new Error('Buffered stdin exceeds the 256 KiB limit.');
+      }
+      request = { stdinMode: 'buffered', stdinBuffer };
+    }
+
+    if (!_onRun) throw new Error('Run callback is unavailable.');
+    term.write(CRLF);
+    await _onRun(request);
+    return true;
+  } catch (error) {
+    setRunPreparationState(false);
+    activeStdinMode = 'none';
+    busy = false;
+    _clearSAB();
+    term.write(`${C.red}Could not start program: ${error?.message || String(error)}${C.reset}${CRLF}`);
     writePrompt();
-    return;
+    return false;
   }
+}
 
-  const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DATA_BYTES);
-  _initSAB(sab);
+/** Mark a validated worker request as actively running. */
+export function onRunStart({ stdinMode = 'none' } = {}) {
+  setRunPreparationState(false);
+  activeStdinMode = stdinMode;
   setRunState(true);
-  inputBuffer = ''; // clear any partial command line
-  term.write(CRLF);
-  _onRun?.(sab);
+  busy = false;
 }
 
 /**
@@ -346,6 +409,8 @@ export function stopRun({ echoCtrlC = false } = {}) {
   }
   inputBuffer = '';
   _clearSAB();
+  setRunPreparationState(false);
+  activeStdinMode = 'none';
   setRunState(false);
   busy = false;
   runDone?.();
@@ -395,15 +460,18 @@ export function onCompileResult({ success, diagnostics, outputPath }) {
  * @param {{ exitCode:number }} result
  */
 export function onRunResult({ exitCode }) {
+  const shouldRestorePrompt = running || preparingRun;
   if (exitCode !== 0) {
     term?.write(`${CRLF}${C.yellow}Process exited with code ${exitCode}.${C.reset}${CRLF}`);
   }
+  setRunPreparationState(false);
+  activeStdinMode = 'none';
   setRunState(false);
   busy = false;
   _clearSAB();
   runDone?.();
   runDone = null;
-  writePrompt();
+  if (shouldRestorePrompt) writePrompt();
 }
 
 /** Print an informational message to the terminal. */
@@ -466,7 +534,11 @@ function handleKey({ key, domEvent }) {
 
   // While a program is executing, route keystrokes to stdin instead of the shell
   if (running) {
-    handleStdinKey(key, domEvent);
+    if (activeStdinMode === 'interactive') {
+      handleStdinKey(key, domEvent);
+    } else if (domEvent.ctrlKey && domEvent.key === 'c') {
+      stopRun({ echoCtrlC: true });
+    }
     return;
   }
 
@@ -659,7 +731,7 @@ async function executeCommand(cmdLine) {
     default:
       // Detect ./exe invocations
       if (cmd.startsWith('./')) {
-        cmdRun(cmd);
+        await cmdRun(cmd);
       } else {
         term.write(
           `${C.red}bash: ${cmd}: command not found${C.reset}${CRLF}` +
@@ -716,7 +788,7 @@ function cmdGxx(args) {
   _onCompile?.({ sourcePaths: resolved, flags, std, outputName, cwd: workspaceCwd });
 }
 
-function cmdRun(cmd) {
+async function cmdRun(cmd) {
   const { ok, error } = resolveRunTarget(cmd, lastBuiltArtifactPath);
   if (!ok) {
     if (error === 'no-binary') {
@@ -727,7 +799,7 @@ function cmdRun(cmd) {
     writePrompt();
     return;
   }
-  startRun();
+  await startRun();
 }
 
 function cmdLs(args = []) {
@@ -936,6 +1008,12 @@ function setRunState(nextRunning) {
   _onRunStateChange?.(running);
 }
 
+function setRunPreparationState(nextPreparing) {
+  if (preparingRun === nextPreparing) return;
+  preparingRun = nextPreparing;
+  _onRunPreparationStateChange?.(preparingRun);
+}
+
 export function __setTerminalTestHarness({
   term: terminalInstance,
   lastBuiltArtifactPath: artifactPath = null,
@@ -943,10 +1021,13 @@ export function __setTerminalTestHarness({
   onRun = null,
   onStopRun = null,
   onRunStateChange = null,
+  onRunPreparationStateChange = null,
   getSource = () => '',
   readWorkspaceFile = null,
   onMkdir = null,
   onTouch = null,
+  supportsInteractiveStdin: supportsInteractiveStdinForTest = () => true,
+  requestBufferedStdin: requestBufferedStdinForTest = async () => '',
 } = {}) {
   term = terminalInstance || null;
   fitAddon = null;
@@ -954,16 +1035,21 @@ export function __setTerminalTestHarness({
   _onRun = onRun;
   _onStopRun = onStopRun;
   _onRunStateChange = onRunStateChange;
+  _onRunPreparationStateChange = onRunPreparationStateChange;
   _getSource = getSource;
   _readWorkspaceFile = readWorkspaceFile;
   _onMkdir = onMkdir;
   _onTouch = onTouch;
+  _supportsInteractiveStdin = supportsInteractiveStdinForTest;
+  _requestBufferedStdin = requestBufferedStdinForTest;
   lastBuiltArtifactPath = artifactPath;
   inputBuffer = '';
   history.length = 0;
   historyIdx = -1;
   busy = false;
   running = false;
+  preparingRun = false;
+  activeStdinMode = 'none';
   runDone = null;
   initialPromptShown = false;
   _clearSAB();
@@ -980,6 +1066,8 @@ export async function __executeTerminalCommandForTesting(cmdLine) {
 export function __getTerminalStateForTesting() {
   return {
     running,
+    preparingRun,
+    activeStdinMode,
     busy,
     inputBuffer,
     pendingChunks: _pendingChunks.length,
diff --git a/src/ui/toolbar.js b/src/ui/toolbar.js
index 4cac616..a8f106d 100644
--- a/src/ui/toolbar.js
+++ b/src/ui/toolbar.js
@@ -26,6 +26,7 @@ let _fsAPI       = null;
 let _fileName    = 'main.cpp';
 let _workspace   = null;
 let _runAfterSuccessfulCompile = false;
+let _runPreparationActive = false;
 let _lastRunBinaryBytes = null;
 const _expandedWorkspaceDirectories = new Set();
 const WORKSPACE_SYNC_INTERVAL_MS = 2_000;
@@ -98,6 +99,7 @@ export function setWorker(worker) {
   }
   _worker = worker;
   _runAfterSuccessfulCompile = false;
+  _runPreparationActive = false;
   handleWorkerMessages();
   updateStatusBar('compiler', 'loading', 'Compiler loading…');
   setButtonsEnabled(false);
@@ -107,6 +109,16 @@ export function getLastRunBinaryBytes() {
   return _lastRunBinaryBytes ? new Uint8Array(_lastRunBinaryBytes) : null;
 }
 
+export function setRunPreparing(preparing) {
+  _runPreparationActive = preparing;
+  setButtonsEnabled(!preparing);
+  updateStatusBar(
+    'compiler',
+    preparing ? 'busy' : 'ready',
+    preparing ? 'Preparing run…' : 'Compiler ready'
+  );
+}
+
 // ── Button bindings ───────────────────────────────────────────────────────────
 
 function bindButtons() {
@@ -233,12 +245,13 @@ async function handleWorkerMessage(data) {
         await persistWorkspaceFile(data.outputPath || 'a.out', data.outputBytes);
       }
       if (shouldRunAfterCompile && data.success) {
-        _terminalAPI.startRun();
+        await _terminalAPI.startRun();
       }
       break;
     }
 
     case 'run-start':
+      _terminalAPI.onRunStart?.(data);
       updateStatusBar('compiler', 'busy', 'Running…');
       setButtonsEnabled(false);
       break;
@@ -602,18 +615,18 @@ async function actionSaveAs() {
 }
 
 async function actionCompile() {
-  if (!_worker) return;
+  if (!_worker || _runPreparationActive) return;
   _runAfterSuccessfulCompile = false;
   const payload = await assembleCompilePayload({});
   _worker.postMessage({ type: 'compile', ...payload });
 }
 
-function actionRun() {
-  _terminalAPI.startRun();
+async function actionRun() {
+  await _terminalAPI.startRun();
 }
 
 async function actionCompileRun() {
-  if (!_worker) return;
+  if (!_worker || _runPreparationActive) return;
   _runAfterSuccessfulCompile = true;
   const payload = await assembleCompilePayload({});
   _worker.postMessage({ type: 'compile', ...payload });
diff --git a/src/workers/compiler.worker.js b/src/workers/compiler.worker.js
index d27f679..50f9b07 100644
--- a/src/workers/compiler.worker.js
+++ b/src/workers/compiler.worker.js
@@ -8,8 +8,11 @@
  *  Inbound messages (from main thread):
  *    { type: 'compile', sourcePaths: string[], files: Array<{path,content}>,
  *                       std: string, flags: string[], primarySourcePath, outputName }
- *    { type: 'run',     sharedBuffer: SharedArrayBuffer, vfsFiles,
- *                       binaryBytes?: Uint8Array }
+ *    { type: 'run', stdinMode: 'interactive', sharedBuffer: SharedArrayBuffer,
+ *                   vfsFiles, binaryBytes?: Uint8Array }
+ *    { type: 'run', stdinMode: 'buffered', stdinBuffer: Uint8Array|ArrayBuffer,
+ *                   vfsFiles, binaryBytes?: Uint8Array }
+ *    { type: 'run', stdinMode: 'none', vfsFiles, binaryBytes?: Uint8Array }
  *    { type: 'status'  }
  *
  *  Outbound messages (to main thread):
@@ -44,6 +47,7 @@
 import { parseCompilePlan } from './compile-plan.mjs';
 import { parseDiagnostics } from '../ui/diagnostics.mjs';
 import { createWasiRuntime } from './wasi-shim.mjs';
+import { validateRunRequest } from './run-request.mjs';
 
 // ── State ────────────────────────────────────────────────────────────────────
 
@@ -472,14 +476,15 @@ function groupDiagnostics(text) {
 /**
  * Instantiate and execute the compiled WASM binary with a minimal WASI shim.
  *
- * @param {SharedArrayBuffer} sharedBuffer – SAB created by the terminal that
- *   provides interactive stdin via Atomics.  The SAB must be pre-zeroed (state
- *   = 0) so that fd_read blocks immediately when no input is ready.
- * @param {Array<{path:string, bytes:Uint8Array}>} vfsFiles – workspace files
- *   to expose to the program via fstream.  Written/created files are collected
- *   and returned in the `run-result` message as `vfsChanges`.
+ * @param {{
+ *   stdin: ({mode:'interactive',sharedBuffer:SharedArrayBuffer}|
+ *           {mode:'buffered',bytes:Uint8Array}|
+ *           {mode:'none'}),
+ *   vfsFiles:Array<{path:string,bytes:Uint8Array}>,
+ *   binaryBytes:Uint8Array|null
+ * }} request validated run request
  */
-async function run(sharedBuffer, vfsFiles = [], binaryBytes = null) {
+async function run({ stdin, vfsFiles = [], binaryBytes = null }) {
   if (binaryBytes) {
     compiledBinary = binaryBytes instanceof Uint8Array
       ? new Uint8Array(binaryBytes)
@@ -493,7 +498,7 @@ async function run(sharedBuffer, vfsFiles = [], binaryBytes = null) {
   }
 
   const wasiRuntime = createWasiRuntime({
-    sharedBuffer,
+    stdin,
     onStdout: (text) => send({ type: 'stdout', data: text }),
     onStderr: (text) => send({ type: 'stderr', data: text }),
   });
@@ -564,10 +569,17 @@ self.onmessage = async ({ data }) => {
       }
       break;
 
-    case 'run':
-      send({ type: 'run-start' });
-      await run(data.sharedBuffer, data.vfsFiles || [], data.binaryBytes || null);
+    case 'run': {
+      const validation = validateRunRequest(data);
+      if (!validation.ok) {
+        send({ type: 'stderr', data: `${validation.error}\n` });
+        send({ type: 'run-result', exitCode: 1, vfsChanges: [], vfsDeletes: [] });
+        break;
+      }
+      send({ type: 'run-start', stdinMode: validation.value.stdin.mode });
+      await run(validation.value);
       break;
+    }
 
     case 'status':
       send({ type: 'status-reply', state: compilerState });
diff --git a/src/workers/run-request.mjs b/src/workers/run-request.mjs
new file mode 100644
index 0000000..70f12ff
--- /dev/null
+++ b/src/workers/run-request.mjs
@@ -0,0 +1,95 @@
+'use strict';
+
+export const BUFFERED_STDIN_MAX_BYTES = 256 * 1024;
+
+function isByteSource(value) {
+  return value instanceof Uint8Array || value instanceof ArrayBuffer;
+}
+
+function asUint8Array(value) {
+  if (value instanceof Uint8Array) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  return new Uint8Array(value);
+}
+
+function invalid(error) {
+  return { ok: false, error };
+}
+
+/**
+ * Validate and normalize the main-thread → compiler-worker run contract.
+ *
+ * This is the trust boundary for UI-provided binary, VFS, and stdin data. The
+ * returned value contains only byte views and a discriminated stdin source.
+ */
+export function validateRunRequest(request) {
+  if (!request || request.type !== 'run') {
+    return invalid('Invalid run request.');
+  }
+
+  let stdin;
+  switch (request.stdinMode) {
+    case 'interactive':
+      if (
+        typeof SharedArrayBuffer === 'undefined' ||
+        !(request.sharedBuffer instanceof SharedArrayBuffer) ||
+        request.stdinBuffer !== undefined
+      ) {
+        return invalid('Invalid interactive stdin: sharedBuffer must be a SharedArrayBuffer.');
+      }
+      stdin = { mode: 'interactive', sharedBuffer: request.sharedBuffer };
+      break;
+
+    case 'buffered':
+      if (!isByteSource(request.stdinBuffer) || request.sharedBuffer !== undefined) {
+        return invalid('Invalid buffered stdin: stdinBuffer must be a Uint8Array or ArrayBuffer.');
+      }
+      if (request.stdinBuffer.byteLength > BUFFERED_STDIN_MAX_BYTES) {
+        return invalid('Invalid buffered stdin: input exceeds the 256 KiB limit.');
+      }
+      stdin = { mode: 'buffered', bytes: asUint8Array(request.stdinBuffer) };
+      break;
+
+    case 'none':
+      if (request.sharedBuffer !== undefined || request.stdinBuffer !== undefined) {
+        return invalid('Invalid none stdin: no stdin buffer may be supplied.');
+      }
+      stdin = { mode: 'none' };
+      break;
+
+    default:
+      return invalid('Invalid stdinMode. Expected interactive, buffered, or none.');
+  }
+
+  let binaryBytes = null;
+  if (request.binaryBytes !== undefined && request.binaryBytes !== null) {
+    if (!isByteSource(request.binaryBytes)) {
+      return invalid('Invalid binaryBytes: expected a Uint8Array or ArrayBuffer.');
+    }
+    binaryBytes = asUint8Array(request.binaryBytes);
+  }
+
+  const rawVfsFiles = request.vfsFiles ?? [];
+  if (!Array.isArray(rawVfsFiles)) {
+    return invalid('Invalid vfsFiles: expected an array.');
+  }
+
+  const vfsFiles = [];
+  for (const file of rawVfsFiles) {
+    if (
+      !file ||
+      typeof file.path !== 'string' ||
+      file.path.length === 0 ||
+      !isByteSource(file.bytes)
+    ) {
+      return invalid('Invalid vfsFiles entry: expected a non-empty path and Uint8Array or ArrayBuffer bytes.');
+    }
+    vfsFiles.push({ path: file.path, bytes: asUint8Array(file.bytes) });
+  }
+
+  return {
+    ok: true,
+    value: { stdin, vfsFiles, binaryBytes },
+  };
+}
diff --git a/src/workers/wasi-shim.mjs b/src/workers/wasi-shim.mjs
index ba614c7..8bd3599 100644
--- a/src/workers/wasi-shim.mjs
+++ b/src/workers/wasi-shim.mjs
@@ -37,15 +37,41 @@ function createWritableFile(path, data, flags = 0) {
   };
 }
 
-export function createWasiRuntime({ sharedBuffer, onStdout, onStderr }) {
+export function createWasiRuntime({
+  stdin = { mode: 'none' },
+  onStdout = () => {},
+  onStderr = () => {},
+}) {
   let memory = null;
   let runVfs = new Map();
   let runVfsDirty = new Set();
   let runVfsDeletes = new Set();
   let runFds = new Map();
   let runNextFd = 4;
-  const sabControl = new Int32Array(sharedBuffer);
+  const stdinMode = stdin?.mode || 'none';
+  let sharedBuffer = null;
+  let sabControl = null;
   const stdinQueue = [];
+  let stdinBytes = new Uint8Array();
+  let stdinCursor = 0;
+
+  if (stdinMode === 'interactive') {
+    if (
+      typeof SharedArrayBuffer === 'undefined' ||
+      !(stdin.sharedBuffer instanceof SharedArrayBuffer)
+    ) {
+      throw new TypeError('Interactive stdin requires a SharedArrayBuffer.');
+    }
+    sharedBuffer = stdin.sharedBuffer;
+    sabControl = new Int32Array(sharedBuffer);
+  } else if (stdinMode === 'buffered') {
+    if (!(stdin.bytes instanceof Uint8Array) && !(stdin.bytes instanceof ArrayBuffer)) {
+      throw new TypeError('Buffered stdin requires Uint8Array or ArrayBuffer bytes.');
+    }
+    stdinBytes = new Uint8Array(stdin.bytes);
+  } else if (stdinMode !== 'none') {
+    throw new TypeError(`Unsupported stdin mode: ${String(stdinMode)}`);
+  }
 
   const setMemory = (m) => {
     memory = m;
@@ -137,6 +163,7 @@ export function createWasiRuntime({ sharedBuffer, onStdout, onStderr }) {
     fd_write(fd, iovsPtr, iovsLen, nwrittenPtr) {
       const spans = iovSpans(iovsPtr, iovsLen);
       let total = 0;
+
       for (const { base, len } of spans) {
         if (fd === 1 || fd === 2) {
           const text = new TextDecoder().decode(u8().subarray(base, base + len));
@@ -184,6 +211,25 @@ export function createWasiRuntime({ sharedBuffer, onStdout, onStderr }) {
 
       const spans = iovSpans(iovsPtr, iovsLen);
       let total = 0;
+
+      if (stdinMode === 'none') {
+        view().setUint32(nreadPtr, 0, true);
+        return WASI_ERRNO_SUCCESS;
+      }
+
+      if (stdinMode === 'buffered') {
+        for (const { base, len } of spans) {
+          const available = stdinBytes.length - stdinCursor;
+          if (available <= 0) break;
+          const toRead = Math.min(len, available);
+          u8().set(stdinBytes.subarray(stdinCursor, stdinCursor + toRead), base);
+          stdinCursor += toRead;
+          total += toRead;
+        }
+        view().setUint32(nreadPtr, total, true);
+        return WASI_ERRNO_SUCCESS;
+      }
+
       for (const { base, len } of spans) {
         if (stdinQueue.length === 0) {
           if (Atomics.load(sabControl, 0) === 0) {