partial-tsx 0.0.1 → 0.0.2

package/README.md

@@ -0,0 +1,39 @@
+# partial-tsx
+
+Completes prefix-growing TSX.
+
+## Input
+
+```ts
+import { completePartialTsx, normalizeGeneratedTsx } from "partial-tsx";
+
+completePartialTsx("<div>Hello");
+completePartialTsx("function App() { return <div>Hello", { mode: "streaming" });
+normalizeGeneratedTsx("function Card() { return <button>OK");
+```
+
+## Output
+
+- `completePartialTsx(code)` returns syntactically safer TSX for a partial prefix.
+- `normalizeGeneratedTsx(code)` returns renderer-ready TSX:
+  - Markdown fences removed.
+  - Safe partial syntax completed.
+  - Missing default export added when a component can be found.
+  - Missing imports added for known React hooks such as `useState`.
+- `{ mode: "streaming" }` first rolls script back to its last committed syntax boundary. It never closes an unfinished call, initializer, callback, control-flow statement, or JSX `{expression`; unterminated JSX string attributes remain the one value-completion exception.
+- The default `{ mode: "final" }` preserves the existing completion behavior. `partial-react` uses streaming mode only for incremental frames and sends final input to the compiler unchanged.
+
+## Corner Cases
+
+- Incomplete component/tag names are left alone when completing them would likely render the wrong element.
+- Unterminated JSX string attributes can be closed; incomplete expression attributes are dropped.
+- Void HTML tags are normalized as self-closing tags.
+- Unknown hooks or custom hooks are not auto-imported.
+- Existing default exports are preserved.
+- Invalid TypeScript semantics are not repaired.
+
+## Test
+
+```sh
+bun test lib/partial-tsx
+```

package/package.json

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

package/src/partial.ts

@@ -1,7 +1,10 @@
 const VOID_TAGS = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
 const BLOCK_FOLLOWERS: Record<string, string> = { "{": "}", "(": ")", "[": "]" };
 const BLOCK_CLOSERS = new Set(Object.values(BLOCK_FOLLOWERS));
-type CompletionFrame = { type: "block"; closer: string; statement: boolean; open?: number } | { type: "jsx"; tag: string };
+export type PartialTsxMode = "streaming" | "final";
+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 };
 
 const stripMarkdownFence = (code: string) => {
   let next = code.trim();
@@ -24,17 +27,19 @@ const findStringLiteralEnd = (code: string, index: number) => {
   }
   return code.length;
 };
