@nifrajs/cli 2.7.1 → 2.8.0

package/dist/mcp-http.js

@@ -1,6 +1,6 @@
 /**
  * The PUBLIC nifra docs MCP - Streamable-HTTP transport exposing the project-INDEPENDENT tools
- * (`nifra_docs`, `nifra_example`, `nifra_types`, `nifra_learn` + the `nifra_examples_app` MCP Apps widget)
+ * (`nifra_docs`, `nifra_example`, `nifra_types`, `nifra_learn` + the `nifra_gallery` MCP Apps widget)
  * so any remote AI agent can learn nifra without a local checkout. They read the bundled corpus
  * (llms-full.txt / examples.json / types.json shipped in this package) and ignore `cwd`, so they reuse the
  * exact definitions from {@link projectTools} - one source, no drift.
@@ -23,14 +23,14 @@ import { loadTypesCorpus } from "./types-search.js";
 export { examplesAppTool, examplesWidget } from "./mcp-app-tool.js";
 export { docsTools } from "./mcp-docs-tools.js";
 // Kept in lockstep with packages/cli/package.json by check:publish's version-consistency gate.
-const VERSION = "2.7.1";
+const VERSION = "2.8.0";
 const SERVER_INFO = { name: "nifra-docs", version: VERSION };
 // Derive the GET/health tool list from the tools actually served, so the line can never drift from them.
 const docsHealth = (tools) => `nifra docs MCP - POST JSON-RPC 2.0 here (methods: initialize, tools/list, tools/call). Tools: ${tools
     .map((tool) => tool.name)
     .join(", ")}.`;
 /** The project-independent tools, reading the package's bundled corpus from disk (CLI use): the text
- * docs tools plus the `nifra_examples_app` MCP Apps widget tool. */
+ * docs tools plus the `nifra_gallery` MCP Apps widget tool. */
 export function publicDocsTools() {
     return [
         ...docsTools(loadDocsCorpus, loadExamplesCorpus, loadTypesCorpus),
@@ -46,7 +46,7 @@ export function respondMcpHttp(request, tools, options = {}) {
     return respondMcpHttpCore(request, tools, SERVER_INFO, { health: docsHealth(tools), ...options });
 }
 /** The CLI HTTP handler: serves the disk-backed corpus tools + registers the examples widget's `ui://`
- * resource so MCP Apps hosts can render `nifra_examples_app`. (`nifra docs-mcp` / `bun run` this file.) */
+ * resource so MCP Apps hosts can render `nifra_gallery`. (`nifra docs-mcp` / `bun run` this file.) */
 export function handleMcpHttp(request) {
     return respondMcpHttp(request, publicDocsTools(), {
         features: {

package/dist/mcp-http.js.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-http.js","sourceRoot":"","sources":["../src/mcp-http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAuB,cAAc,IAAI,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC7F,OAAO,EAAgB,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAInD,qGAAqG;AACrG,0FAA0F;AAC1F,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAG/C,+FAA+F;AAC/F,MAAM,OAAO,GAAG,OAAO,CAAA;AACvB,MAAM,WAAW,GAAG,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;AAC5D,yGAAyG;AACzG,MAAM,UAAU,GAAG,CAAC,KAAgB,EAAU,EAAE,CAC9C,iGAAiG,KAAK;KACnG,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;KACxB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;AAElB;oEACoE;AACpE,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,GAAG,SAAS,CAAC,cAAc,EAAE,kBAAkB,EAAE,eAAe,CAAC;QACjE,eAAe,CAAC,kBAAkB,CAAC;KACpC,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAC5B,OAAgB,EAChB,KAAgB,EAChB,UAA0B,EAAE;IAE5B,OAAO,kBAAkB,CAAC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,CAAA;AACnG,CAAC;AAED;2GAC2G;AAC3G,MAAM,UAAU,aAAa,CAAC,OAAgB;IAC5C,OAAO,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE;QAChD,QAAQ,EAAE;YACR,SAAS,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC;YACpC,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE;YAC5B,YAAY,EACV,wMAAwM;SAC3M;KACF,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,eAAe;IACb,IAAI,EAAE,OAAO,GAAG,KAAK,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI;IACtE,KAAK,EAAE,aAAa;CACrB,CAAA"}
+{"version":3,"file":"mcp-http.js","sourceRoot":"","sources":["../src/mcp-http.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAuB,cAAc,IAAI,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAC7F,OAAO,EAAgB,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAInD,qGAAqG;AACrG,0FAA0F;AAC1F,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAG/C,+FAA+F;AAC/F,MAAM,OAAO,GAAG,OAAO,CAAA;AACvB,MAAM,WAAW,GAAG,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO,EAAE,CAAA;AAC5D,yGAAyG;AACzG,MAAM,UAAU,GAAG,CAAC,KAAgB,EAAU,EAAE,CAC9C,iGAAiG,KAAK;KACnG,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC;KACxB,IAAI,CAAC,IAAI,CAAC,GAAG,CAAA;AAElB;+DAC+D;AAC/D,MAAM,UAAU,eAAe;IAC7B,OAAO;QACL,GAAG,SAAS,CAAC,cAAc,EAAE,kBAAkB,EAAE,eAAe,CAAC;QACjE,eAAe,CAAC,kBAAkB,CAAC;KACpC,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAC5B,OAAgB,EAChB,KAAgB,EAChB,UAA0B,EAAE;IAE5B,OAAO,kBAAkB,CAAC,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,GAAG,OAAO,EAAE,CAAC,CAAA;AACnG,CAAC;AAED;sGACsG;AACtG,MAAM,UAAU,aAAa,CAAC,OAAgB;IAC5C,OAAO,cAAc,CAAC,OAAO,EAAE,eAAe,EAAE,EAAE;QAChD,QAAQ,EAAE;YACR,SAAS,EAAE,CAAC,cAAc,CAAC,QAAQ,CAAC;YACpC,EAAE,EAAE,EAAE,SAAS,EAAE,CAAC,OAAO,CAAC,EAAE;YAC5B,YAAY,EACV,wMAAwM;SAC3M;KACF,CAAC,CAAA;AACJ,CAAC;AAED;;;;;GAKG;AACH,eAAe;IACb,IAAI,EAAE,OAAO,GAAG,KAAK,WAAW,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI;IACtE,KAAK,EAAE,aAAa;CACrB,CAAA"}

package/docs/llms-full.txt

@@ -842,10 +842,11 @@ one stub per export, so the bodies - and every module they import, including you
 stay on the server. Both pipelines do this identically, and the Bun and Vite transforms are
 held to byte-identical output by a parity test.
 
-One pipeline cannot: `nifra dev --bun`. Bun's dev-server bundler accepts no plugins,
-so a `*.fn` module there would ship whole, secrets included. That command refuses to
-start on an app containing one rather than shipping it. `nifra build` and
-`nifra dev` (Vite) are unaffected.
+`nifra dev --bun` applies it too. Bun's dev-server bundler accepts plugins only
+through bunfig's `[serve.static]` channel, so that command generates a config
+under `.nifra/dev-bun/` carrying the same stub plugin and relaunches itself with
+`--config=` pointing at it - verified per launch, refusing to serve if the
+boundary cannot be proven active. Identical stubs across all three pipelines.
 
 ### It is a route, so assurance applies
 
@@ -3861,6 +3862,27 @@ One gap: **CSS Modules**. Bun's dev-server bundler has no
 refuses `--bun` for a CSS-Modules app rather than serving a broken client. Plain CSS
 and Tailwind work normally.
 
+**
+Server functions and `*.server` modules work under `--bun`
+**
+- and the plumbing is worth knowing. The client build strips them: a `*.fn` module
+is replaced with an RPC stub and a `*.server` module is emptied, so their bodies
+(DB handles, secrets, imports) never reach a browser. Bun's dev-server bundling accepts
+plugins only through `bunfig.toml` (`[serve.static] plugins`) - not
+programmatically, and a runtime `Bun.plugin` never reaches it (upstream ask:
+oven-sh/bun#36830). So `nifra dev --bun` generates a config under
+`.nifra/dev-bun/` carrying the _same_ production boundary plugins, merges
+your own bunfig's `[serve.static] plugins` and `preload` entries, and
+re-launches itself once with `--config=` pointing at it. Same stubs as
+`nifra build`, byte for byte - one implementation, three pipelines.
+
+Two pipelines, one contract: what keeps them honest is not hope but guards. Both loops serve
+`public/` through the same handler production uses, the build dedupes the UI
+framework to one physical copy on both paths, SSR verifies at render time that the renderer
+and your components share one core (naming both directories if not), and
+`nifra doctor` flags a stale workspace `dist` before it can shadow
+source. A divergence between the loops is treated as a bug, not a caveat.
+
 ```ts
 // doc-check: skip - fragment: routesDir/outDir/clientModule/createApp are your app's dev config.
 // dev.ts - Bun-native HMR, no Vite in the process

package/docs/types.json

@@ -958,6 +958,13 @@
     "package": "@nifrajs/web",
     "signature": "export interface BuildDiagnosticOptions {\n    readonly request?: {\n        readonly method: string;\n        readonly url: string;\n    };\n    /** Project root; frames outside it are treated as non-user. Defaults to `process.cwd()`. */\n    readonly root?: string;\n    /** Injectable source reader (tests pass a fake; production reads the filesystem). */\n    readonly read?: SourceReader;\n}"
   },
+  {
+    "name": "buildFailureDetail",
+    "kind": "function",
+    "package": "@nifrajs/web",
+    "signature": "export declare function buildFailureDetail(err: unknown): string;",
+    "doc": "/**\n * Format a client-build rejection for the guard's report. Bun.build rejects with an AggregateError\n * whose message is just \"Bundle failed\" - the actionable part (which file, which import) lives in\n * `.errors`. Surface it, or the guard reports a failure while hiding the reason.\n */"
+  },
   {
     "name": "buildManifest",
     "kind": "function",
@@ -4157,7 +4164,7 @@
     "kind": "function",
     "package": "@nifrajs/cli",
     "signature": "export declare function handleMcpHttp(request: Request): Promise<Response>;",
-    "doc": "/** The CLI HTTP handler: serves the disk-backed corpus tools + registers the examples widget's `ui://`\n * resource so MCP Apps hosts can render `nifra_examples_app`. (`nifra docs-mcp` / `bun run` this file.) */"
+    "doc": "/** The CLI HTTP handler: serves the disk-backed corpus tools + registers the examples widget's `ui://`\n * resource so MCP Apps hosts can render `nifra_gallery`. (`nifra docs-mcp` / `bun run` this file.) */"
   },
   {
     "name": "Handler",
@@ -7071,7 +7078,7 @@
     "kind": "function",
     "package": "@nifrajs/cli",
     "signature": "export declare function publicDocsTools(): McpTool[];",
-    "doc": "/** The project-independent tools, reading the package's bundled corpus from disk (CLI use): the text\n * docs tools plus the `nifra_examples_app` MCP Apps widget tool. */"
+    "doc": "/** The project-independent tools, reading the package's bundled corpus from disk (CLI use): the text\n * docs tools plus the `nifra_gallery` MCP Apps widget tool. */"
   },
   {
     "name": "publicEnvDefines",
@@ -10814,14 +10821,14 @@
     "name": "VERSION",
     "kind": "const",
     "package": "@nifrajs/core",
-    "signature": "export declare const VERSION: \"2.7.1\";",
+    "signature": "export declare const VERSION: \"2.8.0\";",
     "doc": "/**\n * Current package version. A hardcoded literal on purpose - core runs on the edge (no fs), so it can't\n * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and\n * `check:publish` asserts it equals `@nifrajs/core`'s package version.\n */"
   },
   {
     "name": "VERSION",
     "kind": "const",
     "package": "nifra",
-    "signature": "export declare const VERSION: \"2.7.1\";",
+    "signature": "export declare const VERSION: \"2.8.0\";",
     "doc": "/**\n * Current package version. A hardcoded literal on purpose - core runs on the edge (no fs), so it can't\n * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and\n * `check:publish` asserts it equals `@nifrajs/core`'s package version.\n */"
   },
   {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nifrajs/cli",
-  "version": "2.7.1",
+  "version": "2.8.0",
   "description": "The nifra CLI - zero-config dev/build/start for a nifra app (`nifra dev`, `nifra build`, `nifra start`).",
   "keywords": [
     "bun",
@@ -41,14 +41,14 @@
     "access": "public"
   },
   "dependencies": {
-    "@nifrajs/client": "2.7.1",
-    "@nifrajs/core": "2.7.1",
-    "@nifrajs/mcp": "2.7.1",
-    "@nifrajs/runner": "2.7.1",
-    "@nifrajs/schema": "2.7.1",
-    "@nifrajs/testing": "2.7.1",
-    "@nifrajs/web": "2.7.1",
-    "create-nifra": "2.7.1"
+    "@nifrajs/client": "2.8.0",
+    "@nifrajs/core": "2.8.0",
+    "@nifrajs/mcp": "2.8.0",
+    "@nifrajs/runner": "2.8.0",
+    "@nifrajs/schema": "2.8.0",
+    "@nifrajs/testing": "2.8.0",
+    "@nifrajs/web": "2.8.0",
+    "create-nifra": "2.8.0"
   },
   "repository": {
     "type": "git",

package/src/check.ts

@@ -511,9 +511,145 @@ interface SqlExpressionShape {
   readonly parameterizedTag: boolean
 }
 
+/** Module-scope `const` initializers by name - the one binding form the SQL scanner resolves. */
+type ModuleConsts = ReadonlyMap<string, TSApi.Expression>
+
+/** Collect the file's top-level `const NAME = <initializer>` declarations. Destructured names, `let`,
+ * `var`, and anything nested stay out on purpose: a module-scope `const` is the only form that
+ * provably cannot carry request data. */
+function moduleConstsOf(ts: TypeScriptApi, source: TSApi.SourceFile): ModuleConsts {
+  const map = new Map<string, TSApi.Expression>()
+  for (const statement of source.statements) {
+    if (!ts.isVariableStatement(statement)) continue
+    if ((statement.declarationList.flags & ts.NodeFlags.Const) === 0) continue
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name) && declaration.initializer !== undefined) {
+        map.set(declaration.name.text, declaration.initializer)
+      }
+    }
+  }
+  return map
+}
+
+/** Whether `name`, read at `at`, might be re-declared by anything between the read and module scope.
+ * Conservative on purpose: the OUTERMOST enclosing function/block subtree is scanned for ANY binding
+ * of the name (parameter, `var`/`let`/`const`, catch, local function, destructuring element) - so a
+ * hoisted `var` in a sibling block, or a binding in a branch that never runs, still refuses
+ * resolution. Over-refusal flags a safe line (the pre-feature behavior); under-refusal would resolve
+ * the wrong binding, which is why the cheap-and-broad scan wins over scope simulation. A use with no
+ * enclosing function or block reads module scope directly and cannot be shadowed. */
+function isShadowedAt(ts: TypeScriptApi, at: TSApi.Node, name: string): boolean {
+  let scope: TSApi.Node | undefined
+  for (let node: TSApi.Node | undefined = at.parent; node !== undefined; node = node.parent) {
+    if (ts.isSourceFile(node)) break
+    if (ts.isFunctionLike(node) || ts.isBlock(node)) scope = node
+  }
+  if (scope === undefined) return false
+  const bindsName = (binding: TSApi.BindingName): boolean =>
+    ts.isIdentifier(binding)
+      ? binding.text === name
+      : binding.elements.some(
+          (element) =>
+            !ts.isOmittedExpression(element) &&
+            (ts.isIdentifier(element.name) ? element.name.text === name : bindsName(element.name)),
+        )
+  let found = false
+  const scan = (node: TSApi.Node): void => {
+    if (found) return
+    if (
+      (ts.isVariableDeclaration(node) || ts.isParameter(node)) &&
+      bindsName(node.name as TSApi.BindingName)
+    ) {
+      found = true
+      return
+    }
+    if (ts.isFunctionDeclaration(node) && node.name?.text === name) {
+      found = true
+      return
+    }
+    ts.forEachChild(node, scan)
+  }
+  scan(scope)
+  return found
+}
+
+const CONST_RESOLUTION_DEPTH = 5
+
+/**
+ * Resolve an interpolated expression to compile-time text, or `undefined` when it can carry runtime
+ * data. Pure syntax, no type checker - the same honest limit the rule already documents. What
+ * resolves: string/number literals, no-substitution templates, templates whose every span resolves,
+ * ternaries with both branches resolvable (BOTH branch texts are returned, so a hostile keyword in
+ * either still feeds the keyword scan), `as`/`satisfies` wrappers, and a same-file module-scope
+ * `const` whose initializer resolves (recursively, depth-capped). Everything else - an imported
+ * name, `let`, a parameter, a call, a member access, a shadowed name - stays unresolved and the
+ * interpolation is flagged exactly as before.
+ */
+function resolveStaticSqlText(
+  ts: TypeScriptApi,
+  node: TSApi.Expression,
+  consts: ModuleConsts,
+  depth: number,
+): string | undefined {
+  if (depth > CONST_RESOLUTION_DEPTH) return undefined
+  if (ts.isParenthesizedExpression(node)) {
+    return resolveStaticSqlText(ts, node.expression, consts, depth)
+  }
+  if (ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) {
+    return resolveStaticSqlText(ts, node.expression, consts, depth)
+  }
+  if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return node.text
+  if (ts.isNumericLiteral(node)) return node.text
+  if (ts.isTemplateExpression(node)) {
+    let text = node.head.text
+    for (const span of node.templateSpans) {
+      const part = resolveStaticSqlText(ts, span.expression, consts, depth + 1)
+      if (part === undefined) return undefined
+      text += part + span.literal.text
+    }
+    return text
+  }
+  if (ts.isConditionalExpression(node)) {
+    const whenTrue = resolveStaticSqlText(ts, node.whenTrue, consts, depth + 1)
+    const whenFalse = resolveStaticSqlText(ts, node.whenFalse, consts, depth + 1)
+    if (whenTrue === undefined || whenFalse === undefined) return undefined
+    return `${whenTrue} ${whenFalse}`
+  }
+  if (ts.isIdentifier(node)) {
+    const initializer = consts.get(node.text)
+    if (initializer === undefined) return undefined
+    if (isShadowedAt(ts, node, node.text)) return undefined
+    return resolveStaticSqlText(ts, initializer, consts, depth + 1)
+  }
+  return undefined
+}
+
+/** A template's contribution to the shape: resolved span texts fold into `staticText` (so the
+ * keyword scan still sees what a `const` carries); any unresolvable span keeps it `dynamic`. */
+function templateShape(
+  ts: TypeScriptApi,
+  template: TSApi.TemplateExpression,
+  consts: ModuleConsts | undefined,
+): { staticText: string; dynamic: boolean } {
+  let staticText = template.head.text
+  let dynamic = false
+  for (const span of template.templateSpans) {
+    const resolved =
+      consts === undefined ? undefined : resolveStaticSqlText(ts, span.expression, consts, 0)
+    if (resolved === undefined) dynamic = true
+    else staticText += resolved
+    staticText += span.literal.text
+  }
+  return { staticText, dynamic }
+}
+
 /** Describe only the first argument's syntax; comments/strings elsewhere cannot influence the result. */
-function sqlExpressionShape(ts: TypeScriptApi, node: TSApi.Expression): SqlExpressionShape {
-  if (ts.isParenthesizedExpression(node)) return sqlExpressionShape(ts, node.expression)
+function sqlExpressionShape(
+  ts: TypeScriptApi,
+  node: TSApi.Expression,
+  consts?: ModuleConsts,
+): SqlExpressionShape {
+  if (ts.isParenthesizedExpression(node)) return sqlExpressionShape(ts, node.expression, consts)
   if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
     return {
       staticText: node.text,
@@ -529,9 +665,10 @@ function sqlExpressionShape(ts: TypeScriptApi, node: TSApi.Expression): SqlExpre
       (ts.isIdentifier(tag) && tag.text === "sql") ||
       (ts.isPropertyAccessExpression(tag) && tag.getText() === "Prisma.sql")
     const template = node.template
-    const staticText = ts.isTemplateExpression(template)
-      ? [template.head.text, ...template.templateSpans.map((span) => span.literal.text)].join("")
-      : template.text
+    const templated = ts.isTemplateExpression(template)
+      ? templateShape(ts, template, parameterizedTag ? undefined : consts)
+      : { staticText: template.text, dynamic: false }
+    const staticText = templated.staticText
     // Only the ecosystem's binding tags are trusted, by NAME - which is the honest limit of a scanner
     // that reads syntax and runs no type checker. `sql` is what postgres.js, drizzle, slonik and Bun's
     // own driver all call theirs, and `Prisma.sql` is Prisma's; taking those at their word is a
@@ -547,32 +684,53 @@ function sqlExpressionShape(ts: TypeScriptApi, node: TSApi.Expression): SqlExpre
     // is treated as plain interpolation.
     return {
       staticText,
-      dynamic: ts.isTemplateExpression(template) && !parameterizedTag,
+      dynamic: templated.dynamic && !parameterizedTag,
       concatenated: false,
       literal: !ts.isTemplateExpression(template),
       parameterizedTag,
     }
   }
   if (ts.isTemplateExpression(node)) {
+    const templated = templateShape(ts, node, consts)
     return {
-      staticText: [node.head.text, ...node.templateSpans.map((span) => span.literal.text)].join(""),
-      dynamic: true,
+      staticText: templated.staticText,
+      dynamic: templated.dynamic,
       concatenated: false,
       literal: false,
       parameterizedTag: false,
     }
   }
   if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.PlusToken) {
-    const left = sqlExpressionShape(ts, node.left)
-    const right = sqlExpressionShape(ts, node.right)
+    const left = sqlExpressionShape(ts, node.left, consts)
+    const right = sqlExpressionShape(ts, node.right, consts)
     return {
       staticText: left.staticText + right.staticText,
-      dynamic: left.dynamic || right.dynamic || !left.literal || !right.literal,
+      // A resolved const operand is static text, not a dynamic part - so the old `!literal` test
+      // narrows to what it always actually meant: an operand that carries runtime data (dynamic) or
+      // a binding tag being concatenated into plain text (which un-parameterizes it).
+      dynamic: left.dynamic || right.dynamic || left.parameterizedTag || right.parameterizedTag,
       concatenated: true,
       literal: left.literal && right.literal,
       parameterizedTag: false,
     }
   }
+  // A resolvable expression (a module-`const` name, a literal ternary) contributes its compile-time
+  // text and stays non-dynamic - this is what lets `"SELECT " + COLS + " FROM t"` and
+  // `db.query(`${COLS} FROM t WHERE id = $1`)` pass while an imported or mutable name still flags.
+  // `literal` stays false: the named escape hatches (`unsafe`, `$queryRawUnsafe`) keep flagging a
+  // resolved const, because taking statement text from ANY variable is what their rule warns about.
+  if (consts !== undefined) {
+    const resolved = resolveStaticSqlText(ts, node, consts, 0)
+    if (resolved !== undefined) {
+      return {
+        staticText: resolved,
+        dynamic: false,
+        concatenated: false,
+        literal: false,
+        parameterizedTag: false,
+      }
+    }
+  }
   return {
     staticText: "",
     dynamic: true,
@@ -623,12 +781,16 @@ export function scanInterpolatedSql(
     source as TSApi.SourceFile & { readonly parseDiagnostics?: readonly TSApi.Diagnostic[] }
   ).parseDiagnostics
   if (parseDiagnostics !== undefined && parseDiagnostics.length > 0) return out
+  // Module-scope consts, resolved once per file: an interpolated same-file `const` cannot carry
+  // request data, so the shared-projection idiom (`const COLS = "id, name"` … `${COLS}`) stays quiet
+  // while imported, mutable, parameter, and shadowed names flag exactly as before.
+  const consts = moduleConstsOf(ts, source)
   const visit = (node: TSApi.Node): void => {
     if (ts.isCallExpression(node)) {
       const sink = sqlMethod(ts, node)
       const argument = node.arguments[0]
       if (sink !== undefined && argument !== undefined) {
-        const shape = sqlExpressionShape(ts, argument)
+        const shape = sqlExpressionShape(ts, argument, consts)
         const unsafeEscape =
           ALWAYS_UNSAFE.has(sink.method) && !shape.literal && !shape.parameterizedTag
         const assembledSql =

package/src/cli.ts

@@ -12,13 +12,7 @@
 import { existsSync } from "node:fs"
 import { resolve } from "node:path"
 import { inProcessClient } from "@nifrajs/client"
-import {
-  createWebApp,
-  DEFAULT_DEV_PORT,
-  type RenderAdapter,
-  SERVER_FN_MODULE,
-  SERVER_ONLY_MODULE,
-} from "@nifrajs/web"
+import { createWebApp, DEFAULT_DEV_PORT, type RenderAdapter } from "@nifrajs/web"
 import { discoverRoutes } from "@nifrajs/web/fs"
 import type { BunPlugin } from "bun"
 import { describeProject, describeRoutes } from "./introspect.ts"
@@ -154,7 +148,7 @@ Port: \`dev\` and \`start\` share the default ${DEFAULT_DEV_PORT}. Override with
 \`PORT\` env var (\`--port\` wins over \`PORT\`, which wins over the default).`
 
 // Kept in lockstep with packages/cli/package.json by check:publish's version-consistency gate.
-const CLI_VERSION = "2.7.1"
+const CLI_VERSION = "2.8.0"
 
 // A render adapter + nifra server are opaque to the CLI (it just forwards them); cast at the seam.
 const asAdapter = (v: unknown): RenderAdapter => v as RenderAdapter
@@ -210,6 +204,15 @@ export function formatCliError(err: unknown): string {
  * an app without CSS Modules still gets the Bun dev loop.
  */
 export async function assertBunDevSupportsApp(app: LoadedApp): Promise<void> {
+  // Server functions and `*.server` modules are handled: the generated bunfig (dev-bun-config.ts)
+  // delivers the SAME serverFnStubPlugin/serverOnlyEmptyPlugin the production build uses to Bun's
+  // dev-server bundler via `[serve.static] plugins` - the one channel that bundler accepts plugins
+  // through (a runtime `Bun.plugin` never reaches it; programmatic ask: oven-sh/bun#36830). The old
+  // fail-closed refusal for those modules is gone because the leak it guarded is gone.
+  //
+  // CSS Modules remain gated: the `*.module.css` plugin rests on an `onResolve` virtual-module
+  // stylesheet emitter that is not yet verified under `[serve.static]`, and its failure mode is a
+  // broken client rather than a leak - refuse loudly until it is proven there.
   const { Glob } = await import("bun")
   const offenders: string[] = []
   for await (const file of new Glob("**/*.module.css").scan({ cwd: app.cwd, dot: false })) {
@@ -217,58 +220,6 @@ export async function assertBunDevSupportsApp(app: LoadedApp): Promise<void> {
     offenders.push(file)
     if (offenders.length >= 5) break
   }
-  // Server functions are the same trade with a worse consequence. The client build replaces a `*.fn`
-  // module with stubs so its body never reaches a browser; Bun's dev-server bundler takes no plugins, so
-  // there it would be bundled WHOLE - the function bodies and every secret they import. Measured, not
-  // assumed: a runtime `Bun.plugin` onLoad does not reach `HTMLBundle`, so the module ships raw.
-  //
-  // `*.server` modules are the same trade again: the client build EMPTIES them, and with no plugins
-  // here they ship whole.
-  //
-  // Both are matched with the SAME regexes the transforms use, imported rather than re-encoded. A
-  // hand-written glob here is how these two gates drifted from the pipelines they guard: the old
-  // `**/*.fn.{ts,tsx,js,jsx}` missed `.fn.mts`, `.fn.cts`, `.fn.mjs` and `.fn.cjs`, every one of which
-  // both build pipelines stub - so a module the framework calls a server function was waved straight
-  // into the browser by the check that exists to stop exactly that. A gate written in a second dialect
-  // is a gate that eventually disagrees with the thing it guards.
-  const leaking: string[] = []
-  const serverOnly: string[] = []
-  for await (const file of new Glob("**/*.{server,fn,ts,tsx,js,jsx,mts,cts,mjs,cjs}").scan({
-    cwd: app.cwd,
-    dot: false,
-  })) {
-    if (/(^|\/)(node_modules|dist|\.nifra|\.git)\//.test(file)) continue
-    // Strip the source extension once so the conventions' regexes see `src/todos.fn` / `src/db.server`,
-    // which is the shape they match. The glob also includes the extensionless `.fn` / `.server` forms;
-    // those already have the matcher-ready shape and pass through unchanged.
-    const stem = file.replace(/\.[cm]?[jt]sx?$/, "")
-    if (SERVER_FN_MODULE.test(stem)) {
-      if (leaking.length < 5) leaking.push(file)
-    } else if (SERVER_ONLY_MODULE.test(stem)) {
-      if (serverOnly.length < 5) serverOnly.push(file)
-    }
-    if (leaking.length >= 5 && serverOnly.length >= 5) break
-  }
-  if (serverOnly.length > 0) {
-    throw new Error(
-      "[nifra] `nifra dev --bun` can't empty `*.server` modules: Bun's DEV-server bundler takes no " +
-        "plugins, so a server-only module would be bundled WHOLE into the browser - along with whatever " +
-        "it imports and any secret it holds. `nifra build` and `nifra dev` (Vite) both replace it with " +
-        "an empty module, so only this pipeline is affected.\n" +
-        `  Server-only modules found: ${serverOnly.join(", ")}\n` +
-        "  Use `nifra dev` (the Vite pipeline), or reach these from a route/loader for the Bun dev loop.",
-    )
-  }
-  if (leaking.length > 0) {
-    throw new Error(
-      "[nifra] `nifra dev --bun` can't transform server functions: Bun's DEV-server bundler takes no " +
-        "plugins, so a `*.fn` module would be bundled WHOLE into the browser - its function bodies and " +
-        "anything they import, secrets included. `nifra build` and `nifra dev` (Vite) both replace it " +
-        "with client stubs, so only this pipeline is affected.\n" +
-        `  Server-function modules found: ${leaking.join(", ")}\n` +
-        "  Use `nifra dev` (the Vite pipeline), or move these calls behind a route for the Bun dev loop.",
-    )
-  }
   if (offenders.length === 0) return
   throw new Error(
     "[nifra] `nifra dev --bun` can't compile CSS Modules: Bun's DEV-server bundler has no `*.module.css` " +
@@ -285,6 +236,42 @@ async function dev(app: LoadedApp, flags: Flags): Promise<void> {
   // each pipeline is selectable in BOTH phases, and neither ever runs inside the other.
   if (flags.bun) {
     await assertBunDevSupportsApp(app)
+    // Bun's dev-server bundler takes plugins only via bunfig `[serve.static]`, read at process
+    // start - so the boundary plugins (server-fn stubs, server-only emptying) are delivered by
+    // generating a config and re-execing this same command once with `--config=`. The child proves
+    // it IS the configured child with a per-launch random token (matched against the file the
+    // parent just wrote, consumed on first read). A fixed sentinel here would be a secret-leak
+    // switch: any inherited environment could set it, skip the generation, and serve the app with
+    // no boundary plugins at all. An unprovable token acts as a parent - fail closed.
+    const { consumeLaunchToken, writeBunDevConfig } = await import("./dev-bun-config.ts")
+    if (!consumeLaunchToken(app.cwd, process.env.NIFRA_BUN_DEV_TOKEN)) {
+      // Re-exec depth backstop: token verification makes recursion terminate (the direct child
+      // always verifies), so hitting this means filesystem/env sabotage - refuse over fork-looping.
+      const depth = Number(process.env.NIFRA_BUN_DEV_DEPTH ?? "0")
+      if (depth >= 3) {
+        throw new Error(
+          "[nifra] `nifra dev --bun` could not verify its generated dev config after several " +
+            "relaunches. Something is rewriting `.nifra/dev-bun/` or the environment between " +
+            "launches; refusing to serve without the client-boundary plugins.",
+        )
+      }
+      const { bunfigPath, launchToken } = await writeBunDevConfig(app.cwd)
+      const child = Bun.spawn(
+        [process.execPath, `--config=${bunfigPath}`, ...process.argv.slice(1)],
+        {
+          stdio: ["inherit", "inherit", "inherit"],
+          env: {
+            ...process.env,
+            NIFRA_BUN_DEV_TOKEN: launchToken,
+            NIFRA_BUN_DEV_DEPTH: String(depth + 1),
+          },
+        },
+      )
+      const forward = (): void => child.kill("SIGINT")
+      process.on("SIGINT", forward)
+      process.on("SIGTERM", forward)
+      process.exit(await child.exited)
+    }
     const { createDevServer } = await import("@nifrajs/web/dev")
     const { framework: fw, routesDir, outDir, backend } = app
     const server = await createDevServer({