@@ -1053,48 +1053,107 @@ describe('code placeholder compiler', () => {
     'total=$(( $(( 1 + 1 )) + {{KEY}} ))',
     'cat <<PAYLOAD\n$(( {{KEY}} * 2 ))\nPAYLOAD',
     'cat <<PAYLOAD\n$[ {{KEY}} * 2 ]\nPAYLOAD',
-  ])('rejects shell placeholders whose values enter arithmetic: %s', async (code) => {
+    // Rejection is value-based and position-independent: a value whose array subscript carries an
+    // expansion would run the embedded command only if it reached arithmetic, so it is refused
+    // wherever the placeholder lands — including ordinary, non-arithmetic positions.
+    'printf "%s" "{{KEY}}"',
+    '[ "{{KEY}}" = x ]',
+    'echo {{KEY}}',
+    'cat <<PAYLOAD\n{{KEY}}\nPAYLOAD',
+    "cat <<'PAYLOAD'\n{{KEY}}\nPAYLOAD",
+  ])(
+    'rejects a shell value whose array subscript contains an expansion, in any position: %s',
+    async (code) => {
+      await expect(
+        compileCodePlaceholders({
+          code,
+          language: CodeLanguage.Shell,
+          environmentVariables: { KEY: 'values[$(printf injected >&2)]' },
+        })
+      ).rejects.toThrow('array subscript with an expansion')
+    }
+  )
+
+  it.each([
+    'values[`printf injected >&2`]',
+    'a[$(id)]',
+    'm[$(cmd)]=x',
+    'a[<(cmd)]',
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: shell expansion inside a subscript, not a JS template
+    'x[${!ref}]',
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: shell expansion inside a subscript, not a JS template
+    'x[${v@P}]',
+  ])('rejects every expansion flavour inside a shell value subscript: %s', async (value) => {
     await expect(
       compileCodePlaceholders({
-        code,
+        code: 'printf "%s" "{{KEY}}"',
         language: CodeLanguage.Shell,
-        environmentVariables: { KEY: 'values[$(printf injected >&2)]' },
+        environmentVariables: { KEY: value },
       })
-    ).rejects.toThrow('is not supported in shell arithmetic')
+    ).rejects.toThrow('array subscript with an expansion')
   })
 
