partial-tsx 0.0.0 → 0.0.2

package/src/partial.ts

@@ -0,0 +1,1619 @@
+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));
+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();
+  next = next.replace(/^```(?:[^\r\n]*)?(?:\r?\n|$)/i, "");
+  next = next.replace(/\s*```$/i, "");
+  return next;
+};
+const maskExportScanRange = (chars: string[], start: number, end: number) => {
+  for (let index = start; index < end; index += 1) if (chars[index] !== "\n") chars[index] = " ";
+};
+const findStringLiteralEnd = (code: string, index: number) => {
+  const quote = code[index];
+  index += 1;
+  while (index < code.length) {
+    if (code[index] === "\\") index += 2;
+    else {
+      if (code[index] === quote) return index + 1;
+      index += 1;
+    }
+  }
+  return code.length;
+};
+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 { 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;
+      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;
+        } else if (code[index] === "/" && code[index + 1] === "*") {
+          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] === "`") {
+          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 { end: code.length, closed: false };
+};
+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;
+  if (tag.startsWith("</")) {
+    const frame = stack.at(-1);
+    if (frame?.type === "jsx" && frame.tag === tagName) stack.pop();
+    return;
+  }
+  if (!tag.endsWith("/>") && !VOID_TAGS.has(tagName)) stack.push({ type: "jsx", tag: tagName, open });
+};
+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[] = [];
+  for (let index = 0; index < code.length; index += 1) {
+    const char = code[index];
+    if (isInsideJsxText(stack) && char !== "<" && char !== "{") {
+      if (chars[index] !== "\n") chars[index] = " ";
+      continue;
+    }
+    if (char === "/" && code[index + 1] === "/") {
+      const end = code.indexOf("\n", index + 2);
+      const next = end === -1 ? code.length : end;
+      maskExportScanRange(chars, index, next);
+      index = next;
+      continue;
+    }
+    if (char === "/" && code[index + 1] === "*") {
+      const close = code.indexOf("*/", index + 2);
+      const next = close === -1 ? code.length : close + 2;
+      maskExportScanRange(chars, index, next);
+      index = next - 1;
+      continue;
+    }
+    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;
+    }
+    if (char === '"' || char === "'") {
+      const next = findStringLiteralEnd(code, index);
+      maskExportScanRange(chars, index, next);
+      index = next - 1;
+      continue;
+    }
+    if (char === "`") {
+      const next = findTemplateLiteralEnd(code, index);
+      maskExportScanRange(chars, index, next);
+      index = next - 1;
+      continue;
+    }
+    if (char === "<" && shouldStartJsxTag(code, index, stack)) {
+      const closeIndex = findJsxTagEnd(code, index);
+      if (closeIndex === -1) break;
+      const tag = code.slice(index, closeIndex + 1);
+      maskExportScanRange(chars, index, closeIndex + 1);
+      chars[index] = "<"; // keep the leading `<` so `export default <Card/>` is still detectable after masking
+      index = closeIndex;
+      updateJsxStackForTag(stack, tag);
+      continue;
+    }
+    if (char in BLOCK_FOLLOWERS) {
+      stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: false });
+      continue;
+    }
+    if (BLOCK_CLOSERS.has(char)) {
+      const frame = stack.at(-1);
+      if (frame?.type === "block" && frame.closer === char) stack.pop();
+    }
+  }
+  return chars.join("");
+};
+const findBalancedTypeArgumentsEnd = (code: string, index: number) => {
+  if (code[index] !== "<") return index;
+  let depth = 0;
+  for (; index < code.length; index += 1) {
+    const char = code[index];
+    if (char === "<") depth += 1;
+    else if (char === ">" && code[index - 1] === "=") continue;
+    else if (char === ">") {
+      depth -= 1;
+      if (depth === 0) return index + 1;
+    }
+  }
+  return -1;
+};
+const findWrappedComponentCallOpen = (code: string, index: number) => {
+  index = findBalancedTypeArgumentsEnd(code, index);
+  if (index === -1) return -1;
+  while (/\s/.test(code[index] ?? "")) index += 1;
+  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 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 });
+  }
+  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(/\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;
+};
+// `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'`).
+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);
+
+// 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",
+  "useEffect",
+  "useRef",
+  "useMemo",
+  "useCallback",
+  "useReducer",
+  "useContext",
+  "useLayoutEffect",
+  "useInsertionEffect",
+  "useTransition",
+  "useDeferredValue",
+  "useId",
+  "useImperativeHandle",
+  "useDebugValue",
+  "useSyncExternalStore",
+  "useActionState",
+  "useOptimistic",
+  "useEffectEvent",
+]);
+
+const isUnmaskedImportMatch = (code: string, maskedCode: string, match: RegExpExecArray) => {
+  const importIndex = (match.index ?? 0) + match[0].indexOf("import");
+  return code.slice(importIndex, importIndex + "import".length) === maskedCode.slice(importIndex, importIndex + "import".length);
+};
+const collectImportedBindings = (code: string, maskedCode: string) => {
+  const bindings = new Set<string>();
+  for (const match of code.matchAll(/(?:^|[;\n])\s*import\s+([\s\S]*?)\s+from\s+["'][^"']*["']/g)) {
+    if (!isUnmaskedImportMatch(code, maskedCode, match)) continue;
+    const clause = match[1].trim();
+    if (!clause.startsWith("{") && !clause.startsWith("*")) {
+      const defaultMatch = /^([A-Za-z_$][\w$]*)/.exec(clause);
+      if (defaultMatch) bindings.add(defaultMatch[1]);
+    }
+    const namespaceMatch = /\*\s+as\s+([A-Za-z_$][\w$]*)/.exec(clause);
+    if (namespaceMatch) bindings.add(namespaceMatch[1]);
+    const namedMatch = /\{([\s\S]*?)\}/.exec(clause);
+    if (!namedMatch) continue;
+    for (const raw of namedMatch[1].split(",")) {
+      const item = raw.trim().replace(/^type\s+/, "");
+      if (!item) continue;
+      const aliased = /^([A-Za-z_$][\w$]*)\s+as\s+([A-Za-z_$][\w$]*)\s*$/.exec(item);
+      if (aliased) {
+        // Track both the original name and the alias so `useState as useS` blocks us from re-importing `useState`.
+        bindings.add(aliased[1]);
+        bindings.add(aliased[2]);
+        continue;
+      }
+      const name = /^([A-Za-z_$][\w$]*)/.exec(item)?.[1];
+      if (name) bindings.add(name);
+    }
+  }
+  return bindings;
+};
+
+const injectMissingReactHookImports = (code: string, maskedCode: string) => {
+  if (!/\buse[A-Z]/.test(maskedCode)) return code;
+  const bindings = collectImportedBindings(code, maskedCode);
+  const missing = new Set<string>();
+  for (const match of maskedCode.matchAll(/\b(use[A-Z][\w$]*)\b/g)) {
+    const name = match[1];
+    if (!REACT_HOOK_NAMES.has(name) || bindings.has(name)) continue;
+    if (maskedCode[(match.index ?? 0) - 1] === ".") continue;
+    missing.add(name);
+  }
+  if (missing.size === 0) return code;
+  const additions = [...missing].join(", ");
+  // Skips `import type { ... } from "react"` so we don't merge value hooks into a type-only import; supports mixed default+named imports like `import React, { useState } from "react"`.
+  const existing = /(?:^|[;\n])\s*import\s+(?:[A-Za-z_$][\w$]*\s*,\s*)?\{([^}]*)\}\s+from\s+["']react["']/.exec(code);
+  if (existing) {
+    if (!isUnmaskedImportMatch(code, maskedCode, existing)) return `import { ${additions} } from "react";\n${code}`;
+    const inner = existing[1].trim().replace(/,\s*$/, "");
+    const merged = inner ? `${inner}, ${additions}` : additions;
+    const rewritten = existing[0].replace(/\{[^}]*\}/, `{ ${merged} }`);
+    return `${code.slice(0, existing.index)}${rewritten}${code.slice(existing.index + existing[0].length)}`;
+  }
+  return `import { ${additions} } from "react";\n${code}`;
+};
+
+const isLikelyJsxTagStart = (code: string, index: number) => {
+  const next = code[index + 1] ?? "";
+  if (!/[A-Za-z/>]/.test(next)) return false;
+  let previous = index - 1;
+  while (previous >= 0 && /\s/.test(code[previous])) previous -= 1;
+  if (previous < 0) return true;
+  const previousChar = code[previous];
+  if ("([{=:?!,&|^~*/%+-;".includes(previousChar)) return true;
+  if (previousChar === ">" && code[previous - 1] === "=") return true;
+  if (/[)\]}"'`]/.test(previousChar)) return false;
+  if (/[A-Za-z0-9_$]/.test(previousChar)) {
+    let word = "";
+    for (let cursor = previous; cursor >= 0 && /[A-Za-z0-9_$]/.test(code[cursor]); cursor -= 1) word = code[cursor] + word;
+    return new Set(["return", "throw", "await", "yield", "case", "default", "else", "typeof", "void", "delete", "new"]).has(word);
+  }
+  return previousChar !== ">";
+};
+
+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|with)\s*\([^)]*\)$/.test(before) || /\bcatch(?:\s*\([^)]*\))?$/.test(before) || /(?:^|[^\w$])(?:else|try|finally|do)$/.test(before) || before.endsWith("=>");
+};
+
+const findJsxTagEnd = (code: string, start: number) => {
+  const stack: string[] = [];
+  let quote: string | null = null;
+  for (let index = start + 1; index < code.length; index += 1) {
+    const char = code[index];
+    if (quote) {
+      if (char === "\\") index += 1;
+      else if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char in BLOCK_FOLLOWERS) {
+      stack.push(BLOCK_FOLLOWERS[char]);
+      continue;
+    }
+    if (BLOCK_CLOSERS.has(char)) {
+      if (stack.at(-1) === char) stack.pop();
+      continue;
+    }
+    if (char === ">" && stack.length === 0) return index;
+  }
+  return -1;
+};
+const findJsxAttributeExpressionEnd = (code: string, index: number) => {
+  let depth = 1;
+  while (index < code.length) {
+    if (code[index] === "/" && code[index + 1] === "/") {
+      const end = code.indexOf("\n", index + 2);
+      index = end === -1 ? code.length : end;
+      continue;
+    }
+    if (code[index] === "/" && code[index + 1] === "*") {
+      const close = code.indexOf("*/", index + 2);
+      index = close === -1 ? code.length : close + 2;
+      continue;
+    }
+    if (isLikelyRegexLiteralStart(code, index)) {
+      index = findRegexLiteralEnd(code, index);
+      continue;
+    }
+    if (code[index] === '"' || code[index] === "'") {
+      index = findStringLiteralEnd(code, index);
+      continue;
+    }
+    if (code[index] === "`") {
+      index = findTemplateLiteralEnd(code, index);
+      continue;
+    }
+    if (code[index] === "{") depth += 1;
+    else if (code[index] === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+    index += 1;
+  }
+  return -1;
+};
+const completeIncompleteJsxTag = (code: string, start: number) => {
+  if (code[start + 1] === "/") return null;
+  const tagMatch = /^<\s*([A-Za-z][\w$.-]*)/.exec(code.slice(start));
+  if (!tagMatch) return null;
+  const [matched, tagName] = tagMatch;
+  // Tag name may still be streaming (`inp` may become `input`, `Sur` may become `Surface`); completing now would render the wrong element or throw `Sur is not defined` and remount. Wait for a separator (space/`>`/attr).
+  if (start + matched.length >= code.length) return null;
+  let index = start;
+  let tag = "";
+  while (index < code.length) {
+    const char = code[index];
+    if (char === "`") {
+      // A backtick is illegal as a JSX attribute value (`title=`x`` → "JSX value should be either an expression or a quoted JSX text"); template literals are only valid inside `{...}`. Drop the attribute.
+      tag = tag.replace(/\s*[\w$:-]+\s*=\s*$/, "");
+      index = findTemplateLiteralEnd(code, index);
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      const end = findStringLiteralEnd(code, index);
+      let literal = code.slice(index, end);
+      const closed = literal.length > 1 && literal.endsWith(char);
+      // 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 ?? 0) % 2) literal = literal.slice(0, -1);
+        literal += char;
+      }
+      tag += literal;
+      index = end;
+      continue;
+    }
+    if (char === "{") {
+      const expressionEnd = findJsxAttributeExpressionEnd(code, index + 1);
+      // An unterminated expression value must not be completed: mid-stream `{x` may still become `x.y`, `xyz`, or `x + 1`, so synthesizing `}` binds the frame to the wrong (or undefined) value and can throw. Drop the attribute, keep the tag. Host and component alike.
+      if (expressionEnd === -1) {
+        tag = tag.replace(/\s*[\w$:-]+\s*=\s*$/, "");
+        index = code.length;
+        continue;
+      }
+      const expression = code.slice(index + 1, expressionEnd);
+      const completedExpression = completeIncompleteExpressionPrefix(completePartialTsx(expression), true);
+      if (!expression.trim() || !completedExpression.trim() || /^(?:const|let|var)\b/.test(completedExpression.trim())) {
+        tag = tag.replace(/\s*[\w$:-]+\s*=\s*$/, "");
+        index = expressionEnd + 1;
+        continue;
+      }
+      tag += `{${completedExpression}}`;
+      index = expressionEnd + 1;
+      continue;
+    }
+    tag += char;
+    index += 1;
+    if (char === ">") return { tag: VOID_TAGS.has(tagName) ? tag.replace(/\s*\/?\s*>$/, " />") : tag, tagName };
+  }
+  // A dangling `prop=` would close as `prop=>` (SWC reads `=>` as an arrow function), breaking the whole module.
+  if (/=\s*$/.test(tag)) tag = tag.replace(/\s*[\w$:-]+\s*=\s*$/, "");
+  // Otherwise a trailing name with no following space is still streaming (`valu` may become `value`); a trailing space commits it as a boolean attr.
+  else if (!/\s$/.test(tag)) tag = tag.replace(/\s+[A-Za-z_$][\w$:-]*$/, "");
+  const completedTag = VOID_TAGS.has(tagName) ? `${tag.replace(/\s*\/\s*$/, "")} />` : `${tag}>`;
+  return { tag: completedTag, tagName };
+};
+
+type PushOutput = (value: string) => void;
+
+const consumeStringLiteral = (code: string, index: number, push: PushOutput) => {
+  const quote = code[index];
+  push(quote);
+  index += 1;
+  let closed = false;
+  while (index < code.length) {
+    const next = code[index];
+    if (next === "\\") {
+      push(code.slice(index, index + 2));
+      index += 2;
+      continue;
+    }
+    push(next);
+    index += 1;
+    if (next === quote) {
+      closed = true;
+      break;
+    }
+  }
+  if (!closed) push(quote);
+  return index;
+};
+
+const closeFrame = (frame: CompletionFrame) => {
+  if (frame.type === "jsx") return frame.tag ? `</${frame.tag}>` : "</>";
+  return frame.closer;
+};
+
+const isExpressionEnd = (value: string) => /(?:<\/[\w$.-]+>|<\/>|\/>|[>`'")\]\w])$/.test(value.trimEnd());
+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] === "/") {
+      const newlineIndex = code.indexOf("\n", index + 2);
+      index = (newlineIndex === -1 ? end : Math.min(newlineIndex, end)) - 1;
+      continue;
+    }
+    if (!isInsideJsxText(stack) && 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)) {
+      index = Math.min(findRegexLiteralEnd(code, index), end) - 1;
+      continue;
+    }
+    if (!isInsideJsxText(stack) && (char === '"' || char === "'")) {
+      index = Math.min(findStringLiteralEnd(code, index), end) - 1;
+      continue;
+    }
+    if (!isInsideJsxText(stack) && char === "`") {
+      index = Math.min(findTemplateLiteralEnd(code, index), end) - 1;
+      continue;
+    }
+    if (char === "<" && shouldStartJsxTag(code, index, stack)) {
+      const closeIndex = findJsxTagEnd(code, index);
+      if (closeIndex === -1 || closeIndex >= end) break;
+      updateJsxStackForTag(stack, code.slice(index, closeIndex + 1));
+      index = closeIndex;
+      continue;
+    }
+    if (char in BLOCK_FOLLOWERS) stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: isLikelyStatementBlock(code, index) });
+    else if (BLOCK_CLOSERS.has(char)) {
+      const frame = stack.at(-1);
+      if (frame?.type === "block" && frame.closer === char) stack.pop();
+    }
+  }
+  return stack;
+};
+const endsWithJsxTagHead = (value: string) => {
+  const lastOpen = value.lastIndexOf("<");
+  if (lastOpen === -1 || !shouldStartJsxTag(value, lastOpen, collectCompletionStackBefore(value, lastOpen))) return false;
+  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;
+    const end = findRegexLiteralEnd(value, index);
+    if (end === endIndex + 1) return true;
+    if (end > index) index = end - 1;
+  }
+  return false;
+};
+// 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 = 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 before;
+};
+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) => {
+  let out = "";
+  let index = 0;
+  while (index < body.length) {
+    const char = body[index];
+    if (char === "/" && body[index + 1] === "/") {
+      const end = body.indexOf("\n", index + 2);
+      const stop = end === -1 ? body.length : end;
+      out += " ".repeat(stop - index);
+      index = stop;
+    } else if (char === "/" && body[index + 1] === "*") {
+      const end = body.indexOf("*/", index + 2);
+      const stop = end === -1 ? body.length : end + 2;
+      out += " ".repeat(stop - index);
+      index = stop;
+    } else if (char === '"' || char === "'") {
+      const stop = findStringLiteralEnd(body, index);
+      out += " ".repeat(stop - index);
+      index = stop;
+    } else if (char === "`") {
+      const stop = findTemplateLiteralEnd(body, index);
+      out += " ".repeat(stop - index);
+      index = stop;
+    } else if (isLikelyRegexLiteralStart(body, index)) {
+      const stop = findRegexLiteralEnd(body, index);
+      out += " ".repeat(stop - index);
+      index = stop;
+    } else {
+      out += char;
+      index += 1;
+    }
+  }
+  return out;
+};
+// Blank out operators that share the `<` glyph so the angle-bracket counter never mistakes them for type brackets: `=>` (arrow,
+// whose `>` would otherwise close a generic early in `useCallback<(x) => void`), `<<`/`<<=` (left-shift, whose `<`s would read as
+// phantom openers in `1 << 2`), and `<=` (a `<` that can't open a generic, sparing `a <= b`). `>>`/`>>>`/`>=` are left alone so
+// nested generic closers (`Map<K, Array<V>>`) still count.
+const neutralizeAngleOperators = (masked: string) => masked.replace(/=>|<<=?|<=/g, (op) => " ".repeat(op.length));
+// True when the masked body has a `<` that never closes AND sits in value position (after an identifier / `)` / `]`) with no
+// bracket past it that would close out the surrounding expression — i.e. a type-argument list whose `>` hasn't streamed yet
+// (`useState<number | null`). Excludes a `<` right after `=` (a generic-arrow `<T,>(x)=>x`, completed elsewhere) and any `<`
+// followed by a `)`/`]`/`}` that ends the initializer (`items.filter((i) => i < 3)` — a real comparison, already terminated).
+const hasUnclosedTypeArgument = (body: string) => {
+  const masked = neutralizeAngleOperators(body);
+  let depth = 0;
+  let firstUnclosed = -1;
+  for (let index = 0; index < masked.length; index += 1) {
+    const char = masked[index];
+    if (char === "<") {
+      if (depth === 0) firstUnclosed = index;
+      depth += 1;
+    } else if (char === ">") {
+      if (depth > 0) depth -= 1;
+      if (depth === 0) firstUnclosed = -1;
+    }
+  }
+  if (firstUnclosed < 0) return false;
+  if (!/[\w$)\]]$/.test(masked.slice(0, firstUnclosed).trimEnd())) return false;
+  let bracketDepth = 0;
+  for (let index = firstUnclosed + 1; index < masked.length; index += 1) {
+    const char = masked[index];
+    if (char === "(" || char === "[" || char === "{") bracketDepth += 1;
+    else if (char === ")" || char === "]" || char === "}") {
+      bracketDepth -= 1;
+      if (bracketDepth < 0) return false;
+    }
+  }
+  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
+// 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);
+  const re = /(?:^|[{};\n]|=>)\s*(const(?!\s+enum\b)|let|var)\b/g;
+  let match: RegExpExecArray | null;
+  let start = -1;
+  let kind = "";
+  while ((match = re.exec(masked))) {
+    const declarationStart = match.index + match[0].length - match[1].length;
+    let depth = 0;
+    let terminated = false;
+    for (let index = declarationStart + match[1].length; index < masked.length; index += 1) {
+      const char = masked[index];
+      if (char === "(" || char === "[" || char === "{") depth += 1;
+      else if (char === ")" || char === "]" || char === "}") {
+        if (depth === 0) {
+          terminated = true;
+          break;
+        }
+        depth -= 1;
+      } else if (char === ";" && depth === 0) {
+        terminated = true;
+        break;
+      }
+    }
+    if (!terminated) {
+      start = declarationStart;
+      kind = match[1];
+    }
+  }
+  return start === -1 ? null : { start, kind, body: value.slice(start + kind.length) };
+};
+const dropTrailingIncompleteStatement = (value: string) => {
+  const declaration = locateTrailingDeclaration(value);
+  if (!declaration) return value;
+  const { start, kind, body } = declaration;
+  // Net bracket depth of the initializer: a trailing `=` only truncates the declaration's own initializer when we're
+  // back at top level. Inside an already-open arrow/function body (`() => { ...; x =`) the `=` belongs to a nested
+  // statement the block-frame completer will close, so rolling back the whole declaration would over-strip and over-close.
+  let initializerDepth = 0;
+  for (const char of maskLiteralSpans(body)) {
+    if (char === "(" || char === "[" || char === "{") initializerDepth += 1;
+    else if (char === ")" || char === "]" || char === "}") initializerDepth -= 1;
+  }
+  const incompleteInitializer = initializerDepth <= 0 && /=\s*$/.test(body);
+  // An initializer truncated mid-generic (`useState<number | null`) is valid-looking JS where SWC reads `<` as a comparison
+  // and keeps `number` as a bare value reference, crashing at runtime; drop the statement until its `>` closer streams in.
+  const unclosedGenericInitializer = body.includes("=") && hasUnclosedTypeArgument(maskLiteralSpans(body));
+  const missingDeclaration = !body.trim() || (!body.includes("=") && (kind === "const" || /^[\s,]*(?:\[|\{)/.test(body)));
+  if (!incompleteInitializer && !missingDeclaration && !unclosedGenericInitializer) return value;
+  return value.slice(0, start);
+};
+const completeTrailingIncompleteTernary = (value: string) => {
+  const masked = maskIgnoredTextForExportScan(value);
+  // `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`;
+};
+// A second `function` declaration that has only streamed up to its keyword/name (no parameter list yet) leaves a dangling
+// `function`/`function Name` that SWC rejects with `Expected ident`/`Expected '('`, blanking the already-rendered prior
+// declaration. Drop it back to the preceding complete statement until its `(` arrives.
+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, 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
+// initializer `[{ foo: useState<number`. We tell them apart with `frame.open` (the opener's offset): if the completed text no
+// longer reaches that offset, the opener is gone, so we emit no closer and report `dropped` for the caller to skip orphaned
+// 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);
+  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 };
+};
+// An empty `(` is a legal empty argument list only when it directly follows a callee; as a grouping or
+// arrow body it must hold an expression, so fill `null` rather than closing into an illegal empty `()`.
+const isCallArgumentParen = (value: string) => /(?:[\w$)\]]|\?\.)$/.test(value.slice(0, -1).trimEnd());
+const completeStatementPrefixFrame = (output: string, frame: CompletionFrame): { text: string; dropped: boolean } => {
+  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);
+};
+// 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[]) => {
+  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 (result.dropped) dropPoint = Math.min(dropPoint, result.text.length);
+    text = result.text;
+  }
+  return text;
+};
+const REGEX_PREFIX_WORDS = new Set(["return", "throw", "case", "delete", "typeof", "void", "new", "in", "of", "await", "yield"]);
+const JSX_CLOSING_TAG_START = /^<\/\s*(?:[A-Za-z][\w$.-]*\s*)?>/;
+
+function isLikelyRegexLiteralStart(code: string, index: number) {
+  if (code[index] !== "/" || code[index + 1] === "/" || code[index + 1] === "*") return false;
+  if (code[index - 1] === "<" && JSX_CLOSING_TAG_START.test(code.slice(index - 1))) return false;
+  let previous = index - 1;
+  while (previous >= 0 && /\s/.test(code[previous])) previous -= 1;
+  if (previous < 0) return true;
+  const previousChar = code[previous];
+  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);
+}
+
+function findRegexLiteralEnd(code: string, index: number) {
+  index += 1;
+  let inClass = false;
+  while (index < code.length) {
+    const next = code[index];
+    if (next === "\\") {
+      index += 2;
+      continue;
+    }
+    index += 1;
+    if (next === "[" && !inClass) inClass = true;
+    else if (next === "]" && inClass) inClass = false;
+    else if (next === "/" && !inClass) {
+      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;
+    }
+  }
+  return code.length;
+}
+
+const consumeRegexLiteral = (code: string, index: number, push: PushOutput) => {
+  push("/");
+  index += 1;
+  let inClass = false;
+  let closed = false;
+  while (index < code.length) {
+    const next = code[index];
+    if (next === "\\") {
+      push(code.slice(index, index + 2));
+      index += 2;
+      continue;
+    }
+    push(next);
+    index += 1;
+    if (next === "[" && !inClass) inClass = true;
+    else if (next === "]" && inClass) inClass = false;
+    else if (next === "/" && !inClass) {
+      closed = true;
+      break;
+    }
+  }
+  while (closed && index < code.length && /[A-Za-z]/.test(code[index])) {
+    push(code[index]);
+    index += 1;
+  }
+  if (!closed) push("/");
+  return index;
+};
+
+const isJsxTagHead = (code: string, index: number) => {
+  const tail = code.slice(index);
+  if (tail.startsWith("<>") || tail.startsWith("</>") || tail === "</") return true;
+  if (tail.startsWith("</")) return /^<\/\s*[A-Za-z][\w$.-]*(?:\s*>|>|$)/.test(tail);
+  const match = /^<[A-Za-z][\w$.-]*/.exec(tail);
+  return match !== null && /^(?:$|[\s/>])/.test(tail.slice(match[0].length));
+};
+
+// 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);
+  return isLikelyJsxTagStart(code, index);
+};
+const isInsideJsxText = (stack: CompletionFrame[]) => stack.at(-1)?.type === "jsx";
+
+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] === "/") {
+      const newlineIndex = code.indexOf("\n", index + 2);
+      const end = newlineIndex === -1 ? code.length : newlineIndex;
+      push(code.slice(index, end));
+      index = end;
+      continue;
+    }
+    if (expressionChar === "/" && code[index + 1] === "*") {
+      const closeIndex = code.indexOf("*/", index + 2);
+      if (closeIndex === -1) {
+        push(`${code.slice(index)}*/`);
+        return code.length;
+      }
+      push(code.slice(index, closeIndex + 2));
+      index = closeIndex + 2;
+      continue;
+    }
+    if (isLikelyRegexLiteralStart(code, index)) {
+      index = consumeRegexLiteral(code, index, push);
+      continue;
+    }
+    if (expressionChar === '"' || expressionChar === "'") {
+      index = consumeStringLiteral(code, index, push);
+      continue;
+    }
+    if (expressionChar === "`") {
+      index = consumeTemplateLiteral(code, index, push);
+      continue;
+    }
+    push(expressionChar);
+    index += 1;
+    if (expressionChar === "{") depth += 1;
+    else if (expressionChar === "}") depth -= 1;
+  }
+  // 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;
+};
+
+const consumeTemplateLiteral = (code: string, index: number, push: PushOutput): number => {
+  push("`");
+  index += 1;
+  let closed = false;
+  while (index < code.length) {
+    const next = code[index];
+    if (next === "\\") {
+      push(code.slice(index, index + 2));
+      index += 2;
+      continue;
+    }
+    if (next === "$" && code[index + 1] === "{") {
+      push("${");
+      index = consumeTemplateExpression(code, index + 2, push);
+      continue;
+    }
+    push(next);
+    index += 1;
+    if (next === "`") {
+      closed = true;
+      break;
+    }
+  }
+  if (!closed) push("`");
+  return index;
+};
+
+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;
+  const push = (value: string) => {
+    output += value;
+  };
+  while (index < code.length) {
+    const char = code[index];
+    if (!isInsideJsxText(stack) && char === "/" && code[index + 1] === "/") {
+      const newlineIndex = code.indexOf("\n", index + 2);
+      const end = newlineIndex === -1 ? code.length : newlineIndex;
+      push(code.slice(index, end));
+      index = end;
+      continue;
+    }
+    if (!isInsideJsxText(stack) && char === "/" && code[index + 1] === "*") {
+      const closeIndex = code.indexOf("*/", index + 2);
+      if (closeIndex === -1) {
+        push(`${code.slice(index)}*/`);
+        index = code.length;
+        continue;
+      }
+      push(code.slice(index, closeIndex + 2));
+      index = closeIndex + 2;
+      continue;
+    }
+    if (!isInsideJsxText(stack) && (regexLiteralStarts?.has(index) || isLikelyRegexLiteralStart(code, index))) {
+      index = consumeRegexLiteral(code, index, push);
+      continue;
+    }
+    if (!isInsideJsxText(stack) && (char === '"' || char === "'")) {
+      index = consumeStringLiteral(code, index, push);
+      continue;
+    }
+    if (!isInsideJsxText(stack) && char === "`") {
+      index = consumeTemplateLiteral(code, index, push);
+      continue;
+    }
+    if (char === "<" && isInsideJsxText(stack) && !shouldStartJsxTag(code, index, stack) && index < code.length - 1) {
+      push("&lt;");
+      index += 1;
+      continue;
+    }
+    if (char === "<" && !shouldStartJsxTag(code, index, stack) && index === code.length - 1) {
+      const frame = stack.at(-1);
+      if (frame?.type === "block" && frame.closer === "}" && !frame.statement) output = output.trimEnd();
+      break;
+    }
+    if (char === "<" && shouldStartJsxTag(code, index, stack)) {
+      const closeIndex = findJsxTagEnd(code, index);
+      if (closeIndex === -1) {
+        const completedTag = completeIncompleteJsxTag(code, index);
+        if (completedTag === null) {
+          break;
+        }
+        push(completedTag.tag);
+        if (!completedTag.tag.trimEnd().endsWith("/>") && !VOID_TAGS.has(completedTag.tagName)) stack.push({ type: "jsx", tag: completedTag.tagName });
+        break;
+      }
+      const tag = code.slice(index, closeIndex + 1);
+      const match = /^<\/?\s*([A-Za-z][\w$.-]*)/.exec(tag);
+      const tagName = match?.[1] ?? (tag === "<>" || tag === "</>" ? "" : null);
+      if (!(tagName && VOID_TAGS.has(tagName) && tag.startsWith("</"))) push(tagName && VOID_TAGS.has(tagName) && !tag.endsWith("/>") ? tag.replace(/\s*\/?\s*>$/, " />") : tag);
+      index = closeIndex + 1;
+      updateJsxStackForTag(stack, tag);
+      continue;
+    }
+    if (char in BLOCK_FOLLOWERS) {
+      stack.push({ type: "block", closer: BLOCK_FOLLOWERS[char], statement: isLikelyStatementBlock(code, index), open: output.length });
+      push(char);
+      index += 1;
+      continue;
+    }
+    if (BLOCK_CLOSERS.has(char)) {
+      const frame = stack.at(-1);
+      if (frame?.type === "block" && frame.closer === char) stack.pop();
+      push(char);
+      index += 1;
+      continue;
+    }
+    push(char);
+    index += 1;
+  }
+  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, 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 = dropTrailingBareLoopHeader(fillEmptyReturnExpression(completeIncompleteExpressionPrefix(beforeStatement, true, options.mode === "streaming")));
+  return `${completedExpression}${isExpressionEnd(completedExpression) ? ";" : ""}${closingFrames.slice(statementIndex).map(closeFrame).join("")}`;
+}
+
+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};`;
+  }
+  next = injectMissingReactHookImports(next, exportScanCode);
+  return next;
+}