diff --git a/CLAY-VITE.md b/CLAY-VITE.md
index 271f8fe..927c7c0 100644
--- a/CLAY-VITE.md
+++ b/CLAY-VITE.md
@@ -442,10 +442,42 @@ absent on the next deploy → old path activates. No code changes needed in the
 | Aspect | `clay compile` | `clay vite` |
 |---|---|---|
 | **How scripts are resolved** | `getDependencies()` reads `_registry.json` | `resolveModuleScripts()` reads `_manifest.json` |
-| **Edit mode scripts** | All `_deps-*.js` + `_models-*.js` + `_kiln-*.js` + templates | Single `_kiln-edit-init` bundle + templates |
+| **Edit mode scripts** | All `_deps-*.js` + `_models-*.js` + `_kiln-*.js` + templates | `vite-bootstrap-no-mount` + `_kiln-edit-init` bundle + templates |
 | **View mode scripts** | Numeric IDs → individual dep files | `vite-bootstrap` + `_globals-init` + shared chunks (typically 3–5 files) |
+| **Component `client.js` in edit mode** | Never runs — the `edit` branch of `getDependencies()` ships no client bundle and no `_client-init.js` | Never runs — edit mode loads the no-mount bootstrap (see below) |
 | **Global scripts** | Individual files per registry entry (70–100 requests) | All `global/js/*.js` in one `_globals-init.js` (1 request) |
 
+#### Component `client.js` does not run in edit mode
+
+Under `clay compile`, component controllers only ran on rendered pages: the `edit` branch of
+`getDependencies()` resolves `model.js`, `kiln.js` and kiln plugins, but neither the client
+dependency graph nor `_client-init.js` — the runtime that mounts controllers. Editors therefore
+never executed component `client.js` inside Kiln.
+
+`clay vite` preserves that. Two bootstrap entries are generated from the same initializer prelude:
+
+| Entry | Loaded in | Contents |
+|---|---|---|
+| `.clay/vite-bootstrap.js` | view mode | prelude + `_clayClientModules` map + `mountComponentModules()` |
+| `.clay/vite-bootstrap-no-mount.js` | edit mode | prelude only |
+
+The prelude (the `window.modules` stub, `_env-init.js`, `_globals-init.js` and the sticky-events
+shim) is required in both modes — Kiln's preloader reads `window.modules`, and every `model.js`
+and kiln plugin reads env through the object `_env-init.js` hydrates. Only the mount runtime is
+view-mode-specific, and it runs at module scope, so serving the view bootstrap in edit mode
+executes every on-page component's `client.js`. That fires analytics, ad calls (GPT injects an
+`<iframe>` per slot), comment embeds and other third-party scripts inside the editing surface,
+where they mutate the DOM Kiln is trying to decorate.
+
+There is no option to opt back in. Mounting components in edit mode has no legitimate use — it
+was never possible under `clay compile`, and a component that needs its `client.js` output visible
+while editing should provide it through `kiln.js` rather than by running every ad and analytics
+script on the page inside the editor.
+
+If `public/js` was built by a claycli that predates the no-mount entry, `resolveModuleScripts()`
+falls back to the mounting bootstrap — serving no initializers at all would break Kiln outright,
+so a stale manifest degrades rather than fails. Re-run `clay vite` to pick up the fix.
+
 ## 6. Configuration
 
 Both commands read the same `claycli.config.js` but use **separate config keys**:
@@ -652,7 +684,7 @@ RUN if [ "$CLAYCLI_VITE_ENABLED" = "true" ]; then \
 | Module | File | Purpose |
 |---|---|---|
 | Orchestrator | [`lib/cmd/vite/scripts.js`](./lib/cmd/vite/scripts.js) | Main build + watch orchestration; `getViteConfig`, `baseViteConfig`, `buildAll`, `watch` |
