jz 0.6.0 → 0.7.0

package/package.json

@@ -1,17 +1,22 @@
 {
   "name": "jz",
-  "version": "0.6.0",
-  "description": "Functional JS subset compiling to WASM",
+  "version": "0.7.0",
+  "description": "Ahead-of-time compiler for the numeric core of JavaScript (DSP, audio, math, parsers) to lean GC-free WASM — valid jz is valid JS, no type annotations, no runtime.",
   "main": "index.js",
+  "types": "index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
     "./wasi": "./wasi.js",
     "./interop": "./interop.js",
     "./transform": "./transform.js"
   },
   "files": [
     "index.js",
+    "index.d.ts",
     "cli.js",
     "wasi.js",
     "interop.js",
@@ -20,6 +25,8 @@
     "jzify",
     "src",
     "module",
+    "dist/jz.js",
+    "dist/interop.js",
     "README.md",
     "jz.svg",
     "alternatives.svg",
@@ -48,9 +55,10 @@
     "bench:size": "node scripts/bench-size.mjs",
     "bench:compile": "node scripts/bench-compile.mjs",
     "bench:startup": "node scripts/bench-startup.mjs",
+    "bench:readme": "node scripts/bench-readme.mjs",
     "build": "node scripts/build-dist.mjs",
-    "build:examples": "for dir in examples/*/; do [ -f \"$dir/build.mjs\" ] && node \"$dir/build.mjs\"; done",
-    "prepublishOnly": "npm test && npm run test:self"
+    "build:examples": "node examples/build.mjs all",
+    "prepare": "npm run build"
   },
   "repository": {
     "type": "git",
@@ -81,10 +89,17 @@
     "audio",
     "creative-coding",
     "assemblyscript",
-    "porffor"
+    "porffor",
+    "numeric",
+    "signal-processing",
+    "math",
+    "audio-worklet",
+    "js-to-wasm",
+    "performance"
   ],
   "devDependencies": {
     "esbuild": "^0.28.0",
+    "sprae": "^13.3.8",
     "tst": "^9.4.0"
   }
 }

package/src/autoload.js

