From fd36de3aa34a9909e8460f8649e9972dd79f6a93 Mon Sep 17 00:00:00 2001
From: Kevin Buffardi <kbuffardi@csuchico.edu>
Date: Thu, 30 Jul 2026 18:43:40 -0700
Subject: [PATCH 1/5] feat(runtime): add buffered stdin contract

Validate discriminated stdin modes at the worker boundary and let the WASI shim consume pre-supplied bytes with deterministic EOF. Preserve the existing SharedArrayBuffer path for interactive input.\n\nRefs #53
---
 scripts/e2e-run-request.test.mjs | 67 ++++++++++++++++++++++++
 scripts/e2e-wasi-shim.test.mjs   | 87 ++++++++++++++++++++++++++++--
 src/workers/compiler.worker.js   | 38 +++++++++-----
 src/workers/run-request.mjs      | 90 ++++++++++++++++++++++++++++++++
 src/workers/wasi-shim.mjs        | 50 +++++++++++++++++-
 5 files changed, 314 insertions(+), 18 deletions(-)
 create mode 100644 scripts/e2e-run-request.test.mjs
 create mode 100644 src/workers/run-request.mjs

diff --git a/scripts/e2e-run-request.test.mjs b/scripts/e2e-run-request.test.mjs
new file mode 100644
index 0000000..49d5ceb
--- /dev/null
+++ b/scripts/e2e-run-request.test.mjs
@@ -0,0 +1,67 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { 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 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-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/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..b15fea6
--- /dev/null
+++ b/src/workers/run-request.mjs
@@ -0,0 +1,90 @@
+'use strict';
+
+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.');
+      }
+      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) {

From bf9673bfecc35f46c50ebba63974e110fa5a7c0e Mon Sep 17 00:00:00 2001
From: Kevin Buffardi <kbuffardi@csuchico.edu>
Date: Thu, 30 Jul 2026 23:35:44 -0700
Subject: [PATCH 2/5] feat(ui): collect buffered stdin before Firefox runs

Make run preparation asynchronous and keep toolbar and terminal state consistent across submit, cancellation, duplicate actions, and failures. Add an accessible size-limited dialog while preserving Chromium live stdin.\n\nRefs #53
---
 scripts/e2e-buffered-stdin-ui.test.mjs |  24 +++
 scripts/e2e-terminal-stop.test.mjs     | 103 ++++++++++--
 src/ui/app.js                          |   7 +-
 src/ui/index.html                      |  23 +++
 src/ui/styles.css                      |  73 +++++++++
 src/ui/terminal.js                     | 213 ++++++++++++++++++++++---
 src/ui/toolbar.js                      |  23 ++-
 7 files changed, 424 insertions(+), 42 deletions(-)
 create mode 100644 scripts/e2e-buffered-stdin-ui.test.mjs

diff --git a/scripts/e2e-buffered-stdin-ui.test.mjs b/scripts/e2e-buffered-stdin-ui.test.mjs
new file mode 100644
index 0000000..3186e18
--- /dev/null
+++ b/scripts/e2e-buffered-stdin-ui.test.mjs
@@ -0,0 +1,24 @@
+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, /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-terminal-stop.test.mjs b/scripts/e2e-terminal-stop.test.mjs
index e222978..6d2b969 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,90 @@ 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'));
+});
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/index.html b/src/ui/index.html
index 62d3a80..272bb34 100644
--- a/src/ui/index.html
+++ b/src/ui/index.html
@@ -96,6 +96,29 @@
     </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"
+        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..d728990 100644
--- a/src/ui/terminal.js
+++ b/src/ui/terminal.js
@@ -87,6 +87,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;
@@ -111,6 +115,7 @@ let initialPromptShown = false;
  */
 const SAB_HEADER_BYTES = 8;
 const SAB_DATA_BYTES   = 4096;
+const BUFFERED_STDIN_MAX_BYTES = 256 * 1024;
 
 let _sabControl    = null;   // Int32Array view of current SAB
 let _sabData       = null;   // Uint8Array  view of current SAB data section
@@ -192,7 +197,92 @@ 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
+  );
+}
+
+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();
+  });
+}
 
 // ── Public API ────────────────────────────────────────────────────────────────
 
@@ -202,24 +292,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 +397,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 +482,8 @@ export function stopRun({ echoCtrlC = false } = {}) {
   }
   inputBuffer = '';
   _clearSAB();
+  setRunPreparationState(false);
+  activeStdinMode = 'none';
   setRunState(false);
   busy = false;
   runDone?.();
@@ -395,15 +533,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 +607,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 +804,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 +861,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 +872,7 @@ function cmdRun(cmd) {
     writePrompt();
     return;
   }
-  startRun();
+  await startRun();
 }
 
 function cmdLs(args = []) {
@@ -936,6 +1081,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 +1094,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 +1108,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 +1139,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 });

From 0266268bc168f403b79d0e2aacad3a38534177e0 Mon Sep 17 00:00:00 2001
From: Kevin Buffardi <kbuffardi@csuchico.edu>
Date: Thu, 30 Jul 2026 23:39:31 -0700
Subject: [PATCH 3/5] fix(firefox): support buffered stdin without isolation

