@reticlehq/init 3.2.0 → 3.3.0

package/dist/patch/astro-patch.js

@@ -1,66 +1,170 @@
 /**
- * Pure, conservative patchers for an Astro app: the config gets the token/root `define` and the
- * raised build target, one layout gets the dev-only connect `<script>`.
+ * Pure, conservative patchers for an Astro app: the config gets the raised build target and the
+ * watcher ignore, one layout gets the pairing token via frontmatter `<meta>` tags and a processed
+ * `<script>` that statically imports a local connect module.
  *
  * Astro was the last gated framework where `init` printed a correct recipe and applied none of it —
  * the only ⚠ left on a supported stack, and the user's first session was two hand-copied snippets
  * away. Astro is Vite-based but renders its own HTML, so the Vite plugin's injection never fires and
- * there is no entry module to wire: the connect has to live in a page or layout `<script>`, and the
- * token has to be inlined by the config because nothing else is in the page's path to inject it.
+ * there is no entry module to wire: the connect has to live in a page or layout.
+ *
+ * The token used to be inlined by `vite.define`. On Astro 7.2+ that substitution no longer reaches
+ * the client pipeline (#1008), so the identifier stays literal, `connect()` omits `token`, and the
+ * bridge refuses with "no pairing token on the page". The channel that does work is a `<meta>`: read
+ * the file in frontmatter and let a local module query `meta[name="reticle-pairing-token"]`. Reading
+ * per request also means a token written after the dev server started needs no restart. The SDK import
+ * lives in `src/components/ReticleDev.ts` so the page only ever statically imports a project module.
  *
  * Both patchers bail to `manual` (the printed recipe) on any shape they do not fully recognise.
  * Half-editing a build config is worse than a documented manual step.
  */
+import { posix } from 'node:path';
 import { RETICLE_DEFAULT_PORT, bridgeWsUrl } from '@reticlehq/core';
 import { PatchKind } from './patch-kind.js';
 import { UiLibrary } from '../detect/detect.js';
 import { registerCapabilitiesCall, sdkImport } from './snippets.js';
 import { patchViteOwningConfig } from './vite-owning-config.js';
-/** Present in a patched layout and in the printed recipe's script. */
+/**
+ * Local module `init` writes for Astro. A processed page `<script>` statically imports this file
+ * so Vite owns the SDK the same way it owns any other project module.
+ *
+ * `.ts`, not `.tsx`: the install-gate scaffold is `create-astro --template minimal`, which has no
+ * React integration. The example app uses the same static import in a processed page `<script>`.
+ */
+export const ASTRO_RETICLE_DEV_PATH = 'src/components/ReticleDev.ts';
+/**
+ * Dev-only Astro connect module. Static SDK import, token from frontmatter `<meta>` tags.
+ */
+export function astroReticleDevFile(port, projectId, uiLibrary = UiLibrary.REACT, testids = []) {
+    const sdk = sdkImport(uiLibrary);
+    const extra = port !== undefined && port !== RETICLE_DEFAULT_PORT ? `\n    url: '${bridgeWsUrl(port)}',` : '';
+    const id = projectId !== undefined && projectId.length > 0 ? `\n    projectId: '${projectId}',` : '';
+    return `import { reticle${sdk.usesInstall ? ', install' : ''}, registerCapabilities } from '${sdk.specifier}';
+
+/** Dev-only: connect Reticle. Imported from a processed page script so Vite owns the SDK graph. */
+export default function connectReticle() {
+  const token =
+    document.querySelector('meta[name="reticle-pairing-token"]')?.getAttribute('content') ?? '';
+  const root =
+    document.querySelector('meta[name="reticle-pairing-root"]')?.getAttribute('content') ?? '';
+  const url =
+    document.querySelector('meta[name="reticle-pairing-url"]')?.getAttribute('content') ?? '';
+  if (0 === token.length) {
+    console.warn(${JSON.stringify(ASTRO_MISSING_TOKEN_WARNING)});
+  }
+  ${sdk.usesInstall ? 'install();' : '// The sensor has no install(); that is the React adapter.'}
+  reticle.connect({${id}${extra}
+    ...(0 < token.length ? { token } : {}),
+    ...(0 < root.length ? { root } : {}),
+    ...(0 < url.length ? { url } : {}),
+  });
+${registerCapabilitiesCall(testids, '  ')}
+}
+`;
+}
+/** Present in a patched layout (and in an already-wired one that still has the old script). */
 const LAYOUT_MARKER = 'reticle.connect';