-const findTemplateLiteralEnd = (code: string, index: number) => {
+type TemplateLiteralEnd = { end: number; closed: boolean };
+const scanTemplateLiteralEnd = (code: string, index: number): TemplateLiteralEnd => {
   index += 1;
   while (index < code.length) {
     if (code[index] === "\\") index += 2;
-    else if (code[index] === "`") return index + 1;
+    else if (code[index] === "`") return { end: index + 1, closed: true };
     // A `${ … }` substitution can hold nested template literals (`${`inner`}`); recurse into it so an inner backtick is not
     // mistaken for the outer literal's terminator, which would leave the substitution body unmasked in the export scan. Skip
     // strings/templates inside the substitution so their braces (`${"{"}`) do not throw off the brace-depth tracking.
     else if (code[index] === "$" && code[index + 1] === "{") {
       index += 2;
-      for (let depth = 1; index < code.length && depth > 0; index += 1) {
+      let depth = 1;
+      for (; index < code.length && depth > 0; index += 1) {
         if (code[index] === "/" && code[index + 1] === "/") {
           const next = code.indexOf("\n", index + 2);
           index = next === -1 ? code.length : next;
@@ -42,16 +47,21 @@ const findTemplateLiteralEnd = (code: string, index: number) => {
           const next = code.indexOf("*/", index + 2);
           index = next === -1 ? code.length : next + 1;
         } else if (isLikelyRegexLiteralStart(code, index)) index = findRegexLiteralEnd(code, index) - 1;
-        else if (code[index] === "`") index = findTemplateLiteralEnd(code, index) - 1;
-        else if (code[index] === '"' || code[index] === "'") index = findStringLiteralEnd(code, index) - 1;
+        else if (code[index] === "`") {
+          const nested = scanTemplateLiteralEnd(code, index);
+          if (!nested.closed) return nested;
+          index = nested.end - 1;
+        } else if (code[index] === '"' || code[index] === "'") index = findStringLiteralEnd(code, index) - 1;
         else if (code[index] === "{") depth += 1;
         else if (code[index] === "}") depth -= 1;
       }
+      if (depth > 0) return { end: code.length, closed: false };
     } else index += 1;
   }
-  return code.length;
+  return { end: code.length, closed: false };
 };
-const updateJsxStackForTag = (stack: CompletionFrame[], tag: string) => {
+const findTemplateLiteralEnd = (code: string, index: number) => scanTemplateLiteralEnd(code, index).end;
+const updateJsxStackForTag = (stack: CompletionFrame[], tag: string, open?: number) => {
   const match = /^<\/?\s*([A-Za-z][\w$.-]*)/.exec(tag);
   const tagName = match?.[1] ?? (tag === "<>" || tag === "</>" ? "" : null);
   if (tagName === null) return;
@@ -60,9 +70,9 @@ const updateJsxStackForTag = (stack: CompletionFrame[], tag: string) => {
     if (frame?.type === "jsx" && frame.tag === tagName) stack.pop();
     return;
   }
-  if (!tag.endsWith("/>") && !VOID_TAGS.has(tagName)) stack.push({ type: "jsx", tag: tagName });
+  if (!tag.endsWith("/>") && !VOID_TAGS.has(tagName)) stack.push({ type: "jsx", tag: tagName, open });
 };
-const maskIgnoredTextForExportScan = (code: string) => {
+const maskIgnoredTextForExportScan = (code: string, regexLiteralStarts?: ReadonlySet<number>) => {
   // split("") keeps code-unit indexing aligned with code[index]; spread would split astral chars (emoji) by code point and desync the two.
   const chars = code.split("");
   const stack: CompletionFrame[] = [];
@@ -86,9 +96,10 @@ const maskIgnoredTextForExportScan = (code: string) => {
       index = next - 1;
       continue;
     }
-    if (isLikelyRegexLiteralStart(code, index)) {
+    if (regexLiteralStarts?.has(index) || isLikelyRegexLiteralStart(code, index)) {
       const next = findRegexLiteralEnd(code, index);
       maskExportScanRange(chars, index, next);
+      chars[index] = "/"; // preserve the token boundary while hiding keyword/bracket-shaped regex contents
       index = next - 1;
       continue;
     }
@@ -157,7 +168,7 @@ const findLastExportableComponent = (code: string) => {
   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 });
   }
-  return [...candidates].toSorted((left, right) => left.index - right.index).at(-1)?.name ?? null;
+  return candidates.toSorted((left, right) => left.index - right.index).at(-1)?.name ?? null;
 };
 // `export default` is also valid mid-line after a `;` or block-closing `}` (`;export default …`, `if(a){} export default …`); match those
 // so the scan does not miss an existing default and append a second one (`Duplicate export of 'default'`).
@@ -264,7 +275,7 @@ const isLikelyJsxTagStart = (code: string, index: number) => {
 const isLikelyStatementBlock = (code: string, index: number) => {
   if (code[index] !== "{") return false;
   const before = code.slice(0, index).trimEnd();
-  return /\bfunction(?:\s+[\w$]+)?\s*\([^)]*\)$/.test(before) || /\b(?:if|for|while|switch|catch|with)\s*\([^)]*\)$/.test(before) || /(?:^|[^\w$])(?:else|try|finally|do)$/.test(before) || before.endsWith("=>");
+  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("=>");
 };
 
 const findJsxTagEnd = (code: string, start: number) => {
@@ -351,7 +362,7 @@ const completeIncompleteJsxTag = (code: string, start: number) => {
       // An unterminated string value is safe to close by synthesizing the missing quote — worst case the frame's text is briefly short, never a throw or a wrong binding. Host and component alike.
       if (!closed) {
         // A trailing odd backslash is an incomplete escape (`title="foo\`); synthesizing the quote would make `\"` an escaped quote, leaving the string unterminated. Drop the dangling backslash before closing.
-        if (/\\*$/.exec(literal)![0].length % 2) literal = literal.slice(0, -1);
+        if ((/\\*$/.exec(literal)?.[0].length ?? 0) % 2) literal = literal.slice(0, -1);
         literal += char;
       }
       tag += literal;
@@ -467,6 +478,11 @@ const endsWithJsxTagHead = (value: string) => {
   const tail = value.slice(lastOpen);
   return /^<\/?(?:[A-Za-z][\w$.-]*|$)/.test(tail) && findJsxTagEnd(value, lastOpen) === -1;
 };
+const endsWithCompleteJsxTag = (value: string) => {
+  const trimmed = value.trimEnd();
+  const lastOpen = trimmed.lastIndexOf("<");
+  return lastOpen !== -1 && shouldStartJsxTag(trimmed, lastOpen, collectCompletionStackBefore(trimmed, lastOpen)) && findJsxTagEnd(trimmed, lastOpen) === trimmed.length - 1;
+};
 const hasCompleteRegexLiteralEndingAt = (value: string, endIndex: number) => {
   for (let index = 0; index <= endIndex; index += 1) {
     if (value[index] !== "/" || !isLikelyRegexLiteralStart(value, index)) continue;
@@ -476,18 +492,30 @@ const hasCompleteRegexLiteralEndingAt = (value: string, endIndex: number) => {
   }
   return false;
 };
-const dropTrailingOperator = (value: string, pattern: RegExp) => {
-  const match = pattern.exec(value);
+// Window = longest operator `>>>=` (4) + the 1 char the `(?<![.\d])\.` lookbehind inspects, rounded up.
+const TRAILING_OPERATOR_WINDOW = 8;
+const endsWithPostfixUpdate = (value: string) => /[\w$)\]](?:\+\+|--)$/.test(value.trimEnd());
+const dropTrailingOperator = (value: string, pattern: RegExp, preservePostfixUpdate = false) => {
+  // `$`-anchored ⇒ the operator is pinned to the trimmed suffix, so a fixed tail window yields the identical match but
+  // turns an O(n)-per-call (O(n²) over a char-by-char stream) scan into O(1) in prefix length.
+  const trimmed = value.trimEnd();
+  const windowStart = Math.max(0, trimmed.length - TRAILING_OPERATOR_WINDOW);
+  const match = pattern.exec(trimmed.slice(windowStart));
   if (!match) return value;
   const operator = match[1];
-  const operatorIndex = value.indexOf(operator, match.index);
-  const before = value.slice(0, match.index).trimEnd();
+  const operatorIndex = trimmed.length - operator.length;
+  // Trimming the operator's leading-whitespace run reproduces the unwindowed scan's `value.slice(0, match.index)`
+  // byte-for-byte (the pattern's `\s*` is greedy, so `match.index` sat at the start of that run).
+  const before = value.slice(0, operatorIndex).trimEnd();
   if (operator === "=>") return `${before} => null`;
+  if (preservePostfixUpdate && (operator === "+" || operator === "-") && endsWithPostfixUpdate(value)) return value;
+  if (operator === "/" && before.endsWith("*") && before.lastIndexOf("/*") > before.lastIndexOf("*/")) return value;
   if (operator === "/" && hasCompleteRegexLiteralEndingAt(value, operatorIndex)) return value;
+  if (operator === ">" && /\/\s*$/.test(before)) return value;
   if ((operator === ">" || operator === ">=") && endsWithJsxTagHead(before)) return value;
-  return value.slice(0, match.index);
+  return before;
 };
-const dropTrailingIncompleteExpressionOperator = (value: string) => dropTrailingOperator(value, /\s*(>>>=?|>>=?|<<=?|===|!==|=>|\*\*=|\?\?=|&&=|\|\|=|[+\-*/%&|^]=|\?\?|\?\.|\*\*|[=!<>]=?|&&|\|\||[+\-*/%&|^~]|(?<![.\d])\.)\s*$/s);
+const dropTrailingIncompleteExpressionOperator = (value: string, preservePostfixUpdate = false) => dropTrailingOperator(value, /\s*(>>>=?|>>=?|<<=?|===|!==|=>|\*\*=|\?\?=|&&=|\|\|=|[+\-*/%&|^]=|\?\?|\?\.|\*\*|[=!<>]=?|&&|\|\||[+\-*/%&|^~]|(?<![.\d])\.)\s*$/s, preservePostfixUpdate);
 // Blanks out string/template/regex/comment spans (but not JSX) so angle-bracket counting in `dropTrailingIncompleteStatement`
 // only sees real `<`/`>` operators and type arguments, never a literal `<` (`"a<b"`) or a `</div>` closer.
 const maskLiteralSpans = (body: string) => {
@@ -566,7 +594,7 @@ const hasUnclosedTypeArgument = (body: string) => {
 // 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);
-  const re = /(?:^|[{};\n]|=>)\s*(const|let|var)\b/g;
+  const re = /(?:^|[{};\n]|=>)\s*(const(?!\s+enum\b)|let|var)\b/g;
   let match: RegExpExecArray | null;
   let start = -1;
   let kind = "";
@@ -617,7 +645,9 @@ const dropTrailingIncompleteStatement = (value: string) => {
 };
 const completeTrailingIncompleteTernary = (value: string) => {
   const masked = maskIgnoredTextForExportScan(value);
-  if (/(?<!\?)\?(?![.?])[^?;{}]*:\s*$/s.test(masked)) return `${value} null`;
+  // `masked` blanks a string/template else-branch (or regex contents) to spaces, so a *complete* `? a : "x"` looks like it ends at `:`.
+  // A genuine trailing `:` is never inside a literal, so confirm against the raw text before synthesizing the else-branch.
+  if (/(?<!\?)\?(?![.?])[^?;{}]*:\s*$/s.test(masked) && /:\s*$/s.test(value)) return `${value} null`;
   const match = /(?<!\?)\?(?![.?])(?<tail>[^?:;{}]*)$/s.exec(masked);
   if (!match?.groups) return value;
   return value.slice(match.index + 1).trim() ? `${value} : null` : `${value} null : null`;
@@ -629,11 +659,56 @@ const dropTrailingIncompleteFunctionDeclaration = (value: string) => {
   const match = /(?:^|[}\n;])\s*((?:export\s+(?:default\s+)?)?(?:async\s+)?function\b\s*\*?\s*[A-Za-z_$]?[\w$]*\s*)$/.exec(value);
   return match ? value.slice(0, match.index + (match[0].length - match[1].length)) : value;
 };
-const completeIncompleteExpressionPrefix = (value: string, dropStatement = false) => completeTrailingIncompleteTernary(dropTrailingIncompleteExpressionOperator(dropStatement ? dropTrailingIncompleteFunctionDeclaration(dropTrailingIncompleteStatement(value)) : value));
+const completeIncompleteExpressionPrefix = (value: string, dropStatement = false, preservePostfixUpdate = false) =>
+  completeTrailingIncompleteTernary(dropTrailingIncompleteExpressionOperator(dropStatement ? dropTrailingIncompleteFunctionDeclaration(dropTrailingIncompleteStatement(value)) : value, preservePostfixUpdate));
 const fillEmptyReturnExpression = (value: string) => {
   if (/\breturn\s*$/.test(value)) return `${value} null`;
   return value.replace(/(\breturn\s*\(\s*)\)$/s, "$1null)");
 };
+// Walk back from a string ending in `close` to the index of the `open` that matches it, or -1 if it never balances.
+const findMatchingOpener = (text: string, open: string, close: string) => {
+  let depth = 0;
+  for (let index = text.length - 1; index >= 0; index -= 1) {
+    if (text[index] === close) depth += 1;
+    else if (text[index] === open && --depth === 0) return index;
+  }
+  return -1;
+};
+// A loop whose header has streamed but whose body has not ends the completed prefix as a bare `for (...)` / `while (...)`.
+// Finalization would give it an empty `;` body, and a header that never advances its counter (`for (let i = 0; i < n;)`)
+// then spins forever and freezes the tab. Loops only live in statement position (JSX iterates via `.map`), so a body-less
+// header renders nothing regardless — drop it back to before the keyword.
+const controlStatementMatches = (code: string) => code.matchAll(/(^|[;{}\n):])(\s*)((?:[A-Za-z_$][\w$]*\s*:\s*)*)(if|for|while|with|try|do)\b/g);
+const isCompleteDoWhileStatement = (value: string, scan = scanStreamingSource(value)) => {
+  const masked = maskIgnoredTextForExportScan(value, scan.regexLiteralStarts);
+  const isControlStatementContext = createControlStatementContextLookup(scan);
+  for (const match of controlStatementMatches(masked)) {
+    const start = (match.index ?? 0) + match[1].length;
+    if (match[4] !== "do" || !isControlStatementContext(start)) continue;
+    const doStart = skipStatementLabels(masked, start);
+    const end = findStatementEnd(masked, doStart);
+    if (end !== -1 && !masked.slice(end).trim()) return true;
+  }
+  return false;
+};
+const dropTrailingBareLoopHeader = (value: string) => {
+  const masked = maskLiteralSpans(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);
+  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;
+  // `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;
+  return value.slice(0, match.index).trimEnd();
+};
 // A non-statement bracket frame gets its expression prefix completed (and possibly dropped). Completing can shorten the output
 // two different ways: a trailing operator/dot trim (the frame's own `{`/`[` survives, so we still close it) or a whole-declaration
 // rollback that removes the frame's own opening bracket plus every nested opener — e.g. `useState<{ nested: { count` or an array
@@ -654,6 +729,9 @@ const completeStatementPrefixFrame = (output: string, frame: CompletionFrame): {
   if (frame.type !== "block") return { text: `${output}${closeFrame(frame)}`, dropped: false };
   if (frame.closer === ")") {
     const completed = completeIncompleteExpressionPrefix(output);
+    // A paren whose entire body is a balanced empty `()` (a double paren `(()`) can only continue as an arrow head — an
+    // empty parenthesized expression is rejected by the compiler. Complete the forced arrow rather than emit illegal `(())`.
+    if (frame.open !== undefined && completed.slice(frame.open + 1).trim() === "()") return { text: `${completed} => null${frame.closer}`, dropped: false };
     return { text: `${completed.endsWith("(") && !isCallArgumentParen(completed) ? `${completed}null` : completed}${frame.closer}`, dropped: false };
   }
   return completeBlockFrame(output, frame);
@@ -702,7 +780,12 @@ function findRegexLiteralEnd(code: string, index: number) {
     if (next === "[" && !inClass) inClass = true;
     else if (next === "]" && inClass) inClass = false;
     else if (next === "/" && !inClass) {
-      while (index < code.length && /[A-Za-z]/.test(code[index])) index += 1;
+      while (index < code.length) {
+        const point = code.codePointAt(index) ?? 0;
+        const char = String.fromCodePoint(point);
+        if (!/[A-Za-z0-9_$\\]/.test(char) && (point <= 0x7f || /\s/u.test(char))) break;
+        index += point > 0xffff ? 2 : 1;
+      }
       return index;
     }
   }
@@ -746,10 +829,11 @@ const isJsxTagHead = (code: string, index: number) => {
   return match !== null && /^(?:$|[\s/>])/.test(tail.slice(match[0].length));
 };
 
-// A comma right after the tag name (`<T,`) is a TSX generic type-param list, not JSX — a JSX tag name is only ever
-// followed by whitespace, `/`, `>`, or end, never a bare comma. Without this, the generic arrow `<T,>(x:T)=>x` is
-// misread as an open `<T>` element and a synthetic `</T>` is appended, breaking the module.
-const isGenericTypeParamList = (code: string, index: number) => /^<\s*[A-Za-z_$][\w$]*\s*,/.test(code.slice(index));
+// A `,`, `extends`, or `=` right after the tag name (`<T,`, `<T extends U`, `<T = U`) is a TSX generic type-param
+// list, not JSX — a JSX tag name is only ever followed by whitespace, `/`, `>`, or end, never these tokens. Without
+// this, generic arrows like `<T,>(x:T)=>x` or `<T extends {}>(x:T)=>x` are misread as an open `<T>` element and a
+// synthetic `</T>` is appended, breaking the module.
+const isGenericTypeParamList = (code: string, index: number) => /^<\s*[A-Za-z_$][\w$]*\s*(?:,|extends\b|=)/.test(code.slice(index));
 const shouldStartJsxTag = (code: string, index: number, stack: CompletionFrame[]) => {
   if (isGenericTypeParamList(code, index)) return false;
   if (stack.at(-1)?.type === "jsx") return isJsxTagHead(code, index);
@@ -759,6 +843,7 @@ const isInsideJsxText = (stack: CompletionFrame[]) => stack.at(-1)?.type === "js
 
 const consumeTemplateExpression = (code: string, index: number, push: PushOutput): number => {
   let depth = 1;
+  const startIndex = index;
   while (index < code.length && depth > 0) {
     const expressionChar = code[index];
     if (expressionChar === "/" && code[index + 1] === "/") {
@@ -795,7 +880,9 @@ const consumeTemplateExpression = (code: string, index: number, push: PushOutput
     if (expressionChar === "{") depth += 1;
     else if (expressionChar === "}") depth -= 1;
   }
-  if (depth > 0) push("}".repeat(depth));
+  // An interpolation that never streamed an expression (`${}` once we synthesize the `}`) is illegal; fill `null` so the
+  // streamed frame parses, mirroring the empty-paren and empty-return synthesis.
+  if (depth > 0) push((code.slice(startIndex, index).trim() ? "" : "null") + "}".repeat(depth));
   return index;
 };
 
@@ -826,11 +913,605 @@ const consumeTemplateLiteral = (code: string, index: number, push: PushOutput):
   return index;
 };
 
-export function completePartialTsx(code: string) {
+type StreamingScope = { statementStart: number };
+type StreamingScan = {
+  stack: CompletionFrame[];
+  closedBlocks: Array<Extract<CompletionFrame, { type: "block" }>>;
+  scopes: StreamingScope[];
+  regexLiteralStarts: Set<number>;
+  lastSignificantEnd: number;
+  unclosedLiteralStart: number | null;
+  unclosedLiteralStatementStart: number | null;
+  incompleteJsxTagStart: number | null;
+};
+
+const FUNCTION_HEADER = /^(?:export\s+(?:default\s+)?)?(?:async\s+)?function(?:\s*\*)?\s*([A-Za-z_$][\w$]*)?(?:\s*<[\s\S]*>)?\s*\([^)]*\)\s*(?::\s*[\s\S]+)?$/;
+const CLASS_HEADER = /^(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Za-z_$][\w$]*)(?:\s+extends[\s\S]+)?(?:\s+implements[\s\S]+)?$/;
+const METHOD_HEADER = /^(?:(?:public|private|protected|static|abstract|async|override|readonly|get|set)\s+)*([A-Za-z_$][\w$]*)(?:\s*<[\s\S]*>)?\s*\([^)]*\)\s*(?::\s*[\s\S]+)?$/;
+const COMPONENT_ARROW_HEADER = /^(?:const|let|var)\s+([A-Z][\w$]*)\s*(?::[^=]+)?=\s*(?:async\s*)?(?:<[\s\S]*>\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)(?:\s*:\s*[^=]+)?\s*=>$/;
+const hasTopLevelClassBody = (value: string) => {
+  let angleDepth = 0;
+  for (const char of maskLiteralSpans(value)) {
+    if (char === "<") angleDepth += 1;
+    else if (char === ">" && angleDepth > 0) angleDepth -= 1;
+    else if (char === "{" && angleDepth === 0) return true;
+  }
+  return false;
+};
+
+const getBlockKind = (code: string, index: number, statementStart: number): BlockKind => {
+  const before = code.slice(statementStart, index).trim();
+  if (!before || /^(?:[A-Za-z_$][\w$]*\s*:\s*)+$/.test(before) || before === "static") return "block";
+  if (FUNCTION_HEADER.test(before)) return "function";
+  if (/^(?:if|for|while|switch|with)\s*\([^)]*\)$/.test(before) || /^catch(?:\s*\([^)]*\))?$/.test(before) || /^(?:else|try|finally|do)$/.test(before)) return "control";
+  if (before.endsWith("=>")) return "arrow";
+  if (CLASS_HEADER.test(before) && !hasUnclosedTypeArgument(maskLiteralSpans(before))) return "class";
+  if (METHOD_HEADER.test(before)) return "method";
+  return "other";
+};
+
+const findKeywordStart = (code: string, index: number, scopeStart: number, kind: BlockKind) => {
+  if (kind !== "function" && kind !== "control") return scopeStart;
+  const segment = code.slice(scopeStart, index);
+  const pattern = kind === "function" ? /(?:^|[;\n{}])\s*((?:export\s+(?:default\s+)?)?(?:async\s+)?function)\b/g : /(?:^|[;\n{}])\s*((?:if|for|while|switch|catch|with|try|finally|do|else))\b/g;
+  let start = scopeStart;
+  let match: RegExpExecArray | null;
+  while ((match = pattern.exec(segment))) start = scopeStart + match.index + match[0].lastIndexOf(match[1]);
+  return start;
+};
+
+const canCommitBoundary = (stack: CompletionFrame[]) => !stack.some((frame) => frame.type === "block" && (frame.closer !== "}" || !frame.statement));
+const LINE_CONTINUING_KEYWORD_OPERATOR = /(?<![.\w$])(?:as|await|delete|in|instanceof|new|satisfies|throw|typeof|void)$/;
+const isAsiBoundary = (before: string, after: string, leftEndsWithRegexLiteral = false) => {
+  const left = before.trimEnd();
+  const right = after.trimStart();
+  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);
+};
+
+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;
+const findRegexLiteralClosingSlash = (code: string, start: number, end: number) => {
+  let inClass = false;
+  for (let index = start + 1; index < end; index += 1) {
+    const char = code[index];
+    if (/\r|\n|\u2028|\u2029/.test(char)) return -1;
+    if (char === "\\") {
+      if (/\r|\n|\u2028|\u2029/.test(code[index + 1] ?? "")) return -1;
+      index += 1;
+    } else if (char === "[" && !inClass) inClass = true;
+    else if (char === "]" && inClass) inClass = false;
+    else if (char === "/" && !inClass) return index;
+  }
+  return -1;
+};
+const hasValidRegexLiteral = (code: string, start: number, end: number) => {
+  const closingSlash = findRegexLiteralClosingSlash(code, start, end);
+  if (closingSlash === -1) return false;
+  const flags = code.slice(closingSlash + 1, end);
+  return /^[dgimsuvy]*$/.test(flags) && new Set(flags).size === flags.length && !(flags.includes("u") && flags.includes("v"));
+};
+const isOnlyJsTrivia = (code: string, start: number, end: number) => {
+  while (start < end) {
+    if (/\s/.test(code[start])) start += 1;
+    else if (code[start] === "/" && code[start + 1] === "/") {
+      const newline = code.indexOf("\n", start + 2);
+      start = newline === -1 || newline >= end ? end : newline + 1;
+    } else if (code[start] === "/" && code[start + 1] === "*") {
+      const close = code.indexOf("*/", start + 2);
+      if (close === -1 || close + 2 > end) return false;
+      start = close + 2;
+    } else return false;
+  }
+  return true;
+};
+const isTrailingClosedRegexLiteral = (code: string, end: number, start: number | null | undefined) => {
+  if (start === null || start === undefined || start >= end) return false;
+  const regexEnd = findRegexLiteralEnd(code, start);
+  return regexEnd <= end && hasValidRegexLiteral(code, start, regexEnd) && isOnlyJsTrivia(code, regexEnd, end);
+};
+const findLastRegexLiteralStart = (starts: ReadonlySet<number>, end: number) => {
+  let last: number | undefined;
+  for (const start of starts) {
+    if (start >= end) break;
+    last = start;
+  }
+  return last;
+};
+const STATEMENT_BLOCK_KINDS = new Set<BlockKind>(["block", "class", "control", "function"]);
+
+// Keep source provenance separate from the legacy completer: JSX escaping and synthetic closers change output offsets, while
+// rollback must always cut the raw stream. The committed prefix is completed only after this source-only pass returns.
+const scanStreamingSource = (code: string): StreamingScan => {
+  const stack: CompletionFrame[] = [];
+  const closedBlocks: Array<Extract<CompletionFrame, { type: "block" }>> = [];
+  const scopes: StreamingScope[] = [{ statementStart: 0 }];
+  const regexLiteralStarts = new Set<number>();
+  let unclosedLiteralStart: number | null = null;
+  let unclosedLiteralStatementStart: number | null = null;
+  let incompleteJsxTagStart: number | null = null;
+  let statementRegexBoundary = false;
+  let lastRegexLiteralStart: number | null = null;
+  let lastSignificantEnd = 0;
+  let index = 0;
+  const currentStatementStart = () => scopes.at(-1)?.statementStart ?? 0;
+  const markUnclosedLiteral = () => {
+    unclosedLiteralStart = index;
+    unclosedLiteralStatementStart = currentStatementStart();
+  };
+  const markDisposableComment = () => {
+    const statementStart = currentStatementStart();
+    const statement = code.slice(statementStart, index);
+    unclosedLiteralStart = index;
+    unclosedLiteralStatementStart = isTrailingClosedRegexLiteral(code, index, lastRegexLiteralStart) || (Boolean(statement.trim()) && hasSafeExpressionTail(statement)) ? index : statementStart;
+  };
+  while (index < code.length) {
+    const insideJsxText = stack.at(-1)?.type === "jsx";
+    const char = code[index];
+    if (!insideJsxText && 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
+        break;
+      }
+      const scope = scopes.at(-1);
+      const boundaryEnd = Math.max(scope?.statementStart ?? 0, lastSignificantEnd);
+      if (scope && canCommitBoundary(stack) && isAsiBoundary(code.slice(scope.statementStart, boundaryEnd), code.slice(newlineIndex + 1), isTrailingClosedRegexLiteral(code, boundaryEnd, lastRegexLiteralStart))) scope.statementStart = newlineIndex + 1;
+      index = newlineIndex + 1;
+      continue;
+    }
+    if (!insideJsxText && char === "/" && code[index + 1] === "*") {
+      const closeIndex = code.indexOf("*/", index + 2);
+      if (closeIndex === -1) {
+        markDisposableComment();
+        break;
+      }
+      index = closeIndex + 2;
+      continue;
+    }
+    if (!insideJsxText && ((statementRegexBoundary && char === "/") || isLikelyRegexLiteralStart(code, index))) {
+      regexLiteralStarts.add(index);
+      lastRegexLiteralStart = index;
+      statementRegexBoundary = false;
+      const end = findRegexLiteralEnd(code, index);
+      if (!hasValidRegexLiteral(code, index, end)) {
+        markUnclosedLiteral();
+        break;
+      }
+      lastSignificantEnd = end;
+      index = end;
+      continue;
+    }
+    if (!insideJsxText && (char === '"' || char === "'")) {
+      statementRegexBoundary = false;
+      const end = findStringLiteralEnd(code, index);
+      if (!isClosedQuotedLiteral(code, index, end, char)) {
+        markUnclosedLiteral();
+        break;
+      }
+      lastSignificantEnd = end;
+      index = end;
+      continue;
+    }
+    if (!insideJsxText && char === "`") {
+      statementRegexBoundary = false;
+      const literal = scanTemplateLiteralEnd(code, index);
+      if (!literal.closed) {
+        markUnclosedLiteral();
+        break;
+      }
+      lastSignificantEnd = literal.end;
+      index = literal.end;
+      continue;
+    }
+    if (char === "<" && shouldStartJsxTag(code, index, stack)) {
+      statementRegexBoundary = false;
+      const closeIndex = findJsxTagEnd(code, index);
+      if (closeIndex === -1) {
+        incompleteJsxTagStart = index;
+        break;
+      }
+      updateJsxStackForTag(stack, code.slice(index, closeIndex + 1), index);
+      lastSignificantEnd = closeIndex + 1;
+      index = closeIndex + 1;
+      continue;
+    }
+    if (char in BLOCK_FOLLOWERS) {
+      statementRegexBoundary = false;
+      const inheritedStart = currentStatementStart();
+      const jsxExpression = char === "{" && insideJsxText;
+      const kind = jsxExpression ? undefined : getBlockKind(code, index, inheritedStart);
+      const statement = !jsxExpression && kind !== "other";
+      const statementStart = statement ? findKeywordStart(code, index, inheritedStart, kind ?? "other") : inheritedStart;
+      stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement, open: index, jsxExpression, statementStart, kind });
+      if (statement && char === "{") scopes.push({ statementStart: index + 1 });
+      lastSignificantEnd = index + 1;
+      index += 1;
+      continue;
+    }
+    if (BLOCK_CLOSERS.has(char)) {
+      const frame = stack.at(-1);
+      let closesStatementBlock = false;
+      if (frame?.type === "block" && frame.closer === char) {
+        stack.pop();
+        frame.close = index;
+        closedBlocks.push(frame);
+        if (frame.statement && char === "}") {
+          closesStatementBlock = STATEMENT_BLOCK_KINDS.has(frame.kind ?? "other");
+          scopes.pop();
+          const parent = scopes.at(-1);
+          if (parent) parent.statementStart = index + 1;
+        }
+      }
+      statementRegexBoundary = closesStatementBlock;
+      lastSignificantEnd = index + 1;
+      index += 1;
+      continue;
+    }
+    if (char === ";" && canCommitBoundary(stack)) {
+      const scope = scopes.at(-1);
+      if (scope) scope.statementStart = index + 1;
+    }
+    if (char === "\n" && !insideJsxText && 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;
+    }
+    if (!/\s/.test(char)) {
+      statementRegexBoundary = false;
+      lastSignificantEnd = index + 1;
+    }
+    index += 1;
+  }
+  return { stack, closedBlocks, scopes, regexLiteralStarts, lastSignificantEnd, unclosedLiteralStart, unclosedLiteralStatementStart, incompleteJsxTagStart };
+};
+
+const getFrameHeader = (code: string, frame: Extract<CompletionFrame, { type: "block" }>) => code.slice(frame.statementStart ?? 0, frame.open ?? 0).trim();
+const isComponentFunctionFrame = (code: string, frame: Extract<CompletionFrame, { type: "block" }>) => /^[A-Z]/.test(FUNCTION_HEADER.exec(getFrameHeader(code, frame))?.[1] ?? "");
+const isFunctionDeclarationFrame = (code: string, frame: Extract<CompletionFrame, { type: "block" }>) => FUNCTION_HEADER.test(getFrameHeader(code, frame));
+const isComponentClassFrame = (code: string, frame: Extract<CompletionFrame, { type: "block" }>) => /^[A-Z]/.test(CLASS_HEADER.exec(getFrameHeader(code, frame))?.[1] ?? "");
+const isRenderMethodFrame = (code: string, frame: Extract<CompletionFrame, { type: "block" }>) => METHOD_HEADER.exec(getFrameHeader(code, frame))?.[1] === "render";
+const isComponentArrowPrefix = (code: string, end: number) => {
+  const before = code
+    .slice(0, end)
+    .trimEnd()
+    .replace(/\(\s*$/, "")
+    .trimEnd();
+  const match = /(?:^|[;}\n])\s*((?:const|let|var)\s+[A-Z][\s\S]*=>)\s*$/.exec(before);
+  return Boolean(match && COMPONENT_ARROW_HEADER.test(match[1]));
+};
+const isComponentArrowFrame = (code: string, frame: Extract<CompletionFrame, { type: "block" }>) => COMPONENT_ARROW_HEADER.test(getFrameHeader(code, frame));
+
+const isCompleteJsxTail = (code: string, scan: StreamingScan) => {
+  const trimmed = code.trimEnd();
+  if (!/(?:\/>|<\/[A-Za-z][\w$.-]*>)\s*;?\s*$/.test(trimmed)) return false;
+  const scopeStart = scan.scopes.at(-1)?.statementStart ?? 0;
+  const tail = trimmed.slice(scopeStart).trim();
+  if (/^(?:return\s*\(?[\s\S]*<|(?:const|let|var)\s+[A-Z][\w$]*\s*(?::[^=]+)?=[\s\S]*=>\s*\(?[\s\S]*<|<)/.test(tail)) return true;
+  const shellFrame = scan.stack.findLast((frame): frame is Extract<CompletionFrame, { type: "block" }> => frame.type === "block" && (frame.kind === "function" || frame.kind === "arrow" || frame.kind === "method"));
+  return shellFrame?.open !== undefined && /\breturn\s*\(?[\s\S]*</.test(trimmed.slice(shellFrame.open + 1));
+};
+
+const hasCompletedRenderMethodTail = (code: string, scan: StreamingScan) => {
+  const frame = scan.closedBlocks.findLast((candidate) => candidate.kind === "method" && isRenderMethodFrame(code, candidate));
+  if (frame?.open === undefined || frame.close === undefined || code.slice(frame.close + 1).trim()) return false;
+  return /\breturn\s*\(?[\s\S]*<(?:[A-Za-z]|>)/.test(code.slice(frame.open + 1, frame.close));
+};
+
+const isAllowedJsxShellFrame = (code: string, frame: Extract<CompletionFrame, { type: "block" }>, componentArrow: boolean) => {
+  if (frame.jsxExpression || frame.kind === "control") return false;
+  if (frame.kind === "function") return isComponentFunctionFrame(code, frame);
+  if (frame.kind === "arrow") return componentArrow && isComponentArrowFrame(code, frame);
+  if (frame.kind === "class") return isComponentClassFrame(code, frame);
+  if (frame.kind === "method") return isRenderMethodFrame(code, frame);
+  if (frame.statement) return false;
+  const context = getFrameHeader(code, frame).trimEnd();
+  return /(?:\breturn\s*|=>\s*)\(?$/.test(context);
+};
+
+// JSX returned directly by a component is the only open script shell we complete. A nested callback/control frame with JSX is
+// rolled back with its statement, so `useEffect(() => <Card` can never become an executable synthetic callback.
+const isJsxShellPreview = (code: string, scan: StreamingScan) => {
+  const jsxFrame = scan.stack.find((frame): frame is Extract<CompletionFrame, { type: "jsx" }> => frame.type === "jsx");
+  if (scan.unclosedLiteralStart !== null) return false;
+  if (scan.stack.some((frame) => frame.type === "block" && frame.jsxExpression)) return false;
+  const allFramesAllowed = (componentArrow: boolean) => scan.stack.every((frame) => frame.type !== "block" || isAllowedJsxShellFrame(code, frame, componentArrow));
+  const rootReturnBefore = (end: number) => {
+    const before = code.slice(0, end);
+    return /\breturn\s*\(?\s*$/.test(before.slice(Math.max(0, before.lastIndexOf(";"), before.lastIndexOf("{"))));
+  };
+  const arrowFrameActive = scan.stack.some((frame) => frame.type === "block" && frame.kind === "arrow" && isComponentArrowFrame(code, frame));
+  if (!jsxFrame) {
+    if (scan.incompleteJsxTagStart === null) {
+      const componentArrow = isComponentArrowPrefix(code, code.length) || arrowFrameActive;
+      return (isCompleteJsxTail(code, scan) || hasCompletedRenderMethodTail(code, scan)) && allFramesAllowed(componentArrow);
+    }
+    const jsxStart = scan.incompleteJsxTagStart;
+    const incompleteComponentArrow = isComponentArrowPrefix(code, jsxStart);
+    if (!rootReturnBefore(jsxStart) && !incompleteComponentArrow && !/^\s*</.test(code)) return false;
+    return allFramesAllowed(incompleteComponentArrow);
+  }
+  const jsxStart = jsxFrame.open ?? code.length;
+  const componentArrow = isComponentArrowPrefix(code, jsxStart) || arrowFrameActive;
+  if (!rootReturnBefore(jsxStart) && !componentArrow && !/^\s*</.test(code)) return false;
+  return allFramesAllowed(componentArrow);
+};
+
+const findAsiBoundary = (code: string, start: number, regexLiteralStarts: ReadonlySet<number>) => {
+  if (code.indexOf("\n", start) === -1) return start;
+  let boundary = start;
+  const regexStarts = [...regexLiteralStarts];
+  let regexIndex = 0;
+  let lastRegexStart: number | undefined;
+  const segment = code.slice(start);
+  for (const match of segment.matchAll(/\n/g)) {
+    const index = match.index ?? 0;
+    const absoluteIndex = start + index;
+    while (regexIndex < regexStarts.length && regexStarts[regexIndex] < absoluteIndex) lastRegexStart = regexStarts[regexIndex++];
+    if (isAsiBoundary(segment.slice(0, index), segment.slice(index + 1), isTrailingClosedRegexLiteral(code, absoluteIndex, lastRegexStart))) boundary = absoluteIndex + 1;
+  }
+  return boundary;
+};
+
+const hasIncompleteControlTail = (tail: string) => {
+  const trimmed = tail.trim();
+  if (/^(?:if|for|while|switch|catch|with)\b[\s\S]*\)\s*$/.test(trimmed)) return true;
+  if (/^(?:else|finally)\s*$/.test(trimmed)) return true;
+  if (/^(?:if|for|while)\b[\s\S]*\)\s+[^;{][\s\S]*$/.test(trimmed) && !/[;} ]$/.test(trimmed)) return true;
+  if (/^try\b[\s\S]*\}\s*$/.test(trimmed) && !/\}\s*(?:catch|finally)\b/.test(trimmed)) return true;
+  if (/^do\b[\s\S]*\}\s*$/.test(trimmed) && !/\}\s*while\b/.test(trimmed)) return true;
+  return false;
+};
+
+const isTypedParameterList = (initializer: string) => {
+  const match = /^(?:async\s+)?(?:<[\s\S]*>\s*)?\(([\s\S]*)\)$/.exec(initializer);
+  if (!match || !match[1].includes(":")) return false;
+  const parameters = maskLiteralSpans(match[1]);
+  let segmentStart = 0;
+  let parenDepth = 0;
+  let bracketDepth = 0;
+  let braceDepth = 0;
+  const isBinding = (segment: string) => /^(?:\.\.\.)?[A-Za-z_$][\w$]*\??$/.test(segment.trim()) || /^(?:\{[\s\S]*\}|\[[\s\S]*\])$/.test(segment.trim());
+  for (let index = 0; index < parameters.length; index += 1) {
+    const char = parameters[index];
+    if (char === "(") parenDepth += 1;
+    else if (char === ")") parenDepth -= 1;
+    else if (char === "[") bracketDepth += 1;
+    else if (char === "]") bracketDepth -= 1;
+    else if (char === "{") braceDepth += 1;
+    else if (char === "}") braceDepth -= 1;
+    else if (char === "," && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) segmentStart = index + 1;
+    else if (char === ":" && parenDepth === 0 && bracketDepth === 0 && braceDepth === 0) return isBinding(parameters.slice(segmentStart, index));
+  }
+  return false;
+};
+
+const hasUnsafeStreamingTypeArgument = (code: string) => {
+  const masked = maskLiteralSpans(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("<");
+  if (lastOpen > 0 && /\s/.test(masked[lastOpen - 1] ?? "") && /^\s*(?:\[|\(|\{)/.test(masked.slice(lastOpen + 1))) return false;
+  return true;
+};
+
+// Bare identifiers, primitives, assignments, and partial operators can all grow on the next chunk. Only real delimiters or a
+// source boundary make an EOF expression stable; this is why the check intentionally rejects valid-looking `const x = value`.
+const hasSafeExpressionTail = (tail: string) => {
+  const trimmed = tail.trim();
+  if (!trimmed) return true;
+  if (/^(?:[A-Za-z_$][\w$]*\s*:\s*)+$/.test(trimmed)) return false;
+  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;
+  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;
+  if (/^(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\b/.test(trimmed) && !hasTopLevelClassBody(trimmed)) return false;
+  if (FUNCTION_HEADER.test(trimmed) || /^(?:export\s+(?:default\s+)?)?(?:async\s+)?function\b[\s\S]*\)\s*:\s*$/.test(trimmed)) return false;
+  if (/^(?:export\s+)?type\b/.test(trimmed) && !/;\s*$/.test(trimmed)) return false;
+  if (/^(?:const|let|var)\b/.test(trimmed)) {
+    const initializer = /\b(?:const|let|var)\b[\s\S]*?=\s*([\s\S]*)$/.exec(trimmed)?.[1]?.trim() ?? "";
+    // A typed parameter list is not an expression until `=>` arrives; its closing `)` must not commit the declaration early.
+    if (!initializer || /^(?:async\s+)?function\b[\s\S]*\)\s*$/.test(initializer) || /^class(?:\s+[A-Za-z_$][\w$]*)?\s*$/.test(initializer) || /^\(\s*\)$/.test(initializer) || isTypedParameterList(initializer) || /[.?]$/.test(initializer) || !/[)\]}"'`]$/.test(initializer)) return false;
+  }
+  if (/^(?:return|throw|yield|await)\b[\s\S]*$/.test(trimmed)) {
+    const expression = trimmed.replace(/^(?:return|throw|yield|await)\s+/, "").trim();
+    if (!/[)\]}"'`]$/.test(expression)) return false;
+  }
+  if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) return false;
+  if (/(?<![\w$])(?:const|let|var)\s+[A-Za-z_$][\w$]*\s*=\s*[A-Za-z_$][\w$]*$/.test(trimmed)) return false;
+  if (!/(?:null|true|false)$/.test(trimmed) && /[A-Za-z_$][\w$]*$/.test(trimmed)) return false;
+  if (/^(?:[A-Za-z_$][\w$]*(?:\.[A-Za-z_$][\w$]*|\[[^\]]+\])*)\s*=/.test(trimmed)) return false;
+  if (/[A-Za-z0-9_$]$/.test(trimmed) && !/[)\]}"'`]$/.test(trimmed)) return false;
+  return true;
+};
+
+const findTrailingUnsafeStatementStart = (code: string, scan: StreamingScan) => {
+  const scopeStart = scan.scopes.at(-1)?.statementStart ?? 0;
+  const start = findAsiBoundary(code, scopeStart, scan.regexLiteralStarts);
+  const tail = code.slice(start, Math.max(start, scan.lastSignificantEnd));
+  if (isTrailingClosedRegexLiteral(code, code.length, findLastRegexLiteralStart(scan.regexLiteralStarts, code.length))) return code.length;
+  if (/^\s*while\s*\([\s\S]*\)\s*$/.test(tail) && isCompleteDoWhileStatement(code, scan)) return code.length;
+  return hasSafeExpressionTail(tail) ? code.length : start;
+};
+
+const skipMaskedWhitespace = (code: string, index: number) => {
+  while (index < code.length && /\s/.test(code[index])) index += 1;
+  return index;
+};
+const findBalancedDelimiterEnd = (code: string, index: number, open: string, close: string) => {
+  if (code[index] !== open) return -1;
+  let depth = 0;
+  for (; index < code.length; index += 1) {
+    if (code[index] === open) depth += 1;
+    else if (code[index] === close && --depth === 0) return index + 1;
+  }
+  return -1;
+};
+const hasKeywordAt = (code: string, index: number, keyword: string) => code.slice(index, index + keyword.length) === keyword && !/[\w$]/.test(code[index + keyword.length] ?? "");
+const isTrailingKeywordPrefix = (code: string, index: number, keywords: string[]) => {
+  const tail = code.slice(index).trim();
+  return !tail || keywords.some((keyword) => tail.length < keyword.length && keyword.startsWith(tail));
+};
+const findRequiredBlockEnd = (code: string, index: number) => {
+  index = skipMaskedWhitespace(code, index);
+  return code[index] === "{" ? findBalancedDelimiterEnd(code, index, "{", "}") : -1;
+};
+const findSimpleStatementEnd = (code: string, index: number) => {
+  index = skipMaskedWhitespace(code, index);
+  if (code[index] === "{") return findBalancedDelimiterEnd(code, index, "{", "}");
+  const start = index;
+  const stack: string[] = [];
+  for (; index < code.length; index += 1) {
+    const char = code[index];
+    if (char in BLOCK_FOLLOWERS) stack.push(BLOCK_FOLLOWERS[char]);
+    else if (BLOCK_CLOSERS.has(char)) {
+      if (stack.at(-1) === char) stack.pop();
+      else if (stack.length === 0) return index;
+    } else if (char === "\n" && stack.length === 0 && isAsiBoundary(code.slice(start, index), code.slice(index + 1))) return index + 1;
+    else if (char === ";" && stack.length === 0) return index + 1;
+  }
+  return -1;
+};
+
+const skipStatementLabels = (code: string, index: number) => {
+  index = skipMaskedWhitespace(code, index);
+  let label: RegExpExecArray | null;
+  while ((label = /^([A-Za-z_$][\w$]*)\s*:\s*/.exec(code.slice(index))) && label[1] !== "case" && label[1] !== "default") index += label[0].length;
+  return index;
+};
+function findIfStatementEnd(code: string, index: number) {
+  const conditionEnd = findBalancedDelimiterEnd(code, skipMaskedWhitespace(code, index + "if".length), "(", ")");
+  if (conditionEnd === -1) return -1;
+  const consequentEnd = findStatementEnd(code, conditionEnd);
+  if (consequentEnd === -1) return -1;
+  const cursor = skipMaskedWhitespace(code, consequentEnd);
+  if (isTrailingKeywordPrefix(code, cursor, ["else"])) return -1;
+  return hasKeywordAt(code, cursor, "else") ? findStatementEnd(code, cursor + "else".length) : consequentEnd;
+}
+function findTryStatementEnd(code: string, index: number) {
+  let cursor = findRequiredBlockEnd(code, index + "try".length);
+  if (cursor === -1) return -1;
+  cursor = skipMaskedWhitespace(code, cursor);
+  if (isTrailingKeywordPrefix(code, cursor, ["catch", "finally"])) return -1;
+  if (hasKeywordAt(code, cursor, "catch")) {
+    cursor = skipMaskedWhitespace(code, cursor + "catch".length);
+    if (code[cursor] === "(") {
+      cursor = findBalancedDelimiterEnd(code, cursor, "(", ")");
+      if (cursor === -1) return -1;
+    }
+    const catchEnd = findRequiredBlockEnd(code, cursor);
+    if (catchEnd === -1) return -1;
+    cursor = skipMaskedWhitespace(code, catchEnd);
+    const tail = code.slice(cursor).trim();
+    if (tail && tail.length < "finally".length && "finally".startsWith(tail)) return -1;
+    if (!hasKeywordAt(code, cursor, "finally")) return catchEnd;
+    cursor += "finally".length;
+  } else if (hasKeywordAt(code, cursor, "finally")) cursor += "finally".length;
+  else return -1;
+  return findRequiredBlockEnd(code, cursor);
+}
+function findDoStatementEnd(code: string, index: number) {
+  const bodyEnd = findStatementEnd(code, index + "do".length);
+  if (bodyEnd === -1) return -1;
+  let cursor = skipMaskedWhitespace(code, bodyEnd);
+  if (!hasKeywordAt(code, cursor, "while")) return -1;
+  cursor = skipMaskedWhitespace(code, cursor + "while".length);
+  const conditionEnd = findBalancedDelimiterEnd(code, cursor, "(", ")");
+  if (conditionEnd === -1) return -1;
+  cursor = skipMaskedWhitespace(code, conditionEnd);
+  return code[cursor] === ";" ? cursor + 1 : conditionEnd;
+}
+function findHeaderBodyStatementEnd(code: string, index: number, keyword: "for" | "while" | "with") {
+  let cursor = skipMaskedWhitespace(code, index + keyword.length);
+  if (keyword === "for" && hasKeywordAt(code, cursor, "await")) cursor = skipMaskedWhitespace(code, cursor + "await".length);
+  const conditionEnd = findBalancedDelimiterEnd(code, cursor, "(", ")");
+  return conditionEnd === -1 ? -1 : findStatementEnd(code, conditionEnd);
+}
+function findSwitchStatementEnd(code: string, index: number) {
+  const conditionEnd = findBalancedDelimiterEnd(code, skipMaskedWhitespace(code, index + "switch".length), "(", ")");
+  return conditionEnd === -1 ? -1 : findRequiredBlockEnd(code, conditionEnd);
+}
+function findStatementEnd(code: string, index: number): number {
+  index = skipStatementLabels(code, index);
+  if (hasKeywordAt(code, index, "if")) return findIfStatementEnd(code, index);
+  if (hasKeywordAt(code, index, "try")) return findTryStatementEnd(code, index);
+  if (hasKeywordAt(code, index, "do")) return findDoStatementEnd(code, index);
+  if (hasKeywordAt(code, index, "switch")) return findSwitchStatementEnd(code, index);
+  for (const keyword of ["for", "while", "with"] as const) if (hasKeywordAt(code, index, keyword)) return findHeaderBodyStatementEnd(code, index, keyword);
+  return findSimpleStatementEnd(code, index);
+}
+
+const createControlStatementContextLookup = (scan: StreamingScan) => {
+  const frames = [...scan.closedBlocks, ...scan.stack].filter((frame): frame is Extract<CompletionFrame, { type: "block" }> & { open: number } => frame.type === "block" && frame.closer === "}" && frame.open !== undefined).toSorted((left, right) => left.open - right.open);
+  const active: typeof frames = [];
+  let frameIndex = 0;
+  return (index: number) => {
+    while (frameIndex < frames.length && frames[frameIndex].open < index) {
+      const frame = frames[frameIndex++];
+      while (active.length && (active.at(-1)?.close ?? Number.POSITIVE_INFINITY) <= frame.open) active.pop();
+      active.push(frame);
+    }
+    while (active.length && (active.at(-1)?.close ?? Number.POSITIVE_INFINITY) <= index) active.pop();
+    const container = active.at(-1);
+    return !container || (container.statement && container.kind !== "class" && !container.jsxExpression);
+  };
+};
+
+// Optional continuations are the dangerous boundary: `if { … } el`, `try { … } cat`, and `do { … } wh` are each valid-looking
+// prefixes if their first block is completed in isolation. Keep the whole originating statement pending until its continuation is
+// either complete or a later token proves that no optional branch follows.
+const findPendingContinuationStart = (code: string, scan: StreamingScan) => {
+  const masked = maskIgnoredTextForExportScan(code, scan.regexLiteralStarts);
+  const isControlStatementContext = createControlStatementContextLookup(scan);
+  let coveredUntil = -1;
+  for (const match of controlStatementMatches(masked)) {
+    const start = (match.index ?? 0) + match[1].length;
+    if (start < coveredUntil || !isControlStatementContext(start)) continue;
+    const end = findStatementEnd(masked, start);
+    if (end === -1) return start;
+    coveredUntil = end;
+  }
+  return code.length;
+};
+
+const trimToCommittedPrefix = (code: string) => {
+  let scan = scanStreamingSource(code);
+  const jsxExpression = scan.stack.find((frame): frame is Extract<CompletionFrame, { type: "block" }> => frame.type === "block" && frame.jsxExpression === true);
+  if (jsxExpression) {
+    code = code.slice(0, jsxExpression.open ?? code.length);
+    // Rolling back the child expression changes the active frames; rescan so its discarded callback/literal cannot invalidate the parent JSX shell.
+    scan = scanStreamingSource(code);
+  }
+  let cut = code.length;
+  if (scan.unclosedLiteralStart !== null) cut = Math.min(cut, scan.unclosedLiteralStatementStart ?? scan.unclosedLiteralStart);
+  const safeJsxShell = isJsxShellPreview(code, scan);
+  const componentArrow = safeJsxShell && (isComponentArrowPrefix(code, code.length) || scan.stack.some((frame) => frame.type === "block" && frame.kind === "arrow" && isComponentArrowFrame(code, frame)));
+  for (const frame of scan.stack) {
+    if (frame.type !== "block" || frame.jsxExpression) continue;
+    if (safeJsxShell && isAllowedJsxShellFrame(code, frame, componentArrow)) continue;
+    if (frame.kind === "function" && isFunctionDeclarationFrame(code, frame)) continue;
+    cut = Math.min(cut, frame.statementStart ?? frame.open ?? code.length);
+  }
+  cut = Math.min(cut, findPendingContinuationStart(code, scan));
+  if (scan.incompleteJsxTagStart !== null && !safeJsxShell) cut = Math.min(cut, scan.scopes.at(-1)?.statementStart ?? scan.incompleteJsxTagStart);
+  if (cut === code.length && !safeJsxShell && scan.incompleteJsxTagStart === null) cut = findTrailingUnsafeStatementStart(code, scan);
+  return { code: code.slice(0, cut), regexLiteralStarts: scan.regexLiteralStarts };
+};
+
+export function completePartialTsx(code: string, options: PartialTsxOptions = {}): string {
+  let regexLiteralStarts: ReadonlySet<number> | undefined;
+  if (options.mode === "streaming") {
+    const committed = trimToCommittedPrefix(code);
+    code = committed.code;
+    regexLiteralStarts = committed.regexLiteralStarts;
+  }
   let output = "";
   const stack: CompletionFrame[] = [];
   let index = 0;
-  let validEnd = code.length;
   const push = (value: string) => {
     output += value;
   };
@@ -854,7 +1535,7 @@ export function completePartialTsx(code: string) {
       index = closeIndex + 2;
       continue;
     }
-    if (!isInsideJsxText(stack) && isLikelyRegexLiteralStart(code, index)) {
+    if (!isInsideJsxText(stack) && (regexLiteralStarts?.has(index) || isLikelyRegexLiteralStart(code, index))) {
       index = consumeRegexLiteral(code, index, push);
       continue;
     }
@@ -881,12 +1562,9 @@ export function completePartialTsx(code: string) {
       if (closeIndex === -1) {
         const completedTag = completeIncompleteJsxTag(code, index);
         if (completedTag === null) {
-          validEnd = index;
-          output = output.slice(0, validEnd);
           break;
         }
         push(completedTag.tag);
-        index = code.length;
         if (!completedTag.tag.trimEnd().endsWith("/>") && !VOID_TAGS.has(completedTag.tagName)) stack.push({ type: "jsx", tag: completedTag.tagName });
         break;
       }
@@ -914,19 +1592,24 @@ export function completePartialTsx(code: string) {
     push(char);
     index += 1;
   }
-  const closingFrames = [...stack].toReversed();
+  const lastRegexLiteralStart = regexLiteralStarts ? findLastRegexLiteralStart(regexLiteralStarts, code.length) : undefined;
+  if (isTrailingClosedRegexLiteral(code, code.length, lastRegexLiteralStart) && canCommitBoundary(stack)) output += ";";
+  const closingFrames = stack.toReversed();
   const closers = closingFrames.map(closeFrame).join("");
-  if (!closers) return completeIncompleteExpressionPrefix(output, true);
+  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));
-  const completedExpression = fillEmptyReturnExpression(completeIncompleteExpressionPrefix(beforeStatement, true));
+  const completedExpression = dropTrailingBareLoopHeader(fillEmptyReturnExpression(completeIncompleteExpressionPrefix(beforeStatement, true, options.mode === "streaming")));
   return `${completedExpression}${isExpressionEnd(completedExpression) ? ";" : ""}${closingFrames.slice(statementIndex).map(closeFrame).join("")}`;
 }
 
-export function normalizeGeneratedTsx(code: string) {
-  let next = completePartialTsx(stripMarkdownFence(code)).trim();
-  const exportScanCode = maskIgnoredTextForExportScan(next);
+export function normalizeGeneratedTsx(code: string, options: PartialTsxOptions = {}) {
+  let next = completePartialTsx(stripMarkdownFence(code), options).trim();
+  let exportScanCode = maskIgnoredTextForExportScan(next);
+  // 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);
   if (!hasDefaultExportDeclaration(exportScanCode)) {
     const componentName = findLastExportableComponent(exportScanCode);
     if (componentName) next += `\nexport default ${componentName};`;