partial-tsx 0.0.3 → 0.0.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "partial-tsx",
   "description": "Utilities for completing prefix-growing TSX.",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "type": "module",
   "repository": {
     "type": "git",

package/src/partial.ts

@@ -6,6 +6,10 @@ export type PartialTsxOptions = { mode?: PartialTsxMode };
 type BlockKind = "function" | "control" | "arrow" | "class" | "method" | "block" | "other";
 type CompletionFrame = { type: "block"; closer: string; statement: boolean; open?: number; close?: number; jsxExpression?: boolean; statementStart?: number; kind?: BlockKind } | { type: "jsx"; tag: string; open?: number };
 
+// Single source of truth for the JSX-text fast path in the four lexer loops below: only `<` (child tag) and `{` (child
+// expression) leave text mode, so none of them reads `(`/`[`/quotes/`//` in ordinary text as unfinished JavaScript.
+const isJsxTextBoundary = (char: string) => char === "<" || char === "{";
+
 const stripMarkdownFence = (code: string) => {
   let next = code.trim();
   next = next.replace(/^```(?:[^\r\n]*)?(?:\r?\n|$)/i, "");
@@ -78,7 +82,7 @@ const maskIgnoredTextForExportScan = (code: string, regexLiteralStarts?: Readonl
   const stack: CompletionFrame[] = [];
   for (let index = 0; index < code.length; index += 1) {
     const char = code[index];
-    if (isInsideJsxText(stack) && char !== "<" && char !== "{") {
+    if (isInsideJsxText(stack) && !isJsxTextBoundary(char)) {
       if (chars[index] !== "\n") chars[index] = " ";
       continue;
     }
@@ -157,14 +161,28 @@ const findWrappedComponentCallOpen = (code: string, index: number) => {
   return code[index] === "(" ? index : -1;
 };
 const isWrappedImplementationFunction = (code: string, index: number) => /\b(?:memo|forwardRef)\s*(?:<[\s\S]*>)?\s*\($/.test(code.slice(0, index).trimEnd());
+const isAmbientDeclaration = (code: string, index: number) => /\bdeclare\s+(?:abstract\s+)?$/.test(code.slice(0, index));
+// A class/function expression's own name is bound only inside its body, so the enclosing binding it is assigned to is the
+// exportable one. Without a binding (argument, object value, `return`) nothing is exportable and the candidate is dropped.
+// A lone HOC call (`withTheme(class Inner …)`) is skipped so arbitrary wrappers resolve like the `memo`/`forwardRef` loop below.
+const findExpressionBindingName = (code: string, index: number) => /\b(?:const|let|var)\s+([A-Z][\w$]*)\s*(?::[^=]+)?=\s*(?:[A-Za-z_$][\w$.]*\s*(?:<[^<>()]*>)?\s*\(\s*)?$/.exec(code.slice(0, index))?.[1] ?? null;
+const isExpressionPosition = (code: string, index: number) => !/(?:^|[;}]|(?<!\$)\{|\n)\s*(?:(?:export\s+)?(?:default\s+)?(?:declare\s+)?(?:abstract\s+)?(?:async\s+)?)$/.test(code.slice(0, index));
 
 const findLastExportableComponent = (code: string) => {
   const candidates: Array<{ name: string; index: number }> = [];
   for (const match of code.matchAll(/\bfunction\s+([A-Z][\w$]*)\s*\(/g)) {
-    if (!isWrappedImplementationFunction(code, match.index ?? 0)) candidates.push({ name: match[1], index: match.index ?? 0 });
+    const index = match.index ?? 0;
+    if (isWrappedImplementationFunction(code, index) || isAmbientDeclaration(code, index)) continue;
+    const name = isExpressionPosition(code, index) ? findExpressionBindingName(code, index) : match[1];
+    if (name) candidates.push({ name, index });
   }
-  for (const match of code.matchAll(/\bclass\s+([A-Z][\w$]*)\s+extends\s+(?:(?:React\.)?(?:Pure)?Component|[A-Za-z_$][\w$]*\.Component)\b/g)) candidates.push({ name: match[1], index: match.index ?? 0 });
-  for (const match of code.matchAll(/\b(?:const|let|var)\s+([A-Z][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)?\s*=>/g)) candidates.push({ name: match[1], index: match.index ?? 0 });
+  for (const match of code.matchAll(/\bclass\s+([A-Z][\w$]*)\s+extends\s+(?:[A-Za-z_$][\w$]*\.)?(?:Pure)?Component\b/g)) {
+    const index = match.index ?? 0;
+    if (isAmbientDeclaration(code, index)) continue;
+    const name = isExpressionPosition(code, index) ? findExpressionBindingName(code, index) : match[1];
+    if (name) candidates.push({ name, index });
+  }
+  for (const match of code.matchAll(/\b(?:const|let|var)\s+([A-Z][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)?\s*(?::[^=;\n]+)?=>/g)) candidates.push({ name: match[1], index: match.index ?? 0 });
   for (const match of code.matchAll(/\b(?:const|let|var)\s+([A-Z][\w$]*)\s*(?::[^=]+)?=\s*(?:[A-Za-z_$][\w$]*\.)?(?:memo|forwardRef)\s*/g)) {
     if (findWrappedComponentCallOpen(code, (match.index ?? 0) + match[0].length) !== -1) candidates.push({ name: match[1], index: match.index ?? 0 });
   }
@@ -174,6 +192,37 @@ const findLastExportableComponent = (code: string) => {
 // so the scan does not miss an existing default and append a second one (`Duplicate export of 'default'`).
 const hasDefaultExportDeclaration = (code: string) => /(?:^|[\n;}])\s*export\s+default\s+(?:async\s+)?(?:function|class|[A-Za-z_$]|\(|<)/m.test(code) || /(?:^|[\n;}])\s*export\s*\{[^}]*\b(?:as\s+default|default\s*(?:,|}))[^}]*\}/m.test(code);
 
+const maskAmbientBlocks = (scanned: string) => {
+  const matches = [...scanned.matchAll(/\bdeclare\s+(?:namespace|module|global)\b[^{;]*\{/g)];
+  if (!matches.length) return scanned;
+  const chars = scanned.split("");
+  // Ambient blocks can contain component-shaped declarations, but none survive into the runtime module.
+  for (const match of matches) {
+    let depth = 1;
+    let end = match.index + match[0].length;
+    while (end < scanned.length && depth) {
+      if (scanned[end] === "{") depth += 1;
+      else if (scanned[end] === "}") depth -= 1;
+      end += 1;
+    }
+    maskExportScanRange(chars, match.index, end);
+  }
+  return chars.join("");
+};
+// Reuse the normalizer's lexical scan: component declarations inside comments or strings are not preview entry points.
+export function hasReactComponent(code: string) {
+  const scanned = maskAmbientBlocks(maskIgnoredTextForExportScan(code));
+  if (findLastExportableComponent(scanned)) return true;
+  for (const match of scanned.matchAll(/(?:^|[\n;}])\s*export\s+default\s+(?:async\s+)?/g)) {
+    const start = match.index + match[0].length;
+    const expression = scanned.slice(start);
+    if (/^(?:function\b|class\s+(?:[A-Za-z_$][\w$]*\s+)?extends\s+(?:[A-Za-z_$][\w$]*\.)?(?:Pure)?Component\b|(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*(?::[^=;\n]+)?=>)/.test(expression)) return true;
+    const wrapper = /^(?:[A-Za-z_$][\w$]*\.)?(?:memo|forwardRef)\b/.exec(expression);
+    if (wrapper && findWrappedComponentCallOpen(scanned, start + wrapper[0].length) !== -1) return true;
+  }
+  return false;
+}
+
 // React hooks the model commonly forgets to import. Stay conservative: anything outside this set (custom hooks, react-dom hooks like useFormStatus) is left alone.
 const REACT_HOOK_NAMES = new Set([
   "useState",
@@ -272,8 +321,9 @@ const isLikelyJsxTagStart = (code: string, index: number) => {
   return previousChar !== ">";
 };
 
-const isLikelyStatementBlock = (code: string, index: number) => {
-  if (code[index] !== "{") return false;
+const isLikelyStatementBlock = (code: string, index: number, stack: CompletionFrame[]) => {
+  // A JSX child expression stays an expression even when the preceding prose looks like a JavaScript block header.
+  if (code[index] !== "{" || isInsideJsxText(stack)) return false;
   const before = code.slice(0, index).trimEnd();
   return /\bfunction(?:\s+[\w$]+)?\s*\([^)]*\)$/.test(before) || /\b(?:if|for|while|switch|with)\s*\([^)]*\)$/.test(before) || /\bcatch(?:\s*\([^)]*\))?$/.test(before) || /(?:^|[^\w$])(?:else|try|finally|do)$/.test(before) || before.endsWith("=>");
 };
@@ -475,25 +525,26 @@ const collectCompletionStackBefore = (code: string, end: number) => {
   const stack: CompletionFrame[] = [];
   for (let index = 0; index < end; index += 1) {
     const char = code[index];
-    if (!isInsideJsxText(stack) && char === "/" && code[index + 1] === "/") {
+    if (isInsideJsxText(stack) && !isJsxTextBoundary(char)) continue;
+    if (char === "/" && code[index + 1] === "/") {
       const newlineIndex = code.indexOf("\n", index + 2);
       index = (newlineIndex === -1 ? end : Math.min(newlineIndex, end)) - 1;
       continue;
     }
-    if (!isInsideJsxText(stack) && char === "/" && code[index + 1] === "*") {
+    if (char === "/" && code[index + 1] === "*") {
       const closeIndex = code.indexOf("*/", index + 2);
       index = (closeIndex === -1 ? end : Math.min(closeIndex + 2, end)) - 1;
       continue;
     }
-    if (!isInsideJsxText(stack) && isLikelyRegexLiteralStart(code, index)) {
+    if (isLikelyRegexLiteralStart(code, index)) {
       index = Math.min(findRegexLiteralEnd(code, index), end) - 1;
       continue;
     }
-    if (!isInsideJsxText(stack) && (char === '"' || char === "'")) {
+    if (char === '"' || char === "'") {
       index = Math.min(findStringLiteralEnd(code, index), end) - 1;
       continue;
     }
-    if (!isInsideJsxText(stack) && char === "`") {
+    if (char === "`") {
       index = Math.min(findTemplateLiteralEnd(code, index), end) - 1;
       continue;
     }
@@ -504,7 +555,7 @@ const collectCompletionStackBefore = (code: string, end: number) => {
       index = closeIndex;
       continue;
     }
-    if (char in BLOCK_FOLLOWERS) stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: isLikelyStatementBlock(code, index) });
+    if (char in BLOCK_FOLLOWERS) stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: false });
     else if (BLOCK_CLOSERS.has(char)) {
       const frame = stack.at(-1);
       if (frame?.type === "block" && frame.closer === char) stack.pop();
@@ -629,11 +680,13 @@ const hasUnclosedTypeArgument = (body: string) => {
   return true;
 };
 // Locate the last `const`/`let`/`var` whose declaration runs to EOF without a depth-0 `;` terminator, scanning the
-// literal-masked text so a `;`/`{`/`<` sitting inside a string or comment (`const s = "a; const x = useState<T"`) is never
+// JSX/literal-masked text so prose declarations and a `;`/`{`/`<` inside a string or comment (`const s = "a; const x = useState<T"`) are never
 // mistaken for a statement boundary. A declaration can begin at the buffer start or right after `{`, `}`, `;`, or `=>`; we keep
 // the latest one that isn't closed by a depth-0 `;` or by a `)`/`]`/`}` that pops out of its enclosing block.
 const locateTrailingDeclaration = (value: string) => {
-  const masked = maskLiteralSpans(value);
+  // Masking cannot create a keyword, so skip the JSX scan on keyword-free streaming prefixes.
+  if (!/\b(?:const|let|var)\b/.test(value)) return null;
+  const masked = maskIgnoredTextForExportScan(value);
   const re = /(?:^|[{};\n]|=>)\s*(const(?!\s+enum\b)|let|var)\b/g;
   let match: RegExpExecArray | null;
   let start = -1;
@@ -732,18 +785,25 @@ const isCompleteDoWhileStatement = (value: string, scan = scanStreamingSource(va
   return false;
 };
 const dropTrailingBareLoopHeader = (value: string) => {
-  const masked = maskLiteralSpans(value).trimEnd();
+  // Masking only ever blanks spans, so it can neither synthesize a `)` nor the letters of the keyword: a value missing
+  // either can never yield a droppable header, and skipping the mask here saves it on most calls of a stream. This does
+  // NOT license hoisting the `endsWith(")")` check below — blanking trailing trivia changes *which* `)` is last, so
+  // `while (a) // note` masks to a droppable header the raw value does not end with.
+  if (!value.includes(")") || !/\b(?:for|while)\b/.test(value)) return value;
+  // Mask JSX too, not just literals: prose like `<p>run for (i` ends in a synthesized `)` closer whose matching `(` sits in
+  // committed text, and `maskLiteralSpans` would let the preceding word read as a real `for`/`while` keyword — rolling the
+  // already-rendered JSX back to `<p>run`.
+  const masked = maskIgnoredTextForExportScan(value).trimEnd();
   if (!masked.endsWith(")")) return value;
   const index = findMatchingOpener(masked, "(", ")");
   if (index <= 0) return value;
   const head = masked.slice(0, index).trimEnd();
-  const match = /\b(for|while)$/.exec(head);
+  const match = /\b(for(?:\s+await)?|while)$/.exec(head);
   if (!match) return value;
   const before = head.slice(0, match.index);
-  // A reserved word used as a member name or identifier suffix is a reference, not a loop: `obj.for(x)`, `arr?.while(p)`,
-  // `a$for(1)` must survive intact. `\b` treats `.` and `$` as boundaries, so guard both — `$` is the only identifier-
-  // continuation char that can precede the keyword (letters/digits/`_` are word chars `\b` would not break on).
-  if (/[.$]$/.test(before.trimEnd())) return value;
+  // `\b` only understands ASCII word characters: member names and Unicode/escaped identifier suffixes are not loops.
+  // Keep whitespace for the identifier check so a separate keyword after an identifier still gets dropped.
+  if (/[.#]$/.test(before.trimEnd()) || /[$\p{ID_Continue}\u200c\u200d]$|\\u\{[\da-f]+\}$/iu.test(before)) return value;
   // `do { ... } while (cond)` is a complete statement that needs no body — keep it. Tell it apart from a plain `while` that
   // merely follows another block (`while(a){...} while(b`) by parsing the source and checking this trailing `while` closes a `do`.
   if (match[1] === "while" && isCompleteDoWhileStatement(value)) return value;
@@ -757,7 +817,9 @@ const dropTrailingBareLoopHeader = (value: string) => {
 // inner frames whose openers were inside the rolled-back span.
 const completeBlockFrame = (output: string, frame: Extract<CompletionFrame, { type: "block" }>) => {
   if (frame.statement) return { text: `${output}${frame.closer}`, dropped: false };
-  const completed = completeIncompleteExpressionPrefix(output, true);
+  // Clean JSX child expressions before `}` hides their loop header; other frames can contain valid type methods `for(...)`.
+  // Drop the header before completing its prefix: it can expose an operator or be hidden by a synthesized ternary branch.
+  const completed = completeIncompleteExpressionPrefix(frame.jsxExpression ? dropTrailingBareLoopHeader(output) : output, true);
   const openerGone = frame.open !== undefined ? completed.length <= frame.open : completed.length < output.length;
   if (openerGone) return { text: completed, dropped: true };
   return { text: `${completed}${frame.closer}`, dropped: false };
@@ -779,12 +841,16 @@ const completeStatementPrefixFrame = (output: string, frame: CompletionFrame): {
 // Close frames from the stack top down. A frame whose own opening bracket was rolled back by a declaration drop must not emit a
 // closer — `completeBlockFrame` detects that and reports `open: number` for the bracket position it would have closed, so once
 // a drop happens we know which later frames lost their opener (those whose recorded bracket offset is past the drop point).
-const closeStackFrames = (output: string, frames: CompletionFrame[]) => {
+const closeStackFrames = (output: string, frames: CompletionFrame[], beforeCloser?: (text: string, closer: string) => string) => {
   let text = output;
   let dropPoint = Infinity;
   for (const frame of frames) {
     if (frame.type === "block" && frame.open !== undefined && frame.open >= dropPoint) continue;
     const result = completeStatementPrefixFrame(text, frame);
+    if (beforeCloser && !result.dropped) {
+      const closer = closeFrame(frame);
+      result.text = beforeCloser(result.text.slice(0, -closer.length), closer);
+    }
     if (result.dropped) dropPoint = Math.min(dropPoint, result.text.length);
     text = result.text;
   }
@@ -1008,7 +1074,7 @@ const isAsiBoundary = (before: string, after: string, leftEndsWithRegexLiteral =
   const endsWithContinuingPunctuator = /[=+\-*/%&|^~?!<>.:,([]$/.test(left) && !endsWithPostfixUpdate(left) && !(left.endsWith("/") && leftEndsWithRegexLiteral) && !(left.endsWith(">") && endsWithCompleteJsxTag(left));
   if (!left || !right || endsWithContinuingPunctuator || right.startsWith(".") || LINE_CONTINUING_KEYWORD_OPERATOR.test(left)) return false;
   if (FUNCTION_HEADER.test(left) || (/(?:^|\n)\s*(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\b/.test(left) && !hasTopLevelClassBody(left))) return false;
-  return /^(?:const|let|var|return|throw|if|else|for|while|switch|try|catch|finally|do|function|class|import|export)\b|^[A-Za-z_$][\w$]*(?:\s*(?:[=(]|$))/.test(right);
+  return /^(?:const|let|var|return|throw|if|else|for|while|switch|try|catch|finally|do|function|class|import|export|type)\b|^[A-Za-z_$][\w$]*(?:\s*(?:[=(]|$))/.test(right);
 };
 
 const isClosedQuotedLiteral = (code: string, start: number, end: number, quote: string) => end > start + 1 && code[end - 1] === quote && (code.slice(start, end - 1).match(/\\+$/)?.[0].length ?? 0) % 2 === 0;
@@ -1087,9 +1153,22 @@ const scanStreamingSource = (code: string): StreamingScan => {
     unclosedLiteralStatementStart = isTrailingClosedRegexLiteral(code, index, lastRegexLiteralStart) || (Boolean(statement.trim()) && hasSafeExpressionTail(statement)) ? index : statementStart;
   };
   while (index < code.length) {
-    const insideJsxText = stack.at(-1)?.type === "jsx";
+    const insideJsxText = isInsideJsxText(stack);
     const char = code[index];
-    if (!insideJsxText && char === "/" && code[index + 1] === "/") {
+    // A label such as "shape (E, r" is committed JSX text, not an unfinished JS call that can roll back the whole return.
+    // Text advances `lastSignificantEnd` but must NOT reach the `;`/`\n` boundary gates below: committing a statement at a
+    // `;` in prose would move the rollback cut into the label. Kept parallel to the shared tail rather than falling through
+    // to it for that reason. `statementRegexBoundary` is only ever set by a statement `}` pop, which leaves a block frame on
+    // top, so it is already false here — mirroring the tail costs one line and keeps the two blocks diffable.
+    if (insideJsxText && !isJsxTextBoundary(char)) {
+      if (!/\s/.test(char)) {
+        statementRegexBoundary = false;
+        lastSignificantEnd = index + 1;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === "/" && code[index + 1] === "/") {
       const newlineIndex = code.indexOf("\n", index + 2);
       if (newlineIndex === -1) {
         markDisposableComment(); // the comment itself is disposable; preserve only a complete statement before it
@@ -1101,7 +1180,7 @@ const scanStreamingSource = (code: string): StreamingScan => {
       index = newlineIndex + 1;
       continue;
     }
-    if (!insideJsxText && char === "/" && code[index + 1] === "*") {
+    if (char === "/" && code[index + 1] === "*") {
       const closeIndex = code.indexOf("*/", index + 2);
       if (closeIndex === -1) {
         markDisposableComment();
@@ -1110,7 +1189,7 @@ const scanStreamingSource = (code: string): StreamingScan => {
       index = closeIndex + 2;
       continue;
     }
-    if (!insideJsxText && ((statementRegexBoundary && char === "/") || isLikelyRegexLiteralStart(code, index))) {
+    if ((statementRegexBoundary && char === "/") || isLikelyRegexLiteralStart(code, index)) {
       regexLiteralStarts.add(index);
       lastRegexLiteralStart = index;
       statementRegexBoundary = false;
@@ -1123,7 +1202,7 @@ const scanStreamingSource = (code: string): StreamingScan => {
       index = end;
       continue;
     }
-    if (!insideJsxText && (char === '"' || char === "'")) {
+    if (char === '"' || char === "'") {
       statementRegexBoundary = false;
       const end = findStringLiteralEnd(code, index);
       if (!isClosedQuotedLiteral(code, index, end, char)) {
@@ -1134,7 +1213,7 @@ const scanStreamingSource = (code: string): StreamingScan => {
       index = end;
       continue;
     }
-    if (!insideJsxText && char === "`") {
+    if (char === "`") {
       statementRegexBoundary = false;
       const literal = scanTemplateLiteralEnd(code, index);
       if (!literal.closed) {
@@ -1193,7 +1272,7 @@ const scanStreamingSource = (code: string): StreamingScan => {
       const scope = scopes.at(-1);
       if (scope) scope.statementStart = index + 1;
     }
-    if (char === "\n" && !insideJsxText && canCommitBoundary(stack)) {
+    if (char === "\n" && canCommitBoundary(stack)) {
       const scope = scopes.at(-1);
       const boundaryEnd = Math.max(scope?.statementStart ?? 0, lastSignificantEnd);
       if (scope && isAsiBoundary(code.slice(scope.statementStart, boundaryEnd), code.slice(index + 1), isTrailingClosedRegexLiteral(code, boundaryEnd, lastRegexLiteralStart))) scope.statementStart = index + 1;
@@ -1328,7 +1407,7 @@ const isTypedParameterList = (initializer: string) => {
 };
 
 const hasUnsafeStreamingTypeArgument = (code: string) => {
-  const masked = maskLiteralSpans(code);
+  const masked = maskIgnoredTextForExportScan(code);
   if (/(?:^|=)\s*<\s*[A-Za-z_$][\w$]*\s*(?:,|extends\b|=)[^>]*$/.test(neutralizeAngleOperators(masked))) return true;
   if (!hasUnclosedTypeArgument(masked)) return false;
   const lastOpen = masked.lastIndexOf("<");
@@ -1345,7 +1424,12 @@ const hasSafeExpressionTail = (tail: string) => {
   if (hasIncompleteControlTail(trimmed) || dropTrailingIncompleteExpressionOperator(trimmed) !== trimmed) return false;
   if (completeTrailingIncompleteTernary(trimmed) !== trimmed) return false;
   if (dropTrailingIncompleteFunctionDeclaration(trimmed) !== trimmed) return false;
-  if (hasUnsafeStreamingTypeArgument(trimmed)) return false;
+  // Strip JSX prefix before checking for unclosed type arguments: `<div>text</div>\ntype Foo` should only examine `type Foo`.
+  // `maskIgnoredTextForExportScan` blanks JSX content but preserves `<`/`>` delimiters, which `hasUnclosedTypeArgument` would
+  // misread as type-argument brackets. Find the last complete JSX tag and check only the tail after it.
+  const lastJsxTagEnd = trimmed.lastIndexOf(">");
+  const tailAfterJsx = lastJsxTagEnd >= 0 && endsWithCompleteJsxTag(trimmed.slice(0, lastJsxTagEnd + 1)) ? trimmed.slice(lastJsxTagEnd + 1).trimStart() : trimmed;
+  if (tailAfterJsx && hasUnsafeStreamingTypeArgument(tailAfterJsx)) return false;
   if (/^import\b/.test(trimmed) && !/^import\s+(?:["'][\s\S]*["']|[\s\S]+\s+from\s+["'][\s\S]*["'])\s*;?$/.test(trimmed)) return false;
   if (/^export\s+(?:d(?:e(?:f(?:a(?:u(?:l(?:t)?)?)?)?)?)?)?\s*$/.test(trimmed) || /^export\s+default\s+[A-Za-z_$][\w$]*$/.test(trimmed)) return false;
   if (/^(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class(?:\s+[A-Za-z_$][\w$]*)?\s*$/.test(trimmed)) return false;
@@ -1550,6 +1634,12 @@ export function completePartialTsx(code: string, options: PartialTsxOptions = {}
     regexLiteralStarts = committed.regexLiteralStarts;
   }
   let output = "";
+  let pendingTrivia = "";
+  const finish = (text: string, suffix = "") => {
+    const trivia = pendingTrivia;
+    pendingTrivia = "";
+    return `${text}${trivia}${suffix}`;
+  };
   const stack: CompletionFrame[] = [];
   let index = 0;
   const push = (value: string) => {
@@ -1557,14 +1647,23 @@ export function completePartialTsx(code: string, options: PartialTsxOptions = {}
   };
   while (index < code.length) {
     const char = code[index];
-    if (!isInsideJsxText(stack) && char === "/" && code[index + 1] === "/") {
+    // Keep completion and committed-prefix scanning in the same lexical mode; never append ')' or ']' to plain text.
+    if (isInsideJsxText(stack) && !isJsxTextBoundary(char)) {
+      push(char);
+      index += 1;
+      continue;
+    }
+    if (char === "/" && code[index + 1] === "/") {
       const newlineIndex = code.indexOf("\n", index + 2);
       const end = newlineIndex === -1 ? code.length : newlineIndex;
-      push(code.slice(index, end));
+      // A newline alone is not enough: expression cleanup can strip an operator from the comment and eat that newline.
+      // Hold EOF trivia apart until the first surviving frame is complete, then restore it before its synthetic closer.
+      if (newlineIndex === -1 && stack.length) pendingTrivia = `${code.slice(index, end)}\n`;
+      else push(code.slice(index, end));
       index = end;
       continue;
     }
-    if (!isInsideJsxText(stack) && char === "/" && code[index + 1] === "*") {
+    if (char === "/" && code[index + 1] === "*") {
       const closeIndex = code.indexOf("*/", index + 2);
       if (closeIndex === -1) {
         push(`${code.slice(index)}*/`);
@@ -1575,15 +1674,15 @@ export function completePartialTsx(code: string, options: PartialTsxOptions = {}
       index = closeIndex + 2;
       continue;
     }
-    if (!isInsideJsxText(stack) && (regexLiteralStarts?.has(index) || isLikelyRegexLiteralStart(code, index))) {
+    if (regexLiteralStarts?.has(index) || isLikelyRegexLiteralStart(code, index)) {
       index = consumeRegexLiteral(code, index, push);
       continue;
     }
-    if (!isInsideJsxText(stack) && (char === '"' || char === "'")) {
+    if (char === '"' || char === "'") {
       index = consumeStringLiteral(code, index, push);
       continue;
     }
-    if (!isInsideJsxText(stack) && char === "`") {
+    if (char === "`") {
       index = consumeTemplateLiteral(code, index, push);
       continue;
     }
@@ -1617,7 +1716,7 @@ export function completePartialTsx(code: string, options: PartialTsxOptions = {}
       continue;
     }
     if (char in BLOCK_FOLLOWERS) {
-      stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: isLikelyStatementBlock(code, index), open: output.length });
+      stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: isLikelyStatementBlock(code, index, stack), open: output.length, jsxExpression: char === "{" && isInsideJsxText(stack) });
       push(char);
       index += 1;
       continue;
@@ -1634,14 +1733,15 @@ export function completePartialTsx(code: string, options: PartialTsxOptions = {}
   }
   const lastRegexLiteralStart = regexLiteralStarts ? findLastRegexLiteralStart(regexLiteralStarts, code.length) : undefined;
   if (isTrailingClosedRegexLiteral(code, code.length, lastRegexLiteralStart) && canCommitBoundary(stack)) output += ";";
+  const beforeCloser = pendingTrivia ? finish : undefined;
   const closingFrames = stack.toReversed();
   const closers = closingFrames.map(closeFrame).join("");
   if (!closers) return completeIncompleteExpressionPrefix(output, true, options.mode === "streaming");
   const statementIndex = closingFrames.findIndex((frame) => frame.type === "block" && frame.statement);
-  if (statementIndex === -1) return closeStackFrames(output, closingFrames);
-  const beforeStatement = closeStackFrames(output, closingFrames.slice(0, statementIndex));
+  if (statementIndex === -1) return finish(closeStackFrames(output, closingFrames, beforeCloser));
+  const beforeStatement = closeStackFrames(output, closingFrames.slice(0, statementIndex), beforeCloser);
   const completedExpression = dropTrailingBareLoopHeader(fillEmptyReturnExpression(completeIncompleteExpressionPrefix(beforeStatement, true, options.mode === "streaming")));
-  return `${completedExpression}${isExpressionEnd(completedExpression) ? ";" : ""}${closingFrames.slice(statementIndex).map(closeFrame).join("")}`;
+  return finish(completedExpression, `${isExpressionEnd(completedExpression) ? ";" : ""}${closingFrames.slice(statementIndex).map(closeFrame).join("")}`);
 }
 
 export function normalizeGeneratedTsx(code: string, options: PartialTsxOptions = {}) {
@@ -1650,6 +1750,7 @@ export function normalizeGeneratedTsx(code: string, options: PartialTsxOptions =
   // The ordinary lexer recognizes every regex position except a new statement after a closed block. The first mask removes
   // false candidates from JSX/templates/comments, so only the ambiguous `} /* trivia */ /regex/` shape pays for provenance.
   if (/}\s*\/(?![/*])/.test(exportScanCode)) exportScanCode = maskIgnoredTextForExportScan(next, scanStreamingSource(next).regexLiteralStarts);
+  exportScanCode = maskAmbientBlocks(exportScanCode);
   if (!hasDefaultExportDeclaration(exportScanCode)) {
     const componentName = findLastExportableComponent(exportScanCode);
     if (componentName) next += `\nexport default ${componentName};`;