@reticlehq/init 3.6.0 → 3.8.0

package/dist/plan/plan-framework.js

@@ -9,14 +9,39 @@ import { patchNextConfig, patchRootLayout, patchPagesApp } from '../patch/next-p
 import { ASTRO_ENV_DTS_PATH, ASTRO_RETICLE_DEV_PATH, astroReticleDevFile, patchAstroConfig, patchAstroEnvDts, patchAstroLayout, } from '../patch/astro-patch.js';
 import { CRA_DEV_MODULE_IMPORT, CRA_ENV_PATH, CRA_TOKEN_PER_MACHINE_NOTICE, TOKEN_VAR, craDevModuleFile, craDevModulePath, craEnvPatch, craImportPatch, } from '../patch/cra.js';
 import { PatchKind } from '../patch/patch-kind.js';
-import { NEXT_LAYOUT_MANUAL, NEXT_LAYOUT_PATH, nextReticleDevFile, NEXT_RETICLE_DEV_PATH, nextConfigManual, svelteKitHooksFile, SVELTEKIT_HOOKS_PATH, SVELTEKIT_SETUP_GATED_NOTE, astroManual, nuxtManual, nuxtPluginFile, nuxtPluginPath, NUXT_PLUGIN_NOTICE, webpack4TranspileNote, WEBPACK4_REACT_SCRIPTS_MAJOR, reactRouterEntryFile, reactRouterEntryPatch, REACT_ROUTER_ENTRY_PATH, UNVERIFIED_TANSTACK_START_NOTE, htmlManual, } from '../patch/snippets.js';
+import { NEXT_LAYOUT_MANUAL, NEXT_LAYOUT_PATH, nextReticleDevFile, NEXT_RETICLE_DEV_PATH, nextConfigManual, svelteKitHooksFile, SVELTEKIT_HOOKS_PATH, SVELTEKIT_SETUP_GATED_NOTE, astroManual, nuxtManual, nuxtPluginFile, nuxtPluginPath, NUXT_PLUGIN_NOTICE, webpack4TranspileNote, WEBPACK4_REACT_SCRIPTS_MAJOR, reactRouterEntryFile, reactRouterEntryPatch, REACT_ROUTER_ENTRY_PATH, UNVERIFIED_TANSTACK_START_NOTE, htmlManual, connectArg, } from '../patch/snippets.js';
 import { StepStatus } from './plan-types.js';
 import { StepTitle } from './connect-steps.js';
 import { patchTanstackStartRoot, tanstackStartConnectFile, tanstackStartConnectPath, tanstackStartManual, TANSTACK_START_ROOT_PATH, } from '../patch/tanstack-start.js';
 import { patchNuxtConfig } from '../patch/nuxt-patch.js';
 import { alreadyOrMovedPort } from './port-steps.js';
 import { capabilitiesTodo, needsManualStore } from './plan-vite.js';
