@abide/abide 0.49.0 → 0.50.0

package/src/build.ts

@@ -1,37 +1,44 @@
 import { clientBuildPlugins } from './clientBuildPlugins.ts'
 import { abideLog } from './lib/shared/abideLog.ts'
 import { exitOnBuildFailure } from './lib/shared/exitOnBuildFailure.ts'
+import { generateDeclarations } from './lib/shared/generateDeclarations.ts'
 import { markFrameworkSourcesIgnored } from './lib/shared/markFrameworkSourcesIgnored.ts'
 
 const CLIENT_ENTRY = new URL('./clientEntry.ts', import.meta.url).pathname
 
 /*
-Builds the client-side bundle into `${cwd}/dist/_app`. Runs Bun.build with
-the abide-ui `.abide` loader, the virtual-module resolver, and (optionally)
-Tailwind. When `compress`, each emitted file is also
+Builds the client-side bundle into `${cwd}/dist` (see `appDir` below for the
+exact directory). Runs Bun.build with the abide-ui `.abide` loader, the
+virtual-module resolver, and (optionally) Tailwind. When `compress`, each emitted file is also
 written as a gzip-compressed `.gz` sibling (level 9 — paid once at build
 time) so the server can stream the precompressed bytes directly to any client
 that accepts gzip (effectively all), and decompress on the fly otherwise. Dev
 skips compression (compressing on every rebuild dwarfs the bundle itself) — the
 server falls back to serving the plain bytes when no `.gz` sibling exists.
 
-The bundle is emitted into a per-build staging dir, then swapped into
-`_app` with two atomic renames. This keeps every build's writes isolated to
-a unique path (so a stray concurrent build can never `rm` files Bun is
-mid-flushing — the "writing sourcemap: No such file or directory" race) and
-means a long-running dev server reading `_app` lazily off disk never sees a
-half-built or emptied directory.
+A production build (`clean`) emits into a per-build staging dir, then swaps it
+into the stable `_app` with two atomic renames. This keeps every build's writes
+isolated to a unique path (so a stray concurrent build can never `rm` files Bun
+is mid-flushing — the "writing sourcemap: No such file or directory" race) and
+means a reader never sees a half-built or emptied `_app`. `clean` also clears
+the whole dist up front so downstream writers — the bundle's connect screen, the
+CLI manifest — start fresh.
 
-`clean` (one-shot builds) clears the whole dist up front so downstream
-writers — the bundle's connect screen, the CLI manifest — start fresh; the
-dev orchestrator passes `clean: false` to leave the live dist untouched and
-only swap `_app` at the end.
+Dev (`clean: false`) instead emits each generation into its OWN
+`_app.gen-<id>` directory and never mutates it afterward. A dev worker serves
+from exactly the generation it was spawned on (via `ABIDE_APP_DIR`), so a rebuild
+gives the new worker a new dir while the retiring worker keeps reading its own —
+there is no shared mutable `_app`, hence no swap gap and no stale-hash 500s while
+a replaced worker drains (both bind the port via reusePort). The orchestrator
+prunes a generation dir once its worker has exited.
 
-Returns whether the build succeeded. Never throws: a thrown Bun.build / fs
-error is logged and treated as a failed build, so the dev loop (and its
-last-good server) survives instead of crashing and orphaning the child. By
-default a failure exits the process (one-shot `abide build` / `compile`);
-the dev orchestrator passes `exitOnFailure: false`.
+Returns `{ appDir }` — the directory the bundle now lives in (`_app` for a
+production build, the generation dir for dev) — on success, or `false` on
+failure. Never throws: a thrown Bun.build / fs error is logged and treated as a
+failed build, so the dev loop (and its last-good server) survives instead of
+crashing and orphaning the child. By default a failure exits the process
+(one-shot `abide build` / `compile`); the dev orchestrator passes
+`exitOnFailure: false`.
 */
 // @documentation building
 export async function build({
@@ -48,15 +55,19 @@ export async function build({
     clean?: boolean
     exitOnFailure?: boolean
     dev?: boolean
-} = {}): Promise<boolean> {
+} = {}): Promise<{ appDir: string } | false> {
     const distDir = `${cwd}/dist`
-    const outDir = `${distDir}/_app`
-    // Per-build staging + holding dirs; the suffix isolates concurrent builds.
+    // The suffix isolates concurrent/successive builds.
     const buildId = crypto.randomUUID().slice(0, 8)
-    const stagingDir = `${distDir}/_app.staging-${buildId}`
+    /* Production owns the stable `_app`; dev owns a fresh per-generation dir it never
+       rewrites (see the header — this is what removes the shared-mutable-`_app` race). */
+    const appDir = clean ? `${distDir}/_app` : `${distDir}/_app.gen-${buildId}`
+    /* Production stages then atomically swaps into `_app`. Dev builds straight into its
+       generation dir — nothing reads it until a worker is spawned pointing at it. */
+    const stagingDir = clean ? `${distDir}/_app.staging-${buildId}` : appDir
     const previousDir = `${distDir}/_app.old-${buildId}`
 
-    const fail = (): boolean => {
+    const fail = (): false => {
         if (exitOnFailure) {
             process.exit(1)
         }
@@ -74,27 +85,36 @@ export async function build({
             tailwindWarning: 'bun-plugin-tailwind not installed; building without Tailwind',
         })
 
-        const result = await Bun.build({
-            entrypoints: [CLIENT_ENTRY],
-            outdir: stagingDir,
-            target: 'browser',
-            splitting: true,
-            minify,
-            sourcemap: 'linked',
-            naming: {
-                entry: 'client-[hash].[ext]',
-                chunk: '[name]-[hash].[ext]',
-                asset: '[name].[ext]',
-            },
-            /* Build-time flag the client reads to fold away dev-only machinery: production
-               (`dev: false`) defines it false so the hot-reload subtree — mountChild's
-               record path, hotReplace, captureModelDoc — dead-code-eliminates instead of
-               shipping behind a runtime flag the minifier can't prove. Dev defines it true
-               to keep HMR. Under `bun test` no define applies; the source falls back to true
-               so `hotReloadEnabled` alone governs (see startClient/mountChild). */
-            define: { __ABIDE_DEV__: dev ? 'true' : 'false' },
-            plugins,
-        })
+        if (!dev) {
+            abideLog.info('building client bundle…')
+        }
+
+        /* generateDeclarations builds the rpc `ts.Program` ONCE per build (ADR-0025 D2's
+           alias-aware method detection) and writes every src/.abide/*.d.ts editor artifact. Run it
+           CONCURRENTLY with Bun.build so its program build hides under the bundle. The runtime
+           worker (dev worker / `abide start`) builds NO program at boot — only lazily on the first
+           rpc request for the wire codec — so all boot-time .d.ts generation is gone. It never
+           throws (editor types are non-critical), so it can't fail the build. */
+        const [result] = await Promise.all([
+            Bun.build({
+                entrypoints: [CLIENT_ENTRY],
+                outdir: stagingDir,
+                target: 'browser',
+                splitting: true,
+                minify,
+                sourcemap: 'linked',
+                /* The abideResolverPlugin's onEnd reachability guard (ADR-0022 D3) reads this to
+                   classify surviving modules post-DCE and reject any server-only code that leaked. */
+                metafile: true,
+                naming: {
+                    entry: 'client-[hash].[ext]',
+                    chunk: '[name]-[hash].[ext]',
+                    asset: '[name].[ext]',
+                },
+                plugins,
+            }),
+            generateDeclarations({ cwd }),
+        ])
 
         if (!result.success) {
             await Bun.$`rm -rf ${stagingDir}`.quiet().nothrow()
@@ -135,29 +155,32 @@ export async function build({
             : 0
 
         /*
-        Swap staging into _app with two renames: move any existing _app aside,
-        then rename staging into place. The window where _app is absent is a
-        single rename, so a reader (the running dev server) never observes a
-        partial bundle. nothrow on the first move: no _app exists on the first
-        build or after `clean`.
+        Production swap: move any existing `_app` aside, then rename staging into
+        place. The window where `_app` is absent is a single rename, so a reader
+        never observes a partial bundle; nothrow on the first move since no `_app`
+        exists on a fresh (just-cleaned) dist. Dev skips this entirely — its bundle
+        was built straight into the generation dir, which no worker reads until the
+        orchestrator spawns one on it.
         */
-        await Bun.$`mv ${outDir} ${previousDir}`.quiet().nothrow()
-        await Bun.$`mv ${stagingDir} ${outDir}`.quiet()
-        await Bun.$`rm -rf ${previousDir}`.quiet().nothrow()
+        if (clean) {
+            await Bun.$`mv ${appDir} ${previousDir}`.quiet().nothrow()
+            await Bun.$`mv ${stagingDir} ${appDir}`.quiet()
+            await Bun.$`rm -rf ${previousDir}`.quiet().nothrow()
+        }
 
         if (compress) {
             abideLog.info(
-                `wrote ${result.outputs.length} files to ${outDir} (+${result.outputs.length} .gz, ${(compressedBytes / 1024).toFixed(1)} KiB total)`,
+                `wrote ${result.outputs.length} files to ${appDir} (+${result.outputs.length} .gz, ${(compressedBytes / 1024).toFixed(1)} KiB total)`,
             )
             // Per-file paths are noise at startup; surface them only under DEBUG=abide:build.
             const buildLog = abideLog.channel('abide:build')
             result.outputs.forEach((output) => {
-                buildLog(`  - ${output.path.replace(stagingDir, outDir)}`)
+                buildLog(`  - ${output.path.replace(stagingDir, appDir)}`)
             })
         } else {
-            abideLog.info(`wrote ${result.outputs.length} files to ${outDir}`)
+            abideLog.info(`wrote ${result.outputs.length} files to ${appDir}`)
         }
-        return true
+        return { appDir }
     } catch (error) {
         abideLog.error(error)
         await Bun.$`rm -rf ${stagingDir} ${previousDir}`.quiet().nothrow()

package/src/buildDisconnected.ts

@@ -51,8 +51,6 @@ export async function buildDisconnected({
         entrypoints: [ENTRY, CSS_ENTRY],
         target: 'browser',
         minify: true,
-        // Connect screen ships in production bundles only — fold dev-only machinery out.
-        define: { __ABIDE_DEV__: 'false' },
         plugins,
     })
 

package/src/checkAbide.ts

@@ -1,7 +1,8 @@
 import { resolve } from 'node:path'
 import ts from 'typescript'
 import { collectAbideDiagnostics } from './lib/ui/compile/collectAbideDiagnostics.ts'
-import { createShadowProgram } from './lib/ui/compile/createShadowProgram.ts'
+import { createShadowProgram, type ShadowProgram } from './lib/ui/compile/createShadowProgram.ts'
+import { interpolationClassifierForRoot } from './lib/ui/compile/interpolationClassifierForRoot.ts'
 import { nearestProjectRoot } from './lib/ui/compile/nearestProjectRoot.ts'
 import type { AbideDiagnostic } from './lib/ui/compile/types/AbideDiagnostic.ts'
 
@@ -58,8 +59,17 @@ function collectByProject(cwd: string): { diagnostics: AbideDiagnostic[]; checke
         const root = nearestProjectRoot(path, cwd)
         byProject.set(root, [...(byProject.get(root) ?? []), path])
     }
+    /* Per-root cache of the VERBATIM classifier program (ADR-0032). The type-check pass peek-wraps
+       async interpolations so they resolve to their settled value, but the classifier that decides
+       WHICH sub-expressions are async must read un-wrapped shadows — so it rides a separate verbatim
+       program, built (and reused) here per root. */
+    const classifierCache = new Map<string, ShadowProgram | undefined>()
     const diagnostics = [...byProject].flatMap(([root, paths]) =>
-        collectAbideDiagnostics(createShadowProgram(root, paths)),
+        collectAbideDiagnostics(
+            createShadowProgram(root, paths, (abidePath) =>
+                interpolationClassifierForRoot(classifierCache, root, abidePath),
+            ),
+        ),
     )
     const checked = [...byProject.values()].reduce((total, paths) => total + paths.length, 0)
     return { diagnostics, checked }

package/src/devEntry.ts

@@ -1,4 +1,4 @@
-import { watch } from 'node:fs'
+import { readdirSync, watch } from 'node:fs'
 import type { Subprocess } from 'bun'
 import { build } from './build.ts'
 import { DEFAULT_PORT } from './lib/server/runtime/DEFAULT_PORT.ts'
@@ -7,6 +7,7 @@ import { DEV_REBUILD_MESSAGE } from './lib/server/runtime/DEV_REBUILD_MESSAGE.ts
 import { findOpenPort } from './lib/server/runtime/findOpenPort.ts'
 import { abideLog } from './lib/shared/abideLog.ts'
 import { changeAffectsClient } from './lib/shared/changeAffectsClient.ts'
+import { DEV_REBUILD_PATH } from './lib/shared/DEV_REBUILD_PATH.ts'
 
 /*
 Dev orchestrator. Replaces `bun --watch` (which only watches the import graph,
@@ -27,6 +28,13 @@ loop we own end to end:
      live-reload channel; it reconnects straight onto the already-listening
      replacement and reloads itself.
 
+Each client build lands in its OWN `dist/_app.gen-<id>` directory (build.ts,
+`clean: false`) and the worker spawned for it is pinned to that dir via
+`ABIDE_APP_DIR`. So the incumbent keeps serving its generation's chunks off disk
+for the whole overlap while the replacement serves the new one — nothing is a
+shared mutable `_app`, so a draining worker can never 500 on chunks the new build
+would otherwise have deleted. A generation dir is pruned once its worker exits.
+
 Restarts are serialized (a build mid-flight queues the next) and the port is
 fixed so the browser tab stays valid across restarts. A failed build — or a
 replacement that dies or hangs while booting — keeps the last-good server
@@ -56,8 +64,9 @@ function isGenerated(filename: string): boolean {
     return filename.split(/[\\/]/).includes(GENERATED_DIR)
 }
 
-// clean:false leaves the live dist in place — each build swaps _app in atomically,
-// so the running server never serves a half-built or emptied bundle.
+// clean:false leaves the live dist in place — each build emits its own
+// `_app.gen-<id>` dir, so the running server never serves a half-built bundle and
+// a rebuild never mutates the dir an existing worker is reading.
 const buildOptions = {
     cwd,
     minify: false,
@@ -69,16 +78,55 @@ const buildOptions = {
 
 // The worker currently meant to be serving; undefined while crashed or replaced.
 let server: Subprocess | undefined
+// The `_app.gen-<id>` dir the active worker is pinned to — the bundle it serves and
+// the dir to prune once it (and no successor sharing it) is gone.
+let currentAppDir = `${cwd}/dist/_app`
 let shuttingDown = false
 // Worker exits since the last ready signal — bounds the crash-respawn loop.
 let exitsWithoutReady = 0
 
+/* Remove a spent generation dir. Guarded to a `_app.gen-*` path so a bug (or the
+   `${cwd}/dist/_app` fallback when the first build failed) can never `rm` the wrong
+   thing. Best-effort — a leftover is swept by pruneStaleBuildDirs next dev start. */
+async function pruneGenDir(dir: string): Promise<void> {
+    if (!dir.includes('/_app.gen-')) {
+        return
+    }
+    await Bun.$`rm -rf ${dir}`.quiet().nothrow()
+}
+
+/* Sweep generation/staging/old dirs left by a prior dev session that exited without
+   cleaning up (crash, kill -9). Runs once before the first build so dist doesn't
+   accumulate them across sessions. */
+function pruneStaleBuildDirs(): void {
+    const distDir = `${cwd}/dist`
+    let entries: string[]
+    try {
+        entries = readdirSync(distDir)
+    } catch {
+        return // no dist yet — nothing to sweep
+    }
+    for (const name of entries) {
+        if (/^_app\.(gen|staging|old)-/.test(name)) {
+            void Bun.$`rm -rf ${distDir}/${name}`.quiet().nothrow()
+        }
+    }
+}
+
 /*
-Spawn a server worker against the fixed dev port. `ready` resolves when the
-worker reports its listener is up and init() has run (DEV_READY_MESSAGE) — the
-cue that a replacement may retire its predecessor.
+Spawn a server worker against the fixed dev port, pinned to `appDir` (its build
+generation) via ABIDE_APP_DIR so its shell, preload manifest, and asset server all
+read that one dir for its whole life. `ready` resolves when the worker reports its
+listener is up and init() has run (DEV_READY_MESSAGE) — the cue that a replacement
+may retire its predecessor.
 */
-function spawnWorker(port: number): { proc: Subprocess; ready: Promise<void> } {
+function spawnWorker(
+    port: number,
+    appDir: string,
+    /* Only the first worker prints the diagnostic surface map (it eager-loads the
+       registry — off the reload hot path for every respawn, whose surface is identical). */
+    printSurface = false,
+): { proc: Subprocess; ready: Promise<void> } {
     const readiness = Promise.withResolvers<void>()
     const proc = Bun.spawn({
         cmd: ['bun', '--preload', PRELOAD, SERVER_ENTRY],
@@ -94,6 +142,8 @@ function spawnWorker(port: number): { proc: Subprocess; ready: Promise<void> } {
             PORT: String(port),
             ABIDE_DEV: '1',
             ABIDE_PARENT_PID: String(process.pid),
+            ABIDE_APP_DIR: appDir,
+            ABIDE_DEV_SURFACE: printSurface ? '1' : '0',
         },
         stdio: ['inherit', 'inherit', 'inherit'],
         // The child's POST /__abide/reload route signals a rebuild over IPC, so the
@@ -108,7 +158,7 @@ function spawnWorker(port: number): { proc: Subprocess; ready: Promise<void> } {
             }
         },
     })
-    respawnOnUnexpectedExit(proc, port)
+    respawnOnUnexpectedExit(proc, port, appDir)
     return { proc, ready: readiness.promise }
 }
 
@@ -118,7 +168,7 @@ shutdown — used to leave the port dead until a manual restart. Respawn it,
 giving up after MAX_EXITS_WITHOUT_READY exits in a row so a crash-on-boot
 doesn't spin; the next save retries through rebuild.
 */
-function respawnOnUnexpectedExit(proc: Subprocess, port: number): void {
+function respawnOnUnexpectedExit(proc: Subprocess, port: number, appDir: string): void {
     void proc.exited.then((exitCode) => {
         if (shuttingDown || server !== proc) {
             return
@@ -132,7 +182,8 @@ function respawnOnUnexpectedExit(proc: Subprocess, port: number): void {
             return
         }
         abideLog.warn(`server exited unexpectedly (code ${exitCode}) — restarting`)
-        server = spawnWorker(port).proc
+        // Respawn on the SAME generation dir — the bundle is fine, the process crashed.
+        server = spawnWorker(port, appDir).proc
     })
 }
 
@@ -145,16 +196,21 @@ async function stopWorker(proc: Subprocess): Promise<void> {
 }
 
 /*
-Zero-downtime swap. The replacement overlaps the incumbent — both bind the dev
-port via reusePort (see createServer) and the kernel keeps delivering
-connections to the incumbent until it stops — so the port answers throughout
-the new module graph's boot. Only a replacement that reports ready retires the
-incumbent; one that dies or hangs booting is discarded and the last-good server
-keeps serving, mirroring how a failed build is handled.
+Zero-downtime swap onto `nextAppDir` (the new build's generation dir). The
+replacement overlaps the incumbent — both bind the dev port via reusePort (see
+createServer) and the kernel keeps delivering connections to the incumbent until it
+stops — so the port answers throughout the new module graph's boot, and each worker
+serves its own generation dir so the overlap never crosses chunk sets. Only a
+replacement that reports ready retires the incumbent; one that dies or hangs booting
+is discarded and the last-good server keeps serving, mirroring how a failed build is
+handled. A generation dir is pruned once no worker references it: the retired
+incumbent's dir after it exits, or the failed replacement's own dir if it never
+took over (unless a server-only restart reused the incumbent's dir — then it stays).
 */
-async function replaceServer(port: number): Promise<void> {
+async function replaceServer(port: number, nextAppDir: string): Promise<void> {
     const previous = server
-    const next = spawnWorker(port)
+    const previousAppDir = currentAppDir
+    const next = spawnWorker(port, nextAppDir)
     const outcome = await Promise.race([
         next.ready.then(() => 'ready' as const),
         next.proc.exited.then(() => 'exited' as const),
@@ -165,11 +221,22 @@ async function replaceServer(port: number): Promise<void> {
             await stopWorker(next.proc)
         }
         abideLog.warn('new server failed to boot — the previous one (if any) keeps serving')
+        // The replacement never served; its fresh generation dir is orphaned. Prune it,
+        // unless a server-only restart reused the still-serving incumbent's dir.
+        if (nextAppDir !== previousAppDir) {
+            await pruneGenDir(nextAppDir)
+        }
         return
     }
     server = next.proc
+    currentAppDir = nextAppDir
     if (previous) {
         await stopWorker(previous)
+        // The incumbent is gone; retire its generation dir — unless the replacement is
+        // serving that same dir (a server-only restart with no client rebuild).
+        if (previousAppDir !== nextAppDir) {
+            await pruneGenDir(previousAppDir)
+        }
     }
 }
 
@@ -200,17 +267,20 @@ async function rebuild(port: number, skipClientBuild = false): Promise<void> {
     }
     building = true
     try {
-        const succeeded = skipClientBuild ? true : await build(buildOptions)
-        if (succeeded) {
-            await replaceServer(port)
+        /* A server/MCP-only change keeps the existing client bundle, so the replacement
+           worker reuses the incumbent's generation dir; a client rebuild produces a fresh
+           one. Either way the swap needs the dir the new worker should serve. */
+        const built = skipClientBuild ? { appDir: currentAppDir } : await build(buildOptions)
+        if (built) {
+            await replaceServer(port, built.appDir)
         }
         /* A server/MCP-only change reuses the existing client bundle. That's correct for
-           an rpc/socket handler BODY edit, but changing an rpc's method, its export name,
-           or `outbox: true` changes the client proxy stub too — the stale bundle then
-           calls with the old shape (e.g. a 405). Flag the skip so that case isn't silent. */
+           an rpc/socket handler BODY edit, but changing an rpc's method or its export name
+           changes the client proxy stub too — the stale bundle then calls with the old shape
+           (e.g. a 405). Flag the skip so that case isn't silent. */
         if (skipClientBuild) {
             abideLog.info(
-                'server-only change — kept the existing client bundle; if you changed an rpc method, export name, or outbox, save a client file (or restart dev) for a full rebuild',
+                'server-only change — kept the existing client bundle; if you changed an rpc method or export name, save a client file (or restart dev) for a full rebuild',
             )
         }
     } finally {
@@ -231,11 +301,23 @@ on the same predictable 3000+ address as `bun start`; reusing the number across
 restarts (not re-scanning) is what keeps the tab valid.
 */
 const port = findOpenPort(DEFAULT_PORT)
+// Sweep generation dirs a prior session may have left behind before building afresh.
+pruneStaleBuildDirs()
+/* Announce the boot before the first build. build() stays silent under dev (its
+   "building…" log is gated so watch rebuilds don't spam), so without this line the
+   terminal shows nothing for the whole initial build — a cold boot reads as a hang.
+   One line up front: the server is alive, building, and where it will land. */
+abideLog.info(`starting dev server at http://localhost:${port} — building client…`)
 const firstBuild = await build(buildOptions)
-if (!firstBuild) {
+if (firstBuild) {
+    currentAppDir = firstBuild.appDir
+} else {
+    // Leave currentAppDir at the `${cwd}/dist/_app` fallback; the worker will serve
+    // broken assets until a save produces a real generation, matching prior behaviour.
     abideLog.warn('initial build failed — fix the error and save to retry')
 }
-server = spawnWorker(port).proc
+// The initial worker prints the surface map once (printSurface); respawns don't.
+server = spawnWorker(port, currentAppDir, true).proc
 
 /*
 ABIDE_DEV_NO_WATCH=1 skips the fs watcher: rebuild only on demand via POST
@@ -268,7 +350,7 @@ const watcher = manualRebuild
       })
 if (manualRebuild) {
     abideLog.info(
-        `manual rebuild mode — POST http://localhost:${port}/__abide/reload to apply changes`,
+        `manual rebuild mode — POST http://localhost:${port}${DEV_REBUILD_PATH} to apply changes`,
     )
 }
 
@@ -279,6 +361,9 @@ const shutdown = async () => {
     if (server) {
         await stopWorker(server)
     }
+    // Drop the active generation dir on the way out; any other leftover is swept on the
+    // next dev start by pruneStaleBuildDirs.
+    await pruneGenDir(currentAppDir)
     process.exit(0)
 }
 process.on('SIGINT', shutdown)

package/src/discoveryEntry.ts

@@ -3,6 +3,7 @@ import { rpc } from './_virtual/rpc.ts'
 // @ts-expect-error virtual module resolved by abideResolverPlugin
 import { sockets } from './_virtual/sockets.ts'
 import type { CliManifestEntry } from './lib/cli/types/CliManifestEntry.ts'
+import { resolveInputJsonSchema } from './lib/server/rpc/resolveRpcJsonSchema.ts'
 import { rpcRegistry } from './lib/server/rpc/rpcRegistry.ts'
 import { socketOperations } from './lib/server/sockets/socketOperations.ts'
 import { socketRegistry } from './lib/server/sockets/socketRegistry.ts'
@@ -24,13 +25,13 @@ await Promise.all([
 const manifest: Record<string, CliManifestEntry> = {}
 
 for (const entry of rpcRegistry.values()) {
-    if (!entry.clients.cli) {
+    if (!entry.remote.clients.cli) {
         continue
     }
     manifest[commandNameForUrl(entry.remote.url)] = {
         method: entry.remote.method,
         url: entry.remote.url,
-        jsonSchema: jsonSchemaForSchema(entry.inputSchema),
+        jsonSchema: resolveInputJsonSchema(entry) ?? jsonSchemaForSchema(undefined),
     }
 }