+const LAYOUT_MODULE_MARKER = 'connectReticle';
 const BODY_CLOSE = '</body>';
+const FRONTMATTER_FENCE = '---';
+/**
+ * Written into the Astro `vite:` block so a second init reports ALREADY. The Nuxt path uses
+ * `__RETICLE_TOKEN__` in `define` as its marker; Astro no longer writes that name into the config.
+ */
+export const ASTRO_VITE_OWNING_MARKER = 'reticle-vite-owning';
+/**
+ * The one runtime condition that guarantees a refused connect, said out loud on the page.
+ *
+ * Matching the Vite plugin's missing-token wording, because Astro never loads that plugin. The
+ * token is read at render time now, not at config load, so a reload is enough — the user does not
+ * have to restart the dev server.
+ */
+export const ASTRO_MISSING_TOKEN_WARNING = '[reticle] no pairing token was available when this page rendered, so the app will connect ' +
+    'and be refused — you will see NO SESSION even though the SDK loads and the socket opens. ' +
+    'The token is written by the Reticle daemon: start it (`reticle serve`, or let your agent start ' +
+    'it) and reload this page.';
 /**
  * Astro's half of the Vite-owning config patch: the call to extend, and the SDK to pre-bundle.
  *
  * `@reticlehq/react` and not the detected UI library: Astro hosts islands from any framework, but
  * `frameworkPackages` gives every Astro app the React kit (see FRAMEWORK_ADAPTERS), so that is the
  * package the connect script imports and the one Vite must pre-bundle.
+ *
+ * `defineToken: false` is the #1008 fix. `build.target`, `optimizeDeps.include` and the `.reticle/`
+ * watcher ignore stay — each has a measured reason and none of them is the defect.
  */
 const ASTRO_VITE_CONFIG = {
     defineCall: /defineConfig\s*\(\s*\{/,
     sdkSpecifier: sdkImport(UiLibrary.REACT).specifier,
+    defineToken: false,
+    alreadyMarker: ASTRO_VITE_OWNING_MARKER,
 };
 export function patchAstroConfig(source) {
     return patchViteOwningConfig(source, ASTRO_VITE_CONFIG);
 }
-/** The dev-only connect that goes inside the layout's `<body>`. */
-function astroConnectScript(port, projectId, uiLibrary, testids) {
-    // Must match what `frameworkPackages` installed. Astro hosts islands from any framework, so an
-    // Astro app whose islands are Vue or Svelte gets the sensor, and a script importing the React
-    // adapter would load a package that is not in node_modules. See sdkImport.
-    const sdk = sdkImport(uiLibrary);
-    const url = port !== undefined && port !== RETICLE_DEFAULT_PORT
-        ? `\n          url: '${bridgeWsUrl(port)}',`
-        : '';
-    const id = projectId !== undefined && projectId.length > 0 ? `\n          projectId: '${projectId}',` : '';
-    return `    <script>
+/**
+ * Aliased imports so a layout that already pulled `readFileSync` from `node:fs` does not get a
+ * duplicate binding. The names are the already-marker for the frontmatter half.
+ */
+const FRONTMATTER_ADDITIONS = `import { readFileSync as reticleReadFileSync } from 'node:fs';
+import { homedir as reticleHomedir } from 'node:os';
+import { join as reticleJoin } from 'node:path';
+const pairingToken = (() => {
+  if (!import.meta.env.DEV) return '';
+  const dir = process.env['RETICLE_PAIRING_TOKEN_DIR'] || reticleJoin(reticleHomedir(), '.reticle');
+  try { return reticleReadFileSync(reticleJoin(dir, 'pairing-token'), 'utf8').trim(); } catch { return ''; }
+})();
+const pairingRoot = import.meta.env.DEV ? process.cwd() : '';
+`;
+/**
+ * Import path from a layout/page to the generated connect module, always relative and posix.
+ *
+ * `src/layouts/Layout.astro` and `src/pages/index.astro` both resolve to `../components/ReticleDev`.
+ */
+export function astroReticleDevImport(layoutPath) {
+    const fromDir = posix.dirname(layoutPath.replaceAll('\\', '/'));
+    const to = ASTRO_RETICLE_DEV_PATH.replace(/\.ts$/, '');
+    let rel = posix.relative(fromDir, to);
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return rel;
+}
+/** Meta tags plus a processed script that statically imports the local connect module. */
+function astroConnectMarkup(moduleSpecifier) {
+    return `    <meta name="reticle-pairing-token" content={pairingToken} />
+    <meta name="reticle-pairing-root" content={pairingRoot} />
+    <script>
+      import connectReticle from '${moduleSpecifier}';
       if (import.meta.env.DEV) {
-        const token = typeof __RETICLE_TOKEN__ !== 'undefined' ? __RETICLE_TOKEN__ : '';
-        const root = typeof __RETICLE_ROOT__ !== 'undefined' ? __RETICLE_ROOT__ : '';
-        const { reticle${sdk.usesInstall ? ', install' : ''}, registerCapabilities } = await import('${sdk.specifier}');
-        ${sdk.usesInstall ? 'install();' : '// The sensor has no install(); that is the React adapter.'}
-        reticle.connect({${id}${url}
-          ...(token.length > 0 ? { token } : {}),
-          ...(root.length > 0 ? { root } : {}),
-        });
-${registerCapabilitiesCall(testids, '        ')}
+        connectReticle();
       }
     </script>
 `;
 }
-export function patchAstroLayout(source, port, projectId, uiLibrary = UiLibrary.REACT, testids = []) {
-    if (source.includes(LAYOUT_MARKER))
+/**
+ * Marker for the frontmatter half. It must be a name ONLY the frontmatter writes: this ran against
+ * `pairingToken`, which the meta markup inserted one step earlier already contains, so the guard
+ * always tripped and the token read was never added — leaving every scaffolded page throwing
+ * `ReferenceError: pairingToken is not defined`.
+ */
+const FRONTMATTER_MARKER = 'reticleReadFileSync';
+function withFrontmatter(source) {
+    if (source.includes(FRONTMATTER_MARKER))
+        return source;
+    if (source.startsWith(FRONTMATTER_FENCE)) {
+        const closeAt = source.indexOf(`\n${FRONTMATTER_FENCE}`, FRONTMATTER_FENCE.length);
+        if (closeAt < 0)
+            return null;
+        const inner = source.slice(FRONTMATTER_FENCE.length + 1, closeAt);
+        const padded = inner.endsWith('\n') ? inner : `${inner}\n`;
+        return `${FRONTMATTER_FENCE}\n${padded}${FRONTMATTER_ADDITIONS}${source.slice(closeAt + 1)}`;
+    }
+    return `${FRONTMATTER_FENCE}\n${FRONTMATTER_ADDITIONS}${FRONTMATTER_FENCE}\n${source}`;
+}
+export function patchAstroLayout(source, layoutPath = 'src/layouts/Layout.astro') {
+    if (source.includes(LAYOUT_MARKER) || source.includes(LAYOUT_MODULE_MARKER)) {
         return { kind: PatchKind.ALREADY };
+    }
     const at = source.lastIndexOf(BODY_CLOSE);
     if (at < 0) {
         return {
@@ -68,28 +172,32 @@ export function patchAstroLayout(source, port, projectId, uiLibrary = UiLibrary.
             reason: "couldn't find a `</body>` to place the connect script before",
         };
     }
-    return {
-        kind: PatchKind.APPLY,
-        code: `${source.slice(0, at)}${astroConnectScript(port, projectId, uiLibrary, testids)}${source.slice(at)}`,
-    };
+    const withScripts = `${source.slice(0, at)}${astroConnectMarkup(astroReticleDevImport(layoutPath))}${source.slice(at)}`;
+    const withFence = withFrontmatter(withScripts);
+    if (null === withFence) {
+        return {
+            kind: PatchKind.MANUAL,
+            reason: "couldn't find a closing frontmatter fence to place the pairing-token read in",
+        };
+    }
+    return { kind: PatchKind.APPLY, code: withFence };
 }
 /** Where Astro keeps ambient types — `create-astro` ships this file. */
 export const ASTRO_ENV_DTS_PATH = 'src/env.d.ts';
 /**
- * The declarations `astro check` needs for the Vite `define` names (#677).
- *
- * Matching SvelteKit's `hooks.client.ts` typing: `string | undefined`, because the define can be
- * absent when the pairing token file is missing.
+ * The declarations `astro check` needs for the window names the inline script writes (#677, #1008).
  */
-export const ASTRO_ENV_DTS_DECLARES = 'declare const __RETICLE_TOKEN__: string | undefined;\n' +
-    'declare const __RETICLE_ROOT__: string | undefined;\n';
-/** Present once either declare is in the file — both are written together. */
+export const ASTRO_ENV_DTS_DECLARES = 'interface Window {\n' +
+    '  __RETICLE_TOKEN__?: string;\n' +
+    '  __RETICLE_ROOT__?: string;\n' +
+    '}\n';
+/** Present once either name is in the file — both are written together. */
 const ENV_DTS_MARKER = '__RETICLE_TOKEN__';
 /**
- * Append the Vite-define ambient declarations to `src/env.d.ts`, or create the file.
+ * Append the window ambient declarations to `src/env.d.ts`, or create the file.
  *
- * Without this, `create-astro`'s default `"astro check && astro build"` fails with four
- * `ts(2304) Cannot find name '__RETICLE_TOKEN__'` errors after a clean init (#677).
+ * Without this, `create-astro`'s default `"astro check && astro build"` fails with
+ * `ts(2339) Property '__RETICLE_TOKEN__' does not exist on type 'Window'` after a clean init.
  */
 export function patchAstroEnvDts(existing) {
     if (null !== existing && existing.includes(ENV_DTS_MARKER)) {

package/dist/patch/nuxt-snippets.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The plugin directory Nuxt actually scans, which is not the same on 3 and 4.
+ *
+ * Nuxt 4's default `srcDir` is `app/`, so plugins live in `app/plugins/`. Nuxt 3's is the project
+ * root, so they live in `plugins/`. Writing to the wrong one is the silent failure this whole change
+ * exists to remove: the file is on disk, `init` reports it green, Nuxt never scans that directory,
+ * and no plugin is ever registered. Keyed on whether the app HAS an `app/` directory, which is the
+ * same signal Nuxt itself uses to pick its srcDir.
+ */
+export declare function nuxtPluginPath(hasAppDir: boolean): string;
+/**
+ * The dev-only Nuxt client plugin `init` writes.
+ *
+ * Every trap in it is one somebody actually hit. `import.meta.dev` rather than a hostname check: the
+ * reported failure was a snippet guarded on `window.location.hostname === 'localhost'`, which is
+ * false on any hosts-file alias or LAN address and throws during SSR, so the connect never ran with
+ * no error and no log line. `.client.ts` rather than an SSR guard, because that suffix is what keeps
+ * this out of the server bundle. `@reticlehq/browser` rather than the React kit, because installing
+ * a package named `@reticlehq/react` into a Vue codebase is the single thing most likely to make
+ * somebody abandon the setup.
+ *
+ * The token is inlined by `nuxt.config`'s `vite.define` (see nuxt-patch.ts). The bridge requires it
+ * even on localhost, and nothing in a browser can read the file it lives in.
+ */
+export declare function nuxtPluginFile(port: number | undefined, projectId?: string, testids?: readonly string[]): string;
+/**
+ * Said as its own NOTICE beside the write, not inside it: a running dev server does not pick up a
+ * new plugin, and off localhost the connect needs two more arguments.
+ *
+ * A ✓ line is one SKILL.md tells the reader to skip, so a caveat carried on the ✓ is a caveat nobody
+ * reads — and both of these end with an app that boots, looks correct and never pairs.
+ */
+export declare const NUXT_PLUGIN_NOTICE: string;
+/**
+ * The Nuxt recipe, written out in full because each trap in it is one a Nuxt 4 app actually hit:
+ * a Vue codebase classified as `html` and handed `@reticlehq/react`, a connect guarded on
+ * `window.location.hostname === 'localhost'` (false on any hosts-file alias, and `window` does not
+ * exist during SSR), and a running dev server that never picked up the new plugin.
+ *
+ * So: `import.meta.dev` instead of a hostname check, `.client.ts` instead of an SSR guard, the
+ * framework-neutral sensor instead of the React kit, the non-localhost flag named up front, and the
+ * restart said out loud.
+ */
+export declare function nuxtManual(port: number | undefined, projectId?: string): string;

package/dist/patch/nuxt-snippets.js

@@ -0,0 +1,135 @@
+/**
+ * The Nuxt connect plugin `reticle init` writes, split out of snippets.ts (which crossed the
+ * 1000-line cap): its path, the plugin file itself, the notice, and the manual fallback.
+ */
+import { ReticleDir } from '@reticlehq/core';
+import { connectArg, registerCapabilitiesCall } from './snippets.js';
+/** Where a Nuxt dev-only client plugin belongs. `.client` keeps it out of SSR; Nuxt auto-registers it. */
+const NUXT_PLUGIN_PATH = 'app/plugins/reticle.client.ts';
+/**
+ * The plugin directory Nuxt actually scans, which is not the same on 3 and 4.
+ *
+ * Nuxt 4's default `srcDir` is `app/`, so plugins live in `app/plugins/`. Nuxt 3's is the project
+ * root, so they live in `plugins/`. Writing to the wrong one is the silent failure this whole change
+ * exists to remove: the file is on disk, `init` reports it green, Nuxt never scans that directory,
+ * and no plugin is ever registered. Keyed on whether the app HAS an `app/` directory, which is the
+ * same signal Nuxt itself uses to pick its srcDir.
+ */
+export function nuxtPluginPath(hasAppDir) {
+    return hasAppDir ? NUXT_PLUGIN_PATH : 'plugins/reticle.client.ts';
+}
+/**
+ * The dev-only Nuxt client plugin `init` writes.
+ *
+ * Every trap in it is one somebody actually hit. `import.meta.dev` rather than a hostname check: the
+ * reported failure was a snippet guarded on `window.location.hostname === 'localhost'`, which is
+ * false on any hosts-file alias or LAN address and throws during SSR, so the connect never ran with
+ * no error and no log line. `.client.ts` rather than an SSR guard, because that suffix is what keeps
+ * this out of the server bundle. `@reticlehq/browser` rather than the React kit, because installing
+ * a package named `@reticlehq/react` into a Vue codebase is the single thing most likely to make
+ * somebody abandon the setup.
+ *
+ * The token is inlined by `nuxt.config`'s `vite.define` (see nuxt-patch.ts). The bridge requires it
+ * even on localhost, and nothing in a browser can read the file it lives in.
+ */
+export function nuxtPluginFile(port, projectId, testids = []) {
+    const base = connectArg(port, projectId);
+    const fields = '' === base ? '' : `${base.slice(1, -1).trim()}, `;
+    return `// Dev-only: connect Reticle from a Nuxt client plugin. Nuxt owns its own Vite instance and
+// renders its own HTML, so the Vite plugin's index.html injection never fires — a .client plugin is
+// the path that can register a session at all.
+export default defineNuxtPlugin(() => {
+  // import.meta.dev is resolved at BUILD time, so it does not care what hostname you develop on.
+  // Do NOT guard on window.location.hostname === 'localhost': that is false on any hosts-file alias
+  // or LAN address, and window does not exist during SSR.
+  if (!import.meta.dev) return;
+  void import('@reticlehq/browser').then(({ reticle, registerCapabilities }) => {
+    // Both inlined by nuxt.config's vite.define, which \`reticle init\` wrote. The bridge refuses a
+    // connect with no token even on localhost; the root makes source paths repo-relative.
+    const token = typeof __RETICLE_TOKEN__ !== 'undefined' ? __RETICLE_TOKEN__ : '';
+    const root = typeof __RETICLE_ROOT__ !== 'undefined' ? __RETICLE_ROOT__ : '';
+    reticle.connect({
+      ${fields}...(token.length > 0 ? { token } : {}),
+      ...(root.length > 0 ? { root } : {}),
+    });
+
+    // What the agent can drive without guessing. Add a store here too — registerStore('cart',
+    // piniaStore(useCartStore())) — and the agent can check what the app BELIEVES, not just what it
+    // rendered. See node_modules/@reticlehq/server/docs/usage.md.
+${registerCapabilitiesCall(testids, '    ')}
+  });
+});
+
+declare const __RETICLE_TOKEN__: string | undefined;
+declare const __RETICLE_ROOT__: string | undefined;
+`;
+}
+/**
+ * Said as its own NOTICE beside the write, not inside it: a running dev server does not pick up a
+ * new plugin, and off localhost the connect needs two more arguments.
+ *
+ * A ✓ line is one SKILL.md tells the reader to skip, so a caveat carried on the ✓ is a caveat nobody
+ * reads — and both of these end with an app that boots, looks correct and never pairs.
+ */
+export const NUXT_PLUGIN_NOTICE = 'Restart the dev server: one that is already running does not pick up a new plugin — it will not ' +
+    'appear in .nuxt/plugins/client.mjs and the app comes up with no SDK at all. And if your dev host ' +
+    'is anything other than localhost (a hosts-file alias, a LAN IP, a tunnel), that connect call ' +
+    'needs TWO additions, not one: allowNonLocalhost: true AND the token from ~/.reticle/pairing-token. ' +
+    'The flag alone is NOT sufficient off localhost.';
+/**
+ * The Nuxt recipe, written out in full because each trap in it is one a Nuxt 4 app actually hit:
+ * a Vue codebase classified as `html` and handed `@reticlehq/react`, a connect guarded on
+ * `window.location.hostname === 'localhost'` (false on any hosts-file alias, and `window` does not
+ * exist during SSR), and a running dev server that never picked up the new plugin.
+ *
+ * So: `import.meta.dev` instead of a hostname check, `.client.ts` instead of an SSR guard, the
+ * framework-neutral sensor instead of the React kit, the non-localhost flag named up front, and the
+ * restart said out loud.
+ */
+export function nuxtManual(port, projectId) {
+    const base = connectArg(port, projectId);
+    const fields = '' === base ? '' : base.slice(1, -1).trim();
+    const connect = '' === fields ? 'reticle.connect()' : `reticle.connect({ ${fields} })`;
+    return `Nuxt owns its own Vite instance and renders its own HTML, so there is no vite.config to patch
+and no index.html to inject into. Wire it with a dev-only CLIENT plugin, which is Nuxt's own idiom:
+
+1. Create ${NUXT_PLUGIN_PATH}:
+
+     export default defineNuxtPlugin(() => {
+       // import.meta.dev is the correct guard: it is resolved at build time, so it does not care
+       // what hostname you develop on. Do NOT guard on window.location.hostname === 'localhost' —
+       // that is false on any hosts-file alias or LAN address, and window does not exist in SSR.
+       if (!import.meta.dev) return
+       void import('@reticlehq/browser').then(({ reticle }) => {
+         ${connect}
+       })
+     })
+
+   The .client.ts suffix is load-bearing: it is what keeps this out of the server bundle.
+
+2. Restart the dev server. A dev server that is already running does not pick up a new plugin —
+   it will not appear in .nuxt/plugins/client.mjs, and the app will come up with no SDK at all.
+
+3. If your dev host is anything other than localhost (a hosts-file alias, a LAN IP, a tunnel), that
+   connect call needs TWO additions, not one: allowNonLocalhost: true AND a pairing token passed as
+   token. The flag alone is NOT sufficient off localhost. The token is the one in
+   ~/.reticle/pairing-token. Without both, the SDK loads and then refuses, and the only sign is one
+   line in the browser console.
+
+4. Add this to nuxt.config, so the dev server does not watch Reticle's own journal:
+
+     vite: { server: { watch: { ignored: [/(^|[\\\\/])\\.${ReticleDir.ROOT.slice(1)}([\\\\/]|$)/] } } }
+
+   Reticle journals every session into ${ReticleDir.ROOT}/ in your project root, rewriting one file
+   in it continuously while a session is live. Nuxt's dev server watches that root, so without this
+   it sees each write as a project file changing and full-reloads the page — which reconnects the
+   SDK, which produces the next write. The loop runs several times a second and looks like anything
+   except what it is: refs go stale, actions die mid-flight, and the session appears to flap.
+   It is a RegExp rather than a glob on purpose — chokidar dropped glob support in v4, so a
+   double-star pattern here is accepted and matches nothing.
+
+The package is @reticlehq/browser — the framework-neutral sensor. DOM, network, console, routing and
+source file:line all work in Vue. What you do not get is React component identity, which is the only
+thing the React adapter adds. There is no Nuxt app in this project's CI, so this path is UNVERIFIED:
+if something does not work, please open an issue.`;
+}

package/dist/patch/snippets.d.ts

@@ -181,8 +181,6 @@ export declare const WEBPACK4_REACT_SCRIPTS_MAJOR = 5;
 export declare function webpack4TranspileNote(reactScriptsMajor: number): string;
 /** React Router's client-entry override point, in framework mode. */
 export declare const REACT_ROUTER_ENTRY_PATH = "app/entry.client.tsx";
-/** The one line that puts Reticle in a React Router client entry. */
-export declare const REACT_ROUTER_CONNECT_LINE = "if (import.meta.env.DEV) void import('/@reticle-connect');";
 /**
  * The client entry `init` writes when React Router framework mode has none.
  *
@@ -204,52 +202,7 @@ export declare function reactRouterEntryFile(): string;
  * still be evaluated first, and this is a side-effect import.
  */
 export declare function reactRouterEntryPatch(source: string): string | null;
-/** Where a Nuxt dev-only client plugin belongs. `.client` keeps it out of SSR; Nuxt auto-registers it. */
-export declare const NUXT_PLUGIN_PATH = "app/plugins/reticle.client.ts";
-/**
- * The plugin directory Nuxt actually scans, which is not the same on 3 and 4.
- *
- * Nuxt 4's default `srcDir` is `app/`, so plugins live in `app/plugins/`. Nuxt 3's is the project
- * root, so they live in `plugins/`. Writing to the wrong one is the silent failure this whole change
- * exists to remove: the file is on disk, `init` reports it green, Nuxt never scans that directory,
- * and no plugin is ever registered. Keyed on whether the app HAS an `app/` directory, which is the
- * same signal Nuxt itself uses to pick its srcDir.
- */
-export declare function nuxtPluginPath(hasAppDir: boolean): string;
-/**
- * The dev-only Nuxt client plugin `init` writes.
- *
- * Every trap in it is one somebody actually hit. `import.meta.dev` rather than a hostname check: the
- * reported failure was a snippet guarded on `window.location.hostname === 'localhost'`, which is
- * false on any hosts-file alias or LAN address and throws during SSR, so the connect never ran with
- * no error and no log line. `.client.ts` rather than an SSR guard, because that suffix is what keeps
- * this out of the server bundle. `@reticlehq/browser` rather than the React kit, because installing
- * a package named `@reticlehq/react` into a Vue codebase is the single thing most likely to make
- * somebody abandon the setup.
- *
- * The token is inlined by `nuxt.config`'s `vite.define` (see nuxt-patch.ts). The bridge requires it
- * even on localhost, and nothing in a browser can read the file it lives in.
- */
-export declare function nuxtPluginFile(port: number | undefined, projectId?: string, testids?: readonly string[]): string;
-/**
- * Said as its own NOTICE beside the write, not inside it: a running dev server does not pick up a
- * new plugin, and off localhost the connect needs two more arguments.
- *
- * A ✓ line is one SKILL.md tells the reader to skip, so a caveat carried on the ✓ is a caveat nobody
- * reads — and both of these end with an app that boots, looks correct and never pairs.
- */
-export declare const NUXT_PLUGIN_NOTICE: string;
-/**
- * The Nuxt recipe, written out in full because each trap in it is one a Nuxt 4 app actually hit:
- * a Vue codebase classified as `html` and handed `@reticlehq/react`, a connect guarded on
- * `window.location.hostname === 'localhost'` (false on any hosts-file alias, and `window` does not
- * exist during SSR), and a running dev server that never picked up the new plugin.
- *
- * So: `import.meta.dev` instead of a hostname check, `.client.ts` instead of an SSR guard, the
- * framework-neutral sensor instead of the React kit, the non-localhost flag named up front, and the
- * restart said out loud.
- */
-export declare function nuxtManual(port: number | undefined, projectId?: string): string;
+export { nuxtPluginPath, nuxtPluginFile, NUXT_PLUGIN_NOTICE, nuxtManual } from './nuxt-snippets.js';
 /**
  * Root-level project config for Reticle. Written by `reticle init`; read by `reticle mcp` for the port
  * and by tooling for the stable projectId (the app's identity across port changes).