diff --git a/runner/apps/authoring/src/App.tsx b/runner/apps/authoring/src/App.tsx
index 0430abd11..261888e95 100644
--- a/runner/apps/authoring/src/App.tsx
+++ b/runner/apps/authoring/src/App.tsx
@@ -531,6 +531,15 @@ function Authoring({
   // Bumped whenever the whole workspace is replaced (example switch or fork) so
   // the runtime remounts even when the framework is unchanged.
   const [mountGen, setMountGen] = useState(0);
+  // Bumped by the error card's "Restart preview". Its own counter rather than `mountGen`:
+  // that one doubles as `EditorShell`'s `workspaceKey`, and a retry is not a new
+  // workspace — sharing it would close the user's open tabs to fix the preview.
+  const [retryGen, setRetryGen] = useState(0);
+  // Whether the current failure is one a remount could clear. False for the refusals the
+  // mount effect makes *before* building a runtime — an unsupported version, a starter
+  // below its core floor. Those depend on the version picker, not on the preview, and
+  // offering to restart them would promise something the button cannot deliver.
+  const [retryable, setRetryable] = useState(true);
 
   const [iframeEl, setIframeEl] = useState<HTMLIFrameElement | null>(null);
   // Where the running preview lives, as reported by mount(). Tier 2 gives the
@@ -963,6 +972,7 @@ function Authoring({
     if (!v.ok) {
       setStatus("error");
       setErrorMessage(v.message);
+      setRetryable(false);
       return;
     }
     // Per-starter floor: these starters were authored against a core API that
@@ -980,8 +990,10 @@ function Authoring({
       setErrorMessage(
         `Could not load this example for Handsontable ${version}. Try another version.`,
       );
+      setRetryable(false);
       return;
     }
+    setRetryable(true);
     setStatus("booting");
     setBootLog("");
     setSyncing(false);
@@ -1031,8 +1043,22 @@ function Authoring({
       runtime.dispose();
       if (runtimeRef.current === runtime) runtimeRef.current = null;
     };
-    // mountGen forces a remount when files are replaced (example switch or fork/edit load).
-  }, [iframeEl, entry, version, mountGen, sourceLoaded, docsNotFound, docsRuntimeBlocked, versionPending, docsPath]);
+    // mountGen forces a remount when files are replaced (example switch or fork/edit load);
+    // retryGen when the user asks for one from the error card.
+  }, [iframeEl, entry, version, mountGen, retryGen, sourceLoaded, docsNotFound, docsRuntimeBlocked, versionPending, docsPath]);
+
+  /** "Restart preview" — mount a fresh runtime from the current (edited) sources.
+   *
+   *  The way out of a failure the code has already outlived. Tier 1 recovers on its own
+   *  now (the bundler's next clean compile re-emits ready), but Tier 2 cannot: a boot
+   *  failure exits the container's dev server, and streaming the fixed file into a
+   *  container with no dev server changes nothing. Only a new session re-runs it. */
+  const retryPreview = useCallback(() => {
+    setStatus("booting");
+    setErrorMessage(null);
+    setBootLog("");
+    setRetryGen((g) => g + 1);
+  }, []);
 
   const onEdit = useCallback(
     (path: string, contents: string) => {
@@ -1358,6 +1384,10 @@ function Authoring({
         errorMessage={errorMessage}
         bootLog={bootLog}
         containerBoot={entry.engine === "container"}
+        // Withheld while a docs bucket/path is unresolved (the mount effect refuses to run
+        // at all in that state) and for pre-mount version refusals: in both cases the
+        // button would restart nothing.
+        onRetry={docsRuntimeBlocked || !retryable ? undefined : retryPreview}
         syncing={syncing}
         refreshing={refreshing}
         version={version}
diff --git a/runner/e2e/preview-recovery.spec.ts b/runner/e2e/preview-recovery.spec.ts
new file mode 100644
index 000000000..f48ce5dee
--- /dev/null
+++ b/runner/e2e/preview-recovery.spec.ts
@@ -0,0 +1,215 @@
+import { test, expect } from "@playwright/test";
+
+// The preview must be able to come back. A runtime error in edited code puts the
+// pane into `error` (the "The preview could not start" card); fixing the code has
+// to clear it again. It did not: `SandpackRuntime.emitReady()` fired at most once
+// per mount, so the bundler's next clean `done` — the honest "your fix compiled
+// and ran" signal — was swallowed, and the error card outlived the error. The only
+// way out was an example switch or a version change, both of which remount.
+//
+// Live — needs the external Sandpack bundler; opt-in via E2E_LIVE=1, like the
+// other render checks.
+
+/** The visible editor. Hidden panes stay mounted (T12), so an unscoped
+ *  `.cm-content` would match every open file and resolve in DOM order. */
+const activeEditor = (page: import("@playwright/test").Page) =>
+  page.locator('[data-pane-active="true"] .cm-content');
+
+const previewStatus = (page: import("@playwright/test").Page) =>
+  page.locator('[aria-label="Preview"]');
+
+// Deterministic — no `E2E_LIVE=1`: the session POST is stubbed to a refusal, so the
+// error card appears whether or not a real API worker (and container pool) happens to be
+// reachable from wherever the suite runs. Without the stub this test passes only when
+// nothing answers `/api` — which is true in CI and false on a developer's machine with
+// the local worker up.
+//
+// Tier 2 has no self-healing equivalent of the Tier-1 fix below. A boot failure means
+// the container's boot script exited, so its dev server is gone: the fixed file streams
+// into a container with nothing left to serve it, and `reload()` (row-2 refresh) bails
+// early because the iframe was never pointed. A remount is the only way back, and this
+// button is the only thing that asks for one.
+test("a failed preview offers a restart that remounts the runtime", async ({ page }) => {
+  const sessionPosts: string[] = [];
+  await page.route("**/api/session", async (route) => {
+    if (route.request().method() !== "POST") return route.fallback();
+    sessionPosts.push(route.request().url());
+    await route.fulfill({
+      status: 503,
+      contentType: "application/json",
+      body: JSON.stringify({ error: "no container slots" }),
+    });
+  });
+
+  // `react-js` is a container starter; `vue`, despite the name, is Tier 1 (see
+  // catalog.json) and boots in-browser with no session at all.
+  await page.goto("/?example=react-js");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "error", {
+    timeout: 60_000,
+  });
+  const restart = page.getByRole("button", { name: "Restart preview" });
+  await expect(restart).toBeVisible();
+
+  const before = sessionPosts.length;
+  expect(before, "the first mount attempted a session").toBeGreaterThan(0);
+  await restart.click();
+  // A fresh session POST is the observable proof the runtime remounted; asserting on the
+  // status attribute alone would pass on a button that did nothing, since the retry ends
+  // in the same error here (there is still no worker).
+  await expect(async () => {
+    expect(sessionPosts.length).toBeGreaterThan(before);
+  }).toPass({ timeout: 30_000 });
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "error", {
+    timeout: 60_000,
+  });
+});
+
+test("live: fixing a runtime error clears the preview error card", async ({ page }) => {
+  test.skip(process.env.E2E_LIVE !== "1", "set E2E_LIVE=1 to run live-render checks");
+  test.setTimeout(180_000);
+
+  await page.goto("/?example=react");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready", {
+    timeout: 120_000,
+  });
+  await expect(page.frameLocator("iframe").first().locator(".handsontable td").first()).toBeVisible({
+    timeout: 90_000,
+  });
+
+  // Break it the way a user does: a reference to something that doesn't exist.
+  // Compiles clean, throws when the module is evaluated.
+  const editor = activeEditor(page);
+  await editor.click();
+  await page.keyboard.press("ControlOrMeta+End");
+  await page.keyboard.type("\nconsole.log(alignHeadersTypo);");
+
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "error", {
+    timeout: 60_000,
+  });
+  await expect(page.getByText("The preview could not start")).toBeVisible();
+
+  // Undo the edit — the fix. Select the broken line and remove it, newline and all.
+  await page.keyboard.press("Shift+Home");
+  await page.keyboard.press("Backspace");
+  await page.keyboard.press("Backspace");
+
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready", {
+    timeout: 60_000,
+  });
+  await expect(page.getByText("The preview could not start")).toHaveCount(0);
+  // Attribute alone would pass on a blanked pane; the grid has to be back.
+  await expect(page.frameLocator("iframe").first().locator(".handsontable td").first()).toBeVisible({
+    timeout: 60_000,
+  });
+});
+
+// The counterpart to the test above: an unsupported version is refused before any runtime
+// is built, so a remount would re-run the same refusal. The card has no action, and the
+// version picker (still live behind it) is where the fix actually is.
+test("a version the runner refuses gets no restart button", async ({ page }) => {
+  await page.goto("/?example=react&v=99.99.99");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "error", {
+    timeout: 30_000,
+  });
+  await expect(page.getByText("The preview could not start")).toBeVisible();
+  await expect(page.getByRole("button", { name: "Restart preview" })).toHaveCount(0);
+});
+
+// A compile the bundler sees as "no module changed" resets the preview document without
+// re-evaluating anything: a blank frame, `done` with no error, nothing in the console.
+// Two paths hit it. This is the one reachable by typing: break a line (the transpile
+// throws, so nothing is pushed and the good render stays), then undo the break — the
+// recomputed sandbox is byte-identical to what the bundler already has, and pushing it
+// blanked a preview that was correct. Not pushing is the fix.
+test("live: breaking and un-breaking a line leaves the grid alone", async ({ page }) => {
+  test.skip(process.env.E2E_LIVE !== "1", "set E2E_LIVE=1 to run live-render checks");
+  test.setTimeout(180_000);
+
+  const grid = page.frameLocator("iframe").first().locator(".handsontable td").first();
+  await page.goto("/?example=react");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready", {
+    timeout: 120_000,
+  });
+  await expect(grid).toBeVisible({ timeout: 90_000 });
+
+  // Drop the comma after a `colHeaders` entry: a syntax error, so the transpile fails and
+  // the bundler is never told. The grid on screen is the last good render.
+  const commaAt = await page.evaluate(`(() => {
+    const view = document.querySelector('.cm-content').cmTile.view;
+    const at = view.state.doc.toString().indexOf("'Company name',") + "'Company name'".length;
+    view.dispatch({ changes: { from: at, to: at + 1, insert: "" } });
+    return at;
+  })()`);
+  await page.waitForTimeout(4000);
+  await expect(grid).toBeVisible();
+
+  // Put it back. The file is now byte-identical to the one that rendered.
+  await page.evaluate(
+    `document.querySelector('.cm-content').cmTile.view.dispatch({ changes: { from: ${commaAt}, insert: "," } })`,
+  );
+  await page.waitForTimeout(8000);
+  await expect(grid).toBeVisible();
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready");
+});
+
+// The other path to the same no-change compile: the row-2 refresh button pushes the
+// current sources unchanged, which blanked the preview outright. `reload()` now stamps the
+// entry *and* the example module so the bundler has a real diff to act on — stamping the
+// HTML shell alone was measured to leave it blank, since a parcel sandbox boots from HTML
+// but the module is what has to re-evaluate.
+test("live: the refresh button re-runs the sandbox instead of blanking it", async ({ page }) => {
+  test.skip(process.env.E2E_LIVE !== "1", "set E2E_LIVE=1 to run live-render checks");
+  test.setTimeout(180_000);
+
+  const preview = page.frameLocator("iframe").first();
+  await page.goto("/?example=react");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready", {
+    timeout: 120_000,
+  });
+  await expect(preview.locator(".handsontable td").first()).toBeVisible({ timeout: 90_000 });
+
+  await page.getByRole("button", { name: "Reload the preview" }).click();
+  await expect(preview.locator(".handsontable td").first()).toBeVisible({ timeout: 60_000 });
+  // Re-evaluating the entry must not stack a second grid on the page (the DEV-2129 class),
+  // and the plugin registry has to survive it — `getPlugin()` returning undefined after a
+  // refresh is exactly how that bug presented, with a grid still on screen.
+  await expect(preview.locator(".ht-root-wrapper")).toHaveCount(1);
+  await preview.locator(".handsontable td").first().click({ button: "right" });
+  await expect(preview.locator(".htContextMenu").first()).toBeVisible({ timeout: 15_000 });
+});
+
+// The reported Vue case (`VueCompilerError` with a template code frame). It reads like a
+// second engine but is not: `vue` is a sandpack starter, so this is the same swallowed-
+// `done` bug — through a *compile* error rather than a runtime one. Worth its own test
+// because the two arrive differently: a compile failure never evaluates the module, so
+// only the `done{compilatonError:true}` + `show-error` pair is seen.
+test("live: fixing a Vue template error clears the preview error card", async ({ page }) => {
+  test.skip(process.env.E2E_LIVE !== "1", "set E2E_LIVE=1 to run live-render checks");
+  test.setTimeout(180_000);
+
+  await page.goto("/?example=vue");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready", {
+    timeout: 120_000,
+  });
+  await expect(page.frameLocator("iframe").first().locator(".handsontable td").first()).toBeVisible({
+    timeout: 90_000,
+  });
+
+  // A second root `<template>` — an SFC compile error, not a runtime one.
+  await activeEditor(page).click();
+  await page.keyboard.press("ControlOrMeta+End");
+  await page.keyboard.type("\n<template><div /></template>");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "error", {
+    timeout: 60_000,
+  });
+
+  await page.keyboard.press("Shift+Home");
+  await page.keyboard.press("Backspace");
+  await page.keyboard.press("Backspace");
+  await expect(previewStatus(page)).toHaveAttribute("data-preview-status", "ready", {
+    timeout: 60_000,
+  });
+  await expect(page.frameLocator("iframe").first().locator(".handsontable td").first()).toBeVisible({
+    timeout: 60_000,
+  });
+});
diff --git a/runner/packages/editor-shell/src/EditorShell.tsx b/runner/packages/editor-shell/src/EditorShell.tsx
index bdb73a808..0df39a1a0 100644
--- a/runner/packages/editor-shell/src/EditorShell.tsx
+++ b/runner/packages/editor-shell/src/EditorShell.tsx
@@ -50,6 +50,8 @@ export interface EditorShellProps {
   bootLog?: string;
   /** Tier 2: the boot overlay explains the tens-of-seconds wait and carries the log. */
   containerBoot?: boolean;
+  /** Re-run the preview from the current sources; the error card's only action. */
+  onRetry?: () => void;
   /** A container rebuild is in flight after an edit (shows "Applying changes…"). */
   syncing?: boolean;
   /** A row-2 refresh is in flight — blanks the pane behind a spinner (`72:26445`). */
@@ -479,6 +481,7 @@ export function EditorShell(props: EditorShellProps) {
             errorMessage={props.errorMessage}
             bootLog={props.bootLog}
             containerBoot={props.containerBoot}
+            onRetry={props.onRetry}
             syncing={props.syncing}
             refreshing={props.refreshing}
           />
diff --git a/runner/packages/editor-shell/src/PreviewPane.tsx b/runner/packages/editor-shell/src/PreviewPane.tsx
index 5ee1be5c2..f13141517 100644
--- a/runner/packages/editor-shell/src/PreviewPane.tsx
+++ b/runner/packages/editor-shell/src/PreviewPane.tsx
@@ -22,6 +22,14 @@ export interface PreviewPaneProps {
    *  pool is full — the window where the explanation matters most is the window where
    *  there is no log to infer it from. */
   containerBoot?: boolean;
+  /** Re-run the preview from the current sources. Rendered as the error card's only
+   *  action, so it is the way out of a failure the sources themselves have already
+   *  fixed — a Tier-2 boot failure kills the container's dev server outright, and no
+   *  amount of editing restarts it (`container.ts`, the `failed` branch).
+   *
+   *  Optional: omitted when a remount cannot help, which is every failure the mount
+   *  effect refuses to run at all (an unresolvable docs bucket or path).  */
+  onRetry?: () => void;
   /** A container rebuild is in flight after an edit. */
   syncing?: boolean;
   /** A row-2 refresh is in flight (`72:26445`). */
@@ -65,6 +73,7 @@ export function PreviewPane({
   errorMessage,
   bootLog,
   containerBoot,
+  onRetry,
   syncing,
   refreshing,
 }: PreviewPaneProps) {
@@ -109,6 +118,11 @@ export function PreviewPane({
           <div style={errorCard}>
             <p style={errorTitle}>The preview could not start</p>
             <pre style={errorBody}>{errorMessage}</pre>
+            {onRetry && (
+              <button type="button" style={retryButton} onClick={onRetry}>
+                Restart preview
+              </button>
+            )}
           </div>
         </div>
       )}
@@ -286,6 +300,25 @@ const errorTitle: CSSProperties = {
   color: theme.color.danger,
 };
 
+/** Accent-filled, matching the dialogs' primary action (`EditInfoDialog`): the card
+ *  has one action and it is the one the user wants. `alignSelf` keeps it to its own
+ *  width instead of stretching across the card's column layout. */
+const retryButton: CSSProperties = {
+  alignSelf: "flex-start",
+  display: "inline-flex",
+  alignItems: "center",
+  height: 32,
+  padding: `0 ${theme.space(3)}`,
+  border: `1px solid ${theme.color.accent}`,
+  borderRadius: theme.radius.md,
+  background: theme.color.accent,
+  color: theme.color.accentContrast,
+  fontFamily: theme.font.ui,
+  fontSize: 13,
+  fontWeight: 600,
+  cursor: "pointer",
+};
+
 const errorBody: CSSProperties = {
   margin: 0,
   maxHeight: 240,
diff --git a/runner/packages/runtime/src/container.ts b/runner/packages/runtime/src/container.ts
index 483af0534..e87e31b33 100644
--- a/runner/packages/runtime/src/container.ts
+++ b/runner/packages/runtime/src/container.ts
@@ -34,6 +34,13 @@ export class SessionStartError extends Error {
  *  Generous: a container that is merely slow should still resolve on the real event. */
 const RELOAD_TIMEOUT_MS = 10_000;
 
+/** Polling cadence and budget *after* the boot script has reported a nonzero exit.
+ *  Slower than the boot cadence (2.5s) and bounded: the point is to notice a dev
+ *  server that comes up in spite of the exit marker, not to keep probing a container
+ *  that is never going to answer. 10s × 12 ≈ two minutes. */
+const FAILED_POLL_INTERVAL_MS = 10_000;
+const FAILED_POLLS_MAX = 12;
+
 /** The live-session API accepts only relative POSIX paths. */
 function relativeFiles(files: FilesMap): FilesMap {
   return Object.fromEntries(
@@ -88,6 +95,11 @@ export class ContainerRuntime implements DemoRuntime {
    *  out rather than leaving the shell's refresh spinner up on a torn-down preview. */
   private readonly reloadSettlers = new Set<() => void>();
   private pollTimer: ReturnType<typeof setTimeout> | null = null;
+  /** How many failed-state polls have gone out since the boot script reported a nonzero
+   *  exit. Kept because polling continues past that report (see `poll()`) and has to
+   *  stop eventually — a dead dev server never comes back on its own, and each poll
+   *  costs two `exec`s in the container. */
+  private failedPolls = 0;
   private keepaliveTimer: ReturnType<typeof setInterval> | null = null;
   // Tear the session down when the page goes away (tab close, navigation) —
   // otherwise the container squats one of the few live-preview instance slots
@@ -224,14 +236,30 @@ export class ContainerRuntime implements DemoRuntime {
           const { ready, log, failed } = (await r.json()) as { ready: boolean; log: string; failed?: boolean };
           if (log && !this.pointed) this.emitProgress(log);
           if (failed && !this.disposed && !this.pointed) {
-            const detail = log
-              .replace(/\x1b\[[0-9;]*m/g, "")
-              .split("\n")
-              .map((l) => l.trimEnd())
-              .filter(Boolean)
-              .slice(-40)
-              .join("\n");
-            this.emitError(new ContainerBootFailure(detail || "Container failed to install dependencies or start."));
+            // Report once, then keep polling rather than returning. Returning made the
+            // failure a one-way door: the shell stopped asking the container anything,
+            // so a dev server that did come up afterwards could never be picked up, and
+            // the error card outlived its cause with no way back but a remount. Reporting
+            // once matters as much as continuing — `onError` is wired to Sentry, and
+            // re-emitting on every poll would file the same boot failure every few
+            // seconds for as long as the tab stayed open.
+            if (this.failedPolls === 0) {
+              const detail = log
+                .replace(/\x1b\[[0-9;]*m/g, "")
+                .split("\n")
+                .map((l) => l.trimEnd())
+                .filter(Boolean)
+                .slice(-40)
+                .join("\n");
+              this.emitError(new ContainerBootFailure(detail || "Container failed to install dependencies or start."));
+            }
+            this.failedPolls += 1;
+            // The boot script has exited, so this is a long shot, not the recovery path —
+            // "Restart preview" in the error card is. Poll on slowly for a short window in
+            // case the port opens anyway, then stop instead of probing a dead container
+            // for the life of the tab.
+            if (this.failedPolls > FAILED_POLLS_MAX) return;
+            this.pollTimer = setTimeout(() => this.poll(), FAILED_POLL_INTERVAL_MS);
             return;
           }
           if (ready && !this.disposed && !this.pointed) {
diff --git a/runner/packages/runtime/src/sandpack.ts b/runner/packages/runtime/src/sandpack.ts
index 8f75912a3..61eb237a6 100644
--- a/runner/packages/runtime/src/sandpack.ts
+++ b/runner/packages/runtime/src/sandpack.ts
@@ -13,7 +13,7 @@ import { loadSandpackClient } from "@codesandbox/sandpack-client";
 import type { CatalogEntry, DemoRuntime, FilesMap, HandsontableVersionRef } from "./types.js";
 import { transpileFilesForParcel } from "./transpile.js";
 import { applyDepShims } from "./dep-shims.js";
-import { resolveSandboxEntry } from "./sandbox-entry.js";
+import { resolveSandboxEntry, toParcelEntry } from "./sandbox-entry.js";
 import { applyHandsontableCss, applyHandsontableVersion } from "./version.js";
 
 // Derive Sandpack's option/setup types straight from the loader signature so we
@@ -99,6 +99,17 @@ function ensureSandpackDeps(files: FilesMap): FilesMap {
  */
 const IFRAME_OWNER = new WeakMap<HTMLIFrameElement, object>();
 
+/** Same paths, same contents. Compared key by key rather than by serialising both maps:
+ *  this runs on every keystroke, and a sandbox carries the compiled sources *and* the
+ *  dependency shims — hundreds of KB it would be pointless to stringify to learn that one
+ *  character changed. */
+function sameFiles(a: FilesMap, b: FilesMap | null): boolean {
+  if (b === null) return false;
+  const paths = Object.keys(a);
+  if (paths.length !== Object.keys(b).length) return false;
+  return paths.every((path) => a[path] === b[path]);
+}
+
 export class SandpackRuntime implements DemoRuntime {
   private readonly entry: CatalogEntry;
   private readonly opts: SandpackRuntimeOptions;
@@ -132,8 +143,17 @@ export class SandpackRuntime implements DemoRuntime {
     this.errorCbs.add(cb);
   }
 
+  /** Fires on *every* clean compile, not just the first.
+   *
+   *  A `done` without `compilatonError` is the bundler saying the current sources
+   *  compiled and evaluated — which is exactly the signal that a preview the user
+   *  broke is working again. Suppressing repeats made the error state a one-way
+   *  door: `show-error` set it, and no later success could clear it (the only exits
+   *  were an example switch or a version change, both of which remount).
+   *
+   *  `didReady` stays, but only for what it is actually needed for — replaying
+   *  readiness to a callback that subscribed after the first compile. */
   private emitReady() {
-    if (this.didReady) return;
     this.didReady = true;
     for (const cb of this.readyCbs) cb();
   }
@@ -150,7 +170,10 @@ export class SandpackRuntime implements DemoRuntime {
     // `this.files` always holds the authored sources; parcel's compiled view is
     // derived from it on every (re)build and never fed back into the editor.
     this.files = sanitizeHtml(ensureSandpackDeps(pinned));
-    return this.setupFrom(await this.sandboxFiles());
+    const sandbox = await this.sandboxFiles();
+    // What the bundler is about to hold, for `pushUpdate`'s no-op check.
+    this.published = sandbox;
+    return this.setupFrom(sandbox);
   }
 
   private get env(): string | undefined {
@@ -254,6 +277,47 @@ export class SandpackRuntime implements DemoRuntime {
     this.pushUpdate();
   }
 
+  /**
+   * Append a changing comment to the sandbox entry, so a compile the bundler would
+   * otherwise see as "no module changed" carries a real diff.
+   *
+   * The bundler's no-change path resets the preview document without re-evaluating
+   * anything: a blank frame, reported `done` with no compile error, and nothing in the
+   * console. That is what a refresh asks for and never got. One line on the entry is
+   * enough to put it back on the path that re-evaluates.
+   *
+   * A comment, so it cannot change behaviour, and matched to the file's language: a
+   * parcel/static sandbox boots from HTML, where `//` would render as text.
+   *
+   * Both the sandbox entry *and* the example's own module are stamped. A parcel sandbox
+   * boots from `index.html`, and a changed HTML shell alone does not get the module
+   * re-evaluated (measured: refresh still blanked). The script it loads is what has to
+   * look different.
+   */
+  private compileStamp = 0;
+  private stampEntry(files: FilesMap): FilesMap {
+    const paths = new Set<string>();
+    try {
+      paths.add(resolveSandboxEntry(this.env, this.entry.entry, this.entry.htmlEntry, files));
+    } catch {
+      // A missing entry is setupFrom()'s error to raise, with its own message.
+      return files;
+    }
+    const modulePath = this.env === "parcel" ? toParcelEntry(this.entry.entry) : this.entry.entry;
+    if (files[modulePath] !== undefined) paths.add(modulePath);
+
+    const stamp = ++this.compileStamp;
+    const out = { ...files };
+    for (const path of paths) {
+      out[path] =
+        out[path] +
+        (path.toLowerCase().endsWith(".html")
+          ? `\n<!-- hot-runner-compile ${stamp} -->\n`
+          : `\n// hot-runner-compile ${stamp}\n`);
+    }
+    return out;
+  }
+
   /** Re-run the sandbox from the current sources — the refresh button. No new client, no
    *  reload of the bundler itself; an ordinary compile push does the whole job.
    *
@@ -262,10 +326,15 @@ export class SandpackRuntime implements DemoRuntime {
    *  `loadSandpackClient` spends that single allowance itself when it replays the setup on
    *  the bundler's `initialized` message — so a refresh that set the flag was discarded in
    *  silence: no `start`, no `done`, no error, and the preview never re-ran. The flag
-   *  suppresses re-compiles rather than requesting one. A plain push is the real thing:
-   *  measured against the live bundler, a non-initial compile with byte-identical sources
-   *  re-transpiles, resets the sandbox document and re-evaluates the entry, leaving one
-   *  grid with its plugins registered.
+   *  suppresses re-compiles rather than requesting one, so a plain push it is.
+   *
+   *  A plain push is not sufficient on its own, though — that part of the DEV-2176 note was
+   *  wrong. A non-initial compile with byte-identical sources does compile (`start` …
+   *  `success`, `done` with no error) but re-evaluates nothing: the preview document is
+   *  reset and left blank, with not even the Handsontable banner in the console. Refresh
+   *  blanked the pane for exactly that reason. `force` is what fixes it: `pushUpdate` stamps
+   *  the entry and the example module (see `stampEntry`) so the bundler has a real diff, and
+   *  skips the no-op check it applies to ordinary edits.
    *
    *  Settles once our transpile is done and the update has been handed to the bundler, not
    *  on the bundler's `done`. `done` is available again now that the compile actually runs,
@@ -275,7 +344,7 @@ export class SandpackRuntime implements DemoRuntime {
    *  work we perform and can time (48–62ms on a warm React starter). */
   reload(): Promise<void> {
     if (!this.client) return Promise.resolve();
-    return this.pushUpdate();
+    return this.pushUpdate({ force: true });
   }
 
   /** Remove a file and recompile (file-tree delete/rename). */
@@ -307,12 +376,35 @@ export class SandpackRuntime implements DemoRuntime {
    * superseded, or failed to transpile. `reload()` reports that edge as its completion.
    */
   private updateSeq = 0;
-  private pushUpdate(): Promise<void> {
+  /** The sandbox the bundler currently holds, as published. Compared against the next
+   *  candidate so a no-op compile is never sent — see `pushUpdate`. */
+  private published: FilesMap | null = null;
+  private pushUpdate(opts: { force?: boolean } = {}): Promise<void> {
     const seq = ++this.updateSeq;
     return Promise.resolve(this.sandboxFiles())
       .then((files) => {
         if (!this.client || seq !== this.updateSeq) return;
-        this.client.updateSandbox(this.setupFrom(files), false);
+        const candidate = opts.force ? this.stampEntry(files) : files;
+        // Skipping a byte-identical update is not an optimisation, it is the fix for a
+        // blank preview. Break a source file and the transpile below throws, so nothing
+        // reaches the bundler and the last good render stays on screen (correct). Undo
+        // the break and the recomputed sandbox is identical to what the bundler already
+        // has — and *that* compile blanks the preview, because the bundler's no-change
+        // path resets the document without re-evaluating any module. Not sending it
+        // leaves the render that is already correct exactly where it is.
+        //
+        // `reload()` passes `force`, and its stamp guarantees a diff, so the refresh
+        // button still re-runs the sandbox rather than being skipped here.
+        if (!opts.force && sameFiles(candidate, this.published)) return;
+        // Recorded *after* the push, never before. `setupFrom` throws when the resolved
+        // entry is transiently missing (mid-rename, the DEV-2130 guard), and a `published`
+        // set ahead of that throw would claim the bundler holds a sandbox it never
+        // received. Restoring those sources would then read as a real diff and send the
+        // byte-identical compile this skip exists to prevent — the blank preview, back
+        // again, on the rename path.
+        const setup = this.setupFrom(candidate);
+        this.client.updateSandbox(setup, false);
+        this.published = candidate;
       })
       .catch(() => {
         /* mid-edit parse error — the user is still typing */
diff --git a/runner/pipeline/sandpack-reload.test.mjs b/runner/pipeline/sandpack-reload.test.mjs
index e0764f89b..d55dcf7ed 100644
--- a/runner/pipeline/sandpack-reload.test.mjs
+++ b/runner/pipeline/sandpack-reload.test.mjs
@@ -16,8 +16,15 @@ import { SandpackRuntime } from "../packages/runtime/dist/sandpack.js";
 // on the bundler's `initialized` message, so a refresh that asks for another
 // initialization compile is silently discarded: no `start`, no `done`, no error,
 // and the preview never re-runs. Every push — refresh included — must therefore
-// go out as an ordinary (non-initial) compile, which does re-transpile, reset the
-// sandbox document and re-evaluate the entry.
+// go out as an ordinary (non-initial) compile.
+//
+// A non-initial compile is necessary but not sufficient, which is what the rest of
+// this file now covers. Measured against the live bundler: a compile whose module
+// contents are byte-identical to what it already holds resets the preview document
+// and re-evaluates nothing — `start` … `success`, `done` with no compile error, and
+// a blank frame. So `reload()` stamps the entry to guarantee a diff, and ordinary
+// edits skip the push entirely when nothing changed (the render on screen is
+// already the right one).
 
 /** A catalog entry the runtime will hand to the bundler as-is (no parcel pre-transpile). */
 const ENTRY = {
@@ -73,6 +80,9 @@ function mounted() {
   const client = fakeClient();
   runtime.client = client;
   runtime.files = { ...FILES };
+  // What mount() records in buildSetup: the sandbox the bundler now holds. Without it the
+  // no-op check has no baseline to compare against, and every push looks like a change.
+  runtime.published = { ...FILES };
   return { runtime, client };
 }
 
@@ -108,10 +118,65 @@ test("reload() publishes the current sources", async () => {
   await runtime.reload();
 
   const last = client.pushes.at(-1).setup;
-  assert.equal(last.files["/src/main.js"].code, "console.log('edited');");
+  // Starts with, not equals: `reload()` appends a stamp comment (see below). The
+  // authored source has to be there in full and unaltered ahead of it.
+  assert.ok(
+    last.files["/src/main.js"].code.startsWith("console.log('edited');"),
+    `expected the edited source to be published, got: ${last.files["/src/main.js"].code}`,
+  );
   assert.equal(last.entry, "/src/main.js");
 });
 
+test("reload() stamps the entry, so the bundler always has a diff to act on", async () => {
+  const { runtime, client } = mounted();
+
+  await runtime.reload();
+  await runtime.reload();
+
+  const [first, second] = client.pushes.map((p) => p.setup.files["/src/main.js"].code);
+  assert.notEqual(
+    first,
+    second,
+    "two refreshes must not publish identical entry code — the bundler treats a no-change compile as nothing to do and blanks the preview",
+  );
+  for (const code of [first, second]) {
+    // A comment, so the stamp can never change what the module does.
+    assert.match(code, /^console\.log\('demo'\);\n\/\/ hot-runner-compile \d+\n$/);
+  }
+});
+
+test("an edit that changes nothing is not pushed at all", async () => {
+  const { runtime, client } = mounted();
+
+  runtime.writeFile("/src/main.js", "console.log('edited');");
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(client.pushes.length, 1, "the edit itself must reach the bundler");
+
+  // What break-then-undo produces: the broken push dies in the transpile, so undoing
+  // it recomputes a sandbox identical to the one the bundler already has. Pushing that
+  // blanks a preview that is currently correct, so it must not be pushed.
+  runtime.writeFile("/src/main.js", "console.log('edited');");
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(client.pushes.length, 1, "a byte-identical sandbox must not be published");
+});
+
+test("a push that fails to build a setup does not count as published", async () => {
+  const { runtime, client } = mounted();
+
+  // Delete the entry: `setupFrom` refuses a sandbox whose entry is missing (DEV-2130),
+  // which is what a mid-rename keystroke produces. Nothing reaches the bundler.
+  runtime.deleteFile("/src/main.js");
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(client.pushes.length, 0, "a sandbox with no entry must not be published");
+
+  // Finish the rename / undo it. The bundler still holds the original sources, so this
+  // recomputed sandbox is byte-identical to what it has — and must not be pushed. It
+  // would be if the failed push above had recorded itself as published.
+  runtime.writeFile("/src/main.js", "console.log('demo');");
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(client.pushes.length, 0, "restoring the sources the bundler already has must not compile");
+});
+
 test("reload() before mount() is a no-op", async () => {
   const runtime = new SandpackRuntime(ENTRY, { iframe: {} });
   await runtime.reload();