Treat Firefox compile and run as supported when SharedArrayBuffer is absent, remove unsupported isolation keys from Firefox manifests, and document the exact runtime acceptance required for cin.\n\nRefs #53
---
 README.md                                  | 12 ++-
 docs/firefox-stdin-runtime-acceptance.md   | 88 ++++++++++++++++++++++
 docs/release-playbook.md                   |  3 +-
 package.json                               |  2 +-
 scripts/build-target-manifest.js           |  2 +
 scripts/e2e-browser-compatibility.test.mjs |  2 +
 scripts/e2e-firefox-compatibility.test.mjs | 26 ++++++-
 scripts/smoke-firefox.mjs                  |  6 +-
 src/ui/browser-capabilities.mjs            | 39 ++++++++--
 9 files changed, 164 insertions(+), 16 deletions(-)
 create mode 100644 docs/firefox-stdin-runtime-acceptance.md

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/package.json b/package.json
index fee44ec..8e50774 100644
--- a/package.json
+++ b/package.json
@@ -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-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/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/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.',

From d879e90d5ea3209a06707cb9a51a317c1657c1d1 Mon Sep 17 00:00:00 2001
From: Kevin Buffardi <kbuffardi@csuchico.edu>
Date: Thu, 30 Jul 2026 23:56:28 -0700
Subject: [PATCH 4/5] refactor(stdin): harden buffered input boundary

Share the 256 KiB contract between the UI and worker validator, reject oversized payloads at the worker boundary, and isolate dialog orchestration from terminal run state. Add regression coverage for oversized requests and the textarea cap.
---
 scripts/e2e-buffered-stdin-ui.test.mjs |  1 +
 scripts/e2e-run-request.test.mjs       | 16 +++++-
 scripts/e2e-terminal-stop.test.mjs     | 14 +++++
 src/ui/buffered-stdin-dialog.mjs       | 78 ++++++++++++++++++++++++++
 src/ui/index.html                      |  1 +
 src/ui/terminal.js                     | 77 +------------------------
 src/workers/run-request.mjs            |  5 ++
 7 files changed, 116 insertions(+), 76 deletions(-)
 create mode 100644 src/ui/buffered-stdin-dialog.mjs

diff --git a/scripts/e2e-buffered-stdin-ui.test.mjs b/scripts/e2e-buffered-stdin-ui.test.mjs
index 3186e18..ac89b73 100644
--- a/scripts/e2e-buffered-stdin-ui.test.mjs
+++ b/scripts/e2e-buffered-stdin-ui.test.mjs
@@ -10,6 +10,7 @@ test('e2e: buffered stdin dialog has accessible controls and status feedback', a
   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"/);
diff --git a/scripts/e2e-run-request.test.mjs b/scripts/e2e-run-request.test.mjs
index 49d5ceb..208119e 100644
--- a/scripts/e2e-run-request.test.mjs
+++ b/scripts/e2e-run-request.test.mjs
@@ -1,7 +1,10 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
 
-import { validateRunRequest } from '../src/workers/run-request.mjs';
+import {
+  BUFFERED_STDIN_MAX_BYTES,
+  validateRunRequest,
+} from '../src/workers/run-request.mjs';
 
 function interactiveRequest(overrides = {}) {
   return {
@@ -54,6 +57,17 @@ test('e2e: worker run contract rejects mismatched stdin variants', () => {
   }
 });
 
+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);
diff --git a/scripts/e2e-terminal-stop.test.mjs b/scripts/e2e-terminal-stop.test.mjs
index 6d2b969..1e7e932 100644
--- a/scripts/e2e-terminal-stop.test.mjs
+++ b/scripts/e2e-terminal-stop.test.mjs
@@ -210,3 +210,17 @@ test('e2e: run callback failure restores idle state without run-start', async ()
   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/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 272bb34..eca57cf 100644
--- a/src/ui/index.html
+++ b/src/ui/index.html
@@ -108,6 +108,7 @@ <h2 id="buffered-stdin-title">Pre-supplied stdin</h2>
       <textarea
         id="buffered-stdin-input"
         rows="8"
+        maxlength="262144"
         spellcheck="false"
         aria-describedby="buffered-stdin-feedback"
       ></textarea>
diff --git a/src/ui/terminal.js b/src/ui/terminal.js
index d728990..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;
@@ -115,7 +117,6 @@ let initialPromptShown = false;
  */
 const SAB_HEADER_BYTES = 8;
 const SAB_DATA_BYTES   = 4096;
-const BUFFERED_STDIN_MAX_BYTES = 256 * 1024;
 
 let _sabControl    = null;   // Int32Array view of current SAB
 let _sabData       = null;   // Uint8Array  view of current SAB data section
@@ -210,80 +211,6 @@ function supportsInteractiveStdin() {
   );
 }
 
-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();
-  });
-}
-
 // ── Public API ────────────────────────────────────────────────────────────────
 
 /**
diff --git a/src/workers/run-request.mjs b/src/workers/run-request.mjs
index b15fea6..70f12ff 100644
--- a/src/workers/run-request.mjs
+++ b/src/workers/run-request.mjs
@@ -1,5 +1,7 @@
 'use strict';
 
+export const BUFFERED_STDIN_MAX_BYTES = 256 * 1024;
+
 function isByteSource(value) {
   return value instanceof Uint8Array || value instanceof ArrayBuffer;
 }
@@ -43,6 +45,9 @@ export function validateRunRequest(request) {
       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;
 

From 37ec3af4ebc4a8006ede13d98806309896251543 Mon Sep 17 00:00:00 2001
From: Kevin Buffardi <kbuffardi@csuchico.edu>
Date: Fri, 31 Jul 2026 06:48:49 -0700
Subject: [PATCH 5/5] chore(release): bump version to 0.4.0

Advance the manifest-driven project version for the Firefox buffered-stdin release PR and keep package metadata synchronized.
---
 manifest.json     | 2 +-
 package-lock.json | 4 ++--
 package.json      | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

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 8e50774..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": {