@solidrt/cli 0.0.26 → 0.0.28

package/server/rebuild.ts

@@ -0,0 +1,54 @@
+import { command } from "flux:subprocess"
+import { state } from "./state"
+
+// Server-owned "rebuild and push": the single place the running app is rebuilt
+// from source on demand (an MCP reload). The srt repl still bundles in-process
+// for its own keystroke reloads, but both routes call the same bundle-cli, so
+// the bundling logic cannot drift. Making the server the rebuild authority is
+// the interim step toward folding the whole CLI into flux (see
+// okf/backlog/cli-flux-migration.md).
+
+// Build the reload message the same way srt's buildReload does, so a
+// server-triggered reload is indistinguishable from a repl-triggered one to
+// clients. proxyFiles/proxyHttp are message flags, not build inputs.
+function buildReload(code: string) {
+  let config = state.config
+  return { type: "reload", proxyFiles: config.proxyFiles, proxyHttp: config.proxyHttp, code }
+}
+
+// Rebuild from state.config.entry via the external bundle-cli subprocess, then
+// latch (for late-joining clients) and broadcast the reload to every connected
+// client. Resolves with an error message on failure (no entry configured, or a
+// build error), or null on success.
+export async function rebuildAndBroadcast(): Promise<string | null> {
+  let config = state.config
+  if (!config.entry) {
+    return "No app entry to rebuild. Start srt with a source file (srt run src/index.tsx)."
+  }
+
+  let params = JSON.stringify({
+    entry: config.entry,
+    devBase: state.serverUrl,
+    dev: true,
+    minify: config.minify,
+  })
+
+  let result = await command(config.bundlerCmd[0]!, [...config.bundlerCmd.slice(1), params]).output()
+  if (!result.success) {
+    let stderr = typeof result.stderr === "string" ? result.stderr : ""
+    return `Rebuild failed:\n${stderr.trim()}`
+  }
+
+  // bundle-cli writes one JSON object { code, map } to stdout.
+  let bundle: { code?: string; map?: string | null }
+  try {
+    bundle = JSON.parse(typeof result.stdout === "string" ? result.stdout : "")
+  } catch {
+    return "Rebuild failed: unreadable bundler output"
+  }
+  state.currentMap = bundle.map ?? null
+  let text = JSON.stringify(buildReload(bundle.code ?? ""))
+  state.currentReload = text
+  for (let ws of state.clients.keys()) ws.send(text)
+  return null
+}

package/server/remap.ts

@@ -0,0 +1,47 @@
+import { TraceMap, originalPositionFor } from "@jridgewell/trace-mapping"
+
+// Stack-trace remapping for forwarded client logs. The runtime evaluates the
+// bundle as module "main", so QuickJS frames cite bundle positions like
+// "at boom (main:212:9)". With the current reload's sourcemap latched on the
+// server (state.currentMap), those positions are rewritten to the original
+// .tsx sources before a log entry is buffered.
+
+// The parsed map is cached per map text; a reload swaps the text and the next
+// lookup rebuilds the tracer.
+let cachedText: string | null = null
+let tracer: TraceMap | null = null
+
+function tracerFor(map: string | null): TraceMap | null {
+  if (map !== cachedText) {
+    cachedText = map
+    tracer = null
+    if (map) {
+      try {
+        tracer = new TraceMap(JSON.parse(map))
+      } catch {
+        // A malformed map disables remapping until the next reload.
+      }
+    }
+  }
+  return tracer
+}
+
+/**
+ * Rewrite every "main:LINE:COL" (or "main:LINE") position in `text` to its
+ * original source position, e.g. "src/app.tsx:42:7". Positions the map has no
+ * entry for, and all text when `map` is null, pass through unchanged.
+ * QuickJS lines and columns are 1-based; sourcemap columns are 0-based.
+ */
+export function remapPositions(text: string, map: string | null): string {
+  if (!map || !text.includes("main:")) return text
+  let t = tracerFor(map)
+  if (!t) return text
+  return text.replace(/\bmain:(\d+)(?::(\d+))?\b/g, (frame, line, column) => {
+    let pos = originalPositionFor(t, {
+      line: parseInt(line, 10),
+      column: column ? Math.max(parseInt(column, 10) - 1, 0) : 0,
+    })
+    if (pos.source == null || pos.line == null) return frame
+    return `${pos.source}:${pos.line}:${(pos.column ?? 0) + 1}`
+  })
+}

