@barefootjs/jsx 0.28.0 → 0.29.0

package/dist/ir-to-client-js/control-flow/stringify/composite-loop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"composite-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/composite-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAOH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAuGrF"}
+{"version":3,"file":"composite-loop.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/composite-loop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAOH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AAEzD,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,iBAAiB,GAAG,IAAI,CA2GrF"}

package/dist/ir-to-client-js/control-flow/stringify/template-parse.d.ts

@@ -125,6 +125,20 @@ export declare function emitLoopItemElementSetup(lines: string[], opts: {
     indent: string;
     /** Single-root layout: 'inline' (plain / branch-plain) or 'multiline' (composite). */
     singleRootLayout: 'inline' | 'multiline';
+    /**
+     * Emit `mountRowRoot(__el)` on the FRESH branch, connecting the row at the
+     * mount point `mapArray` handed down before the body's tail runs.
+     *
+     * Only bodies that initialise something inside the row need it — the tail
+     * is where `useContext` would otherwise resolve against a detached element
+     * and fall through to the global last-writer-wins store. A row with no
+     * nested init has nothing to resolve, so plain loops leave this off and
+     * their emission (and the `mapArrayLazy` measurements) are untouched.
+     *
+     * Never on the hydration branch: that row came from SSR markup and is in
+     * the document already.
+     */
+    mountRow?: boolean;
 }): void;
 /**
  * Multi-root template clone for loop bodies that emit a JSX Fragment with

package/dist/ir-to-client-js/control-flow/stringify/template-parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-parse.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/template-parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkBH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAsB3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAIvE;AAkDD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAKvH;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAIjF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAajF;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,EAAE,OAAO,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,sFAAsF;IACtF,gBAAgB,EAAE,QAAQ,GAAG,WAAW,CAAA;CACzC,GACA,IAAI,CAuBN;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,MAAM,EAAE,CAeV"}
+{"version":3,"file":"template-parse.d.ts","sourceRoot":"","sources":["../../../../src/ir-to-client-js/control-flow/stringify/template-parse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAkBH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAsB3D;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,6BAA6B,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAIvE;AAkDD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAKhE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAKvH;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,GAAG,MAAM,CAIjF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAajF;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,EAAE;IACJ,QAAQ,EAAE,MAAM,CAAA;IAChB,eAAe,EAAE,OAAO,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,sFAAsF;IACtF,gBAAgB,EAAE,QAAQ,GAAG,WAAW,CAAA;IACxC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GACA,IAAI,CA4BN;AAED;;;;;;;;;GASG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,GAChB,MAAM,EAAE,CAeV"}

package/dist/ir-to-client-js/imports.d.ts

@@ -2,9 +2,9 @@
  * Import detection and DOM import management.
  */
 import type { ComponentIR } from '../types.ts';
-export declare const RUNTIME_IMPORT_CANDIDATES: readonly ['createSignal', 'createMemo', 'createEffect', 'onCleanup', 'onMount', 'hydrate', 'insert', 'getLoopChildren', 'getLoopNodes', 'mapArray', 'mapArrayAnchored', 'mapArrayLazy', 'patchLeaf', 'createDisposableEffect', 'createComponent', 'renderChild', 'registerComponent', 'registerTemplate', 'initChild', 'upsertChild', 'createPortal', 'provideContext', 'createContext', 'useContext', 'forwardProps', 'applyRestAttrs', 'splitProps', 'spreadAttrs', 'styleToCss', 'escapeAttr', 'escapeText', 'escapeTextOrNode', 'qsa', 'qsaItem', 'qsaChildScope', 'qsaChildScopes', 'upsertChildItem', '__slot', '__bfSlot', '__bfText', 'claimSlots', 'lazySlots', 'lazyClaimSlots', 'textOrNode', 'beginTurn', 'endTurn', 'date', 'formatDate'];
+export declare const RUNTIME_IMPORT_CANDIDATES: readonly ['createSignal', 'createMemo', 'createEffect', 'onCleanup', 'onMount', 'hydrate', 'insert', 'getLoopChildren', 'getLoopNodes', 'mapArray', 'mapArrayAnchored', 'mapArrayLazy', 'patchLeaf', 'createDisposableEffect', 'createComponent', 'renderChild', 'registerComponent', 'registerTemplate', 'initChild', 'upsertChild', 'mountRowRoot', 'createPortal', 'provideContext', 'createContext', 'useContext', 'forwardProps', 'applyRestAttrs', 'splitProps', 'spreadAttrs', 'styleToCss', 'escapeAttr', 'escapeText', 'escapeTextOrNode', 'qsa', 'qsaItem', 'qsaChildScope', 'qsaChildScopes', 'upsertChildItem', '__slot', '__bfSlot', '__bfText', 'claimSlots', 'lazySlots', 'lazyClaimSlots', 'textOrNode', 'beginTurn', 'endTurn', 'date', 'formatDate'];
 /** @deprecated Use RUNTIME_IMPORT_CANDIDATES */