-| Bootstrap generator | [`lib/cmd/vite/generate-bootstrap.js`](./lib/cmd/vite/generate-bootstrap.js) | Generates `.clay/vite-bootstrap.js` with component mount runtime |
+| Bootstrap generator | [`lib/cmd/vite/generate-bootstrap.js`](./lib/cmd/vite/generate-bootstrap.js) | Generates `.clay/vite-bootstrap.js` (with component mount runtime) and `.clay/vite-bootstrap-no-mount.js` (edit mode, prelude only) |
 | Globals init generator | [`lib/cmd/vite/generate-globals-init.js`](./lib/cmd/vite/generate-globals-init.js) | Generates `.clay/_globals-init.js` |
 | Kiln edit generator | [`lib/cmd/vite/generate-kiln-edit.js`](./lib/cmd/vite/generate-kiln-edit.js) | Generates `.clay/_kiln-edit-init.js` |
 | CSS compilation | [`lib/cmd/vite/styles.js`](./lib/cmd/vite/styles.js) | PostCSS pipeline; `buildStyles`, `SRC_GLOBS` |
@@ -678,7 +710,8 @@ RUN if [ "$CLAYCLI_VITE_ENABLED" = "true" ]; then \
 | File | Generated by | Purpose |
 |---|---|---|
 | `public/js/_manifest.json` | `lib/cmd/vite/scripts.js` (`buildManifest`/`writeManifest`) | Entry → file + chunks map. Replaces `_registry.json` + `_ids.json`. |
-| `.clay/vite-bootstrap.js` | `generate-bootstrap.js` | Imports every `client.js`; mounts via dynamic `import()` on DOM presence |
+| `.clay/vite-bootstrap.js` | `generate-bootstrap.js` | View mode. Imports every `client.js`; mounts via dynamic `import()` on DOM presence |
+| `.clay/vite-bootstrap-no-mount.js` | `generate-bootstrap.js` | Edit mode. Same initializers, no mount runtime — component `client.js` never runs in Kiln |
 | `.clay/_kiln-edit-init.js` | `generate-kiln-edit.js` | Imports every `model.js` + `kiln.js`; registers on `window.kiln.componentModels` |
 | `.clay/_globals-init.js` | `generate-globals-init.js` | Imports all `global/js/*.js` into one non-splitting entry |
 | `client-env.json` | `createClientEnvCollector` (Rollup plugin) | JSON array of `process.env.VAR_NAME` identifiers for `amphora-html` |
diff --git a/lib/cmd/vite/generate-bootstrap.js b/lib/cmd/vite/generate-bootstrap.js
index a8bb173..711cc58 100644
--- a/lib/cmd/vite/generate-bootstrap.js
+++ b/lib/cmd/vite/generate-bootstrap.js
@@ -9,9 +9,11 @@ const { generateViteEnvInit } = require('./generate-env-init');
 const CWD = process.cwd();
 const CLAY_DIR = path.join(CWD, '.clay');
 const VITE_BOOTSTRAP_FILE = path.join(CLAY_DIR, 'vite-bootstrap.js');
+const VITE_BOOTSTRAP_NO_MOUNT_FILE = path.join(CLAY_DIR, 'vite-bootstrap-no-mount.js');
 const GLOBALS_INIT_FILE = path.join(CLAY_DIR, '_globals-init.js');
 
 const VITE_BOOTSTRAP_KEY = '.clay/vite-bootstrap';
+const VITE_BOOTSTRAP_NO_MOUNT_KEY = '.clay/vite-bootstrap-no-mount';
 
 /**
  * Component mount runtime injected into the bootstrap.
@@ -204,37 +206,17 @@ mountComponentModules().catch(console.error);
 `;
 
 /**
- * Generate .clay/vite-bootstrap.js — the single ESM entry point for view mode.
+ * Build the initializer prelude shared by both bootstrap variants.
  *
- * Contains:
- *   1. Static import of _globals-init.js (runs synchronously before any
- *      component dynamic import, ensuring window.DS etc. are available).
- *   2. Sticky custom-event shim (when stickyEvents is configured).
- *   3. _clayClientModules map — one lazy import() per component/layout client.js.
- *   4. mountComponentModules() runtime — scans DOM and mounts components.
+ * Everything in here has to run in edit mode as well as view mode: kiln's
+ * preloader reads `window.modules`, and kiln plugins / model.js files read env
+ * through the object _env-init.js hydrates. Component mounting is the only
+ * view-mode-specific part of the bootstrap, which is why it lives in
+ * MOUNT_RUNTIME rather than here.
  *
- * @returns {Promise<string>} absolute path to the written bootstrap file
+ * @returns {Promise<string[]>} content lines, in evaluation order
  */