package/server/state.ts

@@ -11,6 +11,15 @@ export type Config = {
   address: string
   proxyFiles: boolean
   proxyHttp: boolean
+  /** The app entry (absolute .tsx/.jsx path) the server rebuilds on an
+   * MCP-triggered reload, or undefined when srt was started without a source.
+   * Moved by the repl `load` command via /__internal__/reload. */
+  entry?: string
+  /** Minify the rebuild output, mirroring the srt --minify flag. */
+  minify: boolean
+  /** How the server invokes the external bundler: [bunPath, bundleCliPath],
+   * spawned with a JSON params argument appended (see rebuild.ts). */
+  bundlerCmd: string[]
   /** Enable the sqlite-backed proxy cache. */
   cache: boolean
   /** Directory holding .srt-cache.db. */
@@ -22,17 +31,31 @@ export type Config = {
   tunnel: boolean
 }
 
-export type ClientInfo = { platform: string; version: string; id: number; capabilities: string[] }
+export type ClientInfo = { platform: string; version: string; profile: string; id: number; capabilities: string[] }
 
 export let state = {
   config: undefined as unknown as Config,
   clients: new Map<ServerWebSocket, ClientInfo>(),
   nextClientId: 0,
+  /**
+   * Identity of this server run, included in control responses that carry
+   * cross-call state (client ids, log seq cursors). Both reset on restart, so
+   * a consumer that sees the generation change knows its ids and cursors are
+   * from a dead server and must be re-fetched.
+   */
+  generation: Date.now(),
   /**
    * The latched reload message (JSON text), replayed to late-joining clients.
    * Set by /__internal__/reload posts with `latch`, cleared by a broadcast stop.
    */
   currentReload: null as string | null,
+  /**
+   * The running bundle's sourcemap (JSON text, bundle -> .tsx sources), used
+   * to remap stack traces in forwarded client logs (see control.ts). Replaced
+   * on every reload; a reload without a map clears it so frames are never
+   * remapped against a stale map.
+   */
+  currentMap: null as string | null,
   sourceDir: "",
   serverUrl: "",
   stats: false,

package/src/args.ts

@@ -46,6 +46,9 @@ export function validateArgs() {
         usage("srt bundle [options] <entry.[tsx|jsx|ts|js|srt.js|srt.bin]>")
       }
       break
+    case "check":
+      if (!source || !isSource) usage("srt check <entry.[tsx|jsx|ts|js]>")
+      break
     case "render":
       if (!source || !isTsx) usage("srt render <entry.[tsx|jsx]>")
       break
@@ -74,6 +77,7 @@ Commands:
   server [file]          Start dev server only
   client                 Start solidrt-go client only
   bundle <file>          Transpile TS/JS/TSX/JSX to JS or bytecode
+  check <file>           Verify the app builds and typechecks, without writing anything
   render <file.tsx|jsx>  Replay a script (optional) and render frames for video generation
   pack <file>            Bundle + compile to a standalone executable (experimental)
   mcp                    MCP server (stdio) exposing the running dev server to coding agents

package/src/bundle-cli.ts

@@ -0,0 +1,12 @@
+// Standalone bundler entry, spawned by the dev server (a flux process) as a
+// Bun subprocess to rebuild the app on an MCP-triggered reload. flux cannot call
+// Bun.build, so the server shells out to this. Params arrive as one JSON
+// argument; one JSON object { code, map } goes to stdout and diagnostics to
+// stderr. On a build failure it exits non-zero with an empty stdout.
+
+import { bundleWith, type BundleOptions } from "./bundler"
+
+let params = JSON.parse(process.argv[2] ?? "{}") as BundleOptions
+let result = await bundleWith(params)
+if (!result) process.exit(1)
+process.stdout.write(JSON.stringify(result))

package/src/bundler.ts

@@ -1,6 +1,7 @@
 import { transformAsync } from "@babel/core"
 import jsx from "@babel/plugin-syntax-jsx"
 import ts from "@babel/preset-typescript"
+import remapping from "@jridgewell/remapping"
 import solid from "babel-preset-solid"
 import { type BunPlugin, type BuildArtifact } from "bun"
 import { readFileSync } from "node:fs"
@@ -53,7 +54,7 @@ function binaryImport({ types: t }: { types: any }) {
 // build, skipping emitted asset outputs. Bun's file loader emits binary assets
 // as extra outputs; the callers that flatten outputs into a single code string
 // must not glue those raw bytes onto the program.
-export async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
+async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string> {
   let code = ""
   for (let o of outputs) {
     if (o.kind === "entry-point" || o.kind === "chunk") code += await o.text()
@@ -62,61 +63,106 @@ export async function codeFromOutputs(outputs: BuildArtifact[]): Promise<string>
 }
 
 // Bun build plugin that runs JSX/TSX through babel-preset-solid (universal
-// generate, targeting @solidrt/core) plus the TS preset.
-function solidPlugin(): BunPlugin {
+// generate, targeting @solidrt/core) plus the TS preset. Plain .js/.ts app
+// modules take the same path (solid is a no-op without JSX) so binaryImport
+// can rewrite their `with { type: "binary" }` imports too; dependency code
+// (node_modules) skips the babel detour and keeps Bun's native loaders.
+// With `babelMaps`, each file's transform map (original -> babel output) is
+// collected there, keyed by absolute path, for sourcemap composition later.
+function solidPlugin(babelMaps?: Map<string, object>): BunPlugin {
   return {
     name: "bun-plugin-solid",
     setup: (build) => {
-      build.onLoad({ filter: /\.(js|ts)x$/ }, async (args) => {
+      build.onLoad({ filter: /\.(js|ts)x?$/ }, async (args) => {
+        if (!/\.(js|ts)x$/.test(args.path) && args.path.includes("node_modules")) return
         let file = Bun.file(args.path)
         let code = await file.text()
         let transforms = await transformAsync(code, {
           filename: args.path,
+          sourceMaps: !!babelMaps,
           presets: [[solid, { moduleName: "@solidrt/core", generate: "universal" }], [ts]],
           plugins: [jsx, binaryImport],
         })
+        if (babelMaps && transforms?.map) babelMaps.set(args.path, transforms.map)
         return { contents: transforms?.code ?? "", loader: "js" }
       })
     },
   }
 }
 
-export async function bundle(entry = source) {
-  let result = null
+export type BundleOptions = { entry: string; devBase?: string; dev: boolean; minify: boolean }
 
-  let devBase = state.serverUrl ?? undefined
-  let dev = !!devBase || values.dev
-  // Keep stdout clean when the bundle itself is written to stdout.
-  if (!values.stdout) print(`[cli] Bundling (${dev ? "development" : "production"})`)
+export type BundleResult = {
+  code: string
+  /** Composed sourcemap JSON (bundle -> original .tsx sources), dev builds only. */
+  map: string | null
+}
+
+// The pure bundle: every input is explicit, so it runs identically in the srt
+// (Bun) process and in the standalone bundle-cli subprocess the dev server
+// spawns. It never touches the ambient args/state singletons and never prints
+// progress (callers own that), so its stdout stays clean for subprocess use.
+export async function bundleWith(opts: BundleOptions): Promise<BundleResult | null> {
   let define: Record<string, string> = {
-    "process.env.NODE_ENV": dev ? "development" : "production",
+    "process.env.NODE_ENV": opts.dev ? "development" : "production",
   }
-  if (devBase) define.__SRT_DEV_BASE__ = devBase
+  if (opts.devBase) define.__SRT_DEV_BASE__ = opts.devBase
 
+  let babelMaps = opts.dev ? new Map<string, object>() : undefined
+  let result = null
   try {
     result = await Bun.build({
-      entrypoints: [entry!],
+      entrypoints: [opts.entry],
       target: "browser",
       format: "esm",
-      minify: values.minify,
+      minify: opts.minify,
       external: ["flux:*", "srt:*"],
       define,
       loader: { ".svg": "text" },
-      plugins: [solidPlugin()],
+      sourcemap: opts.dev ? "external" : "none",
+      plugins: [solidPlugin(babelMaps)],
     })
   } catch (e) {
     console.error("[cli] compile error:\n", e)
     return null
   }
 
-  if (result?.success) {
-    return result
+  if (!result.success) {
+    for (let msg of result.logs) console.error(msg)
+    return null
   }
 
-  if (result) {
-    for (let msg of result?.logs) console.error(msg)
-  }
-  return null
+  return { code: await codeFromOutputs(result.outputs), map: await composeMap(result.outputs, babelMaps) }
+}
+
+// Compose Bun's bundle map (babel output -> bundle) with the per-file Babel
+// maps (original source -> babel output) so positions point at the .tsx
+// sources. Bun ignores sourcemaps in plugin onLoad contents, so this second
+// hop has to happen here. Only a single-artifact build gets a map: code
+// splitting is off, and concatenated artifacts would invalidate offsets.
+async function composeMap(outputs: BuildArtifact[], babelMaps?: Map<string, object>): Promise<string | null> {
+  if (!babelMaps) return null
+  let js = outputs.filter((o) => o.kind === "entry-point" || o.kind === "chunk")
+  if (js.length !== 1 || !js[0]!.sourcemap) return null
+  let bunMap = JSON.parse(await js[0]!.sourcemap.text())
+  let composed = remapping(bunMap, (file: string) => {
+    // Bun writes cwd-relative source paths; the babel maps are keyed by the
+    // absolute path. Serve each map exactly once: remapping asks again for a
+    // served map's own original source, and that lookup must return null.
+    let abs = resolvePath(file)
+    let map = babelMaps.get(abs)
+    babelMaps.delete(abs)
+    return (map as any) ?? null
+  })
+  return composed.toString()
+}
+
+export async function bundle(entry = source) {
+  let devBase = state.serverUrl ?? undefined
+  let dev = !!devBase || values.dev
+  // Keep stdout clean when the bundle itself is written to stdout.
+  if (!values.stdout) print(`[cli] Bundling (${dev ? "development" : "production"})`)
+  return bundleWith({ entry: entry!, devBase, dev, minify: values.minify })
 }
 
 export async function bundleTo(outfile: string) {
@@ -125,7 +171,7 @@ export async function bundleTo(outfile: string) {
     console.error("Build failed")
     process.exit(1)
   }
-  await Bun.write(outfile, await codeFromOutputs(result.outputs))
+  await Bun.write(outfile, result.code)
   return result
 }
 
@@ -153,7 +199,7 @@ export async function bundleSolid(): Promise<string> {
     console.error("Build failed")
     process.exit(1)
   }
-  return codeFromOutputs(result.outputs)
+  return result.code
 }
 
 // Compile JS source to QuickJS bytecode via the fluxc binary.

package/src/commands/bundle.ts

@@ -1,5 +1,5 @@
 import { values, source, isPrebuilt } from "../args"
-import { bundle, bundleTo, bundleFlux, compileToBytecode, codeFromOutputs } from "../bundler"
+import { bundle, bundleTo, bundleFlux, compileToBytecode } from "../bundler"
 import { resolve } from "path"
 
 // Write to stdout and resolve only once the whole payload is flushed.
@@ -55,7 +55,7 @@ export async function runBundleCommand() {
       console.error("Build failed")
       process.exit(1)
     }
-    await writeStdout(await codeFromOutputs(result.outputs))
+    await writeStdout(result.code)
     process.exit()
   }
 
@@ -65,15 +65,12 @@ export async function runBundleCommand() {
       console.error("Build failed")
       process.exit(1)
     }
-    let jsCode = await codeFromOutputs(result.outputs)
-    await writeBytecode(jsCode, baseName + ".srt.bin")
+    await writeBytecode(result.code, baseName + ".srt.bin")
     process.exit()
   }
 
   let jsOutfile = baseName + ".srt.js"
   let result = await bundleTo(jsOutfile)
-  for (let output of result.outputs) {
-    console.log(`>> wrote ${output.size} bytes to ${jsOutfile}`)
-  }
+  console.log(`>> wrote ${result.code.length} bytes to ${jsOutfile}`)
   process.exit()
 }

package/src/commands/check.ts

@@ -0,0 +1,94 @@
+import { existsSync } from "node:fs"
+import { dirname, join, resolve } from "node:path"
+import { source } from "../args"
+import { bundleWith } from "../bundler"
+
+// srt check: verify the app without side effects. Bundles in memory (nothing
+// written, so no dev-server reload fires and no build outputs land in the
+// project) and typechecks with the project's own tsc, reporting only
+// diagnostics in app code. @solidrt packages ship raw .ts sources, so a strict
+// consumer config surfaces their internal errors too; those are counted and
+// hidden, not the caller's problem to wade through.
+
+// Walk up from the entry to the enclosing project (tsconfig.json or, failing
+// that, package.json).
+function findProjectRoot(entry: string): string | null {
+  let dir = dirname(resolve(entry))
+  let byConfig: string | null = null
+  let byPackage: string | null = null
+  while (true) {
+    if (!byConfig && existsSync(join(dir, "tsconfig.json"))) byConfig = dir
+    if (!byPackage && existsSync(join(dir, "package.json"))) byPackage = dir
+    let parent = dirname(dir)
+    if (parent === dir) return byConfig ?? byPackage
+    dir = parent
+  }
+}
+
+// One tsc --pretty false diagnostic: the "path(line,col): error TS...: ..."
+// head line plus any indented continuation lines.
+type Diagnostic = { head: string; lines: string[]; inDependencies: boolean }
+
+function parseDiagnostics(output: string): Diagnostic[] {
+  let diagnostics: Diagnostic[] = []
+  let current: Diagnostic | null = null
+  for (let line of output.split("\n")) {
+    let head = /^(.*?)\(\d+,\d+\): (error|warning) TS\d+: /.exec(line) ?? /^(error|warning) TS\d+: /.exec(line)
+    if (head) {
+      let file = line.includes("): ") ? head[1]! : ""
+      current = { head: line, lines: [line], inDependencies: file.includes("node_modules") }
+      diagnostics.push(current)
+    } else if (current && line.trim() !== "") {
+      current.lines.push(line)
+    }
+  }
+  return diagnostics
+}
+
+async function typecheck(root: string): Promise<{ app: Diagnostic[]; hidden: number } | null> {
+  let tsc = join(root, "node_modules", ".bin", process.platform === "win32" ? "tsc.exe" : "tsc")
+  if (!existsSync(tsc)) {
+    console.warn("Typecheck skipped: no tsc in the project (add the typescript devDependency)")
+    return null
+  }
+  let proc = Bun.spawn([tsc, "--noEmit", "--pretty", "false"], { cwd: root, stdout: "pipe", stderr: "pipe" })
+  let [out, err] = await Promise.all([new Response(proc.stdout).text(), new Response(proc.stderr).text()])
+  await proc.exited
+  let diagnostics = parseDiagnostics(out + err)
+  let app = diagnostics.filter((d) => !d.inDependencies)
+  return { app, hidden: diagnostics.length - app.length }
+}
+
+export async function runCheckCommand() {
+  let entry = source!
+  let failed = false
+
+  let result = await bundleWith({ entry, dev: true, minify: false })
+  if (!result) {
+    // bundleWith already printed the compile errors.
+    failed = true
+  }
+
+  let root = findProjectRoot(entry)
+  if (!root) {
+    console.warn("Typecheck skipped: no tsconfig.json or package.json above the entry")
+  } else {
+    let types = await typecheck(root)
+    if (types) {
+      for (let d of types.app) console.error(d.lines.join("\n"))
+      if (types.app.length > 0) {
+        failed = true
+        let hidden = types.hidden > 0 ? ` (${types.hidden} in dependencies hidden)` : ""
+        console.error(`${types.app.length} type error${types.app.length === 1 ? "" : "s"} in app code${hidden}`)
+      } else if (types.hidden > 0) {
+        console.log(`Types OK (${types.hidden} dependency-internal errors hidden)`)
+      } else {
+        console.log("Types OK")
+      }
+    }
+  }
+
+  if (failed) process.exit(1)
+  console.log("Check passed")
+  process.exit(0)
+}

package/src/commands/init.ts

@@ -29,23 +29,48 @@ function packageName(dir: string): string {
 }
 
 const DEFAULT_TEMPLATE = "default"
+const TEMPLATE_MANIFEST = "template.json"
+
+// Each template's template.json declares which level the scaffolded app is
+// written at: "core" (only @solidrt/core, no component framework) or
+// "components" (built with @solidrt/components). The level decides the
+// generated dependencies; the description labels the template in the picker.
+interface TemplateInfo {
+  name: string
+  level: "core" | "components"
+  description: string
+}
 
 // Templates are the directories under scaffold/templates/; each holds the files
-// that become the new project's src/. `default` sorts first as the starting
-// point, the rest alphabetically.
-async function listTemplates(): Promise<string[]> {
+// that become the new project's src/, plus a template.json manifest. `default`
+// sorts first as the starting point, the rest alphabetically.
+async function listTemplates(): Promise<TemplateInfo[]> {
   let entries = await readdir(TEMPLATES_DIR, { withFileTypes: true })
-  return entries
+  let names = entries
     .filter((e) => e.isDirectory())
     .map((e) => e.name)
     .sort((a, b) =>
       a === DEFAULT_TEMPLATE ? -1 : b === DEFAULT_TEMPLATE ? 1 : a.localeCompare(b),
     )
+  let templates: TemplateInfo[] = []
+  for (let name of names) {
+    // A missing manifest falls back to the components level: it keeps every
+    // dependency, so the scaffolded app works at either level.
+    let manifest = await readFile(join(TEMPLATES_DIR, name, TEMPLATE_MANIFEST), "utf8")
+      .then((raw) => JSON.parse(raw))
+      .catch(() => ({}))
+    templates.push({
+      name,
+      level: manifest.level === "core" ? "core" : "components",
+      description: typeof manifest.description === "string" ? manifest.description : "",
+    })
+  }
+  return templates
 }
 
 // Resolve which template to scaffold from: an explicit --template if valid, an
 // interactive picker on a TTY, else `default` (or the first available).
-async function resolveTemplate(): Promise<string> {
+async function resolveTemplate(): Promise<TemplateInfo> {
   let templates = await listTemplates()
   if (templates.length === 0) {
     console.error(`!! No templates found in ${TEMPLATES_DIR}`)
@@ -53,14 +78,25 @@ async function resolveTemplate(): Promise<string> {
   }
   let chosen = values.template
   if (chosen) {
-    if (!templates.includes(chosen)) {
-      console.error(`!! Unknown template "${chosen}"; choose from: ${templates.join(", ")}`)
+    let found = templates.find((t) => t.name === chosen)
+    if (!found) {
+      let names = templates.map((t) => t.name).join(", ")
+      console.error(`!! Unknown template "${chosen}"; choose from: ${names}`)
       process.exit(1)
     }
-    return chosen
+    return found
+  }
+  if (process.stdin.isTTY) {
+    let picked = await select(
+      "Select a template",
+      templates.map((t) => ({
+        label: t.description ? `${t.name} - ${t.description}` : t.name,
+        value: t.name,
+      })),
+    )
+    return templates.find((t) => t.name === picked)!
   }
-  if (process.stdin.isTTY) return select("Select a template", templates)
-  return templates.includes(DEFAULT_TEMPLATE) ? DEFAULT_TEMPLATE : templates[0]!
+  return templates.find((t) => t.name === DEFAULT_TEMPLATE) ?? templates[0]!
 }
 
 export async function runInitCommand() {
@@ -84,7 +120,7 @@ export async function runInitCommand() {
 
   let template = await resolveTemplate()
 
-  console.log(`>> Scaffolding SolidRT project in ${resolve(dir)} (${template})`)
+  console.log(`>> Scaffolding SolidRT project in ${resolve(dir)} (${template.name})`)
   for (let { from, to } of TEMPLATE_FILES) {
     let dest = join(dir, to)
     await mkdir(dirname(dest), { recursive: true })
@@ -93,19 +129,22 @@ export async function runInitCommand() {
   }
 
   // The chosen template's files become the project's src/. Entries may be
-  // nested directories (e.g. an asset folder), so copy recursively.
-  let templateDir = join(TEMPLATES_DIR, template)
+  // nested directories (e.g. an asset folder), so copy recursively. The
+  // manifest describes the template rather than belonging to the app.
+  let templateDir = join(TEMPLATES_DIR, template.name)
   await mkdir(join(dir, "src"), { recursive: true })
   for (let file of await readdir(templateDir)) {
+    if (file === TEMPLATE_MANIFEST) continue
     await cp(join(templateDir, file), join(dir, "src", file), { recursive: true })
     console.log(`   Write src/${file}`)
   }
 
   // The scaffold package.json carries a placeholder name; set it from the
-  // target folder.
+  // target folder. A core-level app gets no component framework dependency.
   let pkgPath = join(dir, "package.json")
   let pkg = JSON.parse(await readFile(pkgPath, "utf8"))
   pkg.name = packageName(dir)
+  if (template.level === "core") delete pkg.dependencies["@solidrt/components"]
   await writeFile(pkgPath, JSON.stringify(pkg, null, 2) + "\n")
 
   // Deps are declared in scaffold/package.json (Solid peers resolve via