feat(compiler): SYN070 — inline array-element .at(N) bypass of SYN-guarded globals (?bs 0.7+)

SYN069 closes the bracket-notation form `[eval][0](code)`. Array.prototype.at()
is the modern equivalent — `[eval].at(0)(code)` — and bypasses SYN069 because
the token sequence after `]` is `.at(N)(` rather than `[N](`. SYN070 closes
this gap with the same pre-pass strategy: find the guarded global in array-element
position, confirm the .at() argument matches the element index, fire when called.

17 tests: fires cases (eval/fetch/Function/WebSocket, multi-element arrays,
paren-wrapped form), no-fire cases (index mismatch, dynamic index, negative index,
no-call form, unsafe suppression, non-guarded globals, below ?bs 0.7), message
content check, and SYN069/SYN070 exclusivity check.

2768 → 2785 tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 2 people

packages/compiler/src/error-codes.ts

@@ -4920,6 +4920,53 @@ const E: Record<string, ErrorCodeEntry> = {
       "  return eval(code)  // SYN004 — visible to checker\n" +
       "}",
   },
+  SYN070: {
+    code: "SYN070",
+    title: "inline array-element .at(N) retrieval of a SYN-guarded global — Array.prototype.at bypass (?bs 0.7+)",
+    rule:
+      "A SYN-guarded global (`eval`, `fetch`, `Function`, `WebSocket`, etc.) appears as an element " +
+      "at index N in an inline array literal, and that array is immediately accessed via " +
+      "`.at(N)` and called — `[eval].at(0)(code)`, `[x, fetch].at(1)(url)`. " +
+      "SYN069 closes the bracket-notation gap (`[eval][0](code)`), but `Array.prototype.at()` is " +
+      "the modern equivalent and bypasses SYN069: the token pattern after `]` is `.at(N)(` rather " +
+      "than `[N](`. All per-ident SYN checks still miss the guarded global inside the array literal " +
+      "(not in call position). All alias-binding checks miss it (no binding declaration). " +
+      "SYN070 closes the gap: when a guarded global appears at index N in an inline array literal " +
+      "that is immediately accessed via `.at(literal-N)` and called, the warning fires. " +
+      "Limitation: cross-statement forms (`const arr = [eval]; arr.at(0)(code)`) require taint " +
+      "analysis and are not yet detected.",
+    idiom:
+      "call the guarded global directly — `eval(code)` or `fetch(url)` — so the relevant SYN check " +
+      "fires; if the `.at()` form is genuinely needed, wrap in " +
+      "`unsafe \"reason\" { [eval].at(0)(code) }` to make the bypass auditable",
+    rewrite:
+      "// before — .at() hides guarded global from call-site SYN checks\n" +
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(0)(code)  // SYN070: eval at index 0, retrieved via .at(0)\n" +
+      "}\n\n" +
+      "// after — call directly so SYN004 fires\n" +
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return eval(code)  // SYN004: direct call, visible to checker\n" +
+      "}",
+    example:
+      "// SYN070: eval at index 0, retrieved via .at(0)\n" +
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(0)(code)  // SYN070\n" +
+      "}\n\n" +
+      "// SYN070: fetch at index 1, accessed via .at(1)\n" +
+      "?bs 0.7\n" +
+      "fn load(url: string) -> any {\n" +
+      "  return [something, fetch].at(1)(url)  // SYN070\n" +
+      "}\n\n" +
+      "// fix: call the guarded global directly\n" +
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return eval(code)  // SYN004 — visible to checker\n" +
+      "}",
+  },
 };
 
 export function getErrorCode(code: string): ErrorCodeEntry | undefined {

packages/compiler/src/passes/syn-check.ts

@@ -740,6 +740,16 @@
  *           index matches the bracket-access literal, and fires when the result is called.
  *           `unsafe {}` suppresses.
  *
+ *   SYN070  A SYN-guarded global (`eval`, `fetch`, `Function`, etc.) appears at index N in an
+ *           inline array literal that is immediately accessed via `.at(N)` and called in a fn
+ *           body — `[eval].at(0)(code)`, `[x, fetch].at(1)(url)`. SYN069 closes the bracket-
+ *           notation gap (`[eval][0](...)`); `Array.prototype.at()` is the modern equivalent and
+ *           bypasses SYN069 because the token sequence after `]` is `.at(N)(` not `[N](`. All
+ *           per-ident checks still miss the global (not in call position inside `[...]`); all
+ *           alias-binding checks miss it (no binding). SYN070 closes the gap: a pre-pass finds
+ *           guarded globals in array-element position, confirms the index matches the `.at()`
+ *           argument, and fires when the result is called. `unsafe {}` suppresses.
+ *
  * All checks share a single token scan per fn body. The outer loop runs once,
  * skipping nested fn bodies once. Per-token dispatch is a switch on tok.text
  * after a kind==="ident" guard.
@@ -1027,6 +1037,7 @@ export function passSynCheck(src: string, version: VersionInfo): SynCheckResult
   const syn067 = getErrorCode("SYN067")!;
   const syn068 = getErrorCode("SYN068")!;
   const syn069 = getErrorCode("SYN069")!;
+  const syn070 = getErrorCode("SYN070")!;
 
   // Collect char-offset ranges where all SYN checks are suppressed:
   // 1. `unsafe "reason" { ... }` expression blocks — explicit acknowledgment.
@@ -1928,6 +1939,123 @@ export function passSynCheck(src: string, version: VersionInfo): SynCheckResult
       });
     }
 
