fix(executor): keep a caller from choosing which secret expands

A placeholder-bearing string stays in source so the boundary compiler can
expand it, which is how a workflow variable holding `{{NAME}}` reaches its
value. Any run value took that path too, so text arriving from a trigger or
a loop item could name a secret and have the compiler materialize it beside
the payload that named it. Only a workflow variable — a surface an author
configures — keeps the inline form now; every other value binds.

A block comment can also stand between a property-access dot and a
keyword-named method, hiding the dot from the control-flow-head check. A
comment ending there now reads as the method call it almost always is.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: icecrasher321

apps/sim/executor/variables/resolver.test.ts

@@ -964,6 +964,28 @@ describe('VariableResolver function block inputs', () => {
     )
   })
 
+  it('binds a run value that names a secret instead of expanding it', async () => {
+    const { block, ctx, resolver } = createResolver('javascript')
+    ctx.workflowVariables = {
+      'var-1': { id: 'var-1', name: 'authTemplate', type: 'string', value: 'Bearer {{API_KEY}}' },
+    }
+
+    const result = await resolver.resolveInputsForFunctionBlock(
+      ctx,
+      'function',
+      { code: `const header = '<variable.authTemplate>'; const item = <producer.result>` },
+      block
+    )
+
+    // An author-configured variable keeps its placeholder in source, where the boundary
+    // compiler expands it; a run value naming a secret binds instead, so whoever supplies
+    // the text cannot pick what the compiler materializes next to it.
+    const code = result.resolvedInputs.code as string
+    expect(code).toContain('{{API_KEY}}')
+    expect(code).toContain('const item = globalThis["__blockRef_0"]')
+    expect(result.contextVariables).toEqual({ __blockRef_0: 'hello world' })
+  })
+
   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.

apps/sim/executor/variables/resolver.ts

@@ -687,7 +687,7 @@ export class VariableResolver {
           throw getNestedLargeValueMaterializationError()
         }
 
-        if (this.canInlineResolvedCodeLiteral(effectiveValue)) {
+        if (this.canInlineResolvedCodeLiteral(effectiveValue, match)) {
           const replacement = this.blockResolver.formatValueForBlock(
             effectiveValue,
             BlockType.FUNCTION,
@@ -976,14 +976,21 @@ export class VariableResolver {
    * Everything else binds, which is what block outputs have always done. Inlining the rest
    * is what let a runtime-assigned variable or loop item carrying trigger data close the
    * string it landed in and run as code.
+   *
+   * The placeholder case is admitted only for a workflow variable, never for a loop item or
+   * any other run value. Whoever supplies the text picks which secret the compiler expands
+   * into the generated source, so that choice stays with the surface an author configures.
    */
-  private canInlineResolvedCodeLiteral(value: unknown): boolean {
+  private canInlineResolvedCodeLiteral(value: unknown, reference: string): boolean {
     if (value === null || typeof value === 'number' || typeof value === 'boolean') {
       return true
     }
     if (typeof value !== 'string') {
       return false
     }
+    if (parseReferencePath(reference)[0] !== REFERENCE.PREFIX.VARIABLE) {
+      return false
+    }
     return createEnvVarPattern().test(value) && !/['"`$\\\n\r\u2028\u2029]/.test(value)
   }
 
@@ -1196,11 +1203,17 @@ export class VariableResolver {
     }
 
     // `p.catch(fn)` is a method call whose name happens to be a keyword, and what follows its
-    // `)` is an operator, not a statement. A control-flow head can never be a property access.
+    // `)` is an operator, not a statement. A control-flow head can never be a property access,
+    // and a comment can hide the dot (`p./* c */catch(fn)`), so a comment ending here is read
+    // as the method call it usually is: the wrong guess there costs a division scanned as a
+    // regex, while this way it costs nothing a regex-free line would notice.
     let before = start
     while (before > 0 && WHITESPACE_CHAR.test(template[before - 1])) {
       before--
     }
+    if (template[before - 1] === '/' && template[before - 2] === '*') {
+      return false
+    }
     return template[before - 1] !== '.'
   }