-async function generateViteBootstrap() {
-  await generateViteEnvInit();
-
-  const clientFiles = [
-    ...globSync(path.join(CWD, 'components', '**', 'client.js')),
-    ...globSync(path.join(CWD, 'layouts', '**', 'client.js')),
-  ];
-
-  const toRel = absPath => {
-    const rel = path.relative(CLAY_DIR, absPath).replace(/\\/g, '/');
-
-    return rel.startsWith('.') ? rel : `./${rel}`;
-  };
-
-  const moduleEntries = clientFiles.map(f => {
-    const key = path.relative(CWD, f).replace(/\\/g, '/');
-
-    return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(toRel(f))})`;
-  }).join(',\n');
-
+async function buildInitPrelude() {
   // ── Sticky events shim ───────────────────────────────────────────────────
   const stickyEvents = getConfigValue('stickyEvents') || [];
   const stickyListeners = stickyEvents
@@ -279,18 +261,72 @@ ${stickyListeners}
   // this path but pay no cost for the empty object.
   const kilnCompatStub = 'window.modules = window.modules || {};\n';
 
+  return [kilnCompatStub, envInitImport, globalsImport, stickyShimBlock];
+}
+
+/**
+ * Generate the two ESM bootstrap entry points.
+ *
+ * .clay/vite-bootstrap.js — view mode. Contains:
+ *   1. The initializer prelude (see buildInitPrelude).
+ *   2. _clayClientModules map — one lazy import() per component/layout client.js.
+ *   3. mountComponentModules() runtime — scans DOM and mounts components.
+ *
+ * .clay/vite-bootstrap-no-mount.js — edit mode. The prelude only.
+ *
+ * ── Why a second entry exists ────────────────────────────────────────────────
+ *
+ * The legacy `clay compile` pipeline resolved component client.js (and
+ * _client-init.js, which mounts it) for VIEW mode only — see the `edit` branch
+ * of getDependencies() in lib/cmd/compile/get-script-dependencies.js, which
+ * ships model.js, kiln.js and kiln plugins but no client bundle. Editors
+ * therefore never ran component controllers while in Kiln.
+ *
+ * Serving the view bootstrap in edit mode broke that contract: it calls
+ * mountComponentModules() at module scope, so every component's client.js
+ * executes as soon as the module evaluates. That runs analytics, ad calls
+ * (GPT injects an <iframe> per slot), comment embeds and other third-party
+ * scripts inside the editing surface, where they mutate the DOM that Kiln is
+ * trying to decorate and edit.
+ *
+ * Edit mode still needs the prelude, so the fix is a second entry rather than
+ * simply dropping the bootstrap: same initializers, no mounting.
+ *
+ * @returns {Promise<string>} absolute path to the written view bootstrap file
+ */
+async function generateViteBootstrap() {
+  await generateViteEnvInit();
+
+  const prelude = await buildInitPrelude();
+
+  const clientFiles = [
+    ...globSync(path.join(CWD, 'components', '**', 'client.js')),
+    ...globSync(path.join(CWD, 'layouts', '**', 'client.js')),
+  ];
+
+  const toRel = absPath => {
+    const rel = path.relative(CLAY_DIR, absPath).replace(/\\/g, '/');
+
+    return rel.startsWith('.') ? rel : `./${rel}`;
+  };
+
+  const moduleEntries = clientFiles.map(f => {
+    const key = path.relative(CWD, f).replace(/\\/g, '/');
+
+    return `  ${JSON.stringify(key)}: () => import(${JSON.stringify(toRel(f))})`;
+  }).join(',\n');
+
+  const timestamp = new Date().toISOString();
+
   const content = [
     '// AUTO-GENERATED — clay vite bootstrap (do not edit)',
-    `// ${new Date().toISOString()}`,
-    '// This file is the single ESM entry point injected into every page via',
+    `// ${timestamp}`,
+    '// This file is the ESM entry point injected into view-mode pages via',
     '// <script type="module">. It runs the global initializers synchronously,',
     '// then scans the DOM and dynamically imports only the component modules',
     '// present on the current page — keeping initial parse cost low.',
     '',
-    kilnCompatStub,
-    envInitImport,
-    globalsImport,
-    stickyShimBlock,
+    ...prelude,
     'const _clayClientModules = {',
     moduleEntries,
     '};',
@@ -298,8 +334,22 @@ ${stickyListeners}
     MOUNT_RUNTIME,
   ].join('\n');
 