@@ -127,6 +127,9 @@ const MOD_DEPS = {
   date: ['core', 'number', 'string'],
   console: ['core', 'string', 'number'],
   regex: ['core', 'string', 'array'],
+  // f64x2.sin/cos lower to math's $math.sin2/$math.cos2 WAT helpers; pull math in so
+  // they're registered. Unused math helpers are pruned by reachability — no output cost.
+  simd: ['math'],
 }
 
 export function includeModule(name) {

package/src/compile/analyze-scans.js

@@ -5,7 +5,7 @@
 
 import { ASSIGN_OPS, collectParamNames, extractParams, REFS_IN_EXPR, refsName, T, isLiteralStr } from '../ast.js'
 import { ctx } from '../ctx.js'
-import { staticObjectProps } from '../static.js'
+import { staticObjectProps, staticArrayElems, staticIndexKey, staticValue, NO_VALUE } from '../static.js'
 import { exprType } from '../type.js'
 
 export function findFreeVars(node, bound, free, scope) {
@@ -168,7 +168,7 @@ export function scanBindingUses(body) {
   const use = (name, kind, extra) => slot(name).uses.push(extra ? { kind, ...extra } : { kind })
 
   // Static string key of a `[]` index node, else null (computed).
-  const litKey = (k) => (Array.isArray(k) && k[0] === 'str' && typeof k[1] === 'string') ? k[1] : null
+  const litKey = (k) => (Array.isArray(k) && k[0] === 'str' && typeof k[1] === 'string') ? k[1] : staticIndexKey(k)
 
   // A child sitting in a value position. A bare string there is a real use —
   // `walk` alone silently drops non-array children, so every value-position
@@ -350,6 +350,10 @@ export function scanBindingUses(body) {
  * Field `i` of binding `o` lives in WASM local `o#${i}` (`#` cannot occur in a
  * jz identifier, so the name is collision-free).
  */
+// Largest array literal that dissolves into scalar slots. Beyond this a single
+// constant data segment is cheaper than N locals (+ the per-slot init prologue).
+const FLAT_ARRAY_MAX = 8
+
 export function scanFlatObjects(body) {
   const cand = new Map()                 // name → {names, values}
 
@@ -357,19 +361,48 @@ export function scanFlatObjects(body) {
   // slots). Used only to reject a self-referential initializer — a literal
   // whose own field values mention the binding is not a self-contained object.
   for (const [name, s] of scanBindingUses(body)) {
-    if (s.decls !== 1 || !Array.isArray(s.initRhs) || s.initRhs[0] !== '{}') continue
-    const props = staticObjectProps(s.initRhs.slice(1))
+    if (s.decls !== 1 || !Array.isArray(s.initRhs)) continue
+    // Candidate aggregate: an object literal `{…}` (string keys) or a small array
+    // literal `[…]` (index keys "0","1",…). An array dissolves into `name#i` scalar
+    // locals exactly like an object — same `.`/`[]` flat hooks, no heap alloc — when
+    // every use is a static-index read/write. Capped at FLAT_ARRAY_MAX: a larger
+    // literal belongs in one constant data-segment region, not N spilled locals.
+    let props
+    if (s.initRhs[0] === '{}') {
+      props = staticObjectProps(s.initRhs.slice(1))
+    } else if (s.initRhs[0] === '[' || s.initRhs[0] === '[]') {
+      const elems = staticArrayElems(s.initRhs)
+      if (!elems || !elems.length || elems.length > FLAT_ARRAY_MAX) continue
+      // Holes (`[1,,3]`) and spreads (`[...x]`) aren't a fixed positional schema.
+      if (elems.some(e => e == null || (Array.isArray(e) && e[0] === '...'))) continue
+      // Only compile-time-constant *value* elements dissolve — number/string/bool/null
+      // ("arrays hold JSON values"). A non-literal element (identifier, call, closure,
+      // arithmetic on a runtime var) can carry a function/closure whose call-indirect
+      // table index binds to the array, not a scalar local — dissolving the slot
+      // desyncs the `elem` section. Conservative: any non-constant element keeps the
+      // array heap-backed.
+      if (!elems.every(e => staticValue(e) !== NO_VALUE)) continue
+      props = { names: elems.map((_, i) => String(i)), values: elems }
+    } else continue
+    const isArr = s.initRhs[0] !== '{}'
     if (!props || new Set(props.names).size !== props.names.length) continue
     if (props.values.some(v => refsName(v, name, REFS_IN_EXPR))) continue
 
-    // Schema = literal keys ∪ plain literal-key member writes. Such a write
-    // monotonically extends the static field universe (the new field reads
-    // `undefined` until the write runs, exactly as JS does); the schema stays
-    // closed because any computed/off-schema access disqualifies below.
+    // Schema = literal keys ∪ plain literal-key member writes. For an OBJECT such a
+    // write monotonically extends the static field universe (the new field reads
+    // `undefined` until the write runs, exactly as JS does). An ARRAY has a *fixed*
+    // positional schema: `a.length = …` / `a[n] = …` (off the literal indices) resize
+    // or grow it — not a field add — so arrays never extend, and any off-schema write
+    // (including `.length`, which isn't a slot) disqualifies below.
+    // `written` = the keys a MEMBER_W reassigns — a slot is write-once (its
+    // value-type is exactly its literal initializer's) iff its key is absent here.
     const schema = new Set(props.names)
+    const written = new Set()
     for (const u of s.uses)
-      if (u.kind === USE.MEMBER_W && !u.compound && !u.computed && u.key != null)
-        schema.add(u.key)
+      if (u.kind === USE.MEMBER_W && !u.compound && !u.computed && u.key != null) {
+        if (!isArr) schema.add(u.key)
+        written.add(u.key)
+      }
 
     // Flat iff every mention is an in-schema literal-key `.`/`[]` READ, or an
     // in-schema literal-key plain `.`/`[]` WRITE. Any other use kind — `?.`,
@@ -385,7 +418,7 @@ export function scanFlatObjects(body) {
     const names = props.names.slice(), values = props.values.slice()
     for (const k of schema)
       if (!names.includes(k)) { names.push(k); values.push(undefined) }
-    cand.set(name, { names, values })
+    cand.set(name, { names, values, written })
   }
   return cand
 }
@@ -432,6 +465,136 @@ export function scanSliceViews(body) {
   return views
 }
 
+/**
+ * Never-relocated array bindings — reads through them may skip the realloc-forwarding
+ * follow (`__ptr_offset`). A fresh array-literal binding is never relocated iff EVERY
+ * occurrence of it is a pure READ — `a[i]` (any index) or `a.length`. Anything else
+ * grows or escapes it: a grow method (push/unshift/shift/splice), a `.length`/element
+ * write (incl. compound `a.length += 1`), a bare value use (alias `let b=a`, store
+ * `w.x=a`, return, call argument, spread), a reassignment, or a dynamic call
+ * `a[i]()`/`a.m()`.
+ *
+ * MEMORY-SAFETY CRITICAL and so DEFAULT-DENY + self-contained: it does NOT trust the
+ * `escapes` map, which misses member-write RHS (`w.data = a`) and compound assigns. If
+ * the analysis is wrong and the array IS relocated, a read through the stale base
+ * corrupts memory — so any unrecognized use disqualifies. (Growing an INNER array,
+ * `a[0].push(x)`, never relocates `a` itself, so `a` stays eligible — see safeReads.)
+ */
+const grownOrEscapes = (op) => ASSIGN_OPS.has(op) || op === '++' || op === '--' || op === 'delete'
+function safeReads(node, name) {
+  if (typeof node === 'string') return node !== name            // bare value use → escape
+  if (!Array.isArray(node)) return true
+  const op = node[0]
+  // `a(…)` / `a.m(…)` / `a[i](…)` — calling `a` or a method/element of it may grow/escape it.
+  if (op === '()') {
+    const c = node[1]
+    if (c === name) return false
+    if (Array.isArray(c) && (c[0] === '.' || c[0] === '?.' || c[0] === '[]' || c[0] === '?.[]') && c[1] === name) return false
+  }
+  // write / update / delete on `a`, `a[..]`, or `a.x` (incl. `a.length = …` and compounds)
+  if (grownOrEscapes(op)) {
+    const t = node[1]
+    if (t === name) return false
+    if (Array.isArray(t) && (t[0] === '[]' || t[0] === '.' || t[0] === '?.') && t[1] === name) return false
+  }
+  // declaration: check each initializer RHS (so `let b = a` aliasing disqualifies);
+  // the bound names themselves are definitions, not uses (skips `a`'s own decl).
+  if (op === 'let' || op === 'const' || op === 'var') {
+    for (let i = 1; i < node.length; i++) {
+      const d = node[i]
+      if (Array.isArray(d) && d[0] === '=' && !safeReads(d[2], name)) return false
+    }
+    return true
+  }
+  // the only safe forms: `a.length` read, and `a[i]` index read (recurse the index expr).
+  if ((op === '.' || op === '?.') && node[1] === name) return node[2] === 'length'
+  if (op === '[]' && node[1] === name) return safeReads(node[2], name)
+  if (op === '...' && node[1] === name) return false            // spread → escape
+  for (let i = 1; i < node.length; i++) if (!safeReads(node[i], name)) return false
+  return true
+}
+
+export function scanNeverGrown(body) {
+  const out = new Set()
+  for (const [name, s] of scanBindingUses(body)) {
+    // Candidate: a single-declaration binding initialized from a fresh array literal.
+    if (s.decls !== 1 || !Array.isArray(s.initRhs)) continue
+    if (s.initRhs[0] !== '[' && !(s.initRhs[0] === '[]' && s.initRhs.length <= 2)) continue
+    if (safeReads(body, name)) out.add(name)
+  }
+  return out
+}
+
+/**
+ * Numeric-fill arrays — the construct-then-fill counterpart of an all-number array
+ * literal. A fresh `Array(n)` / `new Array(n)` / `[]` binding whose EVERY element write
+ * stores a provably-NUMBER value, and which never escapes, aliases, is reassigned, grows
+ * by method, or takes a non-numeric / compound element write, holds only Numbers (unwritten
+ * holes read as 0 in jz, also a Number). So its `a[i]` reads can skip the polymorphic
+ * `__to_num` coercion — exactly the win `[1,2,3]` already gets, extended to the dominant
+ * numeric-kernel shape `let a = Array(n); for (..) a[i] = expr`.
+ *
+ * Default-deny and self-contained, like scanNeverGrown (the same memory-safety discipline):
+ * any occurrence that isn't a pure index/length READ or a NUMBER-valued `a[i] = …` write
+ * disqualifies — so `w.x = a`, `f(a)`, `let b = a`, `a.push(x)`, `a[i] += x` all bail.
+ * `isNumericRhs` injects the value-type judgement (valTypeOf === VAL.NUMBER) the syntactic
+ * scan can't make itself.
+ */
+// Both `Array(n)` and `new Array(n)` normalize to a `new.Array` call by prepare; an
+// empty literal stays `['[]', null]`. (Typed ctors become `new.Float64Array` etc. — the
+// exact-match on `new.Array` keeps them out.)
+const isFreshArrayCtor = (rhs) =>
+  Array.isArray(rhs) && (
+    (rhs[0] === '[]' && rhs.length <= 2) ||             // empty `[]`
+    (rhs[0] === '()' && rhs[1] === 'new.Array')         // `Array(n)` / `new Array(n)` / `Array()`
+  )
+
+function numFillSafe(node, name, isNumericRhs) {
+  if (typeof node === 'string') return node !== name              // bare value use → escape
+  if (!Array.isArray(node)) return true
+  const op = node[0]
+  // `a[i] = rhs` — the fill write. Allowed iff rhs is provably NUMBER; recurse the index
+  // and rhs so a stray `a` inside either still disqualifies. (Compound `a[i] += …` is NOT
+  // matched here, so it falls through to the deny below — conservative for v1.)
+  if (op === '=' && Array.isArray(node[1]) && node[1][0] === '[]' && node[1][1] === name)
+    return isNumericRhs(node[2], name) &&
+      numFillSafe(node[1][2], name, isNumericRhs) && numFillSafe(node[2], name, isNumericRhs)
+  // calling `a`, `a.m(…)`, `a[i](…)` may grow/escape it
+  if (op === '()') {
+    const c = node[1]
+    if (c === name) return false
+    if (Array.isArray(c) && (c[0] === '.' || c[0] === '?.' || c[0] === '[]' || c[0] === '?.[]') && c[1] === name) return false
+  }
+  // any other write/update/delete on `a`, `a[..]`, `a.x` (incl. `a.length = …`, compounds)
+  if (grownOrEscapes(op)) {
+    const t = node[1]
+    if (t === name) return false
+    if (Array.isArray(t) && (t[0] === '[]' || t[0] === '.' || t[0] === '?.') && t[1] === name) return false
+  }
+  if (op === 'let' || op === 'const' || op === 'var') {
+    for (let i = 1; i < node.length; i++) {
+      const d = node[i]
+      if (Array.isArray(d) && d[0] === '=' && !numFillSafe(d[2], name, isNumericRhs)) return false
+    }
+    return true
+  }
+  // the only safe forms: `a.length` read, and `a[i]` index read (recurse the index expr).
+  if ((op === '.' || op === '?.') && node[1] === name) return node[2] === 'length'
+  if (op === '[]' && node[1] === name) return numFillSafe(node[2], name, isNumericRhs)
+  if (op === '...' && node[1] === name) return false              // spread → escape
+  for (let i = 1; i < node.length; i++) if (!numFillSafe(node[i], name, isNumericRhs)) return false
+  return true
+}
+
+export function scanNumericFill(body, isNumericRhs) {
+  const out = new Set()
+  for (const [name, s] of scanBindingUses(body)) {
+    if (s.decls !== 1 || !isFreshArrayCtor(s.initRhs)) continue
+    if (numFillSafe(body, name, isNumericRhs)) out.add(name)
+  }
+  return out
+}
+
 /**
  * Narrow uint32 accumulator locals to unsigned i32. A local qualifies when its
  * initializer is a non-negative integer literal in [0, 2^32), every

package/src/compile/analyze.js

@@ -76,7 +76,7 @@ import { TYPED_ELEM_CODE, TYPED_ELEM_VIEW_FLAG, TYPED_ELEM_BIGINT_FLAG, encodeTy
 import {
   findFreeVars, findMutations, boxedCaptures,
   collectI32SafeIndexVars, collectF64StridedIndexVars, narrowUint32, scanBindingUses,
-  scanFlatObjects, scanSliceViews, USE,
+  scanFlatObjects, scanSliceViews, scanNeverGrown, scanNumericFill, USE,
 } from './analyze-scans.js'
 
 export { findFreeVars, findMutations, boxedCaptures } from './analyze-scans.js'
@@ -124,6 +124,15 @@ const makeTypedTracker = (get, set, del) => {
     }
     const ctor = typedElemCtor(rhs)
     if (ctor) return setOrInvalidate(ctor)
+    // `recv.subarray(...)` is a zero-copy VIEW aliasing the receiver's buffer — its elem
+    // ctor is the receiver's type with the `.view` flag, so the binding unboxes to a typed
+    // pointer and element writes take the descriptor-indirected path (not desc-as-data).
+    if (Array.isArray(rhs) && rhs[0] === '()' && Array.isArray(rhs[1]) && rhs[1][0] === '.'
+        && rhs[1][2] === 'subarray' && typeof rhs[1][1] === 'string') {
+      const recvCtor = resolveName(rhs[1][1])
+      if (recvCtor) return setOrInvalidate((recvCtor.endsWith('.view') ? recvCtor.slice(0, -5) : recvCtor) + '.view')
+      return
+    }
     // TYPED-narrowed call result carries its elem aux on f.sig.ptrAux — reverse-map
     // to a canonical ctor so the unboxed local's rep restores the same aux.
     if (Array.isArray(rhs) && rhs[0] === '()' && typeof rhs[1] === 'string') {
@@ -319,8 +328,12 @@ export function analyzeBody(body) {
       }
       // `x = arr[i]` where `arr` is a known array-of-arrays → `x`'s elements take
       // `arr`'s nested element kind (the missing index-step in observeArrValType).
+      // `arr` may be a function-local (arrElemElemValTypes) or a module-level const
+      // table (global rep, recorded by recordGlobalRep) — the latter dynWrite-guarded.
       if (Array.isArray(rhs) && rhs[0] === '[]' && rhs.length === 3 && typeof rhs[1] === 'string') {
         const nested = arrElemElemValTypes.get(rhs[1])
+          ?? (!ctx.func.localReps?.has(rhs[1]) && !ctx.types?.dynWriteVars?.has(rhs[1])
+                ? ctx.scope.globalReps?.get(rhs[1])?.arrayElemElemValType : null)
         if (nested) observeArrValType(name, nested)
       }
     }
@@ -517,7 +530,7 @@ export function analyzeBody(body) {
   const prevTypedOverlay = ctx.func.localTypedElemsOverlay
   ctx.func.localValTypesOverlay = valTypes
   ctx.func.localTypedElemsOverlay = typedElems
-  let unsignedLocals
+  let unsignedLocals, numericFill
   try {
     walk(body)
     widenLocalTypes(body, locals)
@@ -526,6 +539,18 @@ export function analyzeBody(body) {
     // reconsidered with final types — and stays f64, since a relational compare
     // is a non-transparent read that disqualifies narrowing anyway.
     unsignedLocals = narrowUint32(body, locals)
+    // Numeric-fill arrays — fresh `Array(n)`/`[]` whose every element write stores a
+    // Number, so `a[i]` reads can skip __to_num (the win `[1,2,3]` already gets, for the
+    // construct-then-fill kernel shape). Runs HERE, inside the val-type overlay, so a
+    // write of a bare numeric local (`a[i] = out`) resolves via the just-built `valTypes`.
+    // A bare read of the array's OWN elements (`a[i] = a[j]`, heapsort) is Numeric by
+    // induction; any genuinely non-numeric write still fails the test and disqualifies.
+    const numericFillRhs = (rhs, selfName) => {
+      if (Array.isArray(rhs) && rhs[0] === '[]' && rhs[1] === selfName) return true
+      if (typeof rhs === 'string') return valTypes.get(rhs) === VAL.NUMBER || exprElemSourceVal(rhs) === VAL.NUMBER
+      return valTypeOf(rhs) === VAL.NUMBER
+    }
+    numericFill = scanNumericFill(body, numericFillRhs)
   } finally {
     ctx.func.localValTypesOverlay = prevOverlay
     ctx.func.localTypedElemsOverlay = prevTypedOverlay
@@ -545,7 +570,10 @@ export function analyzeBody(body) {
   // Consumed by emitDecl, which lowers the initializer to a SLICE_BIT view.
   const sliceViews = doSchemas ? scanSliceViews(body) : new Set()
 
-  const result = { locals, valTypes, arrElemSchemas, arrElemValTypes, typedElems, escapes, flatObjects, sliceViews, unsignedLocals }
+  // Never-relocated array bindings — reads may skip the realloc-forwarding follow.
+  const neverGrown = doSchemas ? scanNeverGrown(body) : new Set()
+
+  const result = { locals, valTypes, arrElemSchemas, arrElemValTypes, typedElems, escapes, flatObjects, sliceViews, unsignedLocals, neverGrown, numericFill }
   _bodyFactsCache.set(body, result)
   return result
 }
@@ -677,6 +705,13 @@ export function analyzeValTypes(body) {
   for (const [name, vt] of facts.arrElemValTypes) {
     if (vt != null) updateRep(name, { arrayElemValType: vt })
   }
+  // Construct-then-fill numeric arrays (`let a = Array(n); a[i] = expr`) carry no
+  // element evidence at their decl, so the walk above leaves them untyped. scanNumericFill
+  // proved every write Numeric and every other use a pure read — record NUMBER so `arr[i]`
+  // reads skip __to_num, unless an observation already poisoned the slot to a conflict.
+  for (const name of facts.numericFill || []) {
+    if (facts.arrElemValTypes.get(name) !== null) updateRep(name, { arrayElemValType: VAL.NUMBER })
+  }
   // Propagate body-observed array-elem schemas to localReps so unboxablePtrs's
   // `let p = arr[i]` rule (which only consults rep) sees the schema and can unbox `p`
   // to an i32 offset. Without this, `arr.push({x,y,z})` followed by `arr[i].x` reads

package/src/compile/emit-assign.js

@@ -10,9 +10,9 @@
  * @module compile/emit-assign
  */
 
-import { ctx, err, inc, PTR } from '../ctx.js'
+import { ctx, err, inc, warnDeopt, PTR } from '../ctx.js'
 import { T } from '../ast.js'
-import { staticPropertyKey } from '../static.js'
+import { staticPropertyKey, staticIndexKey } from '../static.js'
 import { valTypeOf, shapeOf } from '../kind.js'
 import { VAL, lookupValType, repOf } from '../reps.js'
 import {
@@ -74,8 +74,9 @@ function storeArrayPayload(arrExpr, idxNode, valueExpr, persist) {
 /** Strict-mode guard for dynamic property writes — emitted in branches that
  *  fall through to `__dyn_set` or its key-kind dispatch. */
 function ensureDynSetAllowed(arr) {
-  if (!ctx.transform.strict) return
   const arrLabel = typeof arr === 'string' ? arr : '<expr>'
+  warnDeopt('deopt-dyn-write', `dynamic property write \`${arrLabel}[…] = …\` couldn't resolve a static type — it falls back to a runtime hash store (~2× slower than a typed/slot write, far worse in a hot loop). Use a literal key, a numeric typed-array index, or a Map for genuinely dynamic keys.`)
+  if (!ctx.transform.strict) return
   err(`strict mode: dynamic property assignment \`${arrLabel}[<expr>] = ...\` falls back to __dyn_set. Use a literal key or known array/typed-array numeric index, or pass { strict: false }.`)
 }
 
@@ -159,10 +160,12 @@ export function emitElementAssign(arr, idx, val) {
     : typeof arr === 'string' && lookupValType(arr) === VAL.OBJECT ? staticPropertyKey(idx)
     : null
 
-  // 1. SRoA flat object: `o['k'] = x` → `local.set $o#i` (no heap store).
-  if (litKey != null && typeof arr === 'string' && ctx.func.flatObjects?.has(arr)) {
+  // 1. SRoA flat object/array: `o['k'] = x` / `a[2] = x` → `local.set $o#i` (no heap
+  // store). A bare integer index resolves its slot key here (not via `litKey`).
+  if (typeof arr === 'string' && ctx.func.flatObjects?.has(arr)) {
     const fo = ctx.func.flatObjects.get(arr)
-    const fi = fo.names.indexOf(litKey)
+    const flatKey = litKey != null ? litKey : staticIndexKey(idx)
+    const fi = flatKey != null ? fo.names.indexOf(flatKey) : -1
     if (fi >= 0) return withTemp(valueExpr, t => [
       ['local.set', `$${arr}#${fi}`, ['local.get', `$${t}`]],
       ['local.get', `$${t}`]])