-import { HTML_INDEX_PATH, hasStaticSnippet } from '../patch/static-page.js';
+import { HTML_INDEX_PATH, STATIC_GITIGNORE_PATH, STATIC_SNIPPET_MARKER, STATIC_TOKEN_MODULE, staticTokenFiles, withStaticSnippet, } from '../patch/static-page.js';
+/*
+ * Threat model for the static page's token module. `reticle.local.js` sits beside `index.html`, so
+ * whatever serves the page serves it too, to any client that can reach that server. That is the same
+ * exposure every other dev path already has: the Vite plugin bakes the token into the connect module
+ * it serves, and the no-package.json path writes this very file. The dev server's bind address is
+ * the boundary; the module is gitignored so it never reaches a commit or a published build.
+ */
+const STATIC_TOKEN_DETAIL = `write this machine’s pairing token to ${STATIC_TOKEN_MODULE} beside the page`;
+const STATIC_IGNORE_DETAIL = `add ${STATIC_TOKEN_MODULE} to ${STATIC_GITIGNORE_PATH} — it holds this machine’s pairing token`;
+const STATIC_CONNECT_DETAIL = 'write the dev-only connect snippet (loopback hosts only)';
+const STATIC_CONNECT_ALREADY_DETAIL = `${HTML_INDEX_PATH} already loads the Reticle SDK`;
+/** The package whose presence makes a static page an Electron renderer. */
+const ELECTRON_PACKAGE = 'electron';
+/**
+ * An Electron app often serves its renderer from a local HTTP server, so the packaged app runs on
+ * `localhost` on every user's machine. The localhost-only guard then lets the snippet run in
+ * production, and a packager glob such as `**\/*.js` can ship the token module.
+ */
+const ELECTRON_STATIC_DETAIL = `This is an Electron app. Its packaged renderer can also run on localhost, so init did not ` +
+    `write the localhost-only snippet into ${HTML_INDEX_PATH} or the ${STATIC_TOKEN_MODULE} token ` +
+    'module. Connect only in development: for example, send `!app.isPackaged` from the main ' +
+    'process to the renderer, and call `reticle.connect()` only when it is true. Use ' +
+    `@reticlehq/electron for IPC and capture. If ${STATIC_TOKEN_MODULE} is in the project, keep ` +
+    `it out of the package: electron-builder \`files: ["!${STATIC_TOKEN_MODULE}"]\`, or Electron ` +
+    `Forge \`packagerConfig.ignore: [/${STATIC_TOKEN_MODULE.replaceAll('.', '\\.')}$/]\`.`;
 /**
  * Turn a conservative source patch into a step: applied when it patched, already when the wiring is
  * there, and the hand-edit instructions when the file shape wasn't one we recognise.
@@ -49,15 +74,21 @@ export function patchStep(title, path, patch, applyDetail, manualDetail) {
  */
 /** The env var withReticle sets from the discovered daemon, and the component must read. */
 const NEXT_DAEMON_URL_ENV = 'NEXT_PUBLIC_RETICLE_URL';
+const NEXT_SDK_VERSION_ENV = 'NEXT_PUBLIC_RETICLE_SDK_VERSION';
 /**
  * The two-line edit that unfreezes an existing install's port.
  *
  * Stated as the edit rather than as a problem, because the reader is an agent that can apply it in
  * one write and is otherwise going to ask what to do.
  */
-const NEXT_DEV_FILE_STALE_DETAIL = 'predates daemon discovery, so it dials the port init saw when it ran. In this file add ' +
+const NEXT_DEV_FILE_STALE_DETAIL_SOLO = 'predates daemon discovery, so it dials the port init saw when it ran. In this file add ' +
     '`const url = process.env.NEXT_PUBLIC_RETICLE_URL;` and spread `...(url ? { url } : {})` into ' +
     'reticle.connect(), after any url already there. Nothing else needs to change.';