-export declare const DOM_IMPORT_CANDIDATES: readonly ["createSignal", "createMemo", "createEffect", "onCleanup", "onMount", "hydrate", "insert", "getLoopChildren", "getLoopNodes", "mapArray", "mapArrayAnchored", "mapArrayLazy", "patchLeaf", "createDisposableEffect", "createComponent", "renderChild", "registerComponent", "registerTemplate", "initChild", "upsertChild", "createPortal", "provideContext", "createContext", "useContext", "forwardProps", "applyRestAttrs", "splitProps", "spreadAttrs", "styleToCss", "escapeAttr", "escapeText", "escapeTextOrNode", "qsa", "qsaItem", "qsaChildScope", "qsaChildScopes", "upsertChildItem", "__slot", "__bfSlot", "__bfText", "claimSlots", "lazySlots", "lazyClaimSlots", "textOrNode", "beginTurn", "endTurn", "date", "formatDate"];
+export declare const DOM_IMPORT_CANDIDATES: readonly ["createSignal", "createMemo", "createEffect", "onCleanup", "onMount", "hydrate", "insert", "getLoopChildren", "getLoopNodes", "mapArray", "mapArrayAnchored", "mapArrayLazy", "patchLeaf", "createDisposableEffect", "createComponent", "renderChild", "registerComponent", "registerTemplate", "initChild", "upsertChild", "mountRowRoot", "createPortal", "provideContext", "createContext", "useContext", "forwardProps", "applyRestAttrs", "splitProps", "spreadAttrs", "styleToCss", "escapeAttr", "escapeText", "escapeTextOrNode", "qsa", "qsaItem", "qsaChildScope", "qsaChildScopes", "upsertChildItem", "__slot", "__bfSlot", "__bfText", "claimSlots", "lazySlots", "lazyClaimSlots", "textOrNode", "beginTurn", "endTurn", "date", "formatDate"];
 export declare const RUNTIME_MODULE = "@barefootjs/client/runtime";
 export declare const IMPORT_PLACEHOLDER = "/* __BAREFOOTJS_DOM_IMPORTS__ */";
 export declare const MODULE_CONSTANTS_PLACEHOLDER = "/* __MODULE_LEVEL_CONSTANTS__ */";
@@ -17,6 +17,30 @@ export declare function detectUsedImports(code: string): Set<string>;
  * compiler-emitted /runtime subpath).
  */
 export declare function collectUserDomImports(ir: ComponentIR): string[];