+  const noMountContent = [
+    '// AUTO-GENERATED — clay vite bootstrap, no-mount variant (do not edit)',
+    `// ${timestamp}`,
+    '// This file is the ESM entry point injected into EDIT-mode pages. It runs',
+    '// the same global initializers as vite-bootstrap.js but omits the',
+    '// component-mounting runtime, so component client.js files do not execute',
+    '// while an editor is in Kiln — matching the legacy clay compile pipeline.',
+    '',
+    ...prelude,
+  ].join('\n');
+
   await fs.ensureDir(CLAY_DIR);
-  await fs.writeFile(VITE_BOOTSTRAP_FILE, content, 'utf8');
+  await Promise.all([
+    fs.writeFile(VITE_BOOTSTRAP_FILE, content, 'utf8'),
+    fs.writeFile(VITE_BOOTSTRAP_NO_MOUNT_FILE, noMountContent, 'utf8'),
+  ]);
 
   return VITE_BOOTSTRAP_FILE;
 }
@@ -307,5 +357,7 @@ ${stickyListeners}
 module.exports = {
   generateViteBootstrap,
   VITE_BOOTSTRAP_FILE,
+  VITE_BOOTSTRAP_NO_MOUNT_FILE,
   VITE_BOOTSTRAP_KEY,
+  VITE_BOOTSTRAP_NO_MOUNT_KEY,
 };
diff --git a/lib/cmd/vite/generators.test.js b/lib/cmd/vite/generators.test.js
index 10ba2d5..ffd8619 100644
--- a/lib/cmd/vite/generators.test.js
+++ b/lib/cmd/vite/generators.test.js
@@ -135,6 +135,45 @@ describe('generate-vite env/bootstrap/kiln generators', () => {
       expect(content).toContain('// no global/js — skipping _globals-init');
       expect(content).not.toContain('clayViteStickyEvents');
     });
