@@ -885,6 +885,34 @@ describe('VariableResolver function block inputs', () => {
     expect(result.contextVariables).toEqual({ __blockRef_0: ref })
   })
 
+  it('reads the context of a reference that follows a statement-position regex', async () => {
+    // `)` ends a value in `(a + b) / 2` and a control-flow head in `if (a) /re/.test(b)`, and
+    // the closing parenthesis alone does not say which. Guessing either way misreads one of
+    // them, and a quote inside the regex then decides how every later reference is spliced.
+    const { block, ctx, resolver } = createResolver('javascript')
+
+    // Both cases stay on one line: a string mode ends at a newline, so only a reference sharing
+    // the line with the misread slash sees the wrong context.
+    const result = await resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      {
+        code: [
+          `if (params.a) /['"]/.test('<producer.result>')`,
+          `const divided = (params.c + 1) / 2 + Number('<producer.result>')`,
+          'return divided',
+        ].join('\n'),
+      },
+      block
+    )
+
+    const code = result.resolvedInputs.code as string
+    // Statement-position regex: the reference after it is inside the author's quotes.
+    expect(code).toContain(`.test('' + JSON.stringify(globalThis["__blockRef_0"]) + '')`)
+    // Division after a value: the slash must not open a regex that swallows the quotes.
+    expect(code).toContain(`Number('' + JSON.stringify(globalThis["__blockRef_1"]) + '')`)
+  })
+
   it('binds a workflow variable carrying quote characters instead of splicing it into code', async () => {
     // A Variables block can assign trigger data at runtime, so a variable's value is not
     // necessarily the author's. Inlined as a literal it closed the string it landed in.
 
@@ -172,9 +172,17 @@ type CodeScanMode =
  * a string, and every reference past that point was then formatted for the wrong context.
  * Division always follows a value — an identifier, literal, `)`, or `]` — so anything else
  * ending the preceding token means a regex may start.
+ *
+ * `)` is the one that is not decidable from the character alone: it ends a value in
+ * `(a + b) / 2` and a control-flow head in `if (a) /re/.test(b)`. Reading it as either one
+ * unconditionally breaks the other, so the scan remembers which kind of parenthesis each `)`
+ * closed rather than guessing — see {@link CONTROL_FLOW_HEAD_KEYWORDS}.
  */
 const JAVASCRIPT_REGEX_ALLOWED_AFTER = new Set('(,=:[!&|?{};+-*%^~<>/'.split(''))
 
+/** Keywords whose parenthesized head is followed by a statement, where a regex may start. */
+const CONTROL_FLOW_HEAD_KEYWORDS = new Set(['if', 'while', 'for', 'switch', 'catch', 'with'])
+
 const WHITESPACE_CHAR = /\s/
 
 /** Keywords a regex may directly follow, where the preceding token is a word rather than punctuation. */
@@ -1118,11 +1126,18 @@ export class VariableResolver {
    * anything else means a regex may start. Guessing wrong is not silent — the scan would swallow
    * text up to the next `/` — so the check reads the actual preceding token rather than assuming.
    */
-  private canStartJavaScriptRegex(template: string, previousSignificantIndex: number): boolean {
+  private canStartJavaScriptRegex(
+    template: string,
+    previousSignificantIndex: number,
+    controlHeadParenCloses: ReadonlySet<number>
+  ): boolean {
     if (previousSignificantIndex < 0) {
       return true
     }
     const previous = template[previousSignificantIndex]
+    if (previous === ')') {
+      return controlHeadParenCloses.has(previousSignificantIndex)
+    }
     if (JAVASCRIPT_REGEX_ALLOWED_AFTER.has(previous)) {
       return true
     }
@@ -1139,6 +1154,26 @@ export class VariableResolver {
     )
   }
 
+  /**
+   * Whether the `(` at this index opens a control-flow head rather than a value.
+   *
+   * What follows the matching `)` differs entirely between the two — a statement, where a regex
+   * literal may begin, versus an operator, where a `/` divides — and the closing parenthesis
+   * carries no trace of which it was. Reading the keyword in front of the opening one is what
+   * lets `if (a) /re/.test(b)` and `(a + b) / 2` both scan correctly.
+   */
+  private opensControlFlowHead(template: string, index: number): boolean {
+    let end = index
+    while (end > 0 && WHITESPACE_CHAR.test(template[end - 1])) {
+      end--
+    }
+    let start = end
+    while (start > 0 && this.isJavaScriptIdentifierChar(template[start - 1])) {
+      start--
+    }
+    return CONTROL_FLOW_HEAD_KEYWORDS.has(template.slice(start, end))
+  }
+
   private matchesKeywordAt(template: string, index: number, keyword: string): boolean {
     if (!template.startsWith(keyword, index)) {
       return false
@@ -1267,6 +1302,8 @@ export class VariableResolver {
     const isPython = language === 'python'
     const modes: CodeScanMode[] = [{ type: 'normal' }]
     let lastSignificantIndex = -1
+    const openParenIsControlHead: boolean[] = []
+    const controlHeadParenCloses = new Set<number>()
 
     for (let i = 0; i < index; i++) {
       const char = template[i]
@@ -1369,10 +1406,15 @@ export class VariableResolver {
         if (!WHITESPACE_CHAR.test(char)) {
           lastSignificantIndex = i
         }
+        if (char === '(') {
+          openParenIsControlHead.push(this.opensControlFlowHead(template, i))
+        } else if (char === ')') {
+          if (openParenIsControlHead.pop()) controlHeadParenCloses.add(i)
+        }
         if (
           !isPython &&
           char === '/' &&
-          this.canStartJavaScriptRegex(template, previousSignificantIndex)
+          this.canStartJavaScriptRegex(template, previousSignificantIndex, controlHeadParenCloses)
         ) {
           modes.push({ type: 'regex', inCharacterClass: false })
           continue
@@ -1430,10 +1472,15 @@ export class VariableResolver {
       if (!WHITESPACE_CHAR.test(char)) {
         lastSignificantIndex = i
       }
+      if (char === '(') {
+        openParenIsControlHead.push(this.opensControlFlowHead(template, i))
+      } else if (char === ')') {
+        if (openParenIsControlHead.pop()) controlHeadParenCloses.add(i)
+      }
       if (
         !isPython &&
         char === '/' &&
-        this.canStartJavaScriptRegex(template, previousSignificantIndex)
+        this.canStartJavaScriptRegex(template, previousSignificantIndex, controlHeadParenCloses)
       ) {
         modes.push({ type: 'regex', inCharacterClass: false })
         continue