+/**
+ * Build the "is this local name used as a value in the generated code?"
+ * test used to decide which imported specifiers survive into the client
+ * bundle. Prefers a real value-reference set over the historical
+ * `\bname\b` text scan (#2432: an object key or string literal that
+ * merely spells an imported name used to emit a phantom import). Falls
+ * back to a substring scan when the generated text cannot be parsed
+ * cleanly — a partial parse would under-report references and DROP a
+ * needed import. The reference set is computed at most once per call.
+ *
+ * The fallback is a plain `includes()`, not a `\bname\b` regex: `\b` is
+ * defined over `[A-Za-z0-9_]`, so a `$`-prefixed name (`$fetch`, as
+ * exported by `ofetch`) or a non-ASCII local both sit outside a word
+ * boundary and would never match — silently dropping the import, the one
+ * failure direction this helper must never take. Worse, splicing
+ * `localName` straight into `new RegExp(...)` treated `$` as the
+ * end-of-input anchor, so `\b$fetch\b` couldn't match `$fetch` at all.
+ * `includes()` is deliberately COARSER than a word-boundary scan (it
+ * matches `helper` inside `helperFoo` too) — that's fine here: the
+ * fallback's only job is "never under-report", and over-keeping an
+ * import whose binding already exists is harmless, while dropping one is
+ * fatal.
+ */
+export declare function makeValueUsageTest(generatedCode: string): (localName: string) => boolean;
 /**
  * Collect external (non-DOM, non-component) imports that are used in generated code.
  * These are third-party libraries like @barefootjs/form, zod, etc. that need to be

package/dist/ir-to-client-js/imports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/imports.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,aAAa,CAAA;AAItD,eAAO,MAAM,yBAAyB,YACpC,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EACpE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,wBAAwB,EAC7I,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,WAAW,EAAE,aAAa,EACrG,cAAc,EACd,gBAAgB,EAAE,eAAe,EAAE,YAAY,EAC/C,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAC3H,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAUxG,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAEzD,WAAW,EAAE,SAAS,EAItB,MAAM,EAIN,YAAY,CACJ,CAAA;AAEV,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,wtBAA4B,CAAA;AAE9D,eAAO,MAAM,cAAc,+BAA+B,CAAA;AAE1D,eAAO,MAAM,kBAAkB,qCAAqC,CAAA;AACpE,eAAO,MAAM,4BAA4B,qCAAqC,CAAA;AAE9E;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAqB3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,EAAE,CAiB/D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAmCvH"}
+{"version":3,"file":"imports.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/imports.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAU,MAAM,aAAa,CAAA;AAKtD,eAAO,MAAM,yBAAyB,YACpC,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EACpE,SAAS,EAAE,QAAQ,EAAE,iBAAiB,EAAE,cAAc,EAAE,UAAU,EAAE,kBAAkB,EAAE,cAAc,EAAE,WAAW,EAAE,wBAAwB,EAC7I,iBAAiB,EAAE,aAAa,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,WAAW,EAAE,aAAa,EAKrG,cAAc,EACd,cAAc,EACd,gBAAgB,EAAE,eAAe,EAAE,YAAY,EAC/C,cAAc,EAAE,gBAAgB,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAC3H,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAUxG,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAEzD,WAAW,EAAE,SAAS,EAItB,MAAM,EAIN,YAAY,CACJ,CAAA;AAEV,gDAAgD;AAChD,eAAO,MAAM,qBAAqB,wuBAA4B,CAAA;AAE9D,eAAO,MAAM,cAAc,+BAA+B,CAAA;AAE1D,eAAO,MAAM,kBAAkB,qCAAqC,CAAA;AACpE,eAAO,MAAM,4BAA4B,qCAAqC,CAAA;AAE9E;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,CAqB3D;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,WAAW,GAAG,MAAM,EAAE,CAoB/D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,kBAAkB,CAAC,aAAa,EAAE,MAAM,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAWxF;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,EAAE,mBAAmB,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAsCvH"}

package/dist/value-references.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Single door for "is this identifier a VALUE reference in emitted JS".
+ *
+ * Replaces `\bname\b` text scans at the import-emission sites (#2432): a
+ * regex scan can't tell a genuine value reference (`paperColor({ ... })`)
+ * from an object key or string literal that merely spells an imported
+ * name (`{ Theme: 'テーマ' }`). That false match used to make
+ * `collectExternalImports` re-emit a per-specifier type-only import
+ * (`import { paperColor, type Theme } from '../lib/theme'`) as a VALUE
+ * import, which the CLI's relative-import inliner then placed in the IIFE's
+ * `return { … }` with no binding — `ReferenceError: Theme is not defined`
+ * at load, killing the whole page's client JS.
+ *
+ * `packages/cli`'s `detectStrippedReferences` (in `resolve-imports.ts`)
+ * shares the same classifier for its own dangling-reference scan, so the
+ * two "is this a real use" checks in the pipeline can never drift apart.
+ */
+import ts from 'typescript';
+/**
+ * Identifier-position classifier: returns `true` when `id` is being USED
+ * as a value, `false` when it's a declaration name, property key, member-
+ * access name, or other non-reference slot.
+ *
+ * A ShorthandPropertyAssignment (`{ Theme }`) intentionally counts as a
+ * reference — it reads the binding, it doesn't just spell its name.
+ *
+ * CONTRACT: this classifies identifier positions in **JavaScript** source.
+ * Both current callers parse with `ts.ScriptKind.JS` —
+ * `collectValueReferencedNames` below, and `detectStrippedReferences` in
+ * `packages/cli/src/lib/resolve-imports.ts`, which parses the assembled
+ * bundle. TypeScript-only positions are deliberately NOT handled: an
+ * identifier in a type position (`const x: Foo = …`, a
+ * `TypeReferenceNode`) is still reported as a value reference, and so are
+ * `interface` / `type` / `enum` declaration names. Do not point this at
+ * TypeScript source — it would over-report there.
+ *
+ * Caveat: this is a syntactic test, not a scope analysis. If a local
+ * function parameter happens to share a name with an imported binding,
+ * references inside that function's body will count as references to
+ * the import (false positive). For the import-emission caller
+ * (`makeValueUsageTest` in `ir-to-client-js/imports.ts`), over-counting is
+ * the safe direction — an extra import whose binding exists is harmless.
+ * It is NOT safe for the BF053 caller (`detectStrippedReferences`): there,
+ * an over-reported reference to a stripped binding is a false build
+ * error on legal code. That asymmetry is why every exclusion branch below
+ * matters — each one is a case that would otherwise misfire BF053.
+ */
+export declare function isValueReferenceIdentifier(id: ts.Identifier): boolean;
+/**
+ * Parse `code` and collect the text of every identifier that is a VALUE
+ * reference per `isValueReferenceIdentifier`.
+ *
+ * Returns `null` when the text did not parse cleanly. `null` means
+ * "cannot answer" — callers MUST fall back to their previous (regex-scan)
+ * behaviour rather than treating it as an empty set. Narrowing on a
+ * partial parse would DROP a needed import, which is the failure
+ * direction we must never take (a phantom missing-import build failure
+ * is recoverable; a silently dead client bundle is not).
+ */
+export declare function collectValueReferencedNames(code: string): Set<string> | null;
+//# sourceMappingURL=value-references.d.ts.map