+const NEXT_DEV_FILE_STALE_DETAIL_DUAL = 'predates daemon discovery, so it dials the port init saw when it ran. In this file add ' +
+    '`const url = process.env.NEXT_PUBLIC_RETICLE_URL;` and spread `...(url ? { url } : {})` into ' +
+    'reticle.connect(), after any url already there.';
+const NEXT_SDK_VERSION_DETAIL = 'lacks the SDK version. In this file add `const sdkVersion = process.env.NEXT_PUBLIC_RETICLE_SDK_VERSION;` ' +
+    'and spread `...(sdkVersion ? { sdkVersion } : {})` into the reticle.connect() options.';
 export function nextSteps(input) {
     const configFile = input.nextConfigFile ?? 'next.config.mjs';
     const devPath = input.nextReticleDevPath ?? NEXT_RETICLE_DEV_PATH;
@@ -71,34 +102,52 @@ export function nextSteps(input) {
     const devStale = true === input.nextReticleDevExists &&
         'string' === typeof input.nextReticleDevSource &&
         !input.nextReticleDevSource.includes(NEXT_DAEMON_URL_ENV);
-    const devFile = input.nextReticleDevExists
-        ? devStale
-            ? {
+    const sdkVersionMissing = true === input.nextReticleDevExists &&
+        'string' === typeof input.nextReticleDevSource &&
+        !input.nextReticleDevSource.includes(NEXT_SDK_VERSION_ENV);
+    const baseDevStep = devStale
+        ? {
+            title: StepTitle.RETICLE_DEV_COMPONENT,
+            target: devPath,
+            status: StepStatus.MANUAL,
+            detail: sdkVersionMissing
+                ? `${NEXT_DEV_FILE_STALE_DETAIL_DUAL} Also ${NEXT_SDK_VERSION_DETAIL}`
+                : NEXT_DEV_FILE_STALE_DETAIL_SOLO,
+        }
+        : alreadyOrMovedPort({
+            title: StepTitle.RETICLE_DEV_COMPONENT,
+            target: devPath,
+            status: StepStatus.ALREADY,
+            detail: 'file exists',
+        }, input.nextReticleDevSource, input.options.port);
+    const devNoticeSteps = !devStale && sdkVersionMissing
+        ? [
+            {
                 title: StepTitle.RETICLE_DEV_COMPONENT,
                 target: devPath,
-                status: StepStatus.MANUAL,
-                detail: NEXT_DEV_FILE_STALE_DETAIL,
-            }
-            : alreadyOrMovedPort({
+                status: StepStatus.NOTICE,
+                detail: NEXT_SDK_VERSION_DETAIL,
+            },
+        ]
+        : [];
+    const devFileSteps = input.nextReticleDevExists
+        ? [baseDevStep, ...devNoticeSteps]
+        : [
+            {
                 title: StepTitle.RETICLE_DEV_COMPONENT,
                 target: devPath,
-                status: StepStatus.ALREADY,
-                detail: 'file exists',
-            }, input.nextReticleDevSource, input.options.port)
-        : {
-            title: StepTitle.RETICLE_DEV_COMPONENT,
-            target: devPath,
-            status: StepStatus.APPLY,
-            detail: 'create dev-only connect component',
-            write: {
-                path: devPath,
-                content: nextReticleDevFile(input.options.port, input.options.projectId, input.testids ?? [], input.storeHints ?? [], 
-                // Next's dev module is not a sibling of `src/` — its imports are resolved from wherever
-                // the component actually lands (`app/`, or `src/app/` in a --src-dir app).
-                input.nextFoundStores ?? []),
+                status: StepStatus.APPLY,
+                detail: 'create dev-only connect component',
+                write: {
+                    path: devPath,
+                    content: nextReticleDevFile(input.options.port, input.options.projectId, input.testids ?? [], input.storeHints ?? [], 
+                    // Next's dev module is not a sibling of `src/` — its imports are resolved from wherever
+                    // the component actually lands (`app/`, or `src/app/` in a --src-dir app).
+                    input.nextFoundStores ?? []),
+                },
+                dependsOnInstall: true,
             },
-            dependsOnInstall: true,
-        };
+        ];
     const configPatch = null === input.nextConfigSource || input.nextConfigSource === undefined
         ? { kind: PatchKind.MANUAL, reason: `no ${configFile} found` }
         : patchNextConfig(input.nextConfigSource, true !== input.detection?.customReconciler);
@@ -106,8 +155,14 @@ export function nextSteps(input) {
     // Pages Router mounts through pages/_app, App Router through the root layout — different edits,
     // and picking by path is what stops a Pages app being handed the layout patch that cannot apply.
     const isPagesRouter = layout !== null && /(^|\/)pages\/_app\.[jt]sx?$/.test(layout.path);
+    const candidates = input.nextLayoutCandidates ?? [];
     const layoutPatch = null === layout
-        ? { kind: PatchKind.MANUAL, reason: 'no root layout (app/layout.tsx) or pages/_app found' }
+        ? {
+            kind: PatchKind.MANUAL,
+            reason: 0 === candidates.length
+                ? 'no root layout (app/layout.tsx) or pages/_app found'
+                : `no app/layout.tsx; route-group root layouts ${candidates.join(', ')}, and none of them alone renders /`,
+        }
         : isPagesRouter
             ? patchPagesApp(layout.source, input.nextReticleDevImport)
             : patchRootLayout(layout.source);
@@ -124,11 +179,26 @@ export function nextSteps(input) {
             },
         ]
         : [];
+    // Each route-group root layout renders only its own routes, so one mount covers one group: the
+    // routes under the other root layouts render without ReticleDev, and saying nothing about them
+    // would read as an app that is fully wired.
+    const unmounted = input.nextUnmountedLayouts ?? [];
+    const otherRootLayouts = null !== layout && 0 < unmounted.length
+        ? [
+            {
+                title: StepTitle.ROUTE_GROUPS_WITHOUT_RETICLE_DEV,
+                target: unmounted.join(', '),
+                status: StepStatus.NOTICE,
+                detail: `<ReticleDev /> is mounted in ${layout.path} only; ${unmounted.join(', ')} ${1 === unmounted.length ? 'is a root layout' : 'are root layouts'} of ${1 === unmounted.length ? 'its' : 'their'} own, so the routes under ${1 === unmounted.length ? 'it' : 'them'} render without it and Reticle sees nothing there. Mount it there too (dev-only) to cover them.`,
+            },
+        ]
+        : [];
     return [
-        devFile,
+        ...devFileSteps,
         ...nextTodo,
         patchStep(StepTitle.NEXT_CONFIG, configFile, configPatch, 'wrap the export in withReticle (source mapping, dev-only)', nextConfigManual(configFile, true !== input.detection?.customReconciler)),
         patchStep(StepTitle.MOUNT_RETICLE_DEV, layout?.path ?? NEXT_LAYOUT_PATH, layoutPatch, 'mount <ReticleDev /> in the root layout (dev-only)', NEXT_LAYOUT_MANUAL),
+        ...otherRootLayouts,
     ];
 }
 /**
@@ -512,28 +582,61 @@ export function astroSteps(input) {
         patchStep(StepTitle.ASTRO_ENV_DTS, ASTRO_ENV_DTS_PATH, envPatch, 'declare window.__RETICLE_TOKEN__ / __RETICLE_ROOT__ for astro check', manualWithLayout),
     ];
 }
+/** Write the gitignored module that holds this machine's pairing token, and its ignore line. */
+function staticTokenSteps(input) {
+    return Object.entries(staticTokenFiles(input.pairingToken, (path) => input.htmlLocalSources?.[path] ?? null)).map(([path, content]) => ({
+        title: StepTitle.STATIC_PAIRING_TOKEN,
+        target: path,
+        status: StepStatus.APPLY,
+        detail: STATIC_GITIGNORE_PATH === path ? STATIC_IGNORE_DETAIL : STATIC_TOKEN_DETAIL,
+        write: { path, content },
+    }));
+}
 /**
- * The plain-HTML path: no bundler to hook, so the connect snippet is printed for a hand edit.
+ * The plain-HTML path: write the static connect when the page exists, otherwise print the recipe.
  *
  * A function of its own, and NOT a fallthrough. Every framework is sent here on purpose or not at
  * all — a member of `Framework` with no adapter entry is a compile error in `FRAMEWORK_ADAPTERS`,
  * where the if/else chain this replaced used to hand it these instructions silently.
  */
 export function htmlSteps(input) {
-    // Read the page before calling the step undone. It used to be MANUAL unconditionally, so a re-run
-    // over a page that already connects said "This app will NOT connect until the ⚠ step".
-    const index = input.htmlIndexSource ?? null;
-    if (null !== index && hasStaticSnippet(index)) {
+    if (input.detection.dependencies?.[ELECTRON_PACKAGE] !== undefined) {
         return [
-            alreadyOrMovedPort({
+            {
                 title: StepTitle.CONNECT_SNIPPET,
                 target: HTML_INDEX_PATH,
-                status: StepStatus.ALREADY,
-                detail: 'index.html already loads the Reticle SDK',
-            }, index, input.options.port),
+                status: StepStatus.MANUAL,
+                detail: ELECTRON_STATIC_DETAIL,
+            },
+        ];
+    }
+    const index = input.htmlIndexSource ?? null;
+    if (null !== index) {
+        // The page is publishable; the pairing token belongs in its gitignored sibling module instead.
+        // Refresh that module even when the connect block itself is already in place.
+        const steps = staticTokenSteps(input);
+        const written = withStaticSnippet(index, connectArg(input.options.port, input.options.projectId));
+        return [
+            ...steps,
+            null !== written
+                ? {
+                    title: StepTitle.CONNECT_SNIPPET,
+                    target: HTML_INDEX_PATH,
+                    status: StepStatus.APPLY,
+                    detail: STATIC_CONNECT_DETAIL,
+                    write: { path: HTML_INDEX_PATH, content: written, expect: [STATIC_SNIPPET_MARKER] },
+                }
+                : alreadyOrMovedPort({
+                    title: StepTitle.CONNECT_SNIPPET,
+                    target: HTML_INDEX_PATH,
+                    status: StepStatus.ALREADY,
+                    detail: STATIC_CONNECT_ALREADY_DETAIL,
+                }, index, input.options.port),
         ];
     }
     return [
+        // The manual snippet imports the token from this module rather than printing it.
+        ...staticTokenSteps(input),
         {
             title: StepTitle.CONNECT_SNIPPET,
             target: HTML_INDEX_PATH,

package/dist/plan/plan-types.d.ts

@@ -8,6 +8,7 @@
 import type { Detection, Framework, UiLibrary } from '../detect/detect.js';
 import type { FoundStore } from '../detect/capabilities.js';
 import type { McpClient } from '../register/mcp-clients.js';
+import type { PromptHookTarget } from '../register/prompt-hooks.js';
 /** Exported so the init telemetry can tell an MCP-registration failure from a dependency install. */
 export declare const MCP_TARGET = "global (claude user scope)";
 /** The step that runs the package manager — the other thing that commonly fails on a user's machine. */
@@ -96,6 +97,11 @@ export interface Plan {
 }
 export interface PlanInput {
     detection: Detection;
+    /**
+     * `node_modules` is a link to another tree (a workspace's, a shared cache). A package manager run
+     * here replaces the link with a fresh tree, so the install is skipped and named instead.
+     */
+    nodeModulesLinked?: boolean | undefined;
     /**
      * Write `captureNetworkBodies: true` into the app's config. Off unless the caller asked (#705).
      *
@@ -110,6 +116,11 @@ export interface PlanInput {
      * handing it an io would let any later step reach the disk from inside `buildPlan`.
      */
     cspSources?: Readonly<Record<string, string | undefined>> | undefined;
+    /**
+     * The project's `.prettierignore` content, pre-read so the prettier-ignore step stays pure.
+     * Null when the file does not exist — `init` creates it only when the project uses Prettier.
+     */
+    prettierIgnoreSource?: string | null | undefined;
     /** Whether the `claude` CLI is installed (so we can register the MCP server globally). */
     claudeCli: boolean;
     /** Whether an `reticle` MCP server is already registered with Claude (any scope) — idempotency. */
@@ -145,11 +156,18 @@ export interface PlanInput {
         configPath: string;
         existing: string | null;
     }[] | undefined;
+    /**
+     * Whether the `codex` CLI is on PATH. Only probed when Codex was detected, and absent otherwise.
+     * With it, Codex registers through `codex mcp add` instead of a block to paste.
+     */
+    codexCli?: boolean | undefined;
     /** Discovered Vite config: its path + source, or null if none found. */
     viteConfig: {
         path: string;
         source: string;
     } | null;
+    /** Config paths found but not safely attributable to the selected dev command. */
+    viteConfigCandidates?: readonly string[] | undefined;
     /** Discovered electron-vite config: its path + source, or null if none found. */
     electronViteConfig?: {
         path: string;
@@ -200,6 +218,16 @@ export interface PlanInput {
         path: string;
         source: string;
     } | null | undefined;
+    /**
+     * Route-group root layouts `init` could not choose between (`app/(a)/layout.tsx`, ...), set only
+     * when there is no top-level layout and no single group renders `/` (#1538).
+     */
+    nextLayoutCandidates?: readonly string[] | undefined;
+    /**
+     * The other route-group root layouts when one was chosen to mount into, that do not mount
+     * `<ReticleDev />` themselves: the routes under them render without it.
+     */
+    nextUnmountedLayouts?: readonly string[] | undefined;
     /** Where the dev-only connect component goes — never inside `pages/`, which routes on presence. */
     nextReticleDevPath?: string | undefined;
     /** What the mount file should import — a sibling for App Router, `../components/…` for Pages. */
@@ -277,10 +305,12 @@ export interface PlanInput {
     /** The generated `reticle.proxy.mjs`, when a previous run left one (idempotency). */
     angularProxySource?: string | null | undefined;
     /**
-     * The plain-HTML app's `index.html`, when it has one — so a re-run over a page that already
-     * carries the connect snippet reports it as done instead of "will NOT connect".
+     * The plain-HTML app's `index.html`, when it has one — patched on the first run, recognised on
+     * later runs, and left manual only when there is no page to write into.
      */
     htmlIndexSource?: string | null | undefined;
+    /** Current token module and .gitignore beside the HTML page, for idempotent token-file writes. */
+    htmlLocalSources?: Record<string, string | null> | undefined;
     /** CRA's bundled entry (src/index.tsx or .js) — where the connect import has to go. */
     craEntry?: {
         path: string;
@@ -306,6 +336,14 @@ export interface PlanInput {
      * see reticleConfigStep for the port that survived every re-run because of it.
      */
     reticleConfigSource?: string | null | undefined;
+    /**
+     * `--new-id`: the app's source files that quote the id being replaced. A hand-written
+     * `connect({ projectId: '…' })` still naming it sends this checkout's evidence to the original.
+     */
+    copiedIdSources?: readonly {
+        path: string;
+        source: string;
+    }[] | undefined;
     /** Current project-root CLAUDE.md content (for the idempotent agent-rule merge), or null/undefined. */
     claudeMdContent?: string | null | undefined;
     /** Current project-root AGENTS.md content (the cross-agent rule), or null/undefined. */
@@ -328,6 +366,12 @@ export interface PlanInput {
     hooks?: boolean | undefined;
     /** Current .claude/settings.json content, or null when absent (the hook is MERGED into it). */
     claudeSettingsContent?: string | null | undefined;
+    /** Install the prompt-capture hook into `.claude/settings.json`: Claude Code is used here. */
+    claudePromptHook?: boolean | undefined;
+    /** Every OTHER agent found here with a prompt hook, and its config as it is now. */
+    promptHooks?: readonly PromptHookTarget[] | undefined;
+    /** See `InitHost.hookBin`. */
+    hookBin?: string | undefined;
     /**
      * Absolute directory the AGENT runs in, when that is not the app's directory.
      *
@@ -342,12 +386,16 @@ export interface PlanInput {
      * that disagrees with the app's is worse than no root config, and only reading it can tell.
      */
     agentRootConfigSource?: string | null | undefined;
+    /** The agent root holds several apps, so its config would name one and mislead about the rest. */
+    agentRootSeveralApps?: boolean | undefined;
     options: {
         port: number | undefined;
         mcp: boolean;
         install: boolean;
         /** Stable project identity derived at init (package.json name + root). Baked into snippets/.reticle.json. */
         projectId?: string;
+        /** `--new-id`: the config on disk takes `projectId` above in place of the id it was copied with. */
+        newId?: boolean;
         /** The CLI's own version, pinned onto the SDK install so a stale registry cache cannot skew it. */
         sdkVersion?: string;
     };

package/dist/plan/plan-vite.js

@@ -194,6 +194,21 @@ function viteConfigSteps(input, detail, inject = true) {
     // plugin, and a file carrying ours alone would not boot the app.
     const plainVite = Framework.VITE === input.detection.framework;
     if (null === cfg) {
+        const candidates = input.viteConfigCandidates ?? [];
+        if (candidates.length > 0) {
+            const named = candidates.map((path) => `\`${path}\``).join(', ');
+            return [
+                {
+                    title: StepTitle.VITE_PLUGIN,
+                    target: candidates[0] ?? 'vite.config',
+                    status: StepStatus.MANUAL,
+                    detail: `Reticle could not safely patch the Vite config used by the dev server. ` +
+                        `Candidate config(s): ${named}. ` +
+                        `Add the Reticle plugin to the config passed to createServer().\n\n` +
+                        viteManual(port, input.detection.uiLibrary, inject, stampSource),
+                },
+            ];
+        }
         if (!plainVite) {
             return [
                 {

package/dist/plan/plan.d.ts

@@ -3,18 +3,9 @@
  * contents, produce an ordered list of steps — each marked apply / manual / already / skip. The
  * runner performs the `write` side-effects; this module decides *what* should happen.
  */
-import { Framework, UiLibrary } from '../detect/detect.js';
 import { type Plan, type PlanInput } from './plan-types.js';
 export { DEPS_TARGET, MCP_TARGET, StepStatus, type Step, type Plan, type PlanInput, } from './plan-types.js';
 import { RETICLE_CONFIG_FILE } from '../detect/existing-config.js';
 export { RETICLE_CONFIG_FILE };
-/**
- * The dev-dependencies `reticle init` installs — kit (or sensor) first, build plugin next.
- *
- * `uiLibrary` matters because the framework does not always name the renderer. The rule below was
- * already written for Nuxt, correctly, and applied only there: a Vue app on plain Vite is
- * `Framework.VITE` and a SvelteKit app renders Svelte, and both were being handed the React kit
- * right after `init` had detected the real UI library and said so on screen.
- */
-export declare function frameworkPackages(framework: Framework, uiLibrary?: UiLibrary): readonly string[];
+export { frameworkPackages } from './framework-adapter.js';
 export declare function buildPlan(input: PlanInput): Plan;