partial-react 0.0.5 → 0.0.7

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "partial-react",
   "description": "A state-preserving renderer for prefix-growing streaming React/TSX.",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "type": "module",
   "repository": {
     "type": "git",
@@ -15,13 +15,16 @@
     "./remote-module": "./src/remoteModule.ts",
     "./render-context": "./src/renderContext.ts"
   },
+  "browser": {
+    "./src/nodeWasm.ts": false
+  },
   "files": [
     "src/**/*",
     "!src/**/*.test.*"
   ],
   "dependencies": {
     "@esm.sh/tsx": "^1.5.3",
-    "partial-tsx": "0.0.3"
+    "partial-tsx": "0.0.4"
   },
   "peerDependencies": {
     "react": "^18.3.0 || ^19.0.0",

package/src/compiler.ts

@@ -7,16 +7,10 @@ export type CompileResult = { code: string; source: string; changed: boolean };
 export type TsxCompiler = { compile: (code: string, options?: CompileOptions) => Promise<CompileResult> };
 
 let initPromise: Promise<unknown> | null = null;
-const loadNodeWasm = async () => {
-  // `import.meta.resolve` yields a `file://` URL under both Bun and Node/Vite SSR, so `new URL` is safe — don't "fix" it with pathToFileURL.
-  const wasmUrl = new URL(import.meta.resolve("@esm.sh/tsx/pkg/tsx_bg.wasm"));
-  if (typeof Bun !== "undefined") return Bun.file(wasmUrl).arrayBuffer();
-  return (await import("node:fs/promises")).readFile(wasmUrl);
-};
 const initCompiler = () =>
   (initPromise ??= (async () => {
     try {
-      if (typeof window === "undefined") return initTsx(await loadNodeWasm());
+      if (typeof window === "undefined") return initTsx(await (await import("./nodeWasm")).loadNodeWasm());
     } catch {
       // Environments without a filesystem (e.g. web workers) fall back to the bundled asset below.
     }

package/src/importMap.ts

@@ -13,9 +13,30 @@ export type RuntimeSingletonSpecifier = (typeof RUNTIME_SINGLETON_SPECIFIERS)[nu
 export const isRuntimeSingletonSpecifier = (specifier: string): specifier is RuntimeSingletonSpecifier => RUNTIME_SINGLETON_SPECIFIERS.includes(specifier as RuntimeSingletonSpecifier);
 // A trailing-slash import-map key also owns matching singleton subpaths.
 export const isRuntimeSingletonImportMapKey = (specifier: string) => isRuntimeSingletonSpecifier(specifier) || (specifier.endsWith("/") && RUNTIME_SINGLETON_SPECIFIERS.some((runtimeSpecifier) => runtimeSpecifier.startsWith(specifier)));
-const IDENTIFIER_CHAR_PATTERN = /[\w$]/;
-const REGEX_PREFIX_WORDS = new Set(["return", "throw", "case", "delete", "typeof", "void", "new", "in", "of", "await", "yield"]);
-const LOCAL_EXPORT_KEYWORDS = ["abstract", "async", "class", "const", "declare", "default", "enum", "function", "interface", "let", "namespace", "var"];
+const IDENTIFIER_START_PATTERN = /[$_\p{ID_Start}]/u;
+const IDENTIFIER_PART_PATTERN = /[$_\u200C\u200D\p{ID_Continue}]/u;
+// Composed from the two above so widening either also widens JSX tag names; `.`/`:`/`-` extend the part set for member,
+// namespaced and dashed tags. The empty alternative matches a fragment (`<>`).
+const JSX_TAG_START_PATTERN = new RegExp(`<(/\\s*)?(${IDENTIFIER_START_PATTERN.source}(?:${IDENTIFIER_PART_PATTERN.source}|[.:-])*|(?=>))(?=[\\s/><])`, "uy");
+const STRING_ESCAPE_PATTERN = /\\(?:x([\da-fA-F]{2})|u\{([\da-fA-F]+)\}|u([\da-fA-F]{4}))/y;
+// Every escape the pattern above doesn't cover denotes the bare character (`\/` → `/`, `\\` → `\`) except these: the
+// named control escapes, and a `\`-LineTerminator line continuation, which denotes nothing. Callers match this value
+// against import-map keys, so returning the source spelling instead yields a third string that is neither the source
+// nor what the runtime resolves — it matches no key, and `rewriteImportSpecifiers` leaves the specifier unrewritten.
+// The escapes that are a syntax error in a module (`\1`-`\9`, `\0` before a digit, a malformed `\x`/`\u`) get no case:
+// such a module never loads, so whatever they decode to names no reachable key. U+2028/U+2029 are spelled as escapes
+// because raw they are invisible.
+const STRING_ESCAPE_VALUES: Record<string, string> = { b: "\b", f: "\f", n: "\n", r: "\r", t: "\t", v: "\v", "0": "\0", "\n": "", "\r": "", "\u2028": "", "\u2029": "" };
+// An escaped identifier character names one code point, so an astral name is spelled `\u{10400}`, never as the two
+// escaped surrogate halves a string literal would pair — no pairing branch belongs here. A lone half is no ID_Start, so
+// the scan stops and the clause falls back to the specifier alone, costing nothing: V8 and tsgo both reject that spelling.
+const IDENTIFIER_ESCAPE_PATTERN = /\\u(?:\{([\da-fA-F]+)\}|([\da-fA-F]{4}))/y;
+// `$` `_` `A-Z` `a-z` as code points (`0-9` joins them for continues, below): an ASCII fast path past
+// IDENTIFIER_START_PATTERN/IDENTIFIER_PART_PATTERN, which answer the same but cost a regex exec per character. Widen
+// alongside them.
+const isAsciiIdentifierStart = (value: number) => value === 36 || value === 95 || (value >= 65 && value <= 90) || (value >= 97 && value <= 122);
+const isIdentifierCodePoint = (value: number, first: boolean) => (value <= 0x7f ? isAsciiIdentifierStart(value) || (!first && value >= 48 && value <= 57) : (first ? IDENTIFIER_START_PATTERN : IDENTIFIER_PART_PATTERN).test(String.fromCodePoint(value)));
+const EXPRESSION_PREFIX_WORDS = new Set(["return", "throw", "case", "delete", "typeof", "void", "new", "in", "of", "await", "yield", "default", "else", "do"]);
 
 export const isBareModuleSpecifier = (specifier: string) => !specifier.startsWith(".") && !specifier.startsWith("/") && !/^(?:[a-z][a-z\d+.-]*:|#)/i.test(specifier);
 export const getBarePackageName = (specifier: string) => (specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0] || specifier);
@@ -28,7 +49,7 @@ export const isSharedInstancePackage = (specifier: string) => SHARED_INSTANCE_PA
 export const isLocalRootRelativeTarget = (target: string) => target.startsWith("/src/") || target.startsWith("/node_modules/");
 const canUseEsmShFallback = (specifier: string) => isBareModuleSpecifier(specifier) && !specifier.startsWith("@/");
 
-const isKeywordAt = (code: string, index: number, keyword: string) => code.startsWith(keyword, index) && !IDENTIFIER_CHAR_PATTERN.test(code[index - 1] ?? "") && !IDENTIFIER_CHAR_PATTERN.test(code[index + keyword.length] ?? "");
+const isKeywordAt = (code: string, index: number, keyword: string) => code.startsWith(keyword, index) && !IDENTIFIER_PART_PATTERN.test(code[index - 1] ?? "") && !IDENTIFIER_PART_PATTERN.test(code[index + keyword.length] ?? "");
 
 const skipLineComment = (code: string, index: number) => {
   const newlineIndex = code.indexOf("\n", index + 2);
@@ -40,18 +61,34 @@ const skipBlockComment = (code: string, index: number) => {
   return closeIndex === -1 ? code.length : closeIndex + 2;
 };
 
+// Callers must have verified `/` at `index`; the second char picks the terminator.
+const skipComment = (code: string, index: number) => (code[index + 1] === "/" ? skipLineComment(code, index) : skipBlockComment(code, index));
+
+const skipScannedComment = (code: string, index: number, commentStarts: Map<number, number>) => {
+  const end = skipComment(code, index);
+  commentStarts.set(end, index);
+  return end;
+};
+
+// Only rewind over comments the forward scan observed: searching backwards for `/*` can land inside comment text.
+const previousCodeIndex = (code: string, end: number, commentStarts: ReadonlyMap<number, number>) => {
+  while (end > 0) {
+    const commentStart = commentStarts.get(end);
+    if (commentStart !== undefined) end = commentStart;
+    else if (/\s/.test(code[end - 1])) end -= 1;
+    else break;
+  }
+  return end - 1;
+};
+
 const skipWhitespaceAndComments = (code: string, index: number) => {
   while (index < code.length) {
     if (/\s/.test(code[index])) {
       index += 1;
       continue;
     }
-    if (code[index] === "/" && code[index + 1] === "/") {
-      index = skipLineComment(code, index);
-      continue;
-    }
-    if (code[index] === "/" && code[index + 1] === "*") {
-      index = skipBlockComment(code, index);
+    if (code[index] === "/" && (code[index + 1] === "/" || code[index + 1] === "*")) {
+      index = skipComment(code, index);
       continue;
     }
     break;
@@ -67,8 +104,27 @@ const readStringLiteral = (code: string, index: number) => {
   while (index < code.length) {
     const char = code[index];
     if (char === "\\") {
-      value += code.slice(index, index + 2);
-      index += 2;
+      // Mirrors STRING_ESCAPE_PATTERN's alternation heads: skipping exec on the common escapes (`\n`, `\"`, `\\`) is
+      // ~1.6x faster on escape-dense literals. Widen this when widening the pattern.
+      const next = code[index + 1];
+      let escape: RegExpExecArray | null = null;
+      if (next === "x" || next === "u") {
+        STRING_ESCAPE_PATTERN.lastIndex = index;
+        escape = STRING_ESCAPE_PATTERN.exec(code);
+      }
+      if (escape) {
+        const point = Number.parseInt(escape[1] ?? escape[2] ?? escape[3], 16);
+        if (point <= 0x10ffff) {
+          value += String.fromCodePoint(point);
+          index += escape[0].length;
+          continue;
+        }
+      }
+      // A lone trailing backslash has no next character to stand for, and `?? next` would append `undefined` verbatim.
+      if (next === undefined) break;
+      value += STRING_ESCAPE_VALUES[next] ?? next;
+      // `\` + CRLF is one line continuation, not a continuation followed by a stray `\n`.
+      index += next === "\r" && code[index + 2] === "\n" ? 3 : 2;
       continue;
     }
     if (char === quote) return { value, end: index + 1, terminated: true };
@@ -80,7 +136,9 @@ const readStringLiteral = (code: string, index: number) => {
   return { value, end: code.length, terminated: false };
 };
 
-const skipTemplateLiteral = (code: string, index: number, onExpression?: (start: number, end: number) => void) => {
+type JsxScanCache = Map<number, { end: number; expressions: [number, number][] }>;
+
+const skipTemplateLiteral = (code: string, index: number, jsxScanCache: JsxScanCache, onExpression?: (start: number, end: number) => void) => {
   index += 1;
   while (index < code.length) {
     if (code[index] === "\\") {
@@ -90,7 +148,7 @@ const skipTemplateLiteral = (code: string, index: number, onExpression?: (start:
     if (code[index] === "`") return index + 1;
     if (code[index] === "$" && code[index + 1] === "{") {
       const expressionStart = index + 2;
-      const expressionEnd = findBalancedBlockEnd(code, index + 1, "{", "}");
+      const expressionEnd = findBalancedBlockEnd(code, index + 1, "{", "}", jsxScanCache);
       onExpression?.(expressionStart, Math.max(expressionStart, expressionEnd - 1));
       index = expressionEnd;
       continue;
@@ -100,19 +158,25 @@ const skipTemplateLiteral = (code: string, index: number, onExpression?: (start:
   return code.length;
 };
 
-const findBalancedBlockEnd = (code: string, index: number, opener: string, closer: string) => {
+const findBalancedBlockEnd = (code: string, index: number, opener: string, closer: string, jsxScanCache: JsxScanCache) => {
   let depth = 0;
+  const commentStarts = new Map<number, number>();
+  const openParens: number[] = [];
+  let closedParen: number | undefined;
   while (index < code.length) {
     const char = code[index];
-    if (char === "/" && code[index + 1] === "/") {
-      index = skipLineComment(code, index);
+    if (char === "/" && (code[index + 1] === "/" || code[index + 1] === "*")) {
+      index = skipScannedComment(code, index, commentStarts);
       continue;
     }
-    if (char === "/" && code[index + 1] === "*") {
-      index = skipBlockComment(code, index);
-      continue;
+    if (char === "<" && opener !== "<" && isLikelyJsxStart(code, index, closedParen, commentStarts)) {
+      const jsxEnd = skipJsxElement(code, index, jsxScanCache);
+      if (jsxEnd > index) {
+        index = jsxEnd;
+        continue;
+      }
     }
-    if (isLikelyRegexLiteralStart(code, index)) {
+    if (char === "/" && isLikelyRegexLiteralStart(code, index, commentStarts)) {
       index = skipRegexLiteral(code, index);
       continue;
     }
@@ -121,9 +185,11 @@ const findBalancedBlockEnd = (code: string, index: number, opener: string, close
       continue;
     }
     if (char === "`") {
-      index = skipTemplateLiteral(code, index);
+      index = skipTemplateLiteral(code, index, jsxScanCache);
       continue;
     }
+    if (char === "(") openParens.push(index);
+    else if (char === ")") closedParen = openParens.pop();
     if (char === opener) depth += 1;
     if (char === closer) {
       depth -= 1;
@@ -134,17 +200,19 @@ const findBalancedBlockEnd = (code: string, index: number, opener: string, close
   return code.length;
 };
 
-const isLikelyRegexLiteralStart = (code: string, index: number) => {
+const isLikelyRegexLiteralStart = (code: string, index: number, commentStarts: ReadonlyMap<number, number>) => {
   if (code[index] !== "/" || code[index + 1] === "/" || code[index + 1] === "*") return false;
-  let previous = index - 1;
-  while (previous >= 0 && /\s/.test(code[previous])) previous -= 1;
+  const previous = previousCodeIndex(code, index, commentStarts);
   if (previous < 0) return true;
   const previousChar = code[previous];
+  // An adjacent `</` opens a JSX closing tag, not a regex after `<` — a real `a < /re/` always has whitespace. Consuming
+  // the tag as a regex swallows every import after it.
+  if (previous === index - 1 && previousChar === "<") return false;
   if ("([{=,:;!&|?+-*~^<>".includes(previousChar)) return true;
   if (!/[A-Za-z_$]/.test(previousChar)) return false;
-  let word = "";
-  for (let cursor = previous; cursor >= 0 && /[A-Za-z0-9_$]/.test(code[cursor]); cursor -= 1) word = code[cursor] + word;
-  return REGEX_PREFIX_WORDS.has(word);
+  const { word, start } = wordEndingAt(code, previous + 1, commentStarts);
+  // Keywords also name properties: `object.default / 2` is division, including optional chains and intervening comments.
+  return EXPRESSION_PREFIX_WORDS.has(word) && ![".", "#"].includes(code[previousCodeIndex(code, start, commentStarts)]);
 };
 
 const skipRegexLiteral = (code: string, index: number) => {
@@ -167,19 +235,143 @@ const skipRegexLiteral = (code: string, index: number) => {
   return code.length;
 };
 
-const readFromSpecifier = (code: string, index: number) => {
+const STATEMENT_CONDITION_WORDS = new Set(["if", "while", "for", "with", "switch", "catch"]);
+
+// What separates a keyword from the token after it can be a comment, not just whitespace (`if /* c */ (`), so rewind
+// over the comment spans the forward scan recorded: stopping on the `*/` yields no word at all, losing the keyword.
+const wordEndingAt = (code: string, end: number, commentStarts: ReadonlyMap<number, number>) => {
+  end = previousCodeIndex(code, end, commentStarts) + 1;
+  let start = end;
+  // Consume whole code points and braced escapes so an identifier prefix cannot leave a keyword-looking suffix behind.
+  while (start > 0) {
+    if (code[start - 1] === "}") {
+      let cursor = start - 2;
+      while (cursor >= 0 && /[\da-fA-F]/.test(code[cursor])) cursor -= 1;
+      if (code.slice(cursor - 2, cursor + 1) === "\\u{") {
+        start = cursor - 2;
+        continue;
+      }
+    }
+    const previous = start - (code.charCodeAt(start - 1) >= 0xdc00 && code.charCodeAt(start - 1) <= 0xdfff ? 2 : 1);
+    if (!IDENTIFIER_PART_PATTERN.test(code.slice(previous, start))) break;
+    start = previous;
+  }
+  return { word: code.slice(start, end), start };
+};
+
+// Both JavaScript scan loops pair parens while skipping literals, comments and JSX. Rewinding from `)` can start
+// inside one of those constructs and lose later imports; using the observed opener also avoids rescanning conditions.
+const isStatementConditionOpen = (code: string, open: number | undefined, commentStarts: ReadonlyMap<number, number>) => {
+  if (open === undefined) return false;
+  let preceding = wordEndingAt(code, open, commentStarts);
+  // `for await (` is the only production putting a word between the controlling keyword and its `(`, so one step is enough.
+  if (preceding.word === "await") preceding = wordEndingAt(code, preceding.start, commentStarts);
+  return STATEMENT_CONDITION_WORDS.has(preceding.word);
+};
+
+const isLikelyJsxStart = (code: string, index: number, closedParen: number | undefined, commentStarts: ReadonlyMap<number, number>) => {
+  let previous = index - 1;
+  while (previous >= 0 && /\s/.test(code[previous])) {
+    // Deliberately optimistic, and the widest edge of this heuristic: a preceding newline admits every multi-line
+    // non-JSX `<` too (a split generic call, a comparison chain, a wrapped type annotation), each paying an element
+    // scan that fails. Results stay right because `skipJsxElement` returns `start` on failure, and affordable only
+    // because `jsxScanCache` memoizes that failure — narrowing this branch would break ordinary formatted JSX.
+    if (code[previous] === "\n") return true;
+    previous -= 1;
+  }
+  // `call()<p>` is a comparison-like expression, not JSX. `jsxScanCache` cannot absorb this the way it does the newline
+  // branch — each `)<` sits at a distinct start — so deleting the guard takes `a=f()<div a={f()};` quadratic (n=500..4000:
+  // 13.7 -> 817.7 ms, versus 1.4 -> 11.2 ms). It also changes results: TS reads `<` after a call as relational, so the
+  // `import` in `f()<div>{import("x")}</div>` is live code. `)` only — `]` would regress `xs[0]<div>` to inert JSX text.
+  // Keep statement-position JSX (`if(ready)<p>`) working by recognizing the controlling keyword before the paren.
+  if (previous === index - 1 && code[previous] === ")" && !isStatementConditionOpen(code, closedParen, commentStarts)) return false;
+  // Exclude type arguments (`Promise<T>`, `call<T>()`) before attempting a potentially long element scan.
+  if (previous < 0 || !IDENTIFIER_PART_PATTERN.test(code[previous])) return true;
+  return EXPRESSION_PREFIX_WORDS.has(wordEndingAt(code, previous + 1, commentStarts).word);
+};
+
+// JSX text is not JavaScript: quotes and import-looking prose are inert, but attribute/child expressions still contain
+// real imports. Only commit a complete element; otherwise a TS angle-bracket assertion could consume the rest of a file.
+const skipJsxElement = (code: string, start: number, jsxScanCache: JsxScanCache, onExpression?: (start: number, end: number) => void): number => {
+  const cached = jsxScanCache.get(start);
+  if (cached) {
+    for (const [expressionStart, expressionEnd] of cached.expressions) onExpression?.(expressionStart, expressionEnd);
+    return cached.end;
+  }
+  let index = start;
+  const tags: { name: string; start: number }[] = [];
+  const expressions: [number, number][] = [];
+  const fail = () => {
+    // Every still-open ancestor would fail on the same suffix. Cache all of them, not just the outer start, so a
+    // streamed stack of unclosed elements does not rescan the tail once per nesting level. The cache is per input.
+    jsxScanCache.set(start, { end: start, expressions: [] });
+    for (const tag of tags) jsxScanCache.set(tag.start, { end: tag.start, expressions: [] });
+    return start;
+  };
+  const skipExpression = (at: number) => {
+    const end = findBalancedBlockEnd(code, at, "{", "}", jsxScanCache);
+    expressions.push([at + 1, Math.max(at + 1, end - 1)]);
+    return end;
+  };
   while (index < code.length) {
-    const char = code[index];
-    if (char === ";") return null;
-    if (char === "/" && code[index + 1] === "/") {
-      index = skipLineComment(code, index);
+    if (code[index] === "{" && tags.length) {
+      index = skipExpression(index);
       continue;
     }
-    if (char === "/" && code[index + 1] === "*") {
-      index = skipBlockComment(code, index);
+    if (code[index] !== "<") {
+      index += 1;
       continue;
     }
-    if (isLikelyRegexLiteralStart(code, index)) {
+    JSX_TAG_START_PATTERN.lastIndex = index;
+    const tag = JSX_TAG_START_PATTERN.exec(code);
+    if (!tag) {
+      if (!tags.length) return fail();
+      index += 1;
+      continue;
+    }
+    const closing = !!tag[1];
+    if (closing && tags.at(-1)?.name !== tag[2]) return fail();
+    const tagStart = index;
+    index += tag[0].length;
+    // Generic arrows use the same expression position as JSX, but `extends`/`=` start type parameters, not attributes.
+    const afterName = skipWhitespaceAndComments(code, index);
+    if (!tags.length && (code[afterName] === "=" || isKeywordAt(code, afterName, "extends"))) return fail();
+    while (index < code.length && code[index] !== ">") {
+      const char = code[index];
+      if (char === '"' || char === "'") {
+        // Backslashes do not escape quotes in JSX attributes.
+        const quoteEnd = code.indexOf(char, index + 1);
+        if (quoteEnd === -1) return fail();
+        index = quoteEnd + 1;
+      } else if (char === "{") index = skipExpression(index);
+      else if (char === "<") index = findBalancedBlockEnd(code, index, "<", ">", jsxScanCache);
+      else if (char === "/" && code[index + 1] === "/") index = skipLineComment(code, index);
+      else if (char === "/" && code[index + 1] === "*") index = skipBlockComment(code, index);
+      else index += 1;
+    }
+    if (index === code.length) return fail();
+    if (closing) tags.pop();
+    else if (code[index - 1] !== "/") tags.push({ name: tag[2], start: tagStart });
+    index += 1;
+    if (!tags.length) {
+      jsxScanCache.set(start, { end: index, expressions });
+      for (const [expressionStart, expressionEnd] of expressions) onExpression?.(expressionStart, expressionEnd);
+      return index;
+    }
+  }
+  return fail();
+};
+
+const readFromSpecifier = (code: string, index: number, jsxScanCache: JsxScanCache) => {
+  const commentStarts = new Map<number, number>();
+  while (index < code.length) {
+    const char = code[index];
+    if (char === ";") return null;
+    if (char === "/" && (code[index + 1] === "/" || code[index + 1] === "*")) {
+      index = skipScannedComment(code, index, commentStarts);
+      continue;
+    }
+    if (char === "/" && isLikelyRegexLiteralStart(code, index, commentStarts)) {
       index = skipRegexLiteral(code, index);
       continue;
     }
@@ -188,10 +380,10 @@ const readFromSpecifier = (code: string, index: number) => {
       continue;
     }
     if (char === "`") {
-      index = skipTemplateLiteral(code, index);
+      index = skipTemplateLiteral(code, index, jsxScanCache);
       continue;
     }
-    if (isKeywordAt(code, index, "from")) {
+    if (char === "f" && isKeywordAt(code, index, "from")) {
       const start = skipWhitespaceAndComments(code, index + "from".length);
       const literal = readStringLiteral(code, start);
       if (literal) return { specifier: literal.value, start, end: literal.end, terminated: literal.terminated };
@@ -203,12 +395,24 @@ const readFromSpecifier = (code: string, index: number) => {
   return null;
 };
 
-const readExportFromSpecifier = (code: string, index: number) => {
+const readExportFromSpecifier = (code: string, index: number, jsxScanCache: JsxScanCache) => {
   let next = skipWhitespaceAndComments(code, index);
-  if (isKeywordAt(code, next, "type")) next = skipWhitespaceAndComments(code, next + "type".length);
-  if (code[next] === "*" || code[next] === "{") return readFromSpecifier(code, next);
-  for (const keyword of LOCAL_EXPORT_KEYWORDS) if (isKeywordAt(code, next, keyword)) return null;
-  return readFromSpecifier(code, next);
+  // A clause-level `type` erases the whole re-export, unlike an inline `export { type A, B } from` which still links for
+  // `B`. Reported as `notLinked` so probing does not fetch what the compiled module never imports.
+  const typeOnly = isKeywordAt(code, next, "type");
+  if (typeOnly) next = skipWhitespaceAndComments(code, next + "type".length);
+  // Only `{` and `*` can start a re-export. Enumerating local declaration keywords misses decorators and lets
+  // semicolonless declarations consume a later import's `from`.
+  if (code[next] === "{") {
+    // A local `export { a }` may have no semicolon either, and the lenient scan below would then read the NEXT
+    // statement's `from` — reporting that import as a nameless re-export and losing every name it binds. The clause's
+    // own `from` can only sit right after the closing brace, so require it there instead of hunting forward.
+    const afterClause = skipWhitespaceAndComments(code, findBalancedBlockEnd(code, next, "{", "}", jsxScanCache));
+    if (!isKeywordAt(code, afterClause, "from")) return null;
+    next = afterClause;
+  } else if (code[next] !== "*") return null;
+  const from = readFromSpecifier(code, next, jsxScanCache);
+  return from && { ...from, notLinked: typeOnly || undefined };
 };
 
 // `.meta.resolve(` after the `import` keyword, returning the string-literal argument. Null means this `import.` is
@@ -224,36 +428,114 @@ const readImportMetaResolveSpecifier = (code: string, dotIndex: number) => {
   if (code[next] !== "(") return null;
   const start = skipWhitespaceAndComments(code, next + 1);
   const literal = readStringLiteral(code, start);
-  return literal ? { ...literal, start } : { value: "", start, end: next, terminated: false };
+  return literal ? { ...literal, start, openParen: next } : { value: "", start, end: next, terminated: false, openParen: next };
 };
 
 const readIdentifierWord = (code: string, index: number) => {
   let end = index;
-  while (end < code.length && IDENTIFIER_CHAR_PATTERN.test(code[end])) end += 1;
-  return end > index ? { name: code.slice(index, end), end } : null;
+  let escapedName: string | undefined;
+  while (end < code.length) {
+    let escape: RegExpExecArray | null = null;
+    if (code[end] === "\\") {
+      IDENTIFIER_ESCAPE_PATTERN.lastIndex = end;
+      escape = IDENTIFIER_ESCAPE_PATTERN.exec(code);
+    }
+    const value = escape ? Number.parseInt(escape[1] ?? escape[2], 16) : code.codePointAt(end)!;
+    if (value > 0x10ffff || !isIdentifierCodePoint(value, end === index)) break;
+    const characterLength = value > 0xffff ? 2 : 1;
+    if (escape) escapedName = `${escapedName ?? code.slice(index, end)}${String.fromCodePoint(value)}`;
+    else if (escapedName !== undefined) escapedName += code.slice(end, end + characterLength);
+    end += escape?.[0].length ?? characterLength;
+  }
+  return end > index ? { name: escapedName ?? code.slice(index, end), end } : null;
+};
+
+const readImportTypeModifierEnd = (code: string, index: number) => {
+  if (!isKeywordAt(code, index, "type")) return undefined;
+  const after = skipWhitespaceAndComments(code, index + "type".length);
+  // `import type from "x"` / `import type, { X } from "x"` bind a default named `type`.
+  return isKeywordAt(code, after, "from") || code[after] === "," ? undefined : after;
+};
+
+// A JSON/CSS module is only importable with its `with { type: … }` clause, so a probe that re-imports the specifier
+// without it fails on a dependency that actually linked, reporting a working import as broken (#1824). Read the clause
+// so probeModuleImports can replay it verbatim.
+//
+// `end` lets the caller resume past the clause: rescanned as statements, a reserved-word key (`with { import: "y" }`)
+// matches as a keyword and swallows the next import's `from`. `partial` separates a clause that is present but
+// unreadable — a stream frame cut inside it — from no clause at all; probing the former bare reproduces exactly the
+// false positive above, so those specifiers are withheld until the clause completes.
+type ImportAttributesClause = { attributes?: Record<string, string>; end: number; partial?: boolean };
+const readImportAttributes = (code: string, index: number, jsxScanCache: JsxScanCache): ImportAttributesClause | undefined => {
+  const next = skipWhitespaceAndComments(code, index);
+  if (!isKeywordAt(code, next, "with")) return;
+  const braceStart = skipWhitespaceAndComments(code, next + "with".length);
+  // `with` streamed but not yet its `{`: the clause is coming, so this frame cannot be probed.
+  if (code[braceStart] !== "{") return { end: braceStart, partial: true };
+  const braceEnd = findBalancedBlockEnd(code, braceStart, "{", "}", jsxScanCache);
+  // findBalancedBlockEnd returns `code.length` when the brace never closes, i.e. the clause is still streaming.
+  // Left undefined until an entry lands, so an empty clause (`with {}`) reads as no attributes — what the engine links with too.
+  // Null-prototype once allocated: keys come from generated code, so a `__proto__` key must land as an own property
+  // instead of hitting the setter, where it would silently vanish and probe the module without the type it asked for.
+  let attributes: Record<string, string> | undefined;
+  let partial = code[braceEnd - 1] !== "}";
+  let cursor = braceStart + 1;
+  while (cursor < braceEnd - 1) {
+    cursor = skipWhitespaceAndComments(code, cursor);
+    if (cursor >= braceEnd - 1) break;
+    // AssertEntry keys are an IdentifierName or a string literal, so `type`, `"type"` and `'type'` are all the same key.
+    const quotedKey = readStringLiteral(code, cursor);
+    const key = quotedKey ?? readIdentifierWord(code, cursor);
+    if (!key || (quotedKey && !quotedKey.terminated)) {
+      partial = true;
+      break;
+    }
+    // Both readers decode escapes, so `"type"` and `type` reach the probe as `type`, the key the engine linked with.
+    const keyName = "name" in key ? key.name : key.value;
+    cursor = skipWhitespaceAndComments(code, key.end);
+    if (code[cursor] !== ":") {
+      partial = true;
+      break;
+    }
+    cursor = skipWhitespaceAndComments(code, cursor + 1);
+    // Values are string literals only — no identifiers, no numbers — so anything else means the clause is truncated.
+    const value = readStringLiteral(code, cursor);
+    if (!value?.terminated) {
+      partial = true;
+      break;
+    }
+    attributes ??= Object.create(null) as Record<string, string>;
+    attributes[keyName] = value.value;
+    cursor = skipWhitespaceAndComments(code, value.end);
+    // The loop head skips whitespace and comments, so stepping over the comma alone is enough.
+    if (code[cursor] === ",") cursor += 1;
+    // Two entries with no comma between them is not a clause the engine links, and not a frame that becomes one.
+    else if (code[cursor] !== "}") {
+      partial = true;
+      break;
+    }
+  }
+  return { attributes, end: braceEnd, partial: partial || undefined };
 };
 
 // Parses one static import clause right after the `import` keyword into the export names the module must provide
-// ("default" for default imports; namespace and side-effect imports demand none). `notLinked` marks a type-only import,
-// which survives specifier collection but is erased before the module is ever instantiated. Returns null on clauses it does not understand
-// (streaming-truncated ones) so callers can fall back to the lenient readFromSpecifier.
-const readImportBindings = (code: string, index: number): { specifier: string; names: string[]; start: number; end: number; terminated: boolean; notLinked?: boolean } | null => {
+// ("default" for default imports; namespace and side-effect imports demand none). `names` holds only the runtime-linked
+// ones and `allNames` adds the erased type positions, which ambient consumers still need to declare; `notLinked` marks a
+// wholly erased clause. Returns null on clauses it does not understand (streaming-truncated ones) so callers can fall
+// back to the lenient readFromSpecifier.
+const readImportBindings = (code: string, index: number): { specifier: string; names: string[]; allNames: string[]; start: number; end: number; terminated: boolean; notLinked?: boolean } | null => {
   const names: string[] = [];
+  let typeOnlyNames: string[] | undefined;
   index = skipWhitespaceAndComments(code, index);
   const sideEffect = readStringLiteral(code, index);
-  if (sideEffect) return sideEffect.value ? { specifier: sideEffect.value, names, start: index, end: sideEffect.end, terminated: sideEffect.terminated } : null;
-  if (isKeywordAt(code, index, "type")) {
-    const after = skipWhitespaceAndComments(code, index + "type".length);
-    // `import type …` is erased at runtime — but `import type from "x"` binds a default named `type`.
-    if (!isKeywordAt(code, after, "from")) {
-      const from = readFromSpecifier(code, after);
-      return from ? { ...from, names, notLinked: true } : null;
-    }
-  }
+  if (sideEffect) return sideEffect.value ? { specifier: sideEffect.value, names, allNames: names, start: index, end: sideEffect.end, terminated: sideEffect.terminated } : null;
+  const afterType = readImportTypeModifierEnd(code, index);
+  const typeOnlyImport = afterType !== undefined;
+  index = afterType ?? index;
   if (code[index] !== "{" && code[index] !== "*") {
     const afterDefault = readIdentifierWord(code, index)?.end;
     if (afterDefault === undefined) return null;
-    names.push("default");
+    (typeOnlyImport ? (typeOnlyNames ??= []) : names).push("default");
     index = skipWhitespaceAndComments(code, afterDefault);
     if (code[index] === ",") index = skipWhitespaceAndComments(code, index + 1);
   }
@@ -284,7 +566,7 @@ const readImportBindings = (code: string, index: number): { specifier: string; n
         if (!local) return null;
         index = skipWhitespaceAndComments(code, local.end);
       }
-      if (!typeOnly) names.push(imported.name);
+      (typeOnlyImport || typeOnly ? (typeOnlyNames ??= []) : names).push(imported.name);
       if (code[index] === ",") index = skipWhitespaceAndComments(code, index + 1);
       else if (code[index] !== "}") return null;
     }
@@ -294,39 +576,60 @@ const readImportBindings = (code: string, index: number): { specifier: string; n
   if (!isKeywordAt(code, index, "from")) return null;
   const start = skipWhitespaceAndComments(code, index + "from".length);
   const literal = readStringLiteral(code, start);
-  return literal?.value ? { specifier: literal.value, names, start, end: literal.end, terminated: literal.terminated } : null;
+  return literal?.value ? { specifier: literal.value, names, allNames: typeOnlyNames ? [...names, ...typeOnlyNames] : names, start, end: literal.end, terminated: literal.terminated, ...(typeOnlyImport ? { notLinked: true } : {}) } : null;
 };
 
-// Walks module-level import/export statements and reports each specifier with the export names bound from it
+// Walks module-level import/export statements and reports each specifier with its runtime names plus all source names
 // (empty for namespace, side-effect, re-export and dynamic imports). `onSpecifier` is the single output channel —
 // callers project it into whatever shape they need. `site` separates the module graph from `import.meta.resolve()`,
 // which is a runtime asset lookup rather than an edge.
-type ResolutionSite = "import" | "meta-resolve";
+export type ResolutionSite = "import" | "meta-resolve";
 type SpecifierRange = { start: number; end: number };
-const collectModuleSpecifiers = (code: string, onSpecifier: (specifier: string, names: string[], notLinked: boolean | undefined, site: ResolutionSite, range?: SpecifierRange) => void, start = 0, end = code.length) => {
-  for (let index = start; index < end; index += 1) {
+// `attributesPartial` marks a specifier whose `with { … }` clause is still streaming. The specifier itself is complete, so
+// import-map building and specifier rewriting must still see it; only probing has to withhold, since replaying a clause that
+// has not fully arrived would link a form the module never requested.
+const collectModuleSpecifiers = (
+  code: string,
+  onSpecifier: (specifier: string, names: string[], notLinked: boolean | undefined, site: ResolutionSite, range?: SpecifierRange, allNames?: string[], attributes?: Record<string, string>, attributesPartial?: boolean) => void,
+  start = 0,
+  end = code.length,
+  jsxScanCache: JsxScanCache = new Map(),
+) => {
+  const scanExpression = (expressionStart: number, expressionEnd: number) => collectModuleSpecifiers(code, onSpecifier, expressionStart, expressionEnd, jsxScanCache);
+  const openParens: number[] = [];
+  const commentStarts = new Map<number, number>();
+  let closedParen: number | undefined;
+  // Each branch below already lands on the next unscanned character, so consuming branches `continue` past the tail
+  // increment. Adding one on top of them skipped a token abutting the construct before it (`/*! banner */import"react"`).
+  let index = start;
+  while (index < end) {
+    // Each branch below gates its predicate on `char` first: those calls each re-test the same character and bail, so
+    // paying them on all ~1.7M characters instead of the <1% that can match cost 1.7x of the whole scan.
     const char = code[index];
-    if (char === "/" && code[index + 1] === "/") {
-      index = skipLineComment(code, index);
-      continue;
+    if (char === "<" && isLikelyJsxStart(code, index, closedParen, commentStarts)) {
+      const jsxEnd = skipJsxElement(code, index, jsxScanCache, scanExpression);
+      if (jsxEnd > index) {
+        index = jsxEnd;
+        continue;
+      }
     }
-    if (char === "/" && code[index + 1] === "*") {
-      index = skipBlockComment(code, index);
+    if (char === "/" && (code[index + 1] === "/" || code[index + 1] === "*")) {
+      index = skipScannedComment(code, index, commentStarts);
       continue;
     }
-    if (isLikelyRegexLiteralStart(code, index)) {
+    if (char === "/" && isLikelyRegexLiteralStart(code, index, commentStarts)) {
       index = skipRegexLiteral(code, index);
       continue;
     }
     if (char === '"' || char === "'") {
-      index = readStringLiteral(code, index)?.end ?? index;
+      index = readStringLiteral(code, index)?.end ?? index + 1;
       continue;
     }
     if (char === "`") {
-      index = skipTemplateLiteral(code, index, (expressionStart, expressionEnd) => collectModuleSpecifiers(code, onSpecifier, expressionStart, expressionEnd));
+      index = skipTemplateLiteral(code, index, jsxScanCache, scanExpression);
       continue;
     }
-    if (isKeywordAt(code, index, "import")) {
+    if (char === "i" && isKeywordAt(code, index, "import")) {
       const afterImport = skipWhitespaceAndComments(code, index + "import".length);
       if (code[afterImport] === ".") {
         // Keep runtime asset lookups visible to callers that scan all specifiers, while separating them from actual
@@ -335,6 +638,8 @@ const collectModuleSpecifiers = (code: string, onSpecifier: (specifier: string,
         if (literal) {
           // notLinked: nothing is instantiated here, so probing it would fetch what the module never requested.
           if (literal.terminated && literal.value) onSpecifier(literal.value, [], true, "meta-resolve", { start: literal.start, end: literal.end });
+          // The fast path skips `(` but leaves `)` to the loop; keep an enclosing condition's parens balanced.
+          if (literal.end > literal.openParen) openParens.push(literal.openParen);
           index = literal.end;
           continue;
         }
@@ -346,23 +651,63 @@ const collectModuleSpecifiers = (code: string, onSpecifier: (specifier: string,
         const literal = readStringLiteral(code, literalStart);
         // A dynamic target is not linked at instantiation, so probing it would issue a real request.
         if (literal?.terminated && literal.value) onSpecifier(literal.value, [], true, "import", { start: literalStart, end: literal.end });
+        if (literal) openParens.push(afterImport);
         index = literal?.end ?? afterImport;
         continue;
       }
       const bindings = readImportBindings(code, afterImport);
-      const from = bindings ?? readFromSpecifier(code, afterImport);
-      if (from?.terminated && from.specifier) onSpecifier(from.specifier, bindings?.names ?? [], bindings?.notLinked, "import", { start: from.start, end: from.end });
-      index = from?.end ?? afterImport;
+      const from = bindings ?? readFromSpecifier(code, afterImport, jsxScanCache);
+      // A truncated clause can lose its bindings, but must not turn an erased import into a runtime fetch.
+      const notLinked = bindings ? bindings.notLinked : readImportTypeModifierEnd(code, afterImport) !== undefined;
+      // Fire the callback even during streaming: rewriteImportSpecifiers needs the range to replace the bare specifier with
+      // the resolved target. `clause.partial` tells the probe path to withhold instead — see readImportAttributes.
+      if (from?.terminated && from.specifier) {
+        const clause = readImportAttributes(code, from.end, jsxScanCache);
+        onSpecifier(from.specifier, bindings?.names ?? [], notLinked, "import", { start: from.start, end: from.end }, bindings?.allNames, clause?.attributes, clause?.partial);
+        // Only a complete clause is safe to resume past: a partial one's `end` is where the scan gave up, which for an
+        // unclosed brace is EOF and for an unterminated value sits inside that string — resuming there would swallow every
+        // import after it. Fall back to the specifier's own end, which the pre-attributes scanner used.
+        index = clause && !clause.partial ? clause.end : from.end;
+      } else {
+        index = from?.end ?? afterImport;
+      }
       continue;
     }
-    if (isKeywordAt(code, index, "export")) {
-      const from = readExportFromSpecifier(code, index + "export".length);
-      if (from?.terminated && from.specifier) onSpecifier(from.specifier, [], undefined, "import", { start: from.start, end: from.end });
-      index = from?.end ?? index;
+    if (char === "e" && isKeywordAt(code, index, "export")) {
+      const from = readExportFromSpecifier(code, index + "export".length, jsxScanCache);
+      // Same split as the import branch: rewriting sees every specifier, the probe path withholds partial clauses.
+      if (from?.terminated && from.specifier) {
+        const clause = readImportAttributes(code, from.end, jsxScanCache);
+        onSpecifier(from.specifier, [], from.notLinked, "import", { start: from.start, end: from.end }, undefined, clause?.attributes, clause?.partial);
+        // A partial clause's `end` can sit inside its own unterminated string, where resuming would re-lex the rest of the
+        // file as that string and lose every import after it; leave the specifier's own end to advance instead.
+        index = clause && !clause.partial ? clause.end : from.end;
+      } else {
+        // Null means a local `export` that consumed nothing, so step one char rather than rescanning the same `e`.
+        index = from?.end ?? index + 1;
+      }
+      continue;
     }
+    if (char === "(") openParens.push(index);
+    else if (char === ")") closedParen = openParens.pop();
+    index += 1;
   }
 };
 
+// Accumulates per-specifier names, deduped across repeated imports of the same module. `select` picks which projection
+// of the clause to merge, or returns undefined to drop the specifier entirely.
+const collectNamesBySpecifier = (code: string, select: (names: string[], allNames: string[], notLinked: boolean | undefined, site: ResolutionSite) => string[] | undefined) => {
+  const bindings = new Map<string, Set<string>>();
+  collectModuleSpecifiers(code, (specifier, names, notLinked, site, _range, allNames) => {
+    const selected = select(names, allNames ?? names, notLinked, site);
+    if (!selected) return;
+    let collected = bindings.get(specifier);
+    if (!collected) bindings.set(specifier, (collected = new Set()));
+    for (const name of selected) collected.add(name);
+  });
+  return new Map([...bindings].map(([specifier, names]) => [specifier, [...names]] as const));
+};
+
 const extractSpecifiers = (code: string, keep: (specifier: string, site: ResolutionSite) => boolean) => {
   const specifiers = new Set<string>();
   collectModuleSpecifiers(code, (specifier, _names, _notLinked, site) => {
@@ -371,6 +716,24 @@ const extractSpecifiers = (code: string, keep: (specifier: string, site: Resolut
   return specifiers;
 };
 
+// One walk, one Set per kind, for a caller that needs several projections of the same buffer: two `extract*` calls walk
+// it twice, and this scan is not cheap — JSX tag recognition, per-character code-point classification and escape
+// decoding all run per character. `classify` returns the kind a specifier belongs to, or undefined to drop it, and is
+// asked once per occurrence rather than once per specifier — so nothing here makes the kinds exclusive. `site` may gate
+// a kind down to undefined, but a `classify` that answers *different* kinds at different sites buckets one specifier
+// twice, and unioning the buckets then repeats it (`Set`s dedupe within a kind, not across). Buckets are keyed for
+// every `K` the caller asks for, empty ones included, so a destructuring caller never reads undefined.
+// `NoInfer` so `kinds` is the only inference source: otherwise a `classify` answering with an unlisted kind widens `K`
+// instead of being rejected, and the unlisted key has no bucket to `add` to.
+export const extractSpecifiersByKind = <const K extends string>(code: string, kinds: readonly K[], classify: (specifier: string, site: ResolutionSite) => NoInfer<K> | undefined) => {
+  const buckets = Object.fromEntries(kinds.map((kind) => [kind, new Set<string>()])) as Record<K, Set<string>>;
+  collectModuleSpecifiers(code, (specifier, _names, _notLinked, site) => {
+    const kind = classify(specifier, site);
+    if (kind !== undefined) buckets[kind].add(specifier);
+  });
+  return buckets;
+};
+
 export const extractBareModuleSpecifiers = (code: string) => extractSpecifiers(code, isBareModuleSpecifier);
 
 // Specifiers reached through an `import`/`export` statement only — the actual module graph. Excludes
@@ -418,17 +781,30 @@ export const rewriteImportMetaResolveSpecifiers = (code: string, imports: Readon
 export const rewriteImportSpecifiers = (code: string, imports: Readonly<Record<string, string>>) => rewriteSpecifiers(code, imports, "import");
 
 // Maps each specifier linked when the module is instantiated to the export names bound from it ("default" included;
-// namespace, side-effect and re-export imports demand no specific names). Type-only and dynamic imports are excluded:
-// neither is linked at instantiation, so probing them would fetch something the failed module never requested.
-// importProbe runs this over *compiled* code, where the import-map rewrite already resolved bare specifiers.
+// namespace, side-effect and re-export imports demand no specific names) and the `with { … }` attributes it was imported
+// under. Type-only and dynamic imports are excluded: neither is linked at instantiation, so probing them would fetch
+// something the failed module never requested. importProbe runs this over *compiled* code, where the import-map rewrite
+// already resolved bare specifiers.
 export function extractImportBindings(code: string) {
-  const bindings = new Map<string, string[]>();
-  collectModuleSpecifiers(code, (specifier, names, notLinked) => {
-    if (!notLinked) bindings.set(specifier, [...new Set([...(bindings.get(specifier) ?? []), ...names])]);
+  const bindings = new Map<string, { names: Set<string>; attributes?: Record<string, string> }>();
+  collectModuleSpecifiers(code, (specifier, names, notLinked, _site, _range, _allNames, attributes, attributesPartial) => {
+    if (notLinked) return;
+    // This is the probe path, so a clause that has not fully arrived must not be replayed — see readImportAttributes.
+    if (attributesPartial) return;
+    let entry = bindings.get(specifier);
+    // One probe stands in for every import of a specifier, so it must replay the FIRST clause seen — including no clause
+    // at all. Letting a later `with { … }` fill in for a bare import probes a form the module never used, turning a
+    // genuine link failure into a silent pass.
+    if (!entry) bindings.set(specifier, (entry = { names: new Set(), attributes }));
+    for (const name of names) entry.names.add(name);
   });
-  return bindings;
+  return new Map([...bindings].map(([specifier, { names, attributes }]) => [specifier, { names: [...names], attributes }] as const));
 }
 
+// Standalone facade declarations also need names imported only for type positions; unlike runtime probing, those imports
+// are erased from the module graph but still need ambient members.
+export const extractImportedExportNames = (code: string) => collectNamesBySpecifier(code, (_names, allNames, _notLinked, site) => (site === "import" ? allNames : undefined));
+
 export function hasImportMapEntry(imports: Record<string, string> | Set<string> | Map<string, string>, specifier: string) {
   const keys = imports instanceof Set ? imports : imports instanceof Map ? new Set(imports.keys()) : new Set(Object.keys(imports));
   if (keys.has(specifier)) return true;
@@ -633,7 +1009,18 @@ export function packageImportMap(packageName: string, options?: { resolve?: (nam
       if (!importMap) throw new Error(`${packageName} has no package.json#genui.importMap — add it to declare the GenUI importmap contract`);
       const packageDir = dirname(manifestPath);
       const rebase = (target: string) => (target.startsWith(".") ? resolvePath(packageDir, target) : target);
-      return { imports: Object.fromEntries(Object.entries(importMap.imports ?? {}).map(([specifier, target]) => [specifier, rebase(target)])), styles: importMap.styles?.map(rebase) };
+      const rebaseEntries = (entries: Record<string, string>) => Object.fromEntries(Object.entries(entries).map(([specifier, target]) => [specifier, rebase(target)]));
+      const rebasedScopes =
+        importMap.scopes &&
+        Object.fromEntries(
+          Object.entries(importMap.scopes).map(([scope, entries]) => {
+            // Validate scope keys are valid URL prefixes (absolute path or URL) after rebasing
+            const rebased = rebase(scope);
+            if (!rebased.startsWith("/") && !/^https?:\/\//i.test(rebased)) throw new Error(`Invalid import map scope key "${scope}" (rebased to "${rebased}"): must be an absolute path or URL`);
+            return [rebased, rebaseEntries(entries)];
+          }),
+        );
+      return { imports: rebaseEntries(importMap.imports ?? {}), scopes: rebasedScopes, styles: importMap.styles?.map(rebase) };
     },
   };
 }

package/src/importProbe.ts

@@ -37,14 +37,16 @@ const reverseResolveSpecifier = (entries: [string, string][], target: string) =>
 // targets back to the bare specifiers the model wrote.
 export async function probeModuleImports(code: string, imports?: Record<string, string>): Promise<GenUIImportDiagnostic[]> {
   const importEntries = Object.entries(imports ?? {});
-  const probes = [...extractImportBindings(code)].map(async ([target, names]): Promise<GenUIImportDiagnostic | null> => {
+  const probes = [...extractImportBindings(code)].map(async ([target, { names, attributes }]): Promise<GenUIImportDiagnostic | null> => {
     const specifier = reverseResolveSpecifier(importEntries, target);
     let module: Record<string, unknown>;
     try {
       // `target` is import-map-resolved at runtime, so it needs the same three-bundler ignore stack as the blob import
       // in runtime.ts — otherwise every probe throws `Cannot find module 'unknown'` and reports each dependency as
       // broken, burying the one that actually is. #1688
-      module = (await import(/* @vite-ignore */ /* webpackIgnore: true */ /* turbopackIgnore: true */ target)) as Record<string, unknown>;
+      // The original `with { type: … }` clause must be replayed: a JSON/CSS module re-imported without it always
+      // fails, which would report a dependency that actually linked as the broken one. #1818
+      module = (await import(/* @vite-ignore */ /* webpackIgnore: true */ /* turbopackIgnore: true */ target, attributes ? { with: attributes } : undefined)) as Record<string, unknown>;
     } catch (error) {
       return { specifier, target, detail: `failed to load: ${error instanceof Error ? error.message : String(error)}` };
     }

package/src/nodeWasm.ts

@@ -0,0 +1,11 @@
+// Kept out of `compiler.ts` so browser bundles never see `import.meta.resolve`: it is a syntax-level construct, so a
+// bundler emitting CJS produces a file that throws on evaluation no matter which branch would run. #1717
+// Typed off `globalThis` instead of the `Bun` global to avoid forcing `@types/bun` on consumers (we ship raw `.ts`).
+const bun = (globalThis as { Bun?: { file(path: URL): { arrayBuffer(): Promise<ArrayBuffer> } } }).Bun;
+
+export const loadNodeWasm = async () => {
+  // `import.meta.resolve` yields a `file://` URL under both Bun and Node/Vite SSR, so `new URL` is safe — don't "fix" it with pathToFileURL.
+  const wasmUrl = new URL(import.meta.resolve("@esm.sh/tsx/pkg/tsx_bg.wasm"));
+  if (bun) return bun.file(wasmUrl).arrayBuffer();
+  return (await import("node:fs/promises")).readFile(wasmUrl);
+};