From cc2a177f208b110cd81a95ea0892674192aa2420 Mon Sep 17 00:00:00 2001
From: Jordan Paulino <jjpaulino@users.noreply.github.com>
Date: Thu, 13 Aug 2026 15:58:21 -0400
Subject: [PATCH 1/2] =?UTF-8?q?=F0=9F=8D=95=20Stop=20component=20client.js?=
 =?UTF-8?q?=20from=20running=20in=20Kiln=20edit=20mode?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The Vite pipeline serves the view-mode bootstrap in edit mode, and that
bootstrap calls mountComponentModules() at module scope — so every on-page
component's client.js executes as soon as the module evaluates, while an
editor is in Kiln.

The legacy clay compile pipeline resolved client.js for view mode only (the
edit branch of getDependencies() ships model.js, kiln.js and kiln plugins,
but no client bundle and no _client-init.js), so this is a regression from
clay compile. It runs ads (GPT injects an iframe per slot), analytics and
comment embeds inside the editing surface, where they mutate the DOM Kiln
is trying to decorate.

Generate a second entry, .clay/vite-bootstrap-no-mount.js, from the same
initializer prelude — the window.modules stub, _env-init, _globals-init and
the sticky-events shim, all of which edit mode genuinely needs — but without
the mount runtime, and serve that in edit mode. resolveModuleScripts() takes
mountInEditMode to opt back in, and falls back to the mounting bootstrap when
public/js was built by a claycli predating the new entry.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 CLAY-VITE.md                       |  40 +++++++++-
 lib/cmd/vite/generate-bootstrap.js | 122 ++++++++++++++++++++---------
 lib/cmd/vite/generators.test.js    |  39 +++++++++
 lib/cmd/vite/index.js              |  77 ++++++++++++++----
 lib/cmd/vite/index.test.js         | 100 +++++++++++++++++++++++
 lib/cmd/vite/scripts.js            |  38 ++++++++-
 6 files changed, 358 insertions(+), 58 deletions(-)