+
+    it('writes a no-mount variant with the same initializers but no mount runtime', async () => {
+      await setupTmpDir('claycli-vite-bootstrap-no-mount-');
+
+      await fs.ensureDir(path.join(tmpDir, '.clay'));
+      await fs.writeFile(path.join(tmpDir, '.clay', '_globals-init.js'), '// globals');
+      await fs.ensureDir(path.join(tmpDir, 'components', 'article'));
+      await fs.writeFile(path.join(tmpDir, 'components', 'article', 'client.js'), 'module.exports = function() {};');
+
+      jest.doMock('./generate-env-init', () => ({
+        generateViteEnvInit: jest.fn().mockResolvedValue(path.join(tmpDir, '.clay', '_env-init.js')),
+      }));
+      jest.doMock('../../config-file-helpers', () => ({
+        getConfigValue: jest.fn().mockReturnValue(['auth:init']),
+      }));
+
+      const {
+        generateViteBootstrap,
+        VITE_BOOTSTRAP_NO_MOUNT_FILE,
+        VITE_BOOTSTRAP_NO_MOUNT_KEY,
+      } = require('./generate-bootstrap');
+
+      await generateViteBootstrap();
+      const content = await fs.readFile(VITE_BOOTSTRAP_NO_MOUNT_FILE, 'utf8');
+
+      expect(VITE_BOOTSTRAP_NO_MOUNT_KEY).toBe('.clay/vite-bootstrap-no-mount');
+
+      // Kiln's preloader reads window.modules, and every model.js / kiln.js env
+      // read goes through _env-init.js, so edit mode still needs the prelude.
+      expect(content).toContain("import './_env-init.js';");
+      expect(content).toContain("import './_globals-init.js';");
+      expect(content).toContain('window.modules = window.modules || {};');
+      expect(content).toContain('fired["auth:init"] = ev.detail;');
+
+      // The point of the variant: no component client.js runs in edit mode.
+      expect(content).not.toContain('mountComponentModules');
+      expect(content).not.toContain('_clayClientModules');
+      expect(content).not.toContain('components/article/client.js');
+    });
   });
 
   describe('generate-kiln-edit', () => {
diff --git a/lib/cmd/vite/index.js b/lib/cmd/vite/index.js
index a60a56c..47eb6d8 100644
--- a/lib/cmd/vite/index.js
+++ b/lib/cmd/vite/index.js
@@ -1,6 +1,13 @@
 'use strict';
 
-const { build, watch, getViteConfig, VITE_BOOTSTRAP_KEY, KILN_EDIT_ENTRY_KEY } = require('./scripts');
+const {
+  build,
+  watch,
+  getViteConfig,
+  VITE_BOOTSTRAP_KEY,
+  VITE_BOOTSTRAP_NO_MOUNT_KEY,
+  KILN_EDIT_ENTRY_KEY,
+} = require('./scripts');
 
 const fs = require('fs');
 const path = require('path');
@@ -39,14 +46,14 @@ function readManifest() {
 // ── Script URL helpers ───────────────────────────────────────────────────────
 
 /**
- * Return the bootstrap script URL for view mode.
- * One <script type="module"> tag is all the browser needs —
- * the bootstrap handles lazy-loading all components on demand.
+ * Return one bootstrap entry's script URL, rebased onto the site's asset
+ * host/prefix. Returns [] when the entry is absent from the manifest.
  *
+ * @param {string} key         - manifest key of the bootstrap entry
  * @param {string} [assetPath] - site asset prefix (e.g. 'https://cdn.example.com')
  * @returns {string[]}
  */
-function getViteViewScripts(assetPath) {
+function getBootstrapScripts(key, assetPath) {
   if (!hasManifest()) return [];
 
   const manifest = readManifest();
@@ -54,13 +61,45 @@ function getViteViewScripts(assetPath) {
   if (!manifest) return [];
 
   const base  = (assetPath || '') + '/js';
-  const entry = manifest[VITE_BOOTSTRAP_KEY];
+  const entry = manifest[key];
 
   if (!entry || !entry.file) return [];
 
   return [entry.file.replace(/^\/js/, base)];
 }
 
+/**
+ * Return the bootstrap script URL for view mode.
+ * One <script type="module"> tag is all the browser needs —
+ * the bootstrap handles lazy-loading all components on demand.
+ *
+ * @param {string} [assetPath] - site asset prefix (e.g. 'https://cdn.example.com')
+ * @returns {string[]}
+ */
+function getViteViewScripts(assetPath) {
+  return getBootstrapScripts(VITE_BOOTSTRAP_KEY, assetPath);
+}
+
+/**
+ * Return the bootstrap script URL for edit mode.
+ *
+ * Always the no-mount variant, so component client.js files never execute while
+ * an editor is in Kiln — see generateViteBootstrap() for why that matters.
+ *
+ * Falls back to the mounting bootstrap when the no-mount entry is absent, which
+ * happens when public/js was built by a claycli predating it. That fallback
+ * reintroduces client.js-in-edit-mode, but serving no initializers at all would
+ * break Kiln outright, so a stale manifest degrades rather than fails.
+ *
+ * @param {string} [assetPath]
+ * @returns {string[]}
+ */
+function getViteEditBootstrapScripts(assetPath) {
+  const noMount = getBootstrapScripts(VITE_BOOTSTRAP_NO_MOUNT_KEY, assetPath);
+
+  return noMount.length ? noMount : getViteViewScripts(assetPath);
+}
+
 /**
  * Return the same URL list for <link rel="modulepreload"> hints.
  *
@@ -95,7 +134,7 @@ function getEditScripts(assetPath) {
  * Populate media.moduleScripts and media.modulePreloads for amphora-html.
  *
  * In view mode: one bootstrap URL.
- * In edit mode: bootstrap + kiln edit bundle.
+ * In edit mode: the no-mount bootstrap + kiln edit bundle.
  *
  * @param {object}  media
  * @param {string}  assetPath
@@ -107,21 +146,20 @@ function resolveModuleScripts(media, assetPath, options) {
   if (!hasManifest()) return;
 
   const { edit = false, preloadEditBundle = false } = options || {};
-  const viewScripts = getViteViewScripts(assetPath);
-  const preloads    = getViteModulePreloads(assetPath);
 
   if (edit) {
-    const editScripts = getEditScripts(assetPath);
+    const editScripts      = getEditScripts(assetPath);
+    const bootstrapScripts = getViteEditBootstrapScripts(assetPath);
 
     // Keep bootstrap first so shared env/bootstrap globals are available
     // before the kiln edit entry executes.
-    media.moduleScripts  = [...viewScripts, ...editScripts];
+    media.moduleScripts  = [...bootstrapScripts, ...editScripts];
     media.modulePreloads = preloadEditBundle
-      ? [...preloads, ...editScripts]
-      : preloads;
+      ? [...bootstrapScripts, ...editScripts]
+      : bootstrapScripts;
   } else {
-    media.moduleScripts  = viewScripts;
-    media.modulePreloads = preloads;
+    media.moduleScripts  = getViteViewScripts(assetPath);
+    media.modulePreloads = getViteModulePreloads(assetPath);
     media.scripts        = [];
   }
 }
@@ -163,5 +201,6 @@ module.exports = {
   getTemplatePaths,
   getDependenciesNext,
   VITE_BOOTSTRAP_KEY,
+  VITE_BOOTSTRAP_NO_MOUNT_KEY,
   KILN_EDIT_ENTRY_KEY,
 };
diff --git a/lib/cmd/vite/index.test.js b/lib/cmd/vite/index.test.js
index eba7709..3b68804 100644
--- a/lib/cmd/vite/index.test.js
+++ b/lib/cmd/vite/index.test.js
@@ -20,6 +20,7 @@ jest.mock('vite', () => ({ build: jest.fn() }));
 // ── Manifest key constants (match generate-bootstrap.js / generate-kiln-edit.js) ──
 
 const BOOTSTRAP_KEY  = '.clay/vite-bootstrap';
+const NO_MOUNT_KEY   = '.clay/vite-bootstrap-no-mount';
 const KILN_EDIT_KEY  = '.clay/vite-kiln-edit-init';
 
 // ── helpers ───────────────────────────────────────────────────────────────────
@@ -219,6 +220,84 @@ describe('index — edit mode scripts', () => {
   });
 });
 
+// ── edit-mode component mounting ──────────────────────────────────────────────
+//
+// The legacy clay compile pipeline resolved component client.js for view mode
+// only, so editors never ran component controllers inside Kiln. Edit mode must
+// therefore load the no-mount bootstrap, not the mounting one.
+
+describe('index — edit mode component mounting', () => {
+  it('serves the no-mount bootstrap in edit mode by default', () => {
+    const { mod, cleanup } = withManifest({
+      [BOOTSTRAP_KEY]: { file: '/js/bootstrap-abc.js',  imports: [] },
+      [NO_MOUNT_KEY]:   { file: '/js/no-mount-def.js',  imports: [] },
+      [KILN_EDIT_KEY]:  { file: '/js/kiln-edit-xyz.js', imports: [] },
+    });
+    const media = {};
+
+    mod.resolveModuleScripts(media, '', { edit: true });
+    cleanup();
+
+    expect(media.moduleScripts).toContain('/js/no-mount-def.js');
+    expect(media.moduleScripts).not.toContain('/js/bootstrap-abc.js');
+  });
+
+  it('keeps the no-mount bootstrap ahead of the kiln edit bundle', () => {
+    const { mod, cleanup } = withManifest({
+      [BOOTSTRAP_KEY]: { file: '/js/bootstrap-abc.js',  imports: [] },
+      [NO_MOUNT_KEY]:   { file: '/js/no-mount-def.js',  imports: [] },
+      [KILN_EDIT_KEY]:  { file: '/js/kiln-edit-xyz.js', imports: [] },
+    });
+    const media = {};
+
+    mod.resolveModuleScripts(media, '', { edit: true });
+    cleanup();
+
+    expect(media.moduleScripts.indexOf('/js/no-mount-def.js'))
+      .toBeLessThan(media.moduleScripts.indexOf('/js/kiln-edit-xyz.js'));
+  });
+
+  it('falls back to the mounting bootstrap when the no-mount entry is absent', () => {
+    const { mod, cleanup } = withManifest({
+      [BOOTSTRAP_KEY]: { file: '/js/bootstrap-abc.js', imports: [] },
+    });
+    const media = {};
+
+    mod.resolveModuleScripts(media, '', { edit: true });
+    cleanup();
+
+    // A manifest built by an older claycli has no no-mount entry. Serving no
+    // initializers at all would break Kiln, so degrade rather than fail.
+    expect(media.moduleScripts).toContain('/js/bootstrap-abc.js');
+  });
+
+  it('preloads the edit bootstrap rather than the view bootstrap', () => {
+    const { mod, cleanup } = withManifest({
+      [BOOTSTRAP_KEY]: { file: '/js/bootstrap-abc.js', imports: [] },
+      [NO_MOUNT_KEY]:   { file: '/js/no-mount-def.js', imports: [] },
+    });
+    const media = {};
+
+    mod.resolveModuleScripts(media, '', { edit: true });
+    cleanup();
+
+    expect(media.modulePreloads).toEqual(['/js/no-mount-def.js']);
+  });
+
+  it('leaves view mode on the mounting bootstrap', () => {
+    const { mod, cleanup } = withManifest({
+      [BOOTSTRAP_KEY]: { file: '/js/bootstrap-abc.js', imports: [] },
+      [NO_MOUNT_KEY]:   { file: '/js/no-mount-def.js', imports: [] },
+    });
+    const media = {};
+
+    mod.resolveModuleScripts(media, '', { edit: false });
+    cleanup();
+
+    expect(media.moduleScripts).toEqual(['/js/bootstrap-abc.js']);
+  });
+});
+
 // ── exported constants ────────────────────────────────────────────────────────
 
 describe('index — exported constants', () => {
@@ -235,4 +314,11 @@ describe('index — exported constants', () => {
     cleanup();
     expect(mod.KILN_EDIT_ENTRY_KEY).toBe(KILN_EDIT_KEY);
   });
+
+  it('exports VITE_BOOTSTRAP_NO_MOUNT_KEY matching the bootstrap generator', () => {
+    const { mod, cleanup } = withNoManifest();
+
+    cleanup();
+    expect(mod.VITE_BOOTSTRAP_NO_MOUNT_KEY).toBe(NO_MOUNT_KEY);
+  });
 });
diff --git a/lib/cmd/vite/scripts.js b/lib/cmd/vite/scripts.js
index 646ceeb..140a4c1 100644
--- a/lib/cmd/vite/scripts.js
+++ b/lib/cmd/vite/scripts.js
@@ -17,7 +17,13 @@ const viteVue2Plugin = require('./plugins/vue2');
 const viteManualChunksPlugin = require('./plugins/manual-chunks');
 const { createClientEnvCollector } = require('./plugins/client-env');
 
-const { generateViteBootstrap, VITE_BOOTSTRAP_FILE, VITE_BOOTSTRAP_KEY } = require('./generate-bootstrap');
+const {
+  generateViteBootstrap,
+  VITE_BOOTSTRAP_FILE,
+  VITE_BOOTSTRAP_NO_MOUNT_FILE,
+  VITE_BOOTSTRAP_KEY,
+  VITE_BOOTSTRAP_NO_MOUNT_KEY,
+} = require('./generate-bootstrap');
 const { generateViteKilnEditEntry, KILN_EDIT_ENTRY_FILE, KILN_EDIT_ENTRY_KEY } = require('./generate-kiln-edit');
 const { generateViteGlobalsInit } = require('./generate-globals-init');
 
@@ -33,6 +39,7 @@ const CLAY_DIR = path.join(CWD, '.clay');
 const BUILD_STEP_NAMES = new Set(['js', 'styles', 'fonts', 'templates', 'vendor', 'media']);
 
 exports.VITE_BOOTSTRAP_KEY = VITE_BOOTSTRAP_KEY;
+exports.VITE_BOOTSTRAP_NO_MOUNT_KEY = VITE_BOOTSTRAP_NO_MOUNT_KEY;
 exports.KILN_EDIT_ENTRY_KEY = KILN_EDIT_ENTRY_KEY;
 
 function normalizeRequestedSteps(only) {
@@ -656,10 +663,31 @@ function buildChunkingOutput(viteCfg) {
  * @param {object} internalPlugins
  * @returns {Promise<Object>}
  */
+/**
+ * Add the edit-mode no-mount bootstrap to a Rollup input map when it exists.
+ *
+ * It rides along in the view graph so Rollup dedupes the initializer chunks
+ * both variants share instead of emitting a second copy.
+ *
+ * Guarded on existence so an older or stubbed generate-bootstrap — one that
+ * predates this entry — still produces a working build.
+ *
+ * @param {object} input - Rollup input map, mutated in place
+ * @returns {object} the same input map
+ */
+function withNoMountBootstrap(input) {
+  if (VITE_BOOTSTRAP_NO_MOUNT_FILE && fs.existsSync(VITE_BOOTSTRAP_NO_MOUNT_FILE)) {
+    input[VITE_BOOTSTRAP_NO_MOUNT_KEY] = VITE_BOOTSTRAP_NO_MOUNT_FILE;
+  }
+
+  return input;
+}
+
 async function runViewBuild(viteCfg, internalPlugins) {
   const entryMap = {};
 
   entryMap[VITE_BOOTSTRAP_KEY] = VITE_BOOTSTRAP_FILE;
+  withNoMountBootstrap(entryMap);
 
   if (viteCfg.kilnSplit) {
     entryMap[KILN_EDIT_ENTRY_KEY] = KILN_EDIT_ENTRY_FILE;
@@ -1179,9 +1207,11 @@ async function watch(options = {}) {
     });
   }
 
-  const watchInput = viteCfg.kilnSplit
-    ? { [VITE_BOOTSTRAP_KEY]: VITE_BOOTSTRAP_FILE, [KILN_EDIT_ENTRY_KEY]: KILN_EDIT_ENTRY_FILE }
-    : { [VITE_BOOTSTRAP_KEY]: VITE_BOOTSTRAP_FILE };
+  const watchInput = withNoMountBootstrap({ [VITE_BOOTSTRAP_KEY]: VITE_BOOTSTRAP_FILE });
+
+  if (viteCfg.kilnSplit) {
+    watchInput[KILN_EDIT_ENTRY_KEY] = KILN_EDIT_ENTRY_FILE;
+  }
 
   const watchCfg = baseViteConfig(viteCfg);