@reticlehq/server 2.2.1 → 2.4.0

package/dist/init/run.js

@@ -5,10 +5,16 @@
  */
 import { dirname, join } from 'node:path';
 import { detect, Framework } from './detect.js';
-import { buildPlan, StepStatus } from './plan.js';
+import { DEPS_TARGET, MCP_TARGET, buildPlan, StepStatus, } from './plan.js';
 import { claudeAvailableProbe, claudeExistsProbe } from './mcp.js';
+import { reticleDevLocation } from './next-patch.js';
+import { scanTestids, storeHints } from './capabilities.js';
 import { CURSOR_DIR_RELPATH, CURSOR_MCP_RELPATH } from './cursor.js';
 import { deriveProjectId, packageName } from './project-id.js';
+import { VITE_DEV_MODULE_PATH } from './snippets.js';
+import { CLAUDE_COMMAND_PATH, CURSOR_COMMAND_PATH } from './slash-command.js';
+import { SERVER_VERSION } from '../server-version.js';
+import { InitFailure, reportInitOutcome } from '../telemetry/init-telemetry.js';
 /** Lockfile basenames, in package-manager preference order (mirrors detect.ts). */
 const LOCKFILE_NAMES = [
     'pnpm-lock.yaml',
@@ -42,8 +48,60 @@ export function resolveLockfiles(rootFiles, cwd, io) {
     return set;
 }
 const PACKAGE_JSON = 'package.json';
-const NEXT_RETICLE_DEV = 'app/reticle-dev.tsx';
+/**
+ * Root-layout candidates, App Router only. `--src-dir` apps keep theirs under `src/app`, and the
+ * ReticleDev component has to land NEXT TO the layout or the relative import it generates is dead.
+ */
+const NEXT_LAYOUT_CANDIDATES = [
+    'app/layout.tsx',
+    'app/layout.jsx',
+    'app/layout.js',
+    'src/app/layout.tsx',
+    'src/app/layout.jsx',
+    'src/app/layout.js',
+];
+/**
+ * Pages Router mount points, checked only when there is no App Router layout. A Pages app has no
+ * `app/` directory at all, so writing the component there produced a file nothing imported.
+ */
+const NEXT_PAGES_APP_CANDIDATES = [
+    'pages/_app.tsx',
+    'pages/_app.jsx',
+    'pages/_app.js',
+    'src/pages/_app.tsx',
+    'src/pages/_app.jsx',
+    'src/pages/_app.js',
+];
 const SVELTEKIT_HOOKS = 'src/hooks.client.ts';
+/** Where an app's components live. Bounded on purpose — this is a hint, not an index of the repo. */
+const SOURCE_DIRS = ['src', 'src/components', 'src/pages', 'app', 'components'];
+const SOURCE_FILE = /\.(tsx|jsx|ts|js|svelte|vue|astro)$/;
+/** Files read for the testid scan. A capabilities block is a hint; reading a whole repo for it is not. */
+const MAX_SCANNED_FILES = 200;
+/** Read a bounded set of the app's source files, for the `data-testid` scan. */
+function readSourceFiles(io) {
+    const out = [];
+    for (const dir of SOURCE_DIRS) {
+        for (const name of io.listFiles(dir)) {
+            if (!SOURCE_FILE.test(name))
+                continue;
+            const content = io.readFile(`${dir}/${name}`);
+            if (content !== null)
+                out.push(content);
+            if (out.length >= MAX_SCANNED_FILES)
+                return out;
+        }
+    }
+    return out;
+}
+/** Direct dependency names, for naming the state libraries an app actually has. */
+function dependencyNames(pkg) {
+    const p = (pkg ?? {});
+    return new Set([
+        ...Object.keys(p['dependencies'] ?? {}),
+        ...Object.keys(p['devDependencies'] ?? {}),
+    ]);
+}
 const VITE_CONFIG_CANDIDATES = [
     'vite.config.ts',
     'vite.config.js',
@@ -56,11 +114,17 @@ const NEXT_CONFIG_CANDIDATES = [
     'next.config.ts',
     'next.config.cjs',
 ];
+/**
+ * `⚠` means WORK LEFT TO DO and nothing else — it is what an agent (and the release gate) counts to
+ * decide whether the install finished. A notice gets its own mark so "steps remaining" can reach zero
+ * on a working install that happens to be on an ungated stack.
+ */
 const STATUS_SYMBOL = {
     [StepStatus.APPLY]: '✓',
     [StepStatus.MANUAL]: '⚠',
     [StepStatus.ALREADY]: '·',
     [StepStatus.SKIP]: '–',
+    [StepStatus.NOTICE]: 'ℹ',
 };
 function firstPresent(files, candidates) {
     for (const c of candidates)
@@ -78,6 +142,8 @@ function gatherPlanInput(options, io, pkgRaw) {
         configFiles: rootFiles,
         // Walk up for the lockfile so a monorepo sub-package picks the workspace's package manager.
         lockfiles: resolveLockfiles(rootFiles, options.cwd, io),
+        // An already-installed tree names its own manager, which matters when no lockfile is committed.
+        nodeModulesMarkers: new Set(io.listFiles('node_modules')),
     };
     const detection = detect(detectInput);
     const vitePath = firstPresent(rootFiles, VITE_CONFIG_CANDIDATES);
@@ -93,51 +159,121 @@ function gatherPlanInput(options, io, pkgRaw) {
     const cursorConfigPath = `${io.homeDir()}/${CURSOR_MCP_RELPATH}`;
     const cursorPresent = options.mcp && io.exists(cursorDir);
     const cursorConfig = cursorPresent ? io.readFile(cursorConfigPath) : null;
+    const nextConfigFile = firstPresent(rootFiles, NEXT_CONFIG_CANDIDATES);
+    // App Router first; a Pages Router app has no layout, and its mount point is pages/_app.
+    const layoutPath = (NEXT_LAYOUT_CANDIDATES.find((p) => io.exists(p)) ??
+        NEXT_PAGES_APP_CANDIDATES.find((p) => io.exists(p))) ??
+        null;
+    const layoutSource = layoutPath === null ? null : io.readFile(layoutPath);
+    // Where the component goes depends on WHICH router mounts it: `pages/` routes on presence, so a
+    // component there becomes a broken route; `app/` routes on filename, so a sibling is inert.
+    const devLocation = reticleDevLocation(layoutPath ?? 'app/layout.tsx', detection.typescript);
     return {
         detection,
         claudeCli,
         mcpExists,
         cursorPresent,
+        cursorProjectPresent: io.exists(CURSOR_DIR_RELPATH),
         cursorConfig,
         cursorConfigPath,
         viteConfig,
-        nextConfigFile: firstPresent(rootFiles, NEXT_CONFIG_CANDIDATES),
-        nextReticleDevExists: io.exists(NEXT_RETICLE_DEV),
+        nextConfigFile,
+        nextConfigSource: nextConfigFile === null ? null : io.readFile(nextConfigFile),
+        nextLayout: layoutPath !== null && layoutSource !== null
+            ? { path: layoutPath, source: layoutSource }
+            : null,
+        // Capabilities: scanned, never asked for. Bounded — a hint for the agent, not a repo index.
+        testids: scanTestids(readSourceFiles(io)),
+        storeHints: storeHints(dependencyNames(pkg)),
+        viteDevModuleExists: io.exists(VITE_DEV_MODULE_PATH),
+        nextReticleDevPath: devLocation.path,
+        nextReticleDevImport: devLocation.importSpecifier,
+        nextReticleDevExists: io.exists(devLocation.path),
         svelteKitHooksExists: io.exists(SVELTEKIT_HOOKS),
         reticleConfigExists: io.exists('.reticle.json'),
         // Read the agent instruction files so the rule merge stays idempotent across re-runs.
         claudeMdContent: io.readFile('CLAUDE.md'),
         agentsMdContent: io.readFile('AGENTS.md'),
         cursorRuleExists: io.exists('.cursor/rules/reticle.mdc'),
-        options: { port: options.port, mcp: options.mcp, install: options.install, projectId },
+        claudeCommandExists: io.exists(CLAUDE_COMMAND_PATH),
+        cursorCommandExists: io.exists(CURSOR_COMMAND_PATH),
+        options: {
+            port: options.port,
+            mcp: options.mcp,
+            install: options.install,
+            projectId,
+            // The SDK must match the CLI asking for it — see pinnedPackages.
+            sdkVersion: SERVER_VERSION,
+        },
     };
 }
+/** Where workspace tooling conventionally puts packages. */
+const WORKSPACE_PARENTS = ['apps', 'packages'];
+/** Deps that mark a directory as a runnable web app even when it has no bundler config file. */
+const APP_DEPS = ['next', 'vite'];
+function looksLikeApp(dir, io) {
+    const pkgRaw = io.readFile(`${dir}/${PACKAGE_JSON}`);
+    if (pkgRaw === null)
+        return false;
+    const configs = [...VITE_CONFIG_CANDIDATES, ...NEXT_CONFIG_CANDIDATES];
+    if (configs.some((c) => io.exists(`${dir}/${c}`)))
+        return true;
+    // `next.config` is optional in Next, so the dependency list is the other half of the signal.
+    return APP_DEPS.some((d) => pkgRaw.includes(`"${d}"`));
+}
+/**
+ * App directories under a workspace root.
+ *
+ * Running `reticle init` at the repo root is what people actually do, and in a monorepo the app is a
+ * directory down — so init detected "no framework", printed a wall of manual HTML instructions, and
+ * would have installed the SDK into the ROOT package.json. It already walks UP for the lockfile, so
+ * it knows it is in a workspace; this is the matching walk DOWN.
+ */
+export function findWorkspaceApps(io) {
+    const found = [];
+    for (const parent of WORKSPACE_PARENTS) {
+        for (const name of io.listDirs(parent)) {
+            const dir = `${parent}/${name}`;
+            if (looksLikeApp(dir, io))
+                found.push(dir);
+        }
+    }
+    return found;
+}
 function restartHint(framework) {
     if (framework === Framework.NEXT)
         return 'Restart `next dev`, then ask your agent: "List Reticle sessions".';
     if (framework === Framework.VITE)
         return 'Restart `vite`, then ask your agent: "List Reticle sessions".';
+    if (framework === Framework.ASTRO)
+        return 'Restart `astro dev`, then ask your agent: "List Reticle sessions".';
     if (framework === Framework.SVELTEKIT)
         return 'Restart your dev server (`npm run dev`), then ask your agent: "List Reticle sessions".';
     return 'Reload your app on localhost, then ask your agent: "List Reticle sessions".';
 }
-function report(plan, dryRun, failed, io) {
+const SKIPPED_DETAIL = 'skipped — the dependency install above failed, and wiring the app to a package that is not ' +
+    'installed stops it booting. Run that install, then re-run `reticle init`.';
+function report(plan, dryRun, failed, skipped, io) {
     io.print(dryRun ? 'reticle init (dry run — no files written)' : 'reticle init');
     io.print('');
     let applied = 0;
     let manual = 0;
     for (const s of plan.steps) {
         // A side effect that failed to apply is reported as a manual step with its fallback command.
-        const downgraded = failed.has(s.target);
+        const downgraded = failed.has(s.target) || skipped.has(s.target);
         const status = downgraded ? StepStatus.MANUAL : s.status;
-        const detail = downgraded && s.exec !== undefined
-            ? `step failed — run manually: ${s.exec.fallback}`
-            : s.detail;
+        const detail = skipped.has(s.target)
+            ? SKIPPED_DETAIL
+            : downgraded && s.exec !== undefined
+                ? `step failed — run manually: ${s.exec.fallback}`
+                : s.detail;
         io.print(`  [${STATUS_SYMBOL[status]}] ${s.title} → ${s.target}`);
         if (status === StepStatus.APPLY)
             applied++;
-        if (status === StepStatus.MANUAL) {
-            manual++;
+        if (status === StepStatus.MANUAL || status === StepStatus.NOTICE) {
+            // A notice prints in full like a manual step — it is worth reading — but is NOT counted as work.
+            if (status === StepStatus.MANUAL)
+                manual++;
             for (const line of detail.split('\n'))
                 io.print(`      ${line}`);
         }
@@ -149,27 +285,110 @@ function report(plan, dryRun, failed, io) {
     io.print(restartHint(plan.framework));
     return { ok: true, applied, manual };
 }
-/** Perform the apply-step side effects; return the targets whose side effect failed. */
+/**
+ * Perform the apply-step side effects; return the targets whose side effect failed.
+ *
+ * Steps run in plan order, which puts the dependency install BEFORE everything that imports what it
+ * installs. If it fails, the wiring is skipped rather than applied: patching `next.config.ts` to
+ * import a `@reticlehq/next` that was never installed takes the dev server down with
+ * MODULE_NOT_FOUND, so the app stops booting *because* Reticle was installed. A skipped step is a
+ * message; a half-wired app is a broken project.
+ */
 function applyEffects(plan, io) {
     const failed = new Set();
+    const skipped = new Set();
+    let installFailed = false;
     for (const s of plan.steps) {
         if (s.status !== StepStatus.APPLY)
             continue;
+        if (installFailed && s.dependsOnInstall === true) {
+            skipped.add(s.target);
+            continue;
+        }
         if (s.write !== undefined)
             io.writeFile(s.write.path, s.write.content);
-        if (s.exec !== undefined && !io.exec(s.exec.command, s.exec.args))
+        if (s.exec !== undefined && !io.exec(s.exec.command, s.exec.args)) {
             failed.add(s.target);
+            if (s.target === DEPS_TARGET)
+                installFailed = true;
+        }
+    }
+    return { failed, skipped };
+}
+/**
+ * Which STEP failed, from the step targets — not from an error string, which would carry paths.
+ *
+ * The distinction that matters: a dependency install failing is a machine/network problem (offline,
+ * a locked registry, a broken package manager), while MCP registration failing means the `claude` CLI
+ * is missing or refused. Two completely different fixes, and until now both were simply "init didn't
+ * work" with nothing to tell them apart.
+ */
+function classifyInitFailure(failed) {
+    if (failed.has(DEPS_TARGET))
+        return InitFailure.DEPENDENCY_INSTALL;
+    if (failed.has(MCP_TARGET))
+        return InitFailure.MCP_REGISTRATION;
+    return InitFailure.OTHER;
+}
+const AMBIGUOUS_HEADER = 'Several apps found in this workspace. Re-run `reticle init` inside the one you want:';
+/**
+ * When the current directory is a workspace root with no app of its own, wire the app instead of the
+ * root. One candidate is wired silently (there is nothing to ask about); several are listed, because
+ * guessing which app someone meant is worse than one line of output.
+ * Returns null when there is nothing to redirect to — the caller then proceeds here as before.
+ */
+function redirectToWorkspaceApp(options, io, pkgRaw) {
+    if (options.redirected === true)
+        return null;
+    const pkg = JSON.parse(pkgRaw);
+    const rootFiles = new Set(io.rootFiles());
+    const here = detect({
+        pkg: typeof pkg === 'object' && pkg !== null ? pkg : {},
+        configFiles: rootFiles,
+        lockfiles: new Set(),
+    });
+    if (here.framework !== Framework.HTML)
+        return null; // this directory IS the app
+    const apps = findWorkspaceApps(io);
+    const target = apps.length === 1 ? apps[0] : undefined;
+    if (target === undefined) {
+        if (apps.length === 0)
+            return null; // not a workspace — fall through to the normal HTML plan
+        io.print(AMBIGUOUS_HEADER);
+        for (const a of apps)
+            io.print(`  ${a}`);
+        return { ok: false, applied: 0, manual: apps.length };
     }
-    return failed;
+    io.print(`No app in this directory — wiring ${target} instead.`);
+    io.print('');
+    return runInit({ ...options, cwd: join(options.cwd, target), redirected: true }, io.scoped(target));
 }
 export function runInit(options, io) {
     const pkgRaw = io.readFile(PACKAGE_JSON);
     if (pkgRaw === null) {
         io.print('No package.json found. Run `reticle init` from your project root.');
+        // The onboarding funnel had NO instrumentation, so a setup that died here was indistinguishable
+        // from someone who never ran the command — the two failure modes with the most different fixes.
+        reportInitOutcome({ ok: false, reason: InitFailure.NO_PACKAGE_JSON });
         return { ok: false, applied: 0, manual: 0 };
     }
+    const redirected = redirectToWorkspaceApp(options, io, pkgRaw);
+    if (redirected !== null)
+        return redirected;
     const plan = buildPlan(gatherPlanInput(options, io, pkgRaw));
-    const failed = options.dryRun ? new Set() : applyEffects(plan, io);
-    return report(plan, options.dryRun, failed, io);
+    const effects = options.dryRun
+        ? { failed: new Set(), skipped: new Set() }
+        : applyEffects(plan, io);
+    const { failed, skipped } = effects;
+    const result = report(plan, options.dryRun, failed, skipped, io);
+    // A dry run is a preview, not an outcome — reporting it would inflate both success and failure.
+    if (!options.dryRun) {
+        reportInitOutcome({
+            ok: result.ok,
+            ...(result.ok ? {} : { reason: classifyInitFailure(failed) }),
+            stack: plan.framework,
+            mcpRegistered: !failed.has(MCP_TARGET),
+        });
+    }
+    return result;
 }
-//# sourceMappingURL=run.js.map

package/dist/init/slash-command.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The `/reticle` slash command — the entry point the docs have been promising and nothing created.
+ *
+ * SKILL.md tells the user "Type `/reticle` anytime to verify the app" in three places, and `init`
+ * never wrote the file that makes it exist. So the one obvious way in was a command that silently did
+ * nothing in every tool. Claude Code and Cursor both read custom commands from a markdown file per
+ * command; the body is the prompt the agent receives.
+ *
+ * Deliberately SCOPED to one flow. A user installing Reticle has an existing app with many flows, and
+ * an agent told to "verify the app" will try to instrument all of them — slow, noisy, and nothing to
+ * see for minutes. One flow, driven where the human can watch it, is the whole difference between a
+ * two-minute first impression and an afternoon.
+ */
+/** Claude Code reads project commands from `.claude/commands/<name>.md`. */
+export declare const CLAUDE_COMMAND_PATH = ".claude/commands/reticle.md";
+/** Cursor reads them from `.cursor/commands/<name>.md`. */
+export declare const CURSOR_COMMAND_PATH = ".cursor/commands/reticle.md";
+export declare const SLASH_COMMAND_BODY = "---\ndescription: Verify this app in the browser with Reticle \u2014 drive one real flow and report what happened.\n---\n\nVerify this running app with Reticle. Drive it; do not read the code and guess.\n\n## Pick ONE flow\n\nNot the whole app. Pick the single most important flow you can complete in a handful of steps \u2014 the\none a user would do first (sign in, search, add to cart, submit the form). If the user named a flow or\njust changed some code, use that one instead.\n\nState which flow you picked in one line before you start.\n\n## Drive it where the human can see\n\n1. `reticle_sessions` \u2014 find the connected tab. None? Tell the user to run their dev server and open\n   the app, then stop. Reticle never starts a dev server.\n2. `reticle_snapshot` \u2014 read the accessibility tree and locate the elements the flow needs. Elements\n   are addressable by role and name; you do **not** need `data-testid` to drive them.\n3. Walk the flow with `reticle_act_and_wait`, one step at a time. Narrate each step first \u2014 the human\n   is watching the page, and the HUD shows what you say.\n4. After each step, check the effect with `reticle_assert` \u2014 not just that the click dispatched, but\n   that the thing it was supposed to do actually happened.\n5. Finish with `reticle_console` and `reticle_network` to catch errors the DOM does not show.\n\n## Report\n\n- What you drove, step by step, and what each step actually produced.\n- Anything broken, with the `file:line` Reticle gave you.\n- If a step could not be verified, say so plainly. \"Unknown\" is a real answer; a green verdict you\n  cannot back is not.\n\nDo not weaken or skip an assertion to make the run pass \u2014 that is a finding, not a fix.\n";

package/dist/init/slash-command.js

@@ -0,0 +1,52 @@
+/**
+ * The `/reticle` slash command — the entry point the docs have been promising and nothing created.
+ *
+ * SKILL.md tells the user "Type `/reticle` anytime to verify the app" in three places, and `init`
+ * never wrote the file that makes it exist. So the one obvious way in was a command that silently did
+ * nothing in every tool. Claude Code and Cursor both read custom commands from a markdown file per
+ * command; the body is the prompt the agent receives.
+ *
+ * Deliberately SCOPED to one flow. A user installing Reticle has an existing app with many flows, and
+ * an agent told to "verify the app" will try to instrument all of them — slow, noisy, and nothing to
+ * see for minutes. One flow, driven where the human can watch it, is the whole difference between a
+ * two-minute first impression and an afternoon.
+ */
+/** Claude Code reads project commands from `.claude/commands/<name>.md`. */
+export const CLAUDE_COMMAND_PATH = '.claude/commands/reticle.md';
+/** Cursor reads them from `.cursor/commands/<name>.md`. */
+export const CURSOR_COMMAND_PATH = '.cursor/commands/reticle.md';
+export const SLASH_COMMAND_BODY = `---
+description: Verify this app in the browser with Reticle — drive one real flow and report what happened.
+---
+
+Verify this running app with Reticle. Drive it; do not read the code and guess.
+
+## Pick ONE flow
+
+Not the whole app. Pick the single most important flow you can complete in a handful of steps — the
+one a user would do first (sign in, search, add to cart, submit the form). If the user named a flow or
+just changed some code, use that one instead.
+
+State which flow you picked in one line before you start.
+
+## Drive it where the human can see
+
+1. \`reticle_sessions\` — find the connected tab. None? Tell the user to run their dev server and open
+   the app, then stop. Reticle never starts a dev server.
+2. \`reticle_snapshot\` — read the accessibility tree and locate the elements the flow needs. Elements
+   are addressable by role and name; you do **not** need \`data-testid\` to drive them.
+3. Walk the flow with \`reticle_act_and_wait\`, one step at a time. Narrate each step first — the human
+   is watching the page, and the HUD shows what you say.
+4. After each step, check the effect with \`reticle_assert\` — not just that the click dispatched, but
+   that the thing it was supposed to do actually happened.
+5. Finish with \`reticle_console\` and \`reticle_network\` to catch errors the DOM does not show.
+
+## Report
+
+- What you drove, step by step, and what each step actually produced.
+- Anything broken, with the \`file:line\` Reticle gave you.
+- If a step could not be verified, say so plainly. "Unknown" is a real answer; a green verdict you
+  cannot back is not.
+
+Do not weaken or skip an assertion to make the run pass — that is a finding, not a fix.
+`;

package/dist/init/snippets.d.ts

@@ -6,8 +6,42 @@
 export declare function viteManual(port: number | undefined): string;
 /** Next.js config wrap — always printed (we never auto-rewrite next.config). */
 export declare function nextConfigManual(configFile: string): string;
-/** The dev-only client component that connects Reticle after hydration. */
-export declare function nextReticleDevFile(port: number | undefined, projectId?: string): string;
+/**
+ * The dev-only client component that connects Reticle after hydration.
+ *
+ * The token is not optional. The bridge requires a pairing token even on localhost, and unlike Vite
+ * (where the plugin injects it) a Next app has to carry it through `withReticle`, which publishes it
+ * as `NEXT_PUBLIC_RETICLE_TOKEN`. This file used to connect with only a projectId, so every Next
+ * setup ended at `bridge refused the connection: authentication failed` and no session ever appeared.
+ */
+export declare function nextReticleDevFile(port: number | undefined, projectId?: string, testids?: readonly string[], stores?: readonly string[]): string;
+/**
+ * Astro connect instructions.
+ *
+ * Astro is Vite-based but SSRs its own HTML, so the plugin's index.html injection never fires, and
+ * `vite` is not a direct dependency — so this used to fall through to the generic HTML advice, which
+ * tells you to add a connect to an "entry module" Astro does not have, or to bundle the SDK with
+ * esbuild. Both are wrong for Astro, and following either gets you nothing.
+ *
+ * Astro bundles a page `<script>`, so the bare import resolves there. The token has to be inlined by
+ * the config because there is no plugin in the page's path to inject it, and `build.target` has to be
+ * raised or Astro down-levels the modern SDK bundle and dies on a destructuring transform.
+ */
+export declare function astroManual(port: number | undefined, projectId?: string): string;
+/**
+ * The app-side dev module the Vite plugin imports by convention.
+ *
+ * `registerCapabilities` tells the agent what it can drive without guessing; `registerStore` is the
+ * one that matters most and the one we cannot write for you — detecting that an app depends on
+ * zustand is easy, knowing which module exports the store instance is not, and a wrong import here
+ * breaks the module everything else hangs off. So the store lines are generated COMMENTED, naming
+ * the libraries actually found in package.json, with the exact call to uncomment.
+ */
+export declare function viteDevModuleFile(testids: readonly string[], stores: readonly string[]): string;
+/** Where that module goes. Matches @reticlehq/vite-plugin's convention list. */
+export declare const VITE_DEV_MODULE_PATH = "src/reticle-dev.ts";
+/** Default root-layout path, used when no layout was found on disk (reporting only). */
+export declare const NEXT_LAYOUT_PATH = "app/layout.tsx";
 /** Mount instruction for the root layout. */
 export declare const NEXT_LAYOUT_MANUAL = "Mount <ReticleDev /> in your root layout (app/layout.tsx), dev-only:\n\n  import { ReticleDev } from './reticle-dev';\n  // inside <body>:\n  {process.env.NODE_ENV === 'development' ? <ReticleDev /> : null}";
 /**
@@ -19,6 +53,18 @@ export declare const NEXT_LAYOUT_MANUAL = "Mount <ReticleDev /> in your root lay
 export declare function htmlManual(port: number | undefined, projectId?: string): string;
 export declare const NEXT_RETICLE_DEV_PATH = "app/reticle-dev.tsx";
 export declare const SVELTEKIT_HOOKS_PATH = "src/hooks.client.ts";
+/**
+ * Said to the user's face rather than discovered later. React, Next, Remix and Astro each have an
+ * app and a CI gate; SvelteKit has neither, so "it generated some wiring" is not evidence it works.
+ */
+/**
+ * Said out loud when the app does not render through React. The SDK is framework-agnostic — DOM,
+ * network, console and routing all still work — but `@reticlehq/react` is a React adapter, so
+ * component names and source mapping do not, and no CI gate covers this stack. Reporting all-green
+ * here is the one thing this project exists not to do.
+ */
+export declare function unverifiedUiLibraryNote(library: string): string;
+export declare const UNVERIFIED_FRAMEWORK_NOTE = "Reticle has no SvelteKit app and no CI gate for one, so this wiring is untested \u2014 it may work, but nothing proves it and nothing will tell us if it breaks. Supported and gated today: Vite + React, Next.js, Remix and Astro. If the hook does not register a session, please open an issue.";
 /**
  * Dev-only client hook that connects Reticle in a SvelteKit app. SvelteKit renders through app.html and
  * never triggers Vite's index.html injection (verified), so the standard plugin can't auto-connect —
@@ -30,4 +76,3 @@ export declare function svelteKitHooksFile(port: number | undefined, projectId?:
  * and by tooling for the stable projectId (the app's identity across port changes).
  */
 export declare function reticleConfigContent(framework: string, port: number | undefined, projectId?: string): string;
-//# sourceMappingURL=snippets.d.ts.map