package/dist/value-references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value-references.d.ts","sourceRoot":"","sources":["../src/value-references.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,0BAA0B,CAAC,EAAE,EAAE,EAAE,CAAC,UAAU,GAAG,OAAO,CAyCrE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,IAAI,CA0B5E"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/jsx",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "JSX compiler for BarefootJS - transforms JSX to server HTML + client JS",
   "type": "module",
   "main": "./dist/index.js",
@@ -53,7 +53,7 @@
     "directory": "packages/jsx"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.28.0"
+    "@barefootjs/shared": "0.29.0"
   },
   "peerDependencies": {
     "@barefootjs/client": ">=0.2.0",

package/src/__tests__/ir-to-client-js/imports.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'bun:test'
-import { collectExternalImports } from '../../ir-to-client-js/imports'
+import { collectExternalImports, collectUserDomImports } from '../../ir-to-client-js/imports'
 import type { ComponentIR, ImportInfo, SourceLocation } from '../../types'
 
 const dummyLoc: SourceLocation = { file: 'test.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } }
@@ -229,4 +229,119 @@ describe('collectExternalImports', () => {
       "import { z } from 'zod'",
     ])
   })
+
+  // #2432: `collectExternalImports` used a `\bname\b` text scan to decide
+  // which specifiers survive into the client bundle. That scan never
+  // consulted the per-specifier `isTypeOnly` flag, so a per-specifier
+  // `import { paperColor, type Theme } from '../lib/theme'` re-emitted
+  // `Theme` as a VALUE import whenever the word "Theme" merely appeared in
+  // the generated code (e.g. as an object key) — the CLI's relative-import
+  // inliner then put `Theme` in the IIFE's `return { … }` with no binding,
+  // producing `ReferenceError: Theme is not defined` at load.
+  test('per-specifier type-only specifier is not emitted, while its value sibling is (#2432)', () => {
+    const ir: ReturnType<typeof makeIR> = makeIR([{
+      source: '../lib/theme',
+      specifiers: [
+        { name: 'paperColor', alias: null, isDefault: false, isNamespace: false },
+        { name: 'Theme', alias: null, isDefault: false, isNamespace: false, isTypeOnly: true },
+      ],
+      isTypeOnly: false,
+      loc: dummyLoc,
+    }])
+    const code = "const labels = { Theme: 'テーマ' };\nconst c = paperColor({ paper: '#fff' });"
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual(["import { paperColor } from '../lib/theme'"])
+  })
+
+  test('a value specifier that appears ONLY as an object key is not emitted (#2432)', () => {
+    const ir = makeIR([makeImport('./utils', ['helper'])])
+    const code = 'const o = { helper: 1 };'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual([])
+  })
+
+  test('a value specifier that appears ONLY inside a string literal is not emitted (#2432)', () => {
+    const ir = makeIR([makeImport('./utils', ['helper'])])
+    const code = "const s = 'helper is a function';"
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual([])
+  })
+
+  test('a value specifier that appears ONLY as a property-access name is not emitted (#2432)', () => {
+    const ir = makeIR([makeImport('./utils', ['helper'])])
+    const code = 'obj.helper();'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual([])
+  })
+
+  test('a value specifier used via shorthand property IS emitted (#2432)', () => {
+    const ir = makeIR([makeImport('./utils', ['helper'])])
+    const code = 'const o = { helper };'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual(["import { helper } from './utils'"])
+  })
+
+  test('unparseable generated text falls back to the text scan (#2432)', () => {
+    const ir = makeIR([makeImport('some-lib', ['helper'])])
+    const code = 'MyComponent helper()'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual(["import { helper } from 'some-lib'"])
+  })
+
+  // These two pin the fallback branch specifically (generated text that does
+  // NOT parse cleanly, so `makeValueUsageTest` falls back to a substring
+  // scan rather than the AST-based value-reference set). #2432: the
+  // fallback used to be a `new RegExp(`\\b${localName}\\b`)` scan, which
+  // silently DROPPED the import for either shape below — `\b` isn't defined
+  // for `$` or non-ASCII characters, and `$` is also a regex metacharacter
+  // (end-of-input anchor) when spliced unescaped into `new RegExp(...)`, so
+  // `\b$fetch\b` could never match `$fetch` at all. Dropping the import is
+  // the one failure direction this helper must never take.
+  test('fallback matches a $-prefixed specifier (#2432)', () => {
+    const ir = makeIR([makeImport('ofetch', ['$fetch'])])
+    const code = 'MyComponent $fetch()'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual(["import { $fetch } from 'ofetch'"])
+  })
+
+  test('fallback matches a non-ASCII specifier (#2432)', () => {
+    const ir = makeIR([makeImport('some-lib', ['日本語'])])
+    const code = 'MyComponent 日本語()'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual(["import { 日本語 } from 'some-lib'"])
+  })
+
+  // #2432 follow-up: a class field name is a member key, not a read — the
+  // same treatment as an object-literal key above.
+  test('a specifier that appears ONLY as a class field name is not emitted (#2432 follow-up)', () => {
+    const ir = makeIR([makeImport('./utils', ['helper'])])
+    const code = 'class Widget { helper = 1 }'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual([])
+  })
+
+  // #2432 follow-up: a COMPUTED class field name (`[helper]`) IS a read of
+  // the binding — pins that the class-field exclusion didn't over-exclude.
+  test('a specifier that appears as a COMPUTED class field name IS emitted (#2432 follow-up)', () => {
+    const ir = makeIR([makeImport('./utils', ['helper'])])
+    const code = 'class Widget { [helper] = 1 }'
+    const result = collectExternalImports(ir, code)
+    expect(result).toEqual(["import { helper } from './utils'"])
+  })
+})
+
+describe('collectUserDomImports', () => {
+  test('per-specifier type-only specifier is not emitted from the runtime subpath (#2432)', () => {
+    const ir = makeIR([{
+      source: '@barefootjs/client',
+      specifiers: [
+        { name: 'createSignal', alias: null, isDefault: false, isNamespace: false },
+        { name: 'Signal', alias: null, isDefault: false, isNamespace: false, isTypeOnly: true },
+      ],
+      isTypeOnly: false,
+      loc: dummyLoc,
+    }])
+    const result = collectUserDomImports(ir)
+    expect(result).toEqual(['createSignal'])
+  })
 })