+    // ── SYN070: inline array-element .at(N) bypass — pre-pass ───────────────
+    // Pattern: [guarded_global].at(N)(...) — guarded global at index N in an
+    // inline array literal, retrieved via Array.prototype.at(N) and called.
+    // Mirrors SYN069 but for the .at() method form instead of [N] bracket form.
+    for (let i70 = bodyStart; i70 < decl.tokenEnd; i70++) {
+      const tok70 = tokens[i70];
+      if (!tok70 || tok70.kind !== "ident") continue;
+      if (!SYN037_GUARDED_GLOBALS.has(tok70.text)) continue;
+
+      // Must be in array-element position: prev significant token is `[` or `,`
+      const prevIdx70 = prevSignificant(tokens, i70 - 1);
+      const prev70 = tokens[prevIdx70];
+      const inArray70 =
+        (prev70 && prev70.kind === "open" && prev70.text === "[") ||
+        (prev70 && prev70.kind === "punct" && prev70.text === ",");
+      if (!inArray70) continue;
+
+      // Backward scan to find the opening `[` of the enclosing array literal.
+      let openBracketIdx70 = -1;
+      {
+        let d70 = 0;
+        for (let j = i70 - 1; j >= bodyStart; j--) {
+          const t = tokens[j];
+          if (!t) continue;
+          if (t.kind === "close") { d70++; continue; }
+          if (t.kind === "open") {
+            if (d70 === 0 && t.text === "[") { openBracketIdx70 = j; break; }
+            d70--;
+          }
+        }
+      }
+      if (openBracketIdx70 < 0) continue;
+
+      // Count commas at depth 0 between opening `[` and tok70 to determine index.
+      let elemIndex70 = 0;
+      {
+        let d70 = 0;
+        for (let j = openBracketIdx70 + 1; j < i70; j++) {
+          const t = tokens[j];
+          if (!t) continue;
+          if (t.kind === "open") { d70++; continue; }
+          if (t.kind === "close") { d70--; continue; }
+          if (d70 === 0 && t.kind === "punct" && t.text === ",") elemIndex70++;
+        }
+      }
+
+      // Use matchedAt to find the closing `]` of the array literal.
+      const closeBracketIdx70 = tokens[openBracketIdx70]!.matchedAt;
+      if (closeBracketIdx70 === undefined) continue;
+
+      // After `]`, skip any closing parens (handles `([eval]).at(0)(code)`).
+      let afterCloseIdx70 = nextSignificant(tokens, closeBracketIdx70 + 1);
+      while (tokens[afterCloseIdx70]?.kind === "close" && tokens[afterCloseIdx70]?.text === ")") {
+        afterCloseIdx70 = nextSignificant(tokens, afterCloseIdx70 + 1);
+      }
+
+      // Expect `.at` — a dot token followed by ident `at`.
+      const dotTok70 = tokens[afterCloseIdx70];
+      if (!dotTok70 || dotTok70.kind !== "punct" || dotTok70.text !== ".") continue;
+      const atIdx70 = nextSignificant(tokens, afterCloseIdx70 + 1);
+      const atTok70 = tokens[atIdx70];
+      if (!atTok70 || atTok70.kind !== "ident" || atTok70.text !== "at") continue;
+
+      // Expect `(` opening the .at() argument list.
+      const openParenIdx70 = nextSignificant(tokens, atIdx70 + 1);
+      const openParen70 = tokens[openParenIdx70];
+      if (!openParen70 || !(openParen70.kind === "open" && openParen70.text === "(")) continue;
+
+      // Inside the parens, must be a numeric literal.
+      const numIdx70 = nextSignificant(tokens, openParenIdx70 + 1);
+      const numTok70 = tokens[numIdx70];
+      if (!numTok70 || numTok70.kind !== "number") continue;
+
+      // The numeric value must match the element index (negative indices not tracked).
+      const indexVal70 = parseInt(numTok70.text, 10);
+      if (isNaN(indexVal70) || indexVal70 < 0 || indexVal70 !== elemIndex70) continue;
+
+      // After the number, must be closing `)`.
+      const closeParenIdx70 = nextSignificant(tokens, numIdx70 + 1);
+      const closeParen70 = tokens[closeParenIdx70];
+      if (!closeParen70 || !(closeParen70.kind === "close" && closeParen70.text === ")")) continue;
+
+      // After `)`, must be `(` or `?.(` — a call on the returned value.
+      const callIdx70 = nextSignificant(tokens, closeParenIdx70 + 1);
+      const callTok70 = tokens[callIdx70];
+      const isCall70 =
+        callTok70 && (
+          (callTok70.kind === "open" && callTok70.text === "(") ||
+          callTok70.kind === "questionDot"
+        );
+      if (!isCall70) continue;
+
+      if (isInsideRange(tok70.start, unsafeRanges)) continue;
+
+      const loc70 = locationOf(src, tok70.start);
+      warnings.push({
+        code: "SYN070",
+        severity: "warning",
+        file: null,
+        line: loc70.line,
+        column: loc70.column,
+        start: tok70.start,
+        end: closeParen70!.end,
+        message:
+          `fn '${decl.name}' stores ${tok70.text} at index ${elemIndex70} of an inline array ` +
+          `then calls it via [${tok70.text}].at(${elemIndex70})(...) — ` +
+          `SYN004/SYN007/… only fire when ${tok70.text} is in call position (followed by '('); ` +
+          `SYN069 closes the [N] bracket form but .at(N) is the modern equivalent and bypasses it; ` +
+          `alias-binding checks (SYN044–SYN068) only track binding declarations, not inline array elements; ` +
+          `the runtime effect is identical to calling ${tok70.text}(...) directly; ` +
+          `refactor to call ${tok70.text} directly or wrap in unsafe "reason" { [${tok70.text}].at(${elemIndex70})(...) }`,
+        rule: syn070.rule,
+        idiom: syn070.idiom,
+        rewrite: syn070.rewrite,
+      });
+    }
+
     // Single dispatch loop: nesting bookkeeping runs once per token position.
     // All SYN checks are dispatched via a switch on tok.text after an ident guard.
     for (let i = bodyStart; i < decl.tokenEnd; i++) {

packages/compiler/tests/error-codes.test.ts

@@ -15,7 +15,7 @@ describe("error-code registry", () => {
       "INT001", "INT002", "INT003", "INT004", "INT005", "INT006", "INT007", "INT008", "INT009", "INT010", "INT011", "INT012", "INT013", "INT014", "INT015", "INT016", "INT017", "INT018", "INT019", "INT020", "INT021", "INT022", "INT023", "INT024", "INT025", "INT026", "INT027", "INT028", "INT029", "INT030", "INT031", "INT032", "INT033", "INT034", "INT035",
       "MAT001", "MAT002", "MAT003", "MAT004", "MAT005", "MAT006",
       "RES001", "RES002", "RES003",
-      "SYN001", "SYN002", "SYN003", "SYN004", "SYN005", "SYN006", "SYN007", "SYN008", "SYN009", "SYN010", "SYN011", "SYN012", "SYN013", "SYN014", "SYN015", "SYN016", "SYN017", "SYN018", "SYN019", "SYN020", "SYN021", "SYN022", "SYN023", "SYN024", "SYN025", "SYN026", "SYN027", "SYN028", "SYN029", "SYN030", "SYN031", "SYN032", "SYN033", "SYN034", "SYN035", "SYN036", "SYN037", "SYN038", "SYN039", "SYN040", "SYN041", "SYN042", "SYN043", "SYN044", "SYN045", "SYN046", "SYN047", "SYN048", "SYN049", "SYN050", "SYN051", "SYN052", "SYN053", "SYN054", "SYN055", "SYN056", "SYN057", "SYN058", "SYN059", "SYN060", "SYN061", "SYN062", "SYN063", "SYN064", "SYN065", "SYN066", "SYN067", "SYN068", "SYN069",
+      "SYN001", "SYN002", "SYN003", "SYN004", "SYN005", "SYN006", "SYN007", "SYN008", "SYN009", "SYN010", "SYN011", "SYN012", "SYN013", "SYN014", "SYN015", "SYN016", "SYN017", "SYN018", "SYN019", "SYN020", "SYN021", "SYN022", "SYN023", "SYN024", "SYN025", "SYN026", "SYN027", "SYN028", "SYN029", "SYN030", "SYN031", "SYN032", "SYN033", "SYN034", "SYN035", "SYN036", "SYN037", "SYN038", "SYN039", "SYN040", "SYN041", "SYN042", "SYN043", "SYN044", "SYN045", "SYN046", "SYN047", "SYN048", "SYN049", "SYN050", "SYN051", "SYN052", "SYN053", "SYN054", "SYN055", "SYN056", "SYN057", "SYN058", "SYN059", "SYN060", "SYN061", "SYN062", "SYN063", "SYN064", "SYN065", "SYN066", "SYN067", "SYN068", "SYN069", "SYN070",
       "THR001", "THR002", "THR003", "THR004",
       "UNS001", "UNS002", "UNS003", "UNS004", "UNS005", "UNS006", "UNS007", "UNS008", "UNS009",
       "VER001", "VER002", "VER003",

packages/compiler/tests/syn070-check.test.ts

@@ -0,0 +1,186 @@
+/**
+ * Tests for SYN070: inline array-element .at(N) bypass (?bs 0.7+).
+ *
+ * SYN070 fires when a SYN-guarded global (`eval`, `fetch`, `Function`, etc.) appears
+ * at index N in an inline array literal that is immediately accessed via `.at(N)` and
+ * called in a fn body.
+ *
+ * Example: `[eval].at(0)(code)`, `[x, fetch].at(1)(url)`.
+ *
+ * SYN069 closes the bracket-notation gap (`[eval][0](...)`). `Array.prototype.at()` is
+ * the modern equivalent and bypasses SYN069: the token sequence after `]` is `.at(N)(`
+ * rather than `[N](`. SYN070 closes this remaining gap.
+ */
+
+import { describe, expect, it } from "vitest";
+import { transform } from "../src/transform.js";
+
+describe("SYN070: inline array-element .at(N) bypass (?bs 0.7+)", () => {
+  // ── fires cases ──────────────────────────────────────────────────────────
+
+  it("fires on [eval].at(0)(code)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(0)(code)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  it("fires on [fetch].at(0)(url)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn load(url: string) -> any {\n" +
+      "  return [fetch].at(0)(url)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  it("fires on [Function].at(0)(body)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn execute(body: string) -> any {\n" +
+      "  return [Function].at(0)(body)()\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  it("fires on [x, fetch].at(1)(url) — guarded global at index 1", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn load(url: string) -> any {\n" +
+      "  return [something, fetch].at(1)(url)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  it("fires on [a, b, eval].at(2)(code) — guarded global at index 2", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [a, b, eval].at(2)(code)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  it("fires on [WebSocket].at(0)(url)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn connect(url: string) -> any {\n" +
+      "  return [WebSocket].at(0)(url)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  it("fires on paren-wrapped ([eval]).at(0)(code)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return ([eval]).at(0)(code)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+
+  // ── no-fire cases ────────────────────────────────────────────────────────
+
+  it("does NOT fire when index mismatches — [eval].at(1)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(1)(code)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire when index mismatches — [x, fetch].at(0)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn load(url: string) -> any {\n" +
+      "  return [something, fetch].at(0)(url)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire when index is not a numeric literal — [eval].at(n)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string, n: number) -> any {\n" +
+      "  return [eval].at(n)(code)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire on negative index — [eval].at(-1)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(-1)(code)\n" +
+      "}\n";
+    // Negative indices are not tracked (would require knowing array length).
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire when no call follows — [eval].at(0) as expression", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run() -> any {\n" +
+      "  const x = [eval].at(0)\n" +
+      "  return x\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire when suppressed by unsafe block", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      '  return unsafe "intentional bypass for sandboxed eval" { [eval].at(0)(code) }\n' +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire on non-guarded globals — [JSON].at(0).stringify(x)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(x: any) -> string {\n" +
+      "  return [JSON].at(0).stringify(x)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  it("does NOT fire below ?bs 0.7", () => {
+    const src =
+      "?bs 0.6\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(0)(code)\n" +
+      "}\n";
+    expect(transform(src).warnings.some((w) => w.code === "SYN070")).toBe(false);
+  });
+
+  // ── message content ──────────────────────────────────────────────────────
+
+  it("message names the guarded global and index", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(0)(code)\n" +
+      "}\n";
+    const w = transform(src).warnings.find((w) => w.code === "SYN070");
+    expect(w).toBeDefined();
+    expect(w!.message).toContain("eval");
+    expect(w!.message).toContain("0");
+  });
+
+  // ── SYN069 not fired (different pattern) ────────────────────────────────
+
+  it("does NOT fire SYN069 when the pattern is .at() form (SYN070 fires instead)", () => {
+    const src =
+      "?bs 0.7\n" +
+      "fn run(code: string) -> any {\n" +
+      "  return [eval].at(0)(code)\n" +
+      "}\n";
+    const result = transform(src);
+    expect(result.warnings.some((w) => w.code === "SYN069")).toBe(false);
+    expect(result.warnings.some((w) => w.code === "SYN070")).toBe(true);
+  });
+});