tjs-lang 0.8.2 → 0.8.4

package/editors/scope-symbols.ts

@@ -0,0 +1,173 @@
+/**
+ * Scope-aware symbol collection for autocomplete.
+ *
+ * Replaces the regex `const NAME =` scraping (which missed ALL destructuring —
+ * and the tosijs examples bind everything via destructuring, so nothing was
+ * suggested). This parses the source (acorn, falling back to acorn-loose for
+ * mid-edit / not-yet-valid source) and walks binding patterns properly:
+ * `const { todoApp } = tosi(...)`, `const { h1, ul } = elements`,
+ * `const [a, , b] = xs`, rename, defaults, rest — all yield their bound names.
+ *
+ * Each symbol also records its **origin** (the initializer expression text, and
+ * for object-destructuring the key it came from). That origin is the hook the
+ * runtime-introspection layer uses: to introspect `h1` it can evaluate
+ * `elements.h1` in the live scope. Names are plumbing; the *types* come from
+ * introspecting real values (see the introspection bridge), not from this parse.
+ */
+import * as acorn from 'acorn'
+import * as acornLoose from 'acorn-loose'
+import * as walk from 'acorn-walk'
+
+export interface SymbolOrigin {
+  /** How the binding was produced. */
+  via: 'init' | 'destructure' | 'param' | 'import' | 'function'
+  /** Source text of the initializer expression (e.g. `elements`, `tosi({...})`). */
+  expr?: string
+  /** For object-destructuring: the key on `expr` this name came from (`elements.h1` → `h1`). */
+  member?: string
+  /** Module specifier, for imports. */
+  module?: string
+}
+
+export interface ScopeSymbol {
+  name: string
+  kind: 'variable' | 'function' | 'parameter' | 'import'
+  origin?: SymbolOrigin
+}
+
+function parse(source: string): any {
+  try {
+    return acorn.parse(source, { ecmaVersion: 'latest' })
+  } catch {
+    try {
+      // Best-effort AST from incomplete / not-yet-valid source.
+      return acornLoose.parse(source, { ecmaVersion: 'latest' })
+    } catch {
+      return null
+    }
+  }
+}
+
+type NameSink = (name: string, member?: string) => void
+
+/** Walk a binding pattern, emitting each bound name (and, one level deep for
+ *  object patterns, the source key it came from). */
+function collectPattern(pat: any, onName: NameSink, member?: string): void {
+  if (!pat) return
+  switch (pat.type) {
+    case 'Identifier':
+      onName(pat.name, member)
+      return
+    case 'ObjectPattern':
+      for (const p of pat.properties) {
+        if (p.type === 'RestElement') {
+          collectPattern(p.argument, onName)
+        } else {
+          const key = p.key && (p.key.name ?? p.key.value)
+          collectPattern(
+            p.value,
+            onName,
+            typeof key === 'string' ? key : undefined
+          )
+        }
+      }
+      return
+    case 'ArrayPattern':
+      for (const el of pat.elements) collectPattern(el, onName)
+      return
+    case 'AssignmentPattern':
+      collectPattern(pat.left, onName, member)
+      return
+    case 'RestElement':
+      collectPattern(pat.argument, onName)
+      return
+  }
+}
+
+const inRange = (node: any, position: number) =>
+  typeof node.start === 'number' &&
+  typeof node.end === 'number' &&
+  node.start <= position &&
+  position <= node.end
+
+/**
+ * Collect the symbols in scope at `position` (defaults to end of source):
+ * variable/function/import bindings declared before the cursor, plus the
+ * parameters of any function whose body the cursor sits inside. Destructuring
+ * is fully handled; results are de-duplicated by name (last declaration wins).
+ */
+export function collectScopeSymbols(
+  source: string,
+  position: number = source.length
+): ScopeSymbol[] {
+  const ast = parse(source)
+  if (!ast) return []
+
+  const byName = new Map<string, ScopeSymbol>()
+  const add = (s: ScopeSymbol) => byName.set(s.name, s)
+
+  walk.full(ast, (node: any) => {
+    switch (node.type) {
+      case 'VariableDeclaration': {
+        // Only count declarations that appear before the cursor.
+        if (node.start >= position) return
+        for (const decl of node.declarations) {
+          const initText =
+            decl.init && typeof decl.init.start === 'number'
+              ? source.slice(decl.init.start, decl.init.end)
+              : undefined
+          collectPattern(decl.id, (name, member) =>
+            add({
+              name,
+              kind: 'variable',
+              origin: {
+                via: member != null ? 'destructure' : 'init',
+                expr: initText,
+                member,
+              },
+            })
+          )
+        }
+        return
+      }
+      case 'FunctionDeclaration': {
+        if (node.id && node.start < position)
+          add({
+            name: node.id.name,
+            kind: 'function',
+            origin: { via: 'function' },
+          })
+        // params only in scope when the cursor is inside the function
+        if (inRange(node, position))
+          for (const p of node.params)
+            collectPattern(p, (name) =>
+              add({ name, kind: 'parameter', origin: { via: 'param' } })
+            )
+        return
+      }
+      case 'FunctionExpression':
+      case 'ArrowFunctionExpression': {
+        if (inRange(node, position))
+          for (const p of node.params)
+            collectPattern(p, (name) =>
+              add({ name, kind: 'parameter', origin: { via: 'param' } })
+            )
+        return
+      }
+      case 'ImportDeclaration': {
+        const module = String(node.source?.value ?? '')
+        for (const spec of node.specifiers) {
+          // local name is spec.local.name for all specifier kinds
+          add({
+            name: spec.local.name,
+            kind: 'import',
+            origin: { via: 'import', module },
+          })
+        }
+        return
+      }
+    }
+  })
+
+  return [...byName.values()]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tjs-lang",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Type-safe JavaScript dialect with runtime validation, sandboxed VM execution, and AI agent orchestration. Transpiles TypeScript to validated JS with fuel-metered execution for untrusted code.",
   "keywords": [
     "typescript",
@@ -161,6 +161,7 @@
   },
   "dependencies": {
     "acorn": "^8.15.0",
+    "acorn-loose": "^8.5.2",
     "acorn-walk": "^8.3.4",
     "tosijs-schema": "^1.3.0"
   }

package/src/lang/index.ts

@@ -44,6 +44,28 @@ export {
   type Dialect,
   type SourceKind,
 } from './dialect'
+export {
+  verifyPredicate,
+  compilePredicate,
+  suggest,
+  effectfulFromAtoms,
+  formatPredicateDiagnostics,
+  PredicateFuelExhausted,
+  type PredicateDiagnostic,
+  type PredicateVerifyResult,
+  type VerifyPredicateOptions,
+  type CompilePredicateOptions,
+  type Suggestion,
+  type SuggestOptions,
+} from './predicate'
+export {
+  compilePredicateSchema,
+  validatePredicateSchema,
+  type PredicateSchema,
+  type SchemaError,
+  type SchemaValidationResult,
+  type PredicateSchemaOptions,
+} from './predicate-schema'
 export { transformFunction } from './emitters/ast'
 export {
   transpileToJS,

package/src/lang/predicate-schema.test.ts

@@ -0,0 +1,97 @@
+import { describe, it, expect } from 'bun:test'
+import {
+  compilePredicateSchema,
+  validatePredicateSchema,
+  type PredicateSchema,
+} from './predicate-schema'
+
+// A composable color predicate cluster (entry = last function, takes the value).
+const COLOR = `
+  function isHex(v){ return typeof v == 'string' && /^#[0-9a-f]{3,8}$/i.test(v) }
+  function isVar(v){ return typeof v == 'string' && v.startsWith('var(--') && v.endsWith(')') }
+  function isCalc(v){ return typeof v == 'string' && v.startsWith('calc(') && v.endsWith(')') }
+  function isColor(v){ return isHex(v) || isVar(v) || isCalc(v) }
+`
+
+// A recursive predicate cluster — validates a tree of string/number leaves.
+// Note the `!Array.isArray(o)` guard: arrays are objects in JS, so a node check
+// must exclude them explicitly (a real predicate-authoring nuance).
+const TREE = `
+  function isLeaf(v){ return typeof v == 'string' || typeof v == 'number' }
+  function isEntry(pair){ var val = pair[1]; return isLeaf(val) || isNode(val) }
+  function isNode(o){ return typeof o == 'object' && o != null && !Array.isArray(o) && Object.entries(o).every(isEntry) }
+`
+
+const colorSchema: PredicateSchema = {
+  type: 'object',
+  required: ['color'],
+  properties: {
+    color: { type: 'string', description: 'a CSS color', $predicate: COLOR },
+  },
+}
+
+describe('predicate-schema — the computational half of JSON-Schema', () => {
+  it('a predicate-aware validator validates the value grammar', () => {
+    const validate = compilePredicateSchema(colorSchema)
+    expect(validate({ color: '#3a3' }).valid).toBe(true)
+    expect(validate({ color: 'var(--brand)' }).valid).toBe(true) // TS/JSON-Schema can't
+    expect(validate({ color: 'calc(1px + 1em)' }).valid).toBe(true)
+
+    const bad = validate({ color: 'notacolor' })
+    expect(bad.valid).toBe(false)
+    expect(bad.errors[0].path).toBe('/color')
+  })
+
+  it('still does structural validation (type / required)', () => {
+    const validate = compilePredicateSchema(colorSchema)
+    expect(validate({ color: 123 }).errors[0].message).toMatch(
+      /expected string/
+    )
+    expect(validate({}).errors[0].message).toMatch(/missing required 'color'/)
+  })
+
+  it('progressive enhancement: a naive validator ignores `$predicate`', () => {
+    // ignorePredicates models any standard JSON-Schema validator that doesn't
+    // know the keyword — it sees only `type: string`.
+    const naive = compilePredicateSchema(colorSchema, {
+      ignorePredicates: true,
+    })
+    expect(naive({ color: 'notacolor' }).valid).toBe(true) // string → passes
+    // …while the aware validator catches it:
+    expect(
+      compilePredicateSchema(colorSchema)({ color: 'notacolor' }).valid
+    ).toBe(false)
+  })
+
+  it('the schema is plain serializable JSON — code travels as data', () => {
+    const roundTripped: PredicateSchema = JSON.parse(
+      JSON.stringify(colorSchema)
+    )
+    expect(roundTripped).toEqual(colorSchema)
+    // and it still validates after a serialize/deserialize round-trip
+    const validate = compilePredicateSchema(roundTripped)
+    expect(validate({ color: '#abc' }).valid).toBe(true)
+    expect(validate({ color: 'nope' }).valid).toBe(false)
+  })
+
+  it('a `$predicate` can recurse into open nested structure', () => {
+    const schema: PredicateSchema = { type: 'object', $predicate: TREE }
+    const validate = compilePredicateSchema(schema)
+    expect(validate({ a: 1, b: { c: 'x', d: { e: 2 } } }).valid).toBe(true)
+    expect(validate({ a: 1, bad: { nope: [] } }).valid).toBe(false) // array leaf
+  })
+
+  it('rejects an unsafe predicate at compile time (IO never embeds)', () => {
+    const evil: PredicateSchema = {
+      type: 'string',
+      $predicate: `function check(v){ return fetch(v) }`,
+    }
+    expect(() => compilePredicateSchema(evil)).toThrow(/Not predicate-safe/)
+  })
+
+  it('one-shot helper works too', () => {
+    expect(validatePredicateSchema(colorSchema, { color: '#fff' }).valid).toBe(
+      true
+    )
+  })
+})

package/src/lang/predicate-schema.ts

@@ -0,0 +1,168 @@
+/**
+ * Predicate-aware JSON-Schema — "the missing computational half."
+ *
+ * A normal JSON-Schema node may carry a `$predicate` keyword whose value is the
+ * *source* of a predicate cluster (a few pure functions; the last is the entry,
+ * takes the value being validated, returns boolean). The source is trivially
+ * serializable (it's a string), and the predicate verifier (`./predicate`) is
+ * what makes it *safe to embed and run*: no IO, no async, fuel-bounded.
+ *
+ * Progressive enhancement falls out for free:
+ *   - A *naive* JSON-Schema validator ignores the unknown `$predicate` keyword
+ *     and validates only the structural part (`type`, `properties`, …).
+ *   - A *predicate-aware* validator (this module — and, in production, an
+ *     incoming `tosijs-schema`) ALSO runs the `$predicate`, validating the value
+ *     grammar that JSON-Schema and TS can't express (var()/calc()/!important,
+ *     order-flexible shorthands, recursive structure).
+ *
+ * This is the reference evaluator that lives with the predicate engine; the
+ * structural subset is intentionally small (type/properties/required/items) —
+ * full JSON-Schema structural validation is `tosijs-schema`'s job. The novel
+ * part is `$predicate`.
+ */
+import { verifyPredicate, compilePredicate } from './predicate'
+import type { CompilePredicateOptions } from './predicate'
+
+/** A JSON-Schema node, optionally carrying a `$predicate` (predicate source). */
+export interface PredicateSchema {
+  type?:
+    | 'string'
+    | 'number'
+    | 'integer'
+    | 'boolean'
+    | 'object'
+    | 'array'
+    | 'null'
+  properties?: Record<string, PredicateSchema>
+  required?: string[]
+  items?: PredicateSchema
+  /**
+   * Predicate cluster source. The LAST top-level function is the entry; it
+   * receives the value at this node and returns a boolean. Ignored by naive
+   * validators (it's a custom keyword); run by predicate-aware ones.
+   */
+  $predicate?: string
+  // description, title, examples, etc. are allowed and ignored.
+  [k: string]: unknown
+}
+
+export interface SchemaError {
+  /** JSON-pointer-ish path to the offending value, e.g. `/style/color`. */
+  path: string
+  message: string
+}
+
+export interface SchemaValidationResult {
+  valid: boolean
+  errors: SchemaError[]
+}
+
+export interface PredicateSchemaOptions extends CompilePredicateOptions {
+  /**
+   * Validate structure only — skip every `$predicate` (i.e. behave like a naive
+   * JSON-Schema validator). Useful for demonstrating progressive enhancement.
+   */
+  ignorePredicates?: boolean
+}
+
+const typeOf = (v: unknown): string =>
+  v === null ? 'null' : Array.isArray(v) ? 'array' : typeof v
+
+function typeMatches(value: unknown, type: string): boolean {
+  if (type === 'integer')
+    return typeof value === 'number' && Number.isInteger(value)
+  return typeOf(value) === type
+}
+
+/**
+ * Compile a predicate-aware JSON-Schema into a reusable validator. Every
+ * `$predicate` cluster is verified + compiled once (fuel-bounded, IO-rejected);
+ * an invalid/unsafe predicate throws here, at compile time.
+ */
+export function compilePredicateSchema(
+  schema: PredicateSchema,
+  opts: PredicateSchemaOptions = {}
+): (value: unknown) => SchemaValidationResult {
+  const { ignorePredicates, ...compileOpts } = opts
+  // Compile every distinct $predicate once.
+  const compiled = new Map<string, (value: unknown) => boolean>()
+  const prepare = (node: PredicateSchema) => {
+    if (
+      node.$predicate &&
+      !ignorePredicates &&
+      !compiled.has(node.$predicate)
+    ) {
+      const src = node.$predicate
+      const names = verifyPredicate(src, compileOpts).predicates
+      const entry = names[names.length - 1]
+      if (!entry)
+        throw new Error('$predicate must declare at least one function')
+      const mod = compilePredicate(src, [entry], compileOpts)
+      compiled.set(src, mod[entry] as (value: unknown) => boolean)
+    }
+    if (node.properties)
+      for (const child of Object.values(node.properties)) prepare(child)
+    if (node.items) prepare(node.items)
+  }
+  prepare(schema)
+
+  const check = (
+    node: PredicateSchema,
+    value: unknown,
+    path: string,
+    errors: SchemaError[]
+  ) => {
+    if (node.type && !typeMatches(value, node.type)) {
+      errors.push({
+        path: path || '/',
+        message: `expected ${node.type}, got ${typeOf(value)}`,
+      })
+      return // structural mismatch — don't run value-grammar checks on it
+    }
+    if (
+      node.type === 'object' &&
+      node.properties &&
+      value &&
+      typeof value === 'object'
+    ) {
+      const obj = value as Record<string, unknown>
+      for (const key of node.required ?? []) {
+        if (!(key in obj))
+          errors.push({
+            path: `${path}/${key}`,
+            message: `missing required '${key}'`,
+          })
+      }
+      for (const [key, child] of Object.entries(node.properties)) {
+        if (key in obj) check(child, obj[key], `${path}/${key}`, errors)
+      }
+    }
+    if (node.type === 'array' && node.items && Array.isArray(value)) {
+      value.forEach((el, i) => check(node.items!, el, `${path}/${i}`, errors))
+    }
+    // The computational half — only the aware validator runs it.
+    if (node.$predicate && !ignorePredicates) {
+      const fn = compiled.get(node.$predicate)!
+      if (!fn(value))
+        errors.push({
+          path: path || '/',
+          message: `failed predicate at ${path || '/'}`,
+        })
+    }
+  }
+
+  return (value: unknown) => {
+    const errors: SchemaError[] = []
+    check(schema, value, '', errors)
+    return { valid: errors.length === 0, errors }
+  }
+}
+
+/** One-shot convenience: compile + validate. */
+export function validatePredicateSchema(
+  schema: PredicateSchema,
+  value: unknown,
+  opts?: PredicateSchemaOptions
+): SchemaValidationResult {
+  return compilePredicateSchema(schema, opts)(value)
+}

package/src/lang/predicate.test.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'bun:test'
+import {
+  verifyPredicate,
+  compilePredicate,
+  effectfulFromAtoms,
+  PredicateFuelExhausted,
+} from './predicate'
+import { coreAtoms } from '../vm/runtime'
+
+const ok = (src: string, opts?: any) => verifyPredicate(src, opts).safe
+const why = (src: string, opts?: any) =>
+  verifyPredicate(src, opts).diagnostics.map((d) => d.message)
+
+describe('verifyPredicate — accepts the pure substrate', () => {
+  it('pure expression + composition + recursion', () => {
+    expect(
+      ok(`
+      function isShort(s) { return typeof s == 'string' && s.length < 10 }
+      function isTag(s) { return isShort(s) && s.startsWith('#') }
+      function depth(o) {
+        if (typeof o != 'object' || o == null) { return 0 }
+        return Object.keys(o).every(isTag) ? 1 : depth(o)  // self-ref ok
+      }
+    `)
+    ).toBe(true)
+  })
+
+  it('pure builtins: regex .test, string/array methods, pure namespaces', () => {
+    expect(ok(`function f(v){ return /^#[0-9a-f]{3}$/i.test(v) }`)).toBe(true)
+    expect(
+      ok(
+        `function f(xs){ return xs.every(isThing) } function isThing(x){ return x.length > 0 }`
+      )
+    ).toBe(true)
+    expect(ok(`function f(o){ return Object.entries(o).length > 0 }`)).toBe(
+      true
+    )
+    expect(ok(`function f(a,b){ return Math.max(a,b) }`)).toBe(true)
+    expect(ok(`function f(s){ return JSON.parse(s) }`)).toBe(true)
+  })
+})
+
+describe('verifyPredicate — rejects impurity (the tightened checks)', () => {
+  it('async / await', () => {
+    expect(ok(`async function f(v){ return await g(v) }`)).toBe(false)
+  })
+  it('new', () => {
+    expect(ok(`function f(v){ return new RegExp(v).test(v) }`)).toBe(false)
+  })
+  it('IO globals (fetch / console)', () => {
+    expect(why(`function f(v){ return fetch(v) }`)[0]).toMatch(
+      /fetch.*effectful/
+    )
+    expect(why(`function f(v){ console.log(v); return true }`)[0]).toMatch(
+      /console\.log.*effectful/
+    )
+  })
+  it('nondeterministic statics (Date.now / Math.random) — caught by the whitelist', () => {
+    expect(why(`function f(){ return Date.now() }`)[0]).toMatch(
+      /Date.*effectful|nondeterministic/
+    )
+    expect(why(`function f(){ return Math.random() }`)[0]).toMatch(
+      /Math\.random.*nondeterministic/
+    )
+  })
+  it('non-pure instance methods (.then / .push)', () => {
+    // .then would let a Promise in; .push mutates — neither is a known pure method
+    expect(why(`function f(p){ return p.then(g) }`)[0]).toMatch(
+      /\.then\(\).*not a known pure method/
+    )
+    expect(why(`function f(a){ a.push(1); return a }`)[0]).toMatch(
+      /\.push\(\).*not a known pure method/
+    )
+  })
+  it('unknown reference (typo / undeclared)', () => {
+    expect(why(`function f(v){ return notDefinedAnywhere(v) }`)[0]).toMatch(
+      /unknown reference/
+    )
+  })
+})
+
+describe('verifyPredicate — driven by the real atom `effects` tag', () => {
+  const effectful = effectfulFromAtoms(coreAtoms as any)
+
+  it('rejects a predicate calling a real io-tagged atom, with a clear message', () => {
+    const r = verifyPredicate(`function isUp(u){ return httpFetch(u) }`, {
+      effectful,
+    })
+    expect(r.safe).toBe(false)
+    expect(r.diagnostics[0].message).toMatch(/httpFetch.*effectful/)
+    expect(r.diagnostics[0].line).toBeGreaterThan(0)
+  })
+
+  it('still allows pure atoms / composition', () => {
+    expect(
+      verifyPredicate(`function f(s){ return s.length < 5 }`, { effectful })
+        .safe
+    ).toBe(true)
+  })
+})
+
+describe('verifyPredicate — cross-source composition (knownPredicates)', () => {
+  it('accepts a reference to an externally-verified predicate', () => {
+    expect(
+      ok(`function isUser(u){ return isEmail(u.email) }`, {
+        knownPredicates: new Set(['isEmail']),
+      })
+    ).toBe(true)
+    // …but not an unknown one
+    expect(ok(`function isUser(u){ return isEmail(u.email) }`)).toBe(false)
+  })
+})
+
+describe('verifyPredicate — rejects loops (#3: keeps work fuel-bounded)', () => {
+  it('while / for / for-of are rejected; recursion + array methods are not', () => {
+    expect(why(`function f(n){ while(n>0){ n=n-1 } return n }`)[0]).toMatch(
+      /loops are not allowed/
+    )
+    expect(ok(`function f(n){ for(let i=0;i<n;i++){} return n }`)).toBe(false)
+    expect(ok(`function f(a){ for(const x of a){} return a }`)).toBe(false)
+    // the sanctioned forms still pass:
+    expect(
+      ok(
+        `function f(a){ return a.every(isShort) } function isShort(s){ return s.length<5 }`
+      )
+    ).toBe(true)
+  })
+})
+
+describe('compilePredicate — fuel-bounded + global-shadowed (#3)', () => {
+  it('verified predicates compile and run; IO ones throw at definition time', () => {
+    const m = compilePredicate(
+      `function isHex(v){ return typeof v == 'string' && /^#[0-9a-f]{3,8}$/i.test(v) }
+       function isVar(v){ return typeof v == 'string' && v.startsWith('var(--') && v.endsWith(')') }
+       function isColor(v){ return isHex(v) || isVar(v) }`,
+      ['isColor']
+    )
+    expect(m.isColor('#3a3')).toBe(true)
+    expect(m.isColor('var(--brand)')).toBe(true)
+    expect(m.isColor('nope')).toBe(false)
+
+    expect(() =>
+      compilePredicate(`function f(v){ return fetch(v) }`, ['f'])
+    ).toThrow(/Not predicate-safe/)
+  })
+
+  it('runaway recursion exhausts fuel instead of hanging', () => {
+    // verifier allows recursion (call-bounded); the runtime fuel stops it.
+    const m = compilePredicate(`function loop(n){ return loop(n) }`, ['loop'], {
+      fuel: 5000,
+    })
+    expect(() => m.loop(1)).toThrow(PredicateFuelExhausted)
+  })
+
+  it('a huge array exhausts fuel via the per-element callback', () => {
+    const m = compilePredicate(
+      `function isPos(x){ return x > 0 }
+       function allPos(a){ return a.every(isPos) }`,
+      ['allPos'],
+      { fuel: 1000 }
+    )
+    expect(m.allPos([1, 2, 3])).toBe(true) // small input fine
+    const big = Array.from({ length: 100000 }, () => 1)
+    expect(() => m.allPos(big)).toThrow(PredicateFuelExhausted)
+  })
+
+  it('each top-level call gets a fresh budget (no cross-call starvation)', () => {
+    const m = compilePredicate(
+      `function rec(n){ if (n <= 0) { return true } return rec(n - 1) }`,
+      ['rec'],
+      { fuel: 10000 }
+    )
+    // 500 deep, well under budget — and repeatable because budget resets
+    for (let i = 0; i < 5; i++) expect(m.rec(500)).toBe(true)
+  })
+
+  it('shadows effectful globals to undefined (defense-in-depth)', () => {
+    // even if a global slipped past the verifier, it is undefined at runtime
+    const m = compilePredicate(`function usesGlobal(){ return typeof fetch }`, [
+      'usesGlobal',
+    ])
+    expect(m.usesGlobal()).toBe('undefined')
+  })
+})