package/src/__tests__/loop-row-creation-paths.test.ts

@@ -0,0 +1,169 @@
+/**
+ * Which code creates a loop row's root element, and whether that row is
+ * connected before its body's tail runs.
+ *
+ * The "connect before init" invariant exists because `useContext` resolves by
+ * walking `parentElement`: a child that initialises inside a detached row finds
+ * no ancestors and falls through to the global last-writer-wins context store,
+ * silently reading whichever provider on the page wrote last. So the creation
+ * site has to know its destination in advance, and there are two ways to tell
+ * it — a PLACEHOLDER already in the tree (`mountAt`, child slots), or the
+ * AMBIENT row mount point.
+ *
+ * Both work because a runtime FUNCTION creates the element and can take an
+ * argument. A row whose root is a template clone written inline in the emitted
+ * body has no such function, so the compiler emits `mountRowRoot(clone)` to
+ * consume the same ambient point — but only for the variant that initialises
+ * anything inside the row. A row with no nested init has nothing that could
+ * resolve wrongly, and skipping it there keeps the high-volume `mapArrayLazy`
+ * emission untouched.
+ *
+ * This matrix pins that split against compiled output rather than
+ * recollection. `mountsRow` is the load-bearing column: if it ever flips to
+ * false for a shape that initialises a child, that shape has silently gone
+ * back to initialising detached, and nothing else in the suite would say so —
+ * the wrong value it produces is only wrong when a second provider of the same
+ * context happens to be on the page.
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+interface RowShape {
+  /** How the row's root element comes into existence. */
+  rowRoot: 'createComponent' | 'template-clone'
+  /**
+   * Does a child inside the row reach its `init` through a placeholder slot
+   * (`upsertChild` / `upsertChildItem`)?
+   *
+   * Narrower than "something initialises in this row" — a conditional child
+   * arrives via `insert` + `initChild` and reads false here. Read it alongside
+   * `mountsRow`, never as a substitute.
+   *
+   * `initChild` on the row ROOT is deliberately excluded: that is the
+   * hydration branch adopting an SSR-rendered row, which is in the document by
+   * construction and never part of this problem.
+   */
+  nestedChildInit: boolean
+  /** Multi-root (Fragment) body — the sibling-walk lookup path. */
+  multiRoot: boolean
+  /** Is the fresh row connected before the body's tail runs? */
+  mountsRow: boolean
+  /** Which list runtime the loop compiles to. */
+  loopRuntime: string
+}
+
+function classify(loopBody: string): RowShape {
+  const source = `"use client"
+import { createSignal } from '@barefootjs/client'
+import { Chip } from './chip'
+function T() {
+  const [items] = createSignal([{ id: '1', name: 'a' }])
+  return <ul>{items().map((it) => ${loopBody})}</ul>
+}
+export { T }`
+  const result = compileJSX(source, 'T.tsx', { adapter: new TestAdapter() })
+  const hard = result.errors.filter((e) => e.severity !== 'warning')
+  if (hard.length > 0) throw new Error(`unexpected compile error: ${hard.map((e) => e.code).join(',')}`)
+  const js = result.files.find((f) => f.type === 'clientJs')?.content ?? ''
+
+  // Slice from the list call to the end of the emitted init function.
+  // Everything the row does at setup time is in there, and the top-level
+  // `createComponent('T', …)` export sits after it, so it cannot be mistaken
+  // for a row root. Starting at the call also excludes the import line, so
+  // `mountsRow` reflects a real call site rather than the import of one.
+  const call = /mapArray(?:Lazy|Anchored)?\(/.exec(js)
+  if (!call) throw new Error('no list runtime call emitted')
+  const hydrateAt = js.indexOf('\nhydrate(')
+  const region = js.slice(call.index, hydrateAt === -1 ? undefined : hydrateAt)
+
+  return {
+    rowRoot: /cloneNode\(/.test(region) ? 'template-clone' : 'createComponent',
+    nestedChildInit: /upsertChild\(|upsertChildItem\(/.test(region),
+    multiRoot: /__bfExtras|upsertChildItem\(|qsaItem\(/.test(region),
+    mountsRow: /mountRowRoot\(/.test(region),
+    loopRuntime: /mapArray(?:Lazy|Anchored)?/.exec(region)?.[0] ?? 'unknown',
+  }
+}
+
+describe('loop row creation paths — who makes the row root, and when it is connected', () => {
+  test('component row root: the runtime creates it, so it takes the mount point itself', () => {
+    // `<Chip/>` IS the row. `createComponent` consumes the ambient point in its
+    // own step 7b, so no separate call is emitted.
+    expect(classify('<Chip key={it.id} id={it.id} />')).toEqual({
+      rowRoot: 'createComponent',
+      nestedChildInit: false,
+      multiRoot: false,
+      mountsRow: false,
+      loopRuntime: 'mapArray',
+    })
+  })
+
+  test('markup row root with no component inside: a clone, and deliberately not mounted', () => {
+    // Nothing initialises inside this row, so there is no `useContext` call
+    // during setup to resolve wrongly — and this is the high-volume path, so
+    // leaving it alone keeps the `mapArrayLazy` emission and the measurements
+    // taken against it untouched. `mountsRow: false` here is a decision.
+    expect(classify('<li key={it.id}>{it.name}</li>')).toEqual({
+      rowRoot: 'template-clone',
+      nestedChildInit: false,
+      multiRoot: false,
+      mountsRow: false,
+      loopRuntime: 'mapArrayLazy',
+    })
+  })
+
+  test('markup row root with a nested component: clone, mounted before the tail', () => {
+    // The row root is user markup, so it is not and cannot become a component;
+    // `mountRowRoot` is what gives it a destination. Flip `mountsRow` to false
+    // and `upsertChild` goes back to running the child's `init` against a
+    // detached element.
+    expect(classify('<li key={it.id}><Chip id={it.id} /></li>')).toEqual({
+      rowRoot: 'template-clone',
+      nestedChildInit: true,
+      multiRoot: false,
+      mountsRow: true,
+      loopRuntime: 'mapArray',
+    })
+  })
+
+  test('two nested components in one markup row: same case, one mount', () => {
+    expect(classify('<li key={it.id}><Chip id={it.id} /><Chip id={it.name} /></li>')).toEqual({
+      rowRoot: 'template-clone',
+      nestedChildInit: true,
+      multiRoot: false,
+      mountsRow: true,
+      loopRuntime: 'mapArray',
+    })
+  })
+
+  test('Fragment row with a nested component: mounted, and the multi-root lookup copes', () => {
+    // A Fragment root can never be a component, so this shape only became
+    // reachable for a mount point once the clone path got one. It is also the
+    // multi-root lookup, whose sibling walk in `qsa-item.ts` used to end with
+    // `return` and skip the `__bfExtras` stash the moment the primary was
+    // attached — a `break` now, so an attached primary still finds its extras.
+    expect(classify('<><Chip id={it.id} /><span>{it.name}</span></>')).toEqual({
+      rowRoot: 'template-clone',
+      nestedChildInit: true,
+      multiRoot: true,
+      mountsRow: true,
+      loopRuntime: 'mapArray',
+    })
+  })
+
+  test('conditional child in a markup row: mounted, though it inits through `insert`', () => {
+    // `nestedChildInit` is false because this child arrives via `insert` +
+    // `initChild` rather than `upsertChild` — but it is still a child
+    // initialising inside the row, and the emission is keyed on the loop
+    // variant (composite), not on which call the child arrives through. This
+    // row is why the two columns have to be read separately.
+    expect(classify('<li key={it.id}>{it.name ? <Chip id={it.id} /> : null}</li>')).toEqual({
+      rowRoot: 'template-clone',
+      nestedChildInit: false,
+      multiRoot: false,
+      mountsRow: true,
+      loopRuntime: 'mapArray',
+    })
+  })
+})

package/src/__tests__/type-only-import-leak.test.ts

@@ -0,0 +1,60 @@
+/**
+ * End-to-end compiler pin for issue #2432's minimal reproduction.
+ *
+ * `collectExternalImports` used to decide which imported specifiers to
+ * re-emit into generated client JS with a `\bname\b` text scan over the
+ * generated code, never consulting the PER-SPECIFIER `isTypeOnly` flag
+ * (only the whole-declaration `import type { ... }` flag). So
+ * `import { paperColor, type Theme } from '../lib/theme'` re-emitted
+ * `Theme` as a VALUE import whenever the word "Theme" merely appeared in
+ * the emitted code — here, as an object key (`{ Theme: 'テーマ' }`).
+ *
+ * The CLI's relative-import inliner then places every requested name in
+ * the target module's top-level IIFE `return { … }`. `Theme` is a
+ * type-only export with no runtime binding, so the `return` referenced an
+ * undeclared name — `ReferenceError: Theme is not defined` at load,
+ * which kills the *entire* page's client JS before hydrate ever runs.
+ * The failure is silent from the user's perspective: the SSR-rendered
+ * markup is already on screen, so the page looks fine even though no
+ * interactivity ever wires up. See piconic-ai/barefootjs#2432.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { TestAdapter } from '../adapters/test-adapter'
+
+const adapter = new TestAdapter()
+
+describe('type-only import leak (#2432)', () => {
+  test('a per-specifier type-only import is never re-emitted into client JS', () => {
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      import { paperColor, type Theme } from '../lib/theme'
+
+      export function ThemedBadge() {
+        const labels = { Theme: 'テーマ' }
+        const [color, setColor] = createSignal(paperColor({ paper: '#fff' }))
+        return <div title={labels.Theme}>{color()}</div>
+      }
+    `
+
+    const result = compileJSX(source, 'ThemedBadge.tsx', { adapter })
+    expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
+
+    const clientJs = result.files.find(f => f.type === 'clientJs')
+    expect(clientJs).toBeDefined()
+    const code = clientJs!.content
+
+    // The value specifier survives as a real import.
+    expect(code).toContain("import { paperColor } from '../lib/theme'")
+
+    // No import statement anywhere in the bundle mentions `Theme` — the
+    // only legal destination for a value import of that name would be a
+    // binding that doesn't exist in the compiled `../lib/theme` module.
+    const importLines = code.split('\n').filter(line => line.trim().startsWith('import'))
+    for (const line of importLines) {
+      expect(line).not.toContain('Theme')
+    }
+  })
+})

package/src/__tests__/value-references.test.ts

@@ -0,0 +1,88 @@
+/**
+ * Tests for `packages/jsx/src/value-references.ts` — the single-door
+ * "is this identifier a VALUE reference" classifier shared by
+ * `collectExternalImports` (jsx) and `detectStrippedReferences` (cli).
+ *
+ * There was no direct test file for this module before this one. It was
+ * added as a follow-up to #2432: a Copilot review on the original PR
+ * flagged that `ts.PropertyDeclaration` (class field) names were not
+ * excluded, so a class field like `helper` in `class C { helper = 1 }`
+ * was misclassified as a value reference. Harmless for the jsx-side
+ * caller (an extra kept import), but a false BF053 build error for the
+ * cli-side caller when the same name is a stripped import binding.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { collectValueReferencedNames } from '../value-references'
+
+describe('collectValueReferencedNames', () => {
+  test('class field name only is NOT a reference', () => {
+    const result = collectValueReferencedNames('class C { helper = 1 }')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(false)
+  })
+
+  test('static class field name only is NOT a reference', () => {
+    const result = collectValueReferencedNames('class C { static helper = 1 }')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(false)
+  })
+
+  test('computed class field name IS a reference (does not over-exclude)', () => {
+    const result = collectValueReferencedNames('class C { [helper] = 1 }')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(true)
+  })
+
+  test('class method name is NOT a reference', () => {
+    const result = collectValueReferencedNames('class C { helper() {} }')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(false)
+  })
+
+  test('object-literal key is NOT a reference', () => {
+    const result = collectValueReferencedNames('const o = { helper: 1 };')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(false)
+  })
+
+  test('property access name is NOT a reference', () => {
+    const result = collectValueReferencedNames('obj.helper();')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(false)
+  })
+
+  test('shorthand property IS a reference (reads the binding)', () => {
+    const result = collectValueReferencedNames('const o = { helper };')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(true)
+  })
+
+  test('a genuine call IS a reference', () => {
+    const result = collectValueReferencedNames('helper();')
+    expect(result).not.toBeNull()
+    expect(result?.has('helper')).toBe(true)
+  })
+
+  test('new.target: "target" is NOT a reference', () => {
+    const result = collectValueReferencedNames('function f() { return new.target; }')
+    expect(result).not.toBeNull()
+    expect(result?.has('target')).toBe(false)
+  })
+
+  // Both halves of the MetaProperty exclusion are pinned: `new.target`
+  // above, and `import.meta` here — the one Copilot flagged as uncovered
+  // on #2439. `import.meta.url` also incidentally covers the
+  // property-access half (`url` is excluded too).
+  test('import.meta: "meta" is NOT a reference', () => {
+    const result = collectValueReferencedNames('const u = import.meta.url;')
+    expect(result).not.toBeNull()
+    expect(result?.has('meta')).toBe(false)
+    expect(result?.has('url')).toBe(false)
+  })
+
+  test('unparseable text returns null ("cannot answer")', () => {
+    const result = collectValueReferencedNames('const x = ;;; {{{ ]]]')
+    expect(result).toBeNull()
+  })
+})

package/src/analyzer.ts

@@ -3974,6 +3974,9 @@ function importsBrowserOnlyClientApi(ctx: AnalyzerContext): boolean {
     if (imp.source !== '@barefootjs/client') continue
     if (imp.isTypeOnly) continue
     for (const spec of imp.specifiers) {
+      // A per-specifier type-only import (`import { type onMount }`) is not
+      // a browser-only API use — it has no runtime binding (#2432).
+      if (spec.isTypeOnly) continue
       const importedName = spec.name
       if (BROWSER_ONLY_CLIENT_APIS.has(importedName)) return true
     }