diff --git a/CLAY-VITE.md b/CLAY-VITE.md
index 271f8fe..1ebdd9f 100644
--- a/CLAY-VITE.md
+++ b/CLAY-VITE.md
@@ -442,10 +442,43 @@ 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.
+
+To opt back into mounting in edit mode, pass `mountInEditMode`:
+
+```js
+clayBuild.resolveModuleScripts(media, assetPath, { edit: true, mountInEditMode: true });
+```
+
+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 +685,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 +711,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..a4eca2a 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,49 @@ 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.
+ *
+ * Defaults to the no-mount variant so component client.js files do not execute
+ * while an editor is in Kiln — see generateViteBootstrap() for why that matters.
+ * Pass mountInEditMode to restore the mounting bootstrap.
+ *
+ * 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]
+ * @param {boolean} [mountInEditMode=false]
+ * @returns {string[]}
+ */
+function getViteEditBootstrapScripts(assetPath, mountInEditMode = false) {
+  if (mountInEditMode) return getViteViewScripts(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,33 +138,34 @@ 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
  * @param {object}  [options]
  * @param {boolean} [options.edit=false]
  * @param {boolean} [options.preloadEditBundle=false]
+ * @param {boolean} [options.mountInEditMode=false] - set true to mount component
+ *   client.js in edit mode as well as view mode
  */
 function resolveModuleScripts(media, assetPath, options) {
   if (!hasManifest()) return;
 
-  const { edit = false, preloadEditBundle = false } = options || {};
-  const viewScripts = getViteViewScripts(assetPath);
-  const preloads    = getViteModulePreloads(assetPath);
+  const { edit = false, preloadEditBundle = false, mountInEditMode = false } = options || {};
 
   if (edit) {
-    const editScripts = getEditScripts(assetPath);
+    const editScripts      = getEditScripts(assetPath);
+    const bootstrapScripts = getViteEditBootstrapScripts(assetPath, mountInEditMode);
 
     // 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 +207,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..1bf64af 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,98 @@ 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('serves the mounting bootstrap when mountInEditMode is true', () => {
+    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, mountInEditMode: true });
+    cleanup();
+
+    expect(media.moduleScripts).toContain('/js/bootstrap-abc.js');
+    expect(media.moduleScripts).not.toContain('/js/no-mount-def.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 +328,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);
 

From 264609edbe4f5133a8cdb6ec63b133882c873ace Mon Sep 17 00:00:00 2001
From: Jordan Paulino <jjpaulino@users.noreply.github.com>
Date: Thu, 13 Aug 2026 16:34:19 -0400
Subject: [PATCH 2/2] =?UTF-8?q?=F0=9F=8D=95=20Drop=20the=20mountInEditMode?=
 =?UTF-8?q?=20escape=20hatch?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Nothing should ever want component client.js running in edit mode. It was
never possible under clay compile, so there is no prior behavior to preserve,
and the option had no caller — it only existed because the fix was framed as
opt-in before it became the default.

A global flag is also the wrong granularity for the one need that sounds
plausible. A component that wants client-rendered output visible while editing
should provide it through kiln.js, not by running every ad call, analytics
beacon and comment embed on the page inside the editing surface.

The stale-manifest fallback stays. When public/js predates the no-mount entry,
serving no initializers at all would break Kiln outright, so that path
degrades rather than fails.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 CLAY-VITE.md               |  9 ++++-----
 lib/cmd/vite/index.js      | 18 ++++++------------
 lib/cmd/vite/index.test.js | 14 --------------
 3 files changed, 10 insertions(+), 31 deletions(-)

diff --git a/CLAY-VITE.md b/CLAY-VITE.md
index 1ebdd9f..927c7c0 100644
--- a/CLAY-VITE.md
+++ b/CLAY-VITE.md
@@ -469,11 +469,10 @@ executes every on-page component's `client.js`. That fires analytics, ad calls (
 `<iframe>` per slot), comment embeds and other third-party scripts inside the editing surface,
 where they mutate the DOM Kiln is trying to decorate.
 
-To opt back into mounting in edit mode, pass `mountInEditMode`:
-
-```js
-clayBuild.resolveModuleScripts(media, assetPath, { edit: true, mountInEditMode: true });
-```
+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,
diff --git a/lib/cmd/vite/index.js b/lib/cmd/vite/index.js
index a4eca2a..47eb6d8 100644
--- a/lib/cmd/vite/index.js
+++ b/lib/cmd/vite/index.js
@@ -83,22 +83,18 @@ function getViteViewScripts(assetPath) {
 /**
  * Return the bootstrap script URL for edit mode.
  *
- * Defaults to the no-mount variant so component client.js files do not execute
- * while an editor is in Kiln — see generateViteBootstrap() for why that matters.
- * Pass mountInEditMode to restore the mounting bootstrap.
+ * 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]
- * @param {boolean} [mountInEditMode=false]
+ * @param {string} [assetPath]
  * @returns {string[]}
  */
-function getViteEditBootstrapScripts(assetPath, mountInEditMode = false) {
-  if (mountInEditMode) return getViteViewScripts(assetPath);
-
+function getViteEditBootstrapScripts(assetPath) {
   const noMount = getBootstrapScripts(VITE_BOOTSTRAP_NO_MOUNT_KEY, assetPath);
 
   return noMount.length ? noMount : getViteViewScripts(assetPath);
@@ -145,17 +141,15 @@ function getEditScripts(assetPath) {
  * @param {object}  [options]
  * @param {boolean} [options.edit=false]
  * @param {boolean} [options.preloadEditBundle=false]
- * @param {boolean} [options.mountInEditMode=false] - set true to mount component
- *   client.js in edit mode as well as view mode
  */
 function resolveModuleScripts(media, assetPath, options) {
   if (!hasManifest()) return;
 
-  const { edit = false, preloadEditBundle = false, mountInEditMode = false } = options || {};
+  const { edit = false, preloadEditBundle = false } = options || {};
 
   if (edit) {
     const editScripts      = getEditScripts(assetPath);
-    const bootstrapScripts = getViteEditBootstrapScripts(assetPath, mountInEditMode);
+    const bootstrapScripts = getViteEditBootstrapScripts(assetPath);
 
     // Keep bootstrap first so shared env/bootstrap globals are available
     // before the kiln edit entry executes.
diff --git a/lib/cmd/vite/index.test.js b/lib/cmd/vite/index.test.js
index 1bf64af..3b68804 100644
--- a/lib/cmd/vite/index.test.js
+++ b/lib/cmd/vite/index.test.js
@@ -257,20 +257,6 @@ describe('index — edit mode component mounting', () => {
       .toBeLessThan(media.moduleScripts.indexOf('/js/kiln-edit-xyz.js'));
   });
 
-  it('serves the mounting bootstrap when mountInEditMode is true', () => {
-    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, mountInEditMode: true });
-    cleanup();
-
-    expect(media.moduleScripts).toContain('/js/bootstrap-abc.js');
-    expect(media.moduleScripts).not.toContain('/js/no-mount-def.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: [] },