-  it('preserves shell literal arithmetic text and leaves completed arithmetic frames', async () => {
-    const value = 'values[$(printf injected >&2)]'
+  it('preserves shell literal arithmetic text for values without a subscript expansion', async () => {
+    const value = 'raw $(text) and `more` [0] value'
     const compiled = await compileCodePlaceholders({
       code: [
         'printf "%s\\n" "{{KEY}}"',
         "printf '%s\\n' '$(( {{KEY}} ))'",
         "printf '%s\\n' '$[ {{KEY}} ]'",
         'printf "%s\\n" "$(printf %s "{{KEY}}")"',
         'printf "%s\\n" "$(( 1 + 1 )){{KEY}}"',
-        'printf "%s\\n" "$[ values[0] + 2 ]{{KEY}}"',
         '(( total = 2 )); printf "%s\\n" "{{KEY}}"',
         'cat <<PAYLOAD',
-        '(( {{KEY}} ))',
+        '{{KEY}}',
         'PAYLOAD',
       ].join('\n'),
       language: CodeLanguage.Shell,
       environmentVariables: { KEY: value },
     })
 
     expect(executeShell(compiled.code, compiled.bindings)).toBe(
-      `${value}\n$(( ${value} ))\n$[ ${value} ]\n${value}\n2${value}\n2${value}\n${value}\n(( ${value} ))\n`
+      `${value}\n$(( ${value} ))\n$[ ${value} ]\n${value}\n2${value}\n${value}\n${value}\n`
     )
   })
 
-  it('discovers shell arithmetic placeholders without compiling missing values', async () => {
+  it.each([
+    'total=$(( {{KEY}} * 2 ))',
+    '(( total = {{KEY}} ))',
+    'total=$[ {{KEY}} ]',
+    '[[ {{KEY}} -eq 0 ]]',
+    'let "x={{KEY}}"',
+    'declare -i x="{{KEY}}"',
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: shell parameter expansion, not a JS template
+    's=abcdef; printf "%s\\n" "${s:{{KEY}}}"',
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: shell parameter expansion, not a JS template
+    'a=(1 2); printf "%s\\n" "${a[{{KEY}}]}"',
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: shell parameter expansion, not a JS template
+    'a=([{{KEY}}]=text); printf "%s\\n" "${a[*]}"',
+    '[[ "{{KEY}}" == "-eq" ]] && printf "%s\\n" matched',
+    'unset "a[{{KEY}}]"',
+  ])('compiles a safe value in any position, including arithmetic ones: %s', async (code) => {
+    // A value with no array-subscript expansion cannot run a command in arithmetic (verified in
+    // bash 5.2), so it is accepted everywhere — no position detection, no over-rejection.
+    await expect(
+      compileCodePlaceholders({
+        code,
+        language: CodeLanguage.Shell,
+        environmentVariables: { KEY: 'items[0]' },
+      })
+    ).resolves.toBeDefined()
+  })
+
+  it('discovers shell arithmetic placeholders without binding missing values', async () => {
     const code = 'total=$(( {{MISSING}} + {{KEY}} ))'
     await expect(analyzeCodePlaceholders(code, CodeLanguage.Shell)).resolves.toEqual([
       'MISSING',
       'KEY',
     ])
     const compiled = await compileCodePlaceholders({ code, language: CodeLanguage.Shell })
-    expect(compiled.code).toBe(code)
+    // With no configured values nothing is bound; unresolved placeholders expand to empty, as in
+    // every other position (the arithmetic position itself is no longer special).
+    expect(compiled.bindings).toEqual([])
+    expect(compiled.code).toBe('total=$((  +  ))')
   })
 
   it('renders quoted shell heredocs nested in double-quoted command substitutions', async () => {
 
@@ -327,12 +327,12 @@ export function createOffsetRangeLookup(
  * The placeholders lying wholly inside `[start, end]`. Occurrences are ordered and never
  * overlap, so the matches are one contiguous run found by bisection.
  */
-export function occurrencesWithin(
-  occurrences: readonly CodePlaceholderOccurrence[],
+export function occurrencesWithin<T extends Pick<CodePlaceholderOccurrence, 'start' | 'end'>>(
+  occurrences: readonly T[],
   start: number,
   end: number
-): CodePlaceholderOccurrence[] {
-  const matches: CodePlaceholderOccurrence[] = []
+): T[] {
+  const matches: T[] = []
   for (
     let index = partitionPoint(occurrences, (occurrence) => occurrence.start < start);
     index < occurrences.length && occurrences[index].end <= end;
 
@@ -37,11 +37,33 @@ interface ShellScanFrame {
 
 interface ShellOccurrenceContext {
   quote: ShellQuote
-  /** Includes nested command substitutions whose output can become an arithmetic operand. */
-  arithmetic?: boolean
   unsupported?: 'escaped sequence'
 }
 
+/**
+ * Whether a resolved value would run a command if it reached shell arithmetic evaluation. The only
+ * such path is an array subscript whose expression contains an expansion: when bash evaluates
+ * `name[expr]` as arithmetic it expands `expr`, so a command substitution (`$(…)`, backticks) or a
+ * process substitution (`<(…)`, `>(…)`) there executes, and prompt/indirection expansions can too.
+ * Plain `$(…)` text, `${…}` and `$((…))` outside a subscript are never executed by arithmetic, so
+ * only the bracketed case is refused. The depth walk is conservative: ANY `$`, backtick, or process
+ * substitution inside `[ … ]` is rejected (e.g. `a[$((1+1))]`), which is safe to over-refuse in data.
+ */
+function hasArithmeticExecutingSubscript(value: string): boolean {
+  let bracketDepth = 0
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index]
+    if (character === '[') bracketDepth += 1
+    else if (character === ']') {
+      if (bracketDepth > 0) bracketDepth -= 1
+    } else if (bracketDepth > 0) {
+      if (character === '$' || character === '`') return true
+      if ((character === '<' || character === '>') && value[index + 1] === '(') return true
+    }
+  }
+  return false
+}
+
 function lineEndAfterNewline(code: string, start: number): number {
   const newline = code.indexOf('\n', start)
   return newline === -1 ? code.length : newline + 1
@@ -450,7 +472,6 @@ function getUnsupportedShellPosition(
   occurrence: CodePlaceholderOccurrence,
   context: ShellOccurrenceContext
 ): string | undefined {
-  if (context.arithmetic) return 'in shell arithmetic'
   if (code[occurrence.start - 1] === '$') return 'immediately after "$"'
   if (context.quote !== 'none') return undefined
 
@@ -492,7 +513,6 @@ function collectShellOccurrenceContexts(
     { kind: 'root', quote: 'none', parenthesisDepth: 0, literalRoot },
   ]
   let skippedRangeIndex = 0
-  let arithmeticDepth = 0
 
   for (let index = start; index < end; ) {
     const frame = frames.at(-1)
@@ -512,7 +532,7 @@ function collectShellOccurrenceContexts(
 
     const occurrence = occurrenceByStart.get(index)
     if (occurrence) {
-      contexts.set(occurrence, { quote: frame.quote, arithmetic: arithmeticDepth > 0 })
+      contexts.set(occurrence, { quote: frame.quote })
       index = occurrence.end
       continue
     }
@@ -552,7 +572,6 @@ function collectShellOccurrenceContexts(
         ...(brackets ? { bracketDepth: 1 } : {}),
         literalRoot: false,
       })
-      arithmeticDepth += 1
       index += arithmeticExpansion && !brackets ? 3 : 2
       continue
     }
@@ -649,10 +668,7 @@ function collectShellOccurrenceContexts(
       if (character === '[') frame.bracketDepth += 1
       if (character === ']') {
         frame.bracketDepth -= 1
-        if (frame.bracketDepth === 0) {
-          frames.pop()
-          arithmeticDepth -= 1
-        }
+        if (frame.bracketDepth === 0) frames.pop()
       }
       index += 1
       continue
@@ -664,10 +680,7 @@ function collectShellOccurrenceContexts(
     }
     if ((frame.kind === 'command' || frame.kind === 'arithmetic') && character === ')') {
       frame.parenthesisDepth -= 1
-      if (frame.parenthesisDepth === 0) {
-        frames.pop()
-        if (frame.kind === 'arithmetic') arithmeticDepth -= 1
-      }
+      if (frame.parenthesisDepth === 0) frames.pop()
       index += 1
       continue
     }
@@ -782,6 +795,13 @@ export async function compileShellPlaceholders(
         occurrence.start
       )
     }
+    if (resolved && !input.analysisOnly && hasArithmeticExecutingSubscript(resolved.value)) {
+      throw new CodePlaceholderCompileError(
+        `Variable placeholder "${occurrence.name}" cannot contain an array subscript with an expansion in shell code`,
+        input.code,
+        occurrence.start
+      )
+    }
     return resolved
   }
   const resolveShellOccurrence = (occurrence: CodePlaceholderOccurrence) =>