@reticlehq/vite-plugin 2.13.0 → 2.14.0

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(index_exports, {
   RETICLE_VITE_PLUGIN_NAME: () => RETICLE_VITE_PLUGIN_NAME,
   connectChurnWarning: () => connectChurnWarning,
   connectModuleSource: () => connectModuleSource,
+  connectModuleUrl: () => connectModuleUrl,
   findDevModule: () => findDevModule,
   installedSdk: () => installedSdk,
   readPairingToken: () => readPairingToken,
@@ -155,7 +156,9 @@ var ReticleEnv = {
    * exhaust, so the one spec that proves the proxy SURVIVES exhaustion could not run at all without
    * shortening it. A budget nobody can reach in a test is a budget nobody tests.
    */
-  RECONNECT_ATTEMPTS: "RETICLE_RECONNECT_ATTEMPTS"
+  RECONNECT_ATTEMPTS: "RETICLE_RECONNECT_ATTEMPTS",
+  /** Quiet window before an abandoned MCP stdio proxy exits; `0` disables the watcher. */
+  MCP_PROXY_IDLE: "RETICLE_MCP_PROXY_IDLE_MS"
 };
 var TRANSPORT_LIMITS = {
   MAX_MESSAGE_BYTES: 1024 * 1024,
@@ -311,6 +314,16 @@ var EventType = {
    * `data: { href }` — the URL the page asked to open, when it named one.
    */
   CONTEXT_OPENED: "context.opened",
+  /**
+   * The app opened a native `alert`/`confirm`/`prompt` while Reticle was driving it.
+   *
+   * Recorded because Reticle ANSWERS these rather than letting them block — a native dialog halts
+   * the main thread, and the SDK's own message pump is on that thread, so one `confirm` behind a
+   * driven click made the tab permanently unresponsive with no recovery from inside the session.
+   * Answering silently would trade a wedge for an invisible one, so the question the app asked, and
+   * the answer given, ride out as an event.
+   */
+  DIALOG_OPENED: "dialog.opened",
   /** aggregated React commits over a throttle window (dev builds) — `data: { commits }`. Commit storms /
    * wasted re-renders show up here without a per-render flood. */
   RENDER_COMMIT: "render.commit",
@@ -4787,6 +4800,25 @@ function optimizerOptions(key, inherited, add) {
   };
 }
 
+// src/watch-ignore.ts
+function mergeIgnored(existing, ours) {
+  if (void 0 === existing || null === existing) return [ours];
+  const listed = Array.isArray(existing) ? existing : [existing];
+  return [...listed.filter(isWatchPattern), ours];
+}
+function isWatchPattern(value) {
+  return "string" === typeof value || value instanceof RegExp || "function" === typeof value;
+}
+
+// src/vitest-browser.ts
+function isVitestBrowserServer(config) {
+  const test = config.test;
+  if (null === test || "object" !== typeof test) return false;
+  const browser = test.browser;
+  if (null === browser || "object" !== typeof browser) return false;
+  return true === browser.enabled;
+}
+
 // src/index.ts
 var RETICLE_VITE_PLUGIN_NAME = "reticle";
 var RETICLE_PACKAGE2 = "@reticlehq/react";
@@ -4796,6 +4828,13 @@ var JSX_FILE = /\.[jt]sx$/;
 var VIRTUAL_PREFIX = "\0";
 var NODE_MODULES = "node_modules";
 var RETICLE_CONNECT_MODULE = "/@reticle-connect";
+function connectModuleUrl(base) {
+  if (void 0 === base || !base.startsWith("/")) return RETICLE_CONNECT_MODULE;
+  let end = base.length;
+  while (0 < end && "/" === base[end - 1]) end -= 1;
+  const trimmed = base.slice(0, end);
+  return 0 === trimmed.length ? RETICLE_CONNECT_MODULE : `${trimmed}${RETICLE_CONNECT_MODULE}`;
+}
 var RENDER_PREHOOK_SOURCE = `(function(){try{
 var K='__REACT_DEVTOOLS_GLOBAL_HOOK__',P='${RETICLE_RENDER_PREHOOK}';
 if(globalThis[P])return;
@@ -4880,6 +4919,10 @@ function connectArgs(options) {
   if (true === options.captureNetworkBodies || "1" === process.env["VITE_RETICLE_CAPTURE_BODIES"]) {
     args["captureNetworkBodies"] = true;
   }
+  if (false === options.sourceMapping) args["sourceMapping"] = false;
+  if (false === options.captureErrorBodies || "1" === process.env["VITE_RETICLE_NO_ERROR_BODIES"]) {
+    args["captureErrorBodies"] = false;
+  }
   if (true === options.exposePresenter || "1" === process.env["VITE_RETICLE_EXPOSE_PRESENTER"]) {
     args["exposePresenter"] = true;
   }
@@ -4946,6 +4989,8 @@ function reticle(options = {}) {
   let htmlEntrySpecifier;
   let root;
   let command;
+  let base;
+  let vitestBrowser = false;
   const warn = options.onWarn ?? ((message) => globalThis.console.warn(message));
   let injected = false;
   const resolveLazy = () => {
@@ -5012,7 +5057,7 @@ function reticle(options = {}) {
         // Appends to the app's list rather than replacing it, so nothing it already excluded is lost.
         server: {
           watch: {
-            ignored: [...config.server?.watch?.ignored ?? [], JOURNAL_IGNORE]
+            ignored: mergeIgnored(config.server?.watch?.ignored, JOURNAL_IGNORE)
           }
         },
         // Expose the daemon's pairing token to hand-written connects in the same Vite app. The
@@ -5096,6 +5141,8 @@ ${code}`;
     configResolved(config) {
       root = config.root;
       command = config.command;
+      base = config.base;
+      vitestBrowser = isVitestBrowserServer(config);
     },
     /**
      * Serve the connect module fresh, every time.
@@ -5148,7 +5195,8 @@ ${code}`;
         announce();
       }
       server.middlewares.use((req, _res, next) => {
-        if ((req.url ?? "").split("?")[0] === RETICLE_CONNECT_MODULE) {
+        const requestPath = (req.url ?? "").split("?")[0];
+        if (requestPath === RETICLE_CONNECT_MODULE || requestPath === connectModuleUrl(base)) {
           if (currentConnectSource() !== lastServedConnectSource) {
             connectChanges++;
             if (CONNECT_CHURN_LIMIT === connectChanges) warn(connectChurnWarning());
@@ -5175,6 +5223,7 @@ ${code}`;
         timer.unref?.();
       }
       if (!inject || desktop) return [];
+      if (true !== options.inject && vitestBrowser) return [];
       return [
         // A CLASSIC inline script in <head>, and it has to be both.
         //
@@ -5185,7 +5234,7 @@ ${code}`;
         // `renderers.size === 0`, so the render meter counted zero forever while the docs advertised
         // commit counts. This runs during parse, before any module, and the meter adopts its buffer.
         { tag: "script", children: RENDER_PREHOOK_SOURCE, injectTo: "head-prepend" },
-        { tag: "script", attrs: { type: "module", src: RETICLE_CONNECT_MODULE }, injectTo: "body" }
+        { tag: "script", attrs: { type: "module", src: connectModuleUrl(base) }, injectTo: "body" }
       ];
     }
   };
@@ -5200,6 +5249,7 @@ ${code}`;
   RETICLE_VITE_PLUGIN_NAME,
   connectChurnWarning,
   connectModuleSource,
+  connectModuleUrl,
   findDevModule,
   installedSdk,
   readPairingToken,

package/dist/index.d.cts

@@ -12,6 +12,21 @@ export declare const RETICLE_TOKEN_GLOBAL = "__RETICLE_TOKEN__";
  * by the injected <script src> and served by the load hook below.
  */
 export declare const RETICLE_CONNECT_MODULE = "/@reticle-connect";
+/**
+ * The URL the injected `<script src>` must actually point at: `base` + the module id.
+ *
+ * {@link RETICLE_CONNECT_MODULE} is a SERVER-ROOT path, and emitting it verbatim is only correct
+ * when Vite is serving from the root. Under `base: '/playground/'` the browser asked for
+ * `/@reticle-connect`, Vite answered 404 with its own "did you mean /playground/@reticle-connect"
+ * hint, and the page rendered perfectly while never connecting (#676) — the exact failure shape
+ * Reticle exists to catch, in Reticle's own setup path.
+ *
+ * Vite does not prefix tags returned from `transformIndexHtml`, so the prefix has to be applied
+ * here. Only a path base is joined: Vite serves the dev app from the root when `base` is an
+ * external URL, so prefixing a CDN origin onto a dev-server module would point the tag off-host.
+ */
+import { type WatchPattern } from './watch-ignore.js';
+export declare function connectModuleUrl(base: string | undefined): string;
 /**
  * The pre-hook, as source for an inline <head> script.
  *
@@ -84,6 +99,14 @@ export interface ReticleVitePluginOptions {
      * session without editing vite.config.
      */
     captureNetworkBodies?: boolean;
+    /**
+     * Retain a FAILED request's response body even with `captureNetworkBodies` off. Default true.
+     *
+     * Reachable here for the reason `captureNetworkBodies` is: the plugin is the only `connect()`
+     * most apps ever have. Also settable as `VITE_RETICLE_NO_ERROR_BODIES=1`, which turns it OFF --
+     * the inverse of the other env vars, because this is the one that defaults on (#800).
+     */
+    captureErrorBodies?: boolean;
     /**
      * Make Reticle's OWN presenter visible to snapshots and queries. CONTRIBUTORS ONLY.
      *
@@ -125,28 +148,53 @@ export interface ReticleVitePluginOptions {
      */
     onWarn?: (message: string) => void;
 }
+/**
+ * The slice of Vite's `UserConfig` the `config` hook reads. Everything is optional AND nullable
+ * because that is what Vite declares — a stand-in that is narrower than the real value is not a
+ * looser type, it is a stricter one, and it makes the whole plugin unassignable to `Plugin`.
+ */
+export interface ViteUserConfigLike {
+    optimizeDeps?: {
+        include?: string[] | undefined;
+        /** Whichever key the app used — the plugin reads both and writes the one this Vite wants. */
+        esbuildOptions?: Record<string, unknown> | undefined;
+        rolldownOptions?: Record<string, unknown> | undefined;
+    } | undefined;
+    define?: Record<string, unknown> | undefined;
+    root?: string | undefined;
+    /**
+     * The app's own watcher config. `watch` is nullable because `null` is how a config switches the
+     * watcher off, and `ignored` is `unknown` because Vite's `AnymatchMatcher` is not an array — it is
+     * a string, a RegExp, a predicate function, or an array of those. Typing it as an array here is
+     * the narrowing that made the whole plugin unassignable to Vite's `Plugin`, and it also invited a
+     * runtime defect: see `mergeIgnored`.
+     */
+    server?: {
+        watch?: {
+            ignored?: unknown;
+        } | null | undefined;
+    } | undefined;
+    /**
+     * Vitest's block, when this config belongs to a Vitest run. Read ONLY to spot browser mode — see
+     * `isVitestBrowserServer`. Typed as `unknown` because it is Vitest's shape, not Vite's, and this
+     * plugin has no business asserting anything about the rest of it.
+     */
+    test?: unknown;
+}
 /** Structural Vite plugin shape — avoids a hard dependency on `vite` while staying assignable to its `Plugin`. */
 export interface ReticleVitePlugin {
     name: string;
     /**
      * Vite's `config` hook. Used to declare the SDK's CJS runtime deps for pre-bundling — see the
      * implementation for why omitting them makes the whole SDK fail to load on linked setups.
+     *
+     * METHOD syntax, not a property, and every field it reads is optional-and-nullable. Both halves
+     * are load-bearing, and both are the contravariance trap this file's sibling test documents:
+     * a property's parameter is checked strictly, so a narrow stand-in REJECTS the wider `UserConfig`
+     * Vite actually passes. `server.watch` is where it bit — Vite types it `WatchOptions | null`,
+     * `null` being how a config turns the watcher off, and SvelteKit's template does exactly that.
      */
-    config?: (config: {
-        optimizeDeps?: {
-            include?: string[];
-            /** Whichever key the app used — the plugin reads both and writes the one this Vite wants. */
-            esbuildOptions?: Record<string, unknown>;
-            rolldownOptions?: Record<string, unknown>;
-        };
-        define?: Record<string, string>;
-        root?: string;
-        server?: {
-            watch?: {
-                ignored?: (string | RegExp)[];
-            };
-        };
-    }) => {
+    config?(config: ViteUserConfigLike): {
         optimizeDeps: {
             include: string[];
             [optionsKey: string]: unknown;
@@ -154,7 +202,7 @@ export interface ReticleVitePlugin {
         define: Record<string, string>;
         server: {
             watch: {
-                ignored: (string | RegExp)[];
+                ignored: WatchPattern[];
             };
         };
     };
@@ -172,6 +220,9 @@ export interface ReticleVitePlugin {
     configResolved?: (config: {
         root?: string;
         command?: string;
+        base?: string;
+        /** Vitest's block, read only to spot browser mode. See isVitestBrowserServer. */
+        test?: unknown;
     }) => void;
     /** Dev-server hook: keeps the served connect module from outliving the token it was built without. */
     configureServer?: (server: ViteDevServerLike) => void;

package/dist/index.d.ts

@@ -12,6 +12,21 @@ export declare const RETICLE_TOKEN_GLOBAL = "__RETICLE_TOKEN__";
  * by the injected <script src> and served by the load hook below.
  */
 export declare const RETICLE_CONNECT_MODULE = "/@reticle-connect";
+/**
+ * The URL the injected `<script src>` must actually point at: `base` + the module id.
+ *
+ * {@link RETICLE_CONNECT_MODULE} is a SERVER-ROOT path, and emitting it verbatim is only correct
+ * when Vite is serving from the root. Under `base: '/playground/'` the browser asked for
+ * `/@reticle-connect`, Vite answered 404 with its own "did you mean /playground/@reticle-connect"
+ * hint, and the page rendered perfectly while never connecting (#676) — the exact failure shape
+ * Reticle exists to catch, in Reticle's own setup path.
+ *
+ * Vite does not prefix tags returned from `transformIndexHtml`, so the prefix has to be applied
+ * here. Only a path base is joined: Vite serves the dev app from the root when `base` is an
+ * external URL, so prefixing a CDN origin onto a dev-server module would point the tag off-host.
+ */
+import { type WatchPattern } from './watch-ignore.js';
+export declare function connectModuleUrl(base: string | undefined): string;
 /**
  * The pre-hook, as source for an inline <head> script.
  *
@@ -84,6 +99,14 @@ export interface ReticleVitePluginOptions {
      * session without editing vite.config.
      */
     captureNetworkBodies?: boolean;
+    /**
+     * Retain a FAILED request's response body even with `captureNetworkBodies` off. Default true.
+     *
+     * Reachable here for the reason `captureNetworkBodies` is: the plugin is the only `connect()`
+     * most apps ever have. Also settable as `VITE_RETICLE_NO_ERROR_BODIES=1`, which turns it OFF --
+     * the inverse of the other env vars, because this is the one that defaults on (#800).
+     */
+    captureErrorBodies?: boolean;
     /**
      * Make Reticle's OWN presenter visible to snapshots and queries. CONTRIBUTORS ONLY.
      *
@@ -125,28 +148,53 @@ export interface ReticleVitePluginOptions {
      */
     onWarn?: (message: string) => void;
 }
+/**
+ * The slice of Vite's `UserConfig` the `config` hook reads. Everything is optional AND nullable
+ * because that is what Vite declares — a stand-in that is narrower than the real value is not a
+ * looser type, it is a stricter one, and it makes the whole plugin unassignable to `Plugin`.
+ */
+export interface ViteUserConfigLike {
+    optimizeDeps?: {
+        include?: string[] | undefined;
+        /** Whichever key the app used — the plugin reads both and writes the one this Vite wants. */
+        esbuildOptions?: Record<string, unknown> | undefined;
+        rolldownOptions?: Record<string, unknown> | undefined;
+    } | undefined;
+    define?: Record<string, unknown> | undefined;
+    root?: string | undefined;
+    /**
+     * The app's own watcher config. `watch` is nullable because `null` is how a config switches the
+     * watcher off, and `ignored` is `unknown` because Vite's `AnymatchMatcher` is not an array — it is
+     * a string, a RegExp, a predicate function, or an array of those. Typing it as an array here is
+     * the narrowing that made the whole plugin unassignable to Vite's `Plugin`, and it also invited a
+     * runtime defect: see `mergeIgnored`.
+     */
+    server?: {
+        watch?: {
+            ignored?: unknown;
+        } | null | undefined;
+    } | undefined;
+    /**
+     * Vitest's block, when this config belongs to a Vitest run. Read ONLY to spot browser mode — see
+     * `isVitestBrowserServer`. Typed as `unknown` because it is Vitest's shape, not Vite's, and this
+     * plugin has no business asserting anything about the rest of it.
+     */
+    test?: unknown;
+}
 /** Structural Vite plugin shape — avoids a hard dependency on `vite` while staying assignable to its `Plugin`. */
 export interface ReticleVitePlugin {
     name: string;
     /**
      * Vite's `config` hook. Used to declare the SDK's CJS runtime deps for pre-bundling — see the
      * implementation for why omitting them makes the whole SDK fail to load on linked setups.
+     *
+     * METHOD syntax, not a property, and every field it reads is optional-and-nullable. Both halves
+     * are load-bearing, and both are the contravariance trap this file's sibling test documents:
+     * a property's parameter is checked strictly, so a narrow stand-in REJECTS the wider `UserConfig`
+     * Vite actually passes. `server.watch` is where it bit — Vite types it `WatchOptions | null`,
+     * `null` being how a config turns the watcher off, and SvelteKit's template does exactly that.
      */
-    config?: (config: {
-        optimizeDeps?: {
-            include?: string[];
-            /** Whichever key the app used — the plugin reads both and writes the one this Vite wants. */
-            esbuildOptions?: Record<string, unknown>;
-            rolldownOptions?: Record<string, unknown>;
-        };
-        define?: Record<string, string>;
-        root?: string;
-        server?: {
-            watch?: {
-                ignored?: (string | RegExp)[];
-            };
-        };
-    }) => {
+    config?(config: ViteUserConfigLike): {
         optimizeDeps: {
             include: string[];
             [optionsKey: string]: unknown;
@@ -154,7 +202,7 @@ export interface ReticleVitePlugin {
         define: Record<string, string>;
         server: {
             watch: {
-                ignored: (string | RegExp)[];
+                ignored: WatchPattern[];
             };
         };
     };
@@ -172,6 +220,9 @@ export interface ReticleVitePlugin {
     configResolved?: (config: {
         root?: string;
         command?: string;
+        base?: string;
+        /** Vitest's block, read only to spot browser mode. See isVitestBrowserServer. */
+        test?: unknown;
     }) => void;
     /** Dev-server hook: keeps the served connect module from outliving the token it was built without. */
     configureServer?: (server: ViteDevServerLike) => void;

package/dist/index.js

@@ -36,6 +36,33 @@ const NODE_MODULES = 'node_modules';
  * by the injected <script src> and served by the load hook below.
  */
 export const RETICLE_CONNECT_MODULE = '/@reticle-connect';
+/**
+ * The URL the injected `<script src>` must actually point at: `base` + the module id.
+ *
+ * {@link RETICLE_CONNECT_MODULE} is a SERVER-ROOT path, and emitting it verbatim is only correct
+ * when Vite is serving from the root. Under `base: '/playground/'` the browser asked for
+ * `/@reticle-connect`, Vite answered 404 with its own "did you mean /playground/@reticle-connect"
+ * hint, and the page rendered perfectly while never connecting (#676) — the exact failure shape
+ * Reticle exists to catch, in Reticle's own setup path.
+ *
+ * Vite does not prefix tags returned from `transformIndexHtml`, so the prefix has to be applied
+ * here. Only a path base is joined: Vite serves the dev app from the root when `base` is an
+ * external URL, so prefixing a CDN origin onto a dev-server module would point the tag off-host.
+ */
+import { mergeIgnored } from './watch-ignore.js';
+import { isVitestBrowserServer } from './vitest-browser.js';
+export function connectModuleUrl(base) {
+    if (undefined === base || !base.startsWith('/'))
+        return RETICLE_CONNECT_MODULE;
+    // Trimmed by slicing rather than with `/\/+$/`: a trailing-slash-run regex is a polynomial
+    // backtracking shape over a value that comes out of the user's config, and CodeQL is right to
+    // flag it. This is linear and says the same thing.
+    let end = base.length;
+    while (0 < end && '/' === base[end - 1])
+        end -= 1;
+    const trimmed = base.slice(0, end);
+    return 0 === trimmed.length ? RETICLE_CONNECT_MODULE : `${trimmed}${RETICLE_CONNECT_MODULE}`;
+}
 /**
  * The pre-hook, as source for an inline <head> script.
  *
@@ -207,6 +234,16 @@ function connectArgs(options) {
     if (true === options.captureNetworkBodies || '1' === process.env['VITE_RETICLE_CAPTURE_BODIES']) {
         args['captureNetworkBodies'] = true;
     }
+    // Only the OPT-OUT is announced, never the default. The daemon reads absence as "unknown", so
+    // sending `true` here would say nothing it does not already assume — while sending `false` is the
+    // one fact a red verdict needs to stop prescribing a plugin this project has deliberately muted.
+    if (false === options.sourceMapping)
+        args['sourceMapping'] = false;
+    // The one option that defaults ON, so the env var and the config flag both DISABLE rather than
+    // enable. Emitted only when switched off; the default stays implicit in the SDK.
+    if (false === options.captureErrorBodies || '1' === process.env['VITE_RETICLE_NO_ERROR_BODIES']) {
+        args['captureErrorBodies'] = false;
+    }
     // Same shape, same reason. Off unless asked for, in a config or for one session.
     if (true === options.exposePresenter || '1' === process.env['VITE_RETICLE_EXPOSE_PRESENTER']) {
         args['exposePresenter'] = true;
@@ -344,6 +381,10 @@ export function reticle(options = {}) {
     let root;
     /** 'serve' | 'build'. The dev check only applies to serve; buildEnd covers the other. */
     let command;
+    /** Vite's resolved `base`. Undefined until configResolved, which is before any HTML is served. */
+    let base;
+    /** True only when THIS server is Vitest's browser-mode runner — see isVitestBrowserServer. */
+    let vitestBrowser = false;
     const warn = options.onWarn ?? ((message) => globalThis.console.warn(message));
     /** Whether connect() actually reached a module — asserted at buildEnd, never assumed. */
     let injected = false;
@@ -453,7 +494,7 @@ export function reticle(options = {}) {
                 // Appends to the app's list rather than replacing it, so nothing it already excluded is lost.
                 server: {
                     watch: {
-                        ignored: [...(config.server?.watch?.ignored ?? []), JOURNAL_IGNORE],
+                        ignored: mergeIgnored(config.server?.watch?.ignored, JOURNAL_IGNORE),
                     },
                 },
                 // Expose the daemon's pairing token to hand-written connects in the same Vite app. The
@@ -550,6 +591,8 @@ export function reticle(options = {}) {
         configResolved(config) {
             root = config.root;
             command = config.command;
+            base = config.base;
+            vitestBrowser = isVitestBrowserServer(config);
         },
         /**
          * Serve the connect module fresh, every time.
@@ -623,7 +666,11 @@ export function reticle(options = {}) {
                 announce();
             }
             server.middlewares.use((req, _res, next) => {
-                if ((req.url ?? '').split('?')[0] === RETICLE_CONNECT_MODULE) {
+                // Matched against BOTH forms: plugin middlewares run ahead of Vite's own base
+                // middleware, so the request still carries `base` here, while a middleware-mode host may
+                // have stripped it already.
+                const requestPath = (req.url ?? '').split('?')[0];
+                if (requestPath === RETICLE_CONNECT_MODULE || requestPath === connectModuleUrl(base)) {
                     if (currentConnectSource() !== lastServedConnectSource) {
                         connectChanges++;
                         if (CONNECT_CHURN_LIMIT === connectChanges)
@@ -656,9 +703,12 @@ export function reticle(options = {}) {
                 timer.unref?.();
             }
             // Desktop injects via the entry module instead (see transform) — a tag here would be a dead
-            // URL in a packaged build.
+            // URL in a packaged build. A Vitest run gets nothing unless `inject: true` says otherwise —
+            // see isVitestBrowserServer.
             if (!inject || desktop)
                 return [];
+            if (true !== options.inject && vitestBrowser)
+                return [];
             return [
                 // A CLASSIC inline script in <head>, and it has to be both.
                 //
@@ -669,7 +719,7 @@ export function reticle(options = {}) {
                 // `renderers.size === 0`, so the render meter counted zero forever while the docs advertised
                 // commit counts. This runs during parse, before any module, and the meter adopts its buffer.
                 { tag: 'script', children: RENDER_PREHOOK_SOURCE, injectTo: 'head-prepend' },
-                { tag: 'script', attrs: { type: 'module', src: RETICLE_CONNECT_MODULE }, injectTo: 'body' },
+                { tag: 'script', attrs: { type: 'module', src: connectModuleUrl(base) }, injectTo: 'body' },
             ];
         },
     };

package/dist/installed.d.ts

@@ -56,7 +56,7 @@ export declare const OPTIMIZER_OPTIONS_KEY: {
     readonly ESBUILD: "esbuildOptions";
     readonly ROLLDOWN: "rolldownOptions";
 };
-export type OptimizerOptionsKey = (typeof OPTIMIZER_OPTIONS_KEY)[keyof typeof OPTIMIZER_OPTIONS_KEY];
+type OptimizerOptionsKey = (typeof OPTIMIZER_OPTIONS_KEY)[keyof typeof OPTIMIZER_OPTIONS_KEY];
 /**
  * Which key carries optimizer options on this Vite.
  *
@@ -84,3 +84,4 @@ export declare function optimizerOptionsKey(major: number | null): OptimizerOpti
  * app's own, it meant something, and passing it through unchanged is what produced the warning.
  */
 export declare function optimizerOptions(key: OptimizerOptionsKey, inherited: Record<string, unknown>, add: Record<string, string>): Record<string, unknown>;
+export {};

package/dist/vitest-browser.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Telling Vitest's browser-mode runner apart from every other Vite server.
+ *
+ * Split out of index.ts at the file cap. Small, but it is the discriminator a wrong first cut got
+ * wrong in production, so it earns its own file and its own name.
+ */
+/**
+ * Is THIS server Vitest's browser-mode runner?
+ *
+ * Vitest browser mode renders each component test into its own iframe served by the same Vite dev
+ * server, so `transformIndexHtml` injects into every one of them. The HUD then sits in the test
+ * document's hit-test path and intercepts pointer events, and a user who adds Reticle watches their
+ * unrelated component tests start timing out on clicks.
+ *
+ * The signal is `test.browser.enabled` on the RESOLVED config. The first cut used the `VITEST`
+ * environment variable and was wrong in a way its own unit tests could not show: `VITEST` means
+ * "Vitest is running somewhere in this process", which is ALSO true when a Vitest suite boots an app
+ * in order to test it. `frameworks.integration.test.ts` starts a real Vite dev server per example
+ * app and asserts Reticle connects; under the env check it injected nothing and the suite failed
+ * with "@reticlehq/example-react never connected an Reticle session". CI caught that; three local
+ * battery runs did not, because that suite is not the battery.
+ *
+ * A bare `test` key is wrong the other way — most projects configure Vitest and are not under it.
+ * `test.browser.enabled` is true only for the server actually serving browser-mode test iframes,
+ * which is the one case with a HUD to suppress.
+ *
+ * An explicit `inject: true` still beats it: the check is a default chosen on the user's behalf.
+ */
+export declare function isVitestBrowserServer(config: {
+    test?: unknown;
+}): boolean;

package/dist/vitest-browser.js

@@ -0,0 +1,37 @@
+/**
+ * Telling Vitest's browser-mode runner apart from every other Vite server.
+ *
+ * Split out of index.ts at the file cap. Small, but it is the discriminator a wrong first cut got
+ * wrong in production, so it earns its own file and its own name.
+ */
+/**
+ * Is THIS server Vitest's browser-mode runner?
+ *
+ * Vitest browser mode renders each component test into its own iframe served by the same Vite dev
+ * server, so `transformIndexHtml` injects into every one of them. The HUD then sits in the test
+ * document's hit-test path and intercepts pointer events, and a user who adds Reticle watches their
+ * unrelated component tests start timing out on clicks.
+ *
+ * The signal is `test.browser.enabled` on the RESOLVED config. The first cut used the `VITEST`
+ * environment variable and was wrong in a way its own unit tests could not show: `VITEST` means
+ * "Vitest is running somewhere in this process", which is ALSO true when a Vitest suite boots an app
+ * in order to test it. `frameworks.integration.test.ts` starts a real Vite dev server per example
+ * app and asserts Reticle connects; under the env check it injected nothing and the suite failed
+ * with "@reticlehq/example-react never connected an Reticle session". CI caught that; three local
+ * battery runs did not, because that suite is not the battery.
+ *
+ * A bare `test` key is wrong the other way — most projects configure Vitest and are not under it.
+ * `test.browser.enabled` is true only for the server actually serving browser-mode test iframes,
+ * which is the one case with a HUD to suppress.
+ *
+ * An explicit `inject: true` still beats it: the check is a default chosen on the user's behalf.
+ */
+export function isVitestBrowserServer(config) {
+    const test = config.test;
+    if (null === test || 'object' !== typeof test)
+        return false;
+    const browser = test.browser;
+    if (null === browser || 'object' !== typeof browser)
+        return false;
+    return true === browser.enabled;
+}

package/dist/watch-ignore.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Normalising Vite's watcher `ignored` list, which is not a list.
+ *
+ * Split out of index.ts at the file cap. Small but cohesive: one third-party type shape, one
+ * runtime hazard it hides, and the guard that makes the plugin's return assignable without a cast.
+ */
+/**
+ * Append our journal pattern to whatever the app already ignored, without assuming it is an array.
+ *
+ * Vite's `ignored` is `AnymatchMatcher`, so `watch: { ignored: '**\/fixtures/**' }` is a legal
+ * config. Spreading that string would explode it into one pattern PER CHARACTER — every one of
+ * which matches nothing, so the app's own exclusion is silently dropped and no error is raised. A
+ * function matcher is worse: it is not iterable at all, so the spread throws at config time and
+ * takes the dev server down, blaming the last plugin to touch the config.
+ */
+export declare function mergeIgnored(existing: unknown, ours: RegExp): WatchPattern[];
+/** Vite's `AnymatchPattern`, restated so the return type needs no cast. */
+export type WatchPattern = string | RegExp | ((path: string) => boolean);

package/dist/watch-ignore.js

@@ -0,0 +1,26 @@
+/**
+ * Normalising Vite's watcher `ignored` list, which is not a list.
+ *
+ * Split out of index.ts at the file cap. Small but cohesive: one third-party type shape, one
+ * runtime hazard it hides, and the guard that makes the plugin's return assignable without a cast.
+ */
+/**
+ * Append our journal pattern to whatever the app already ignored, without assuming it is an array.
+ *
+ * Vite's `ignored` is `AnymatchMatcher`, so `watch: { ignored: '**\/fixtures/**' }` is a legal
+ * config. Spreading that string would explode it into one pattern PER CHARACTER — every one of
+ * which matches nothing, so the app's own exclusion is silently dropped and no error is raised. A
+ * function matcher is worse: it is not iterable at all, so the spread throws at config time and
+ * takes the dev server down, blaming the last plugin to touch the config.
+ */
+export function mergeIgnored(existing, ours) {
+    if (undefined === existing || null === existing)
+        return [ours];
+    const listed = Array.isArray(existing) ? existing : [existing];
+    // Filtered rather than cast: an entry that is none of the three legal matcher shapes could never
+    // have excluded anything, so dropping it loses nothing and keeps the return honest without `any`.
+    return [...listed.filter(isWatchPattern), ours];
+}
+function isWatchPattern(value) {
+    return 'string' === typeof value || value instanceof RegExp || 'function' === typeof value;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reticlehq/vite-plugin",
-  "version": "2.13.0",
+  "version": "2.14.0",
   "description": "Vite plugin for Reticle: dev-only source-map stamping plus auto-injected reticle.connect(). apply:'serve' guarantees it never ships to production.",
   "type": "module",
   "license": "Apache-2.0",
@@ -41,8 +41,8 @@
   ],
   "dependencies": {
     "@babel/core": "^7.26.0",
-    "@reticlehq/core": "2.13.0",
-    "@reticlehq/babel-plugin": "2.13.0"
+    "@reticlehq/babel-plugin": "2.14.0",
+    "@reticlehq/core": "2.14.0"
   },
   "devDependencies": {
     "@types/babel__core": "^7.20.5",