@reticlehq/init 2.14.0

package/dist/dev-script.js

@@ -0,0 +1,66 @@
+/**
+ * Which command starts this project, and should we start it ourselves?
+ *
+ * `init` finishes by telling the human to start or restart their dev server, in a closing
+ * paragraph, in a terminal that is about to be cleared by the client restart it also asks for.
+ * That is the second unmarked hand-off in the install, after the capabilities file, and it lands
+ * on the same surface: prose nobody re-reads.
+ *
+ * Every fact needed to remove it is already in the project. `package.json` names the script; the
+ * framework tells us the conventional port; a probe tells us whether something already answers
+ * there. Nothing here needs a human.
+ *
+ * Kept as a PURE decision, separate from spawning, because the interesting part is the judgement —
+ * which script, and whether to touch anything at all — and that is what wants testing. Spawning a
+ * process is not.
+ */
+/** Script names a JS project uses to run itself, in the order we would pick them. */
+export const DEV_SCRIPT_NAMES = ['dev', 'start', 'serve'];
+const CANDIDATES = DEV_SCRIPT_NAMES;
+export const DevScriptChoice = {
+    /** Something already answers on the port. Use it; never replace a server the user is running. */
+    ALREADY_SERVING: 'already-serving',
+    /** We know the command and nothing is listening. Start it. */
+    START: 'start',
+    /** No script we recognise. Say so rather than guess a command. */
+    NO_SCRIPT: 'no-script',
+};
+/**
+ * Pick the script and decide whether to run it.
+ *
+ * `serving` is the probe result, passed in rather than measured here so the decision stays pure.
+ * When something is already answering we do not care which script exists: the rule is never to
+ * start a second server, because the one that is running may be the user's, with their state in it.
+ */
+export function planDevScript(scripts, packageManager, serving) {
+    if (serving)
+        return { choice: DevScriptChoice.ALREADY_SERVING };
+    const name = CANDIDATES.find((c) => 'string' === typeof scripts[c] && scripts[c] !== '');
+    if (name === undefined)
+        return { choice: DevScriptChoice.NO_SCRIPT };
+    // `npm` needs `run`; the others take the script name directly. Getting this wrong prints a
+    // command that fails, which is worse than printing nothing.
+    const command = 'npm' === packageManager ? `npm run ${name}` : `${packageManager} ${name}`;
+    return { choice: DevScriptChoice.START, script: name, command };
+}
+/**
+ * The command to print for this project, straight from its `package.json`.
+ *
+ * Lives here rather than in `run.ts` because it is the same judgement as `planDevScript` with the
+ * parsing attached, and `run.ts` is at its cohesion limit. Returns undefined for anything it cannot
+ * read: this phrasing decides nothing, so it must never be able to break an install.
+ */
+export function devCommandFrom(pkg, packageManager) {
+    try {
+        // Takes the PARSED manifest. It used to take the raw string and parse it a fourth time — the
+        // caller now reads the file once, through a guard, so there is one place a malformed manifest
+        // can be noticed and it is not this one.
+        const scripts = 'object' === typeof pkg && null !== pkg
+            ? (pkg.scripts ?? {})
+            : {};
+        return planDevScript(scripts, packageManager, false).command;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/dev-server-ports.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Ports that belong to a DEV SERVER, not to Reticle's bridge. Next defaults to 3000, Vite to 5173,
+ * Astro to 4321, and so on.
+ *
+ * `.reticle.json`'s `port` is the bridge — the daemon ↔ SDK channel, default 4400 — and it has
+ * nothing to do with the port the app is served on. Setting it to the dev-server port makes the
+ * daemon try to bind the port the app already holds; what the user sees is either a bind failure or
+ * a daemon that never connects, neither of which mentions the actual mistake. The old setup skill
+ * asked "what port does your dev server run on?" a few lines before showing this field, which is how
+ * the confusion got manufactured in the first place.
+ *
+ * Lives in the scaffolder because `existing-config.ts` is what diagnoses the mistake in a config
+ * somebody already wrote, and this package may not import the daemon. `cli/cli-port.ts` re-exports
+ * all three for the runtime readers (the dev-server probe and the no-session diagnosis), so nothing
+ * on the server side changed.
+ */
+export declare const DEV_SERVER_PORTS: ReadonlySet<number>;
+export declare function isLikelyDevServerPort(port: number): boolean;
+/** The warning printed when a project pins the bridge to something that looks like its dev server. */
+export declare function devServerPortWarning(port: number): string;

package/dist/dev-server-ports.js

@@ -0,0 +1,45 @@
+/**
+ * Ports that belong to a DEV SERVER, not to Reticle's bridge. Next defaults to 3000, Vite to 5173,
+ * Astro to 4321, and so on.
+ *
+ * `.reticle.json`'s `port` is the bridge — the daemon ↔ SDK channel, default 4400 — and it has
+ * nothing to do with the port the app is served on. Setting it to the dev-server port makes the
+ * daemon try to bind the port the app already holds; what the user sees is either a bind failure or
+ * a daemon that never connects, neither of which mentions the actual mistake. The old setup skill
+ * asked "what port does your dev server run on?" a few lines before showing this field, which is how
+ * the confusion got manufactured in the first place.
+ *
+ * Lives in the scaffolder because `existing-config.ts` is what diagnoses the mistake in a config
+ * somebody already wrote, and this package may not import the daemon. `cli/cli-port.ts` re-exports
+ * all three for the runtime readers (the dev-server probe and the no-session diagnosis), so nothing
+ * on the server side changed.
+ */
+export const DEV_SERVER_PORTS = new Set([
+    3000,
+    3001,
+    4200,
+    4321,
+    5000,
+    5173,
+    5174,
+    8000,
+    8080,
+    8100,
+    9000,
+    // Added after the scan reported "nothing is listening" at people whose app was plainly running.
+    // A narrow list is not just unhelpful, it is CONFIDENTLY wrong — the message states absence as a
+    // fact — so the defaults of the frameworks agents actually meet belong in it.
+    1420, // Tauri
+    3100, // Next, second instance
+    4173, // vite preview
+    5175, // Vite, third instance
+    7860, // Gradio
+    8501, // Streamlit
+]);
+export function isLikelyDevServerPort(port) {
+    return DEV_SERVER_PORTS.has(port);
+}
+/** The warning printed when a project pins the bridge to something that looks like its dev server. */
+export function devServerPortWarning(port) {
+    return `[reticle] .reticle.json sets "port": ${port}, which is a common DEV-SERVER port. That field is the Reticle BRIDGE port (default 4400), not the port your app is served on — they must be different, or the daemon fights your dev server for it. Remove "port" unless you are running several apps at once.`;
+}

package/dist/electron-patch.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Conservative patchers for the Electron halves `init` can see whole: the preload IPC shim and
+ * the main-process screenshot helper.
+ *
+ * Preload is mechanical — prepend one line — so it is APPLY. Main is only APPLY when the file
+ * constructs exactly one BrowserWindow as `const <name> = new BrowserWindow(`; anything else
+ * (zero, several, a factory) is MANUAL carrying the doctor's existing fix text, not a guess.
+ */
+import { type SourcePatch } from './patch-kind.js';
+export declare function patchElectronPreload(source: string, path: string): SourcePatch;
+export declare function patchElectronMain(source: string, path?: string): SourcePatch;

package/dist/electron-patch.js

@@ -0,0 +1,70 @@
+/**
+ * Conservative patchers for the Electron halves `init` can see whole: the preload IPC shim and
+ * the main-process screenshot helper.
+ *
+ * Preload is mechanical — prepend one line — so it is APPLY. Main is only APPLY when the file
+ * constructs exactly one BrowserWindow as `const <name> = new BrowserWindow(`; anything else
+ * (zero, several, a factory) is MANUAL carrying the doctor's existing fix text, not a guess.
+ */
+import { matchingParenEnd } from './brace-scan.js';
+import { CAPTURE_REQUIRE, ELECTRON_CAPTURE_FIX, PRELOAD_REQUIRE } from './desktop-doctor.js';
+import { PatchKind } from './patch-kind.js';
+const ESM_PRELOAD_EXT = /\.(?:ts|mts|mjs)$/i;
+const WINDOW_DECL = /const\s+(\w+)\s*=\s*new\s+BrowserWindow\s*\(/g;
+const IMPORT_LINE = /^import\s.+from\s+['"][^'"]+['"];?\s*$/gm;
+const REQUIRE_LINE = /^(?:const|let|var)\s+.+=\s+require\s*\(/gm;
+function isEsmPath(path) {
+    return ESM_PRELOAD_EXT.test(path);
+}
+function preloadLine(path) {
+    return isEsmPath(path) ? `import '${PRELOAD_REQUIRE}'\n` : `require('${PRELOAD_REQUIRE}');\n`;
+}
+export function patchElectronPreload(source, path) {
+    if (source.includes(PRELOAD_REQUIRE)) {
+        return { kind: PatchKind.ALREADY };
+    }
+    return { kind: PatchKind.APPLY, code: `${preloadLine(path)}${source}` };
+}
+function insertMainImport(source, path) {
+    if (source.includes(CAPTURE_REQUIRE))
+        return source;
+    if (isEsmPath(path)) {
+        const line = `import { installReticleCapture } from '${CAPTURE_REQUIRE}'`;
+        const matches = [...source.matchAll(IMPORT_LINE)];
+        const last = matches[matches.length - 1];
+        if (last?.index === undefined)
+            return `${line}\n${source}`;
+        const end = last.index + last[0].length;
+        return `${source.slice(0, end)}\n${line}${source.slice(end)}`;
+    }
+    const line = `const { installReticleCapture } = require('${CAPTURE_REQUIRE}');`;
+    const matches = [...source.matchAll(REQUIRE_LINE)];
+    const last = matches[matches.length - 1];
+    if (last?.index === undefined)
+        return `${line}\n${source}`;
+    const endOfLine = source.indexOf('\n', last.index);
+    const end = endOfLine < 0 ? source.length : endOfLine;
+    return `${source.slice(0, end)}\n${line}${source.slice(end)}`;
+}
+export function patchElectronMain(source, path = 'electron/main.cjs') {
+    if (source.includes(CAPTURE_REQUIRE)) {
+        return { kind: PatchKind.ALREADY };
+    }
+    const matches = [...source.matchAll(WINDOW_DECL)];
+    if (matches.length !== 1 || matches[0]?.index === undefined || matches[0][1] === undefined) {
+        return { kind: PatchKind.MANUAL, reason: ELECTRON_CAPTURE_FIX };
+    }
+    const name = matches[0][1];
+    const openAt = source.indexOf('(', matches[0].index + matches[0][0].length - 1);
+    const closeAt = matchingParenEnd(source, openAt);
+    if (closeAt === undefined) {
+        return { kind: PatchKind.MANUAL, reason: ELECTRON_CAPTURE_FIX };
+    }
+    let insertAt = closeAt + 1;
+    if (';' === source[insertAt])
+        insertAt += 1;
+    const indentMatch = /^[ \t]*/.exec(source.slice(source.lastIndexOf('\n', matches[0].index) + 1));
+    const indent = indentMatch?.[0] ?? '  ';
+    const withCall = `${source.slice(0, insertAt)}\n${indent}installReticleCapture(${name})${source.slice(insertAt)}`;
+    return { kind: PatchKind.APPLY, code: insertMainImport(withCall, path) };
+}

package/dist/electron-vite-patch.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Conservative patcher for an electron-vite config: add `@reticlehq/vite-plugin` and drop
+ * `reticle({ desktop: true, ... })` into the RENDERER block's plugins array.
+ *
+ * A generic Vite patcher takes the first `plugins: [` in the file, which in a conventional
+ * electron-vite config is `main`'s. Wiring the SDK into the main process installs it where there
+ * is no document, and reports success — worse than today's honest refusal. This patcher finds the
+ * `renderer` block specifically and refuses anything it cannot see whole.
+ */
+import { type SourcePatch } from './patch-kind.js';
+export declare const ELECTRON_VITE_IMPORT = "import { reticle } from '@reticlehq/vite-plugin';";
+export declare function patchElectronViteConfig(source: string, port?: number): SourcePatch;

package/dist/electron-vite-patch.js

@@ -0,0 +1,100 @@
+/**
+ * Conservative patcher for an electron-vite config: add `@reticlehq/vite-plugin` and drop
+ * `reticle({ desktop: true, ... })` into the RENDERER block's plugins array.
+ *
+ * A generic Vite patcher takes the first `plugins: [` in the file, which in a conventional
+ * electron-vite config is `main`'s. Wiring the SDK into the main process installs it where there
+ * is no document, and reports success — worse than today's honest refusal. This patcher finds the
+ * `renderer` block specifically and refuses anything it cannot see whole.
+ */
+import { matchingBraceEnd } from './brace-scan.js';
+import { PatchKind } from './patch-kind.js';
+export const ELECTRON_VITE_IMPORT = "import { reticle } from '@reticlehq/vite-plugin';";
+const RETICLE_MARKER = '@reticlehq/vite-plugin';
+const RETICLE_CALL = /reticle\s*\(/;
+const DESKTOP_FLAG = /desktop\s*:/;
+const PLUGINS_ARRAY = /plugins\s*:\s*\[/;
+const IMPORT_LINE = /^import\s.+from\s+['"][^'"]+['"];?\s*$/gm;
+const RENDERER_KEY = /renderer\s*:\s*/;
+const NO_RENDERER_REASON = "couldn't find a `renderer` key to extend";
+const RENDERER_NOT_LITERAL_REASON = 'this config sets `renderer:` to something other than an object literal — merging into it is your call, not a text edit Reticle should make';
+const WRONG_BLOCK_REASON = 'reticle() is in this file but not in the `renderer` block — the plugin belongs where there is a document, and leaving it in `main` or `preload` would report success for an app that cannot connect';
+const MISSING_DESKTOP_REASON = 'reticle() is already in the `renderer` block but without `desktop: true` — a packaged renderer is a production build with no dev server, so the plugin is dropped from `vite build` and the shipped app has no connect()';
+function reticlePluginCall(port) {
+    const options = [
+        'desktop: true',
+        ...(port === undefined ? [] : [`port: ${String(port)}`]),
+        'captureNetworkBodies: true',
+    ];
+    return `reticle({ ${options.join(', ')} })`;
+}
+function insertImport(source) {
+    if (source.includes(RETICLE_MARKER))
+        return source;
+    const matches = [...source.matchAll(IMPORT_LINE)];
+    const last = matches[matches.length - 1];
+    if (last?.index === undefined) {
+        return `${ELECTRON_VITE_IMPORT}\n${source}`;
+    }
+    const end = last.index + last[0].length;
+    return `${source.slice(0, end)}\n${ELECTRON_VITE_IMPORT}${source.slice(end)}`;
+}
+function rendererBounds(source) {
+    const key = RENDERER_KEY.exec(source);
+    if (key?.index === undefined)
+        return undefined;
+    const after = key.index + key[0].length;
+    if (source[after] !== '{')
+        return undefined;
+    const innerStart = after + 1;
+    const innerEnd = matchingBraceEnd(source, innerStart);
+    if (innerEnd === undefined)
+        return undefined;
+    return { keyAt: key.index, braceAt: after, innerStart, innerEnd };
+}
+function insertPluginInRenderer(source, bounds, port) {
+    const inner = source.slice(bounds.innerStart, bounds.innerEnd);
+    const match = PLUGINS_ARRAY.exec(inner);
+    if (match?.index === undefined)
+        return source;
+    const next = inner[match.index + match[0].length] ?? '';
+    const separator = '' === next || /\s/.test(next) ? '' : ' ';
+    const patched = `${inner.slice(0, match.index)}${match[0]}${reticlePluginCall(port)},${separator}${inner.slice(match.index + match[0].length)}`;
+    return `${source.slice(0, bounds.innerStart)}${patched}${source.slice(bounds.innerEnd)}`;
+}
+function insertPluginsKeyInRenderer(source, bounds, port) {
+    const rest = source.slice(bounds.braceAt + 1);
+    const multiline = /^\s*\n/.test(rest);
+    const indent = /^\s*\n(\s*)\S/.exec(rest)?.[1] ?? '  ';
+    const key = `plugins: [${reticlePluginCall(port)}],`;
+    const inserted = multiline ? `\n${indent}${key}` : ` ${key}`;
+    return `${source.slice(0, bounds.braceAt + 1)}${inserted}${source.slice(bounds.braceAt + 1)}`;
+}
+export function patchElectronViteConfig(source, port) {
+    const key = RENDERER_KEY.exec(source);
+    if (key?.index === undefined) {
+        return { kind: PatchKind.MANUAL, reason: NO_RENDERER_REASON };
+    }
+    const after = key.index + key[0].length;
+    if ('{' !== source[after]) {
+        return { kind: PatchKind.MANUAL, reason: RENDERER_NOT_LITERAL_REASON };
+    }
+    const bounds = rendererBounds(source);
+    if (bounds === undefined) {
+        return { kind: PatchKind.MANUAL, reason: NO_RENDERER_REASON };
+    }
+    const renderer = source.slice(bounds.innerStart, bounds.innerEnd);
+    if (RETICLE_CALL.test(renderer)) {
+        if (DESKTOP_FLAG.test(renderer)) {
+            return { kind: PatchKind.ALREADY };
+        }
+        return { kind: PatchKind.MANUAL, reason: MISSING_DESKTOP_REASON };
+    }
+    if (source.includes(RETICLE_MARKER) || RETICLE_CALL.test(source)) {
+        return { kind: PatchKind.MANUAL, reason: WRONG_BLOCK_REASON };
+    }
+    const withPlugin = PLUGINS_ARRAY.test(renderer)
+        ? insertPluginInRenderer(source, bounds, port)
+        : insertPluginsKeyInRenderer(source, bounds, port);
+    return { kind: PatchKind.APPLY, code: insertImport(withPlugin) };
+}

package/dist/existing-config.d.ts

@@ -0,0 +1,31 @@
+/** The project config file, named once. Lives here because this module is what reads it. */
+export declare const RETICLE_CONFIG_FILE = ".reticle.json";
+/**
+ * Reading a `.reticle.json` that is ALREADY on disk.
+ *
+ * Split out of plan.ts when it crossed the line cap. These two are one job -- looking at a config
+ * somebody else wrote and deciding what it tells us -- and neither knows anything about steps,
+ * plans or the shape of a report, which is what made them the cohesive piece to lift rather than
+ * the nearest thousand-line boundary.
+ */
+/**
+ * What is wrong with the config that is already there, if anything.
+ *
+ * Reported from the field (#317): a project carried `"port": 3000` — its own dev-server port, which
+ * is the confusion SKILL.md names as the top setup failure — and `init` printed `.reticle.json
+ * already exists` on every re-run without reading a single field of it, so the file could never be
+ * repaired by the command that wrote it. It stayed invisible because a daemon on `127.0.0.1:3000`
+ * and Vite on `[::1]:3000` split the port by address family and neither reported a conflict.
+ *
+ * Narrower than the issue asked for on purpose: `init`'s IO surface is synchronous, so this cannot
+ * probe what is LISTENING right now. `isLikelyDevServerPort` covers the framework defaults, which is
+ * where the mistake is actually made.
+ */
+export declare function existingConfigProblem(source: string | null | undefined): string | undefined;
+/**
+ * The project a `.reticle.json` claims, or undefined when it does not claim one we can read.
+ *
+ * Unreadable is deliberately NOT a conflict. A file we cannot parse tells us nothing about which
+ * app it points at, and refusing on it would block the redirect on any hand-edited config.
+ */
+export declare function projectIdOf(source: string | null | undefined): string | undefined;

package/dist/existing-config.js

@@ -0,0 +1,63 @@
+import { devServerPortWarning, isLikelyDevServerPort } from './dev-server-ports.js';
+/** The project config file, named once. Lives here because this module is what reads it. */
+export const RETICLE_CONFIG_FILE = '.reticle.json';
+/**
+ * Reading a `.reticle.json` that is ALREADY on disk.
+ *
+ * Split out of plan.ts when it crossed the line cap. These two are one job -- looking at a config
+ * somebody else wrote and deciding what it tells us -- and neither knows anything about steps,
+ * plans or the shape of a report, which is what made them the cohesive piece to lift rather than
+ * the nearest thousand-line boundary.
+ */
+/**
+ * What is wrong with the config that is already there, if anything.
+ *
+ * Reported from the field (#317): a project carried `"port": 3000` — its own dev-server port, which
+ * is the confusion SKILL.md names as the top setup failure — and `init` printed `.reticle.json
+ * already exists` on every re-run without reading a single field of it, so the file could never be
+ * repaired by the command that wrote it. It stayed invisible because a daemon on `127.0.0.1:3000`
+ * and Vite on `[::1]:3000` split the port by address family and neither reported a conflict.
+ *
+ * Narrower than the issue asked for on purpose: `init`'s IO surface is synchronous, so this cannot
+ * probe what is LISTENING right now. `isLikelyDevServerPort` covers the framework defaults, which is
+ * where the mistake is actually made.
+ */
+export function existingConfigProblem(source) {
+    if (null === source || source === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        return (`${RETICLE_CONFIG_FILE} is present but is not valid JSON, so nothing reads it — neither the ` +
+            'daemon nor the SDK. Delete it and re-run `reticle init`.');
+    }
+    if ('object' !== typeof parsed || null === parsed)
+        return undefined;
+    const port = parsed['port'];
+    if ('number' !== typeof port || !isLikelyDevServerPort(port))
+        return undefined;
+    return `${devServerPortWarning(port)} Fix it by removing the "port" field from ${RETICLE_CONFIG_FILE}.`;
+}
+/**
+ * The project a `.reticle.json` claims, or undefined when it does not claim one we can read.
+ *
+ * Unreadable is deliberately NOT a conflict. A file we cannot parse tells us nothing about which
+ * app it points at, and refusing on it would block the redirect on any hand-edited config.
+ */
+export function projectIdOf(source) {
+    if (null === source || source === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        return undefined;
+    }
+    if ('object' !== typeof parsed || null === parsed)
+        return undefined;
+    const id = parsed['projectId'];
+    return 'string' === typeof id && id.length > 0 ? id : undefined;
+}

package/dist/format-generated.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Format a file `init` is about to write, using the project's own Prettier when it is installed.
+ *
+ * Reported from the field (#684): a clean CRA install failed the project's own lint because
+ * `src/reticle-dev.ts` was emitted as one long line. The project already had Prettier; init never
+ * asked it. Best-effort: resolve Prettier from the app (not from ours — we do not ship it), apply
+ * its config, and on any failure return the original content so init never fails because of a
+ * formatter. Sync only — `applyEffects` is sync, and Prettier 3's async `format` cannot join here.
+ */
+/** True when this write is a connect/dev module lint will treat as project source. */
+export declare function isGeneratedSourcePath(relPath: string): boolean;
+/**
+ * Format `content` for `relPath` under `projectRoot`, or return it unchanged.
+ *
+ * Only the sync Prettier API is used. Prettier 3's async `format` is skipped (returns the original)
+ * rather than holding init open on a promise `applyEffects` cannot await.
+ */
+export declare function formatGeneratedSource(content: string, relPath: string, projectRoot: string): string;

package/dist/format-generated.js

@@ -0,0 +1,48 @@
+/**
+ * Format a file `init` is about to write, using the project's own Prettier when it is installed.
+ *
+ * Reported from the field (#684): a clean CRA install failed the project's own lint because
+ * `src/reticle-dev.ts` was emitted as one long line. The project already had Prettier; init never
+ * asked it. Best-effort: resolve Prettier from the app (not from ours — we do not ship it), apply
+ * its config, and on any failure return the original content so init never fails because of a
+ * formatter. Sync only — `applyEffects` is sync, and Prettier 3's async `format` cannot join here.
+ */
+import { createRequire } from 'node:module';
+import { basename, join } from 'node:path';
+/** Basenames of full-file generators that a project's lint will see. */
+const GENERATED_SOURCE_NAMES = new Set([
+    'reticle-dev.ts',
+    'reticle-dev.tsx',
+    // CRA's JavaScript branch. Missing here, so the one project shape that HAS no TypeScript — and
+    // whose boilerplate lint is the strictest about line width — was the one never formatted.
+    'reticle-dev.js',
+    'hooks.client.ts',
+    'reticle.client.ts',
+    'entry.client.tsx',
+]);
+/** True when this write is a connect/dev module lint will treat as project source. */
+export function isGeneratedSourcePath(relPath) {
+    return GENERATED_SOURCE_NAMES.has(basename(relPath));
+}
+/**
+ * Format `content` for `relPath` under `projectRoot`, or return it unchanged.
+ *
+ * Only the sync Prettier API is used. Prettier 3's async `format` is skipped (returns the original)
+ * rather than holding init open on a promise `applyEffects` cannot await.
+ */
+export function formatGeneratedSource(content, relPath, projectRoot) {
+    if (!isGeneratedSourcePath(relPath))
+        return content;
+    try {
+        const require = createRequire(join(projectRoot, 'package.json'));
+        const prettier = require('prettier');
+        const filePath = join(projectRoot, relPath);
+        const resolved = prettier.resolveConfig.sync?.(filePath) ?? {};
+        const formatted = prettier.format(content, { ...resolved, filepath: filePath });
+        // Prettier 2 returns a string; Prettier 3 returns a Promise we cannot join from sync code.
+        return 'string' === typeof formatted ? formatted : content;
+    }
+    catch {
+        return content;
+    }
+}

package/dist/framework-adapter.d.ts

@@ -0,0 +1,60 @@
+/**
+ * One record per framework, in one table the compiler refuses to leave a hole in.
+ *
+ * Adding a framework used to mean editing nine places — the enum, the detection globs, the
+ * detection chain, the package switch, an ad-hoc `SVELTEKIT || NUXT` pair test, the step switch,
+ * the step builder, the connect snippet, the connect-step title set — and only two of them went
+ * red when missed. The rest failed the way this whole area fails: `init` printed a clean plan and
+ * the app never dialled the daemon.
+ *
+ * Everything that is per-framework AND mechanical lives here. What is NOT here is deliberate:
+ *
+ * - Detection (`FRAMEWORK_SIGNALS` / `DETECTION_ORDER` in `detect.ts`). The step builders below
+ *   import `detect.ts` transitively, so folding detection in would make the module that answers
+ *   "what is this project" depend on the module that answers "how do we wire it". It is a
+ *   `Record<Framework, …>` of its own there, so it is completed by the compiler just the same.
+ * - The snippet builders (`snippets.ts`). Each is a different recipe in a different language, and
+ *   they are reached through the `steps` builder anyway.
+ *
+ * `framework-adapter.test.ts` asserts the seam between the two halves.
+ */
+import { Framework } from './detect.js';
+import { StepTitle } from './connect-steps.js';
+import type { PlanInput, Step } from './plan.js';
+export declare const RETICLE_REACT_KIT = "@reticlehq/react";
+/** The framework-neutral sensor, for stacks the React adapter has nothing to attach to. */
+export declare const RETICLE_BROWSER_SDK = "@reticlehq/browser";
+export declare const RETICLE_VITE_PLUGIN = "@reticlehq/vite-plugin";
+export declare const RETICLE_NEXT_PLUGIN = "@reticlehq/next";
+/** The Electron main/preload helper — what makes IPC and screenshots exist at all. */
+export declare const RETICLE_ELECTRON = "@reticlehq/electron";
+export interface FrameworkAdapter {
+    /**
+     * The dev dependencies `init` installs, given the kit the UI-library check chose
+     * (`@reticlehq/react` or the neutral sensor). A framework that knows its own renderer ignores the
+     * argument — Next is React by construction and Nuxt is Vue, so neither has a detection result
+     * worth honouring here.
+     */
+    readonly packages: (kit: string) => readonly string[];
+    /** The per-framework half of the plan. */
+    readonly steps: (input: PlanInput) => Step[];
+    /**
+     * The steps WITHOUT which this framework's app never dials the daemon.
+     *
+     * `connect-steps.ts` decides whether a ⚠ makes `init` exit non-zero, and it does so from a
+     * hand-written set of titles. A framework whose connect step is missing from that set reports the
+     * ⚠ and exits 0 over an app that cannot connect; the test pins that no entry here is unknown to
+     * it, and that between them the entries account for the whole set.
+     */
+    readonly connectStepTitles: readonly StepTitle[];
+    /**
+     * Whether this framework's own recipe already says it is unverified.
+     *
+     * Read by the generic "<library> is UNVERIFIED" notice, which must not argue with the more
+     * specific wording a recipe carries. This replaced a literal `SVELTEKIT || NUXT` test — a pair
+     * that had to be remembered, and is not the same question as "renders its own HTML" (Astro and
+     * React Router do that too and DO want the generic notice).
+     */
+    readonly carriesOwnUnverifiedNote: boolean;
+}
+export declare const FRAMEWORK_ADAPTERS: Record<Framework, FrameworkAdapter>;