gofront 1.7.0 → 1.9.0

package/src/backend/js/runtime.js

@@ -7,33 +7,288 @@ export const HELPER_LEN = `var __len = __len || function(a) {
   return a?.length ?? 0;
 };`;
 
-export const HELPER_APPEND = `var __append = __append || function(a, ...b) {
-  if (a && ArrayBuffer.isView(a)) {
-    const res = new a.constructor(a.length + b.length);
-    res.set(a);
-    res.set(b, a.length);
-    return res;
+// string -> []byte: UTF-8, except that a lone surrogate U+DC80-U+DCFF (a raw
+// byte from a \xNN escape) encodes as that single byte.
+export const HELPER_U8ENC = `var __u8e = __u8e || new TextEncoder();
+var __u8enc = __u8enc || function(s) {
+  const e = __u8e;
+  if (s.isWellFormed()) return e.encode(s);
+  const out = [];
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c >= 0xdc80 && c <= 0xdcff && !(i > 0 && (s.charCodeAt(i - 1) & 0xfc00) === 0xd800)) { out.push(c - 0xdc00); continue; }
+    const cp = s.codePointAt(i);
+    if (cp > 0xffff) i++;
+    for (const b of e.encode(String.fromCodePoint(cp))) out.push(b);
+  }
+  return Uint8Array.from(out);
+};`;
+
+// []byte -> string: UTF-8 with U+FFFD for invalid bytes. A typed array is
+// decoded in place; anything else is copied into one first.
+export const HELPER_U8DEC = `var __u8d = __u8d || null;
+var __u8dec = __u8dec || function(b) {
+  return (__u8d ??= new TextDecoder()).decode(ArrayBuffer.isView(b) ? b : new Uint8Array(b));
+};`;
+
+// Slice views (Go's `b[lo:hi:max]` shares the backing store).  A view of a
+// plain array is a Proxy over an empty `__SV` array that holds the backing
+// array `b`, offset `o`, length `n` and capacity `c`: Array.isArray, length,
+// indexing, iteration and the Array.prototype methods work through the traps,
+// so the rest of the runtime and JS callers see an ordinary array (`__SV`
+// makes Array.prototype methods return plain arrays and Node print the
+// elements).  A view covering its whole backing array is that array.  A
+// typed-array view is a `subarray`; a capacity beyond its length is kept in a
+// WeakMap shared by every compiled module.  `__slice` also accepts strings
+// (generic code).  `__reslice` is `x = x[lo:hi]`: within `len(x)` a plain
+// array is copied instead (a Proxy is much slower to index, and the old
+// value of `x` is usually dead), see docs/go-compatibility.md.
+// The copy keeps the capacity of the old value: its `__rcap` symbol property
+// (shared by every compiled module) is `{b, o, c, s, so, own}` (backing array,
+// offset, capacity, snapshot of the copy, its offset in `s`, and false while
+// `s` is shared with another copy).  An index
+// write `x[i] = v` to a chain that the package self-reslices is followed by
+// `__rcs(x, i)`, which writes the element through to `b` (and `s`), so it is
+// ordered with writes through other slices of `b`.  A slice or `append`
+// beyond the copy's length writes the remaining elements that differ from the
+// snapshot (written through other references to the copy) back into `b`
+// first and continues with a view over `b`.  `__mkslice` is `make([]T, n, cap)`.
+// `__sv` is its own helper ("sv") so range loops can unwrap a view without
+// pulling in the rest.
+export const HELPER_SV = `var __sv = __sv || Symbol.for("gofront.sliceView");`;
+
+export const HELPER_SLICE = `var __tcap = __tcap || (globalThis[Symbol.for("gofront.typedCap")] ??= new WeakMap());
+var __SV = __SV || class extends Array {
+  static get [Symbol.species]() { return Array; }
+  [Symbol.for("nodejs.util.inspect.custom")]() { return Array.from(this); }
+};
+var __rcap = __rcap || Symbol.for("gofront.resliceCap");
+var __svh = __svh || {
+  get(t, k) {
+    if (typeof k === "string") {
+      const ch = k.charCodeAt(0);
+      if (ch >= 48 && ch <= 57) { const i = +k; return i < t.n ? t.b[t.o + i] : undefined; }
+      if (k === "length") return t.n;
+    } else if (k === __sv) return t;
+    return t[k];
+  },
+  set(t, k, v) {
+    if (typeof k === "string") {
+      const ch = k.charCodeAt(0);
+      if (ch >= 48 && ch <= 57) { const i = +k; if (i < t.n) t.b[t.o + i] = v; return true; }
+      if (k === "length") return true;
+    }
+    t[k] = v;
+    return true;
+  },
+  has(t, k) {
+    if (typeof k === "string") {
+      const ch = k.charCodeAt(0);
+      if (ch >= 48 && ch <= 57) return +k < t.n;
+    }
+    return k in t;
+  },
+  defineProperty(t, k, d) {
+    if (typeof k === "string") {
+      const ch = k.charCodeAt(0);
+      if (ch >= 48 && ch <= 57) {
+        const i = +k;
+        if (i >= t.n || d.get || d.set || d.configurable === false) return false;
+        if ("value" in d) t.b[t.o + i] = d.value;
+        return true;
+      }
+    }
+    return Reflect.defineProperty(t, k, d);
+  },
+  preventExtensions() { return false; },
+  deleteProperty(t, k) {
+    if (typeof k === "string" && k.charCodeAt(0) >= 48 && k.charCodeAt(0) <= 57) return true;
+    return delete t[k];
+  },
+  ownKeys(t) {
+    const ks = [];
+    for (let i = 0; i < t.n; i++) ks.push(String(i));
+    ks.push("length");
+    return ks;
+  },
+  getOwnPropertyDescriptor(t, k) {
+    if (typeof k === "string") {
+      const ch = k.charCodeAt(0);
+      if (ch >= 48 && ch <= 57) {
+        const i = +k;
+        return i < t.n ? { value: t.b[t.o + i], writable: true, enumerable: true, configurable: true } : undefined;
+      }
+      if (k === "length") return { value: t.n, writable: true, enumerable: false, configurable: false };
+    }
+    return Reflect.getOwnPropertyDescriptor(t, k);
+  },
+};
+var __mkview = __mkview || function(b, o, n, c, f) {
+  if (o === 0 && n === b.length && c === n && !f) return b;
+  if (c === 0) return [];
+  const t = new __SV();
+  t.b = b; t.o = o; t.n = n; t.c = c;
+  return new Proxy(t, __svh);
+};
+var __cap = __cap || function(a) {
+  if (a == null) return 0;
+  const s = a[__sv];
+  if (s !== undefined) return s.c;
+  if (ArrayBuffer.isView(a)) return __tcap.get(a) ?? a.length;
+  return a[__rcap]?.c ?? a.length;
+};
+// A snapshot shared by a copy of a copy (e.own false) is cloned before it is
+// updated, so the update does not reach the other copy's snapshot (whose
+// write-back would then revert the element).
+var __rcown = __rcown || function(e, a) {
+  if (e.own === false) { e.s = e.s.slice(e.so, e.so + a.length); e.so = 0; e.own = true; }
+  return e.s;
+};
+// Write back only the elements of a __reslice copy that changed since it was
+// made (e.s from e.so is its snapshot, kept up to date by __rcs), so writes
+// made meanwhile through other slices of the backing array are kept.
+var __rcput = __rcput || function(e, a, from, to) {
+  for (let i = from; i < to; i++) {
+    const v = a[i];
+    if (!Object.is(v, e.s[e.so + i])) { e.b[e.o + i] = v; __rcown(e, a)[e.so + i] = v; }
+  }
+};
+// After an index write to a possible __reslice copy: write element i through.
+var __rcs = __rcs || function(a, i) {
+  const e = a?.[__rcap];
+  if (e !== undefined && i >= 0 && i < e.c && i < a.length) { const v = a[i]; e.b[e.o + i] = v; __rcown(e, a)[e.so + i] = v; }
+};
+var __rcdef = __rcdef || function(r, e) {
+  Object.defineProperty(r, __rcap, { value: e, writable: true });
+};
+var __rcflush = __rcflush || function(a) {
+  const e = a[__rcap];
+  if (e !== undefined) __rcput(e, a, 0, a.length);
+  return e;
+};
+var __slice = __slice || function(a, lo, hi, max) {
+  if (typeof a === "string") return a.slice(lo, hi);
+  const s = a == null ? undefined : a[__sv];
+  const n = s !== undefined ? s.n : a == null ? 0 : a.length;
+  const c = s !== undefined ? s.c : __cap(a);
+  const mx = max;
+  if (hi === undefined) hi = n;
+  if (max === undefined) max = c;
+  if (!(lo >= 0 && lo <= hi && hi <= max && max <= c)) throw new Error("runtime error: slice bounds out of range");
+  if (a == null) return a;
+  if (s !== undefined) return __mkview(s.b, s.o + lo, hi - lo, max - lo);
+  if (c > n && Array.isArray(a)) {
+    // a is a __reslice copy (only those have cap > len): reach past its
+    // length or capacity through the backing array, else stay on the copy
+    // (an explicit max needs a view: the copy itself keeps the old cap).
+    if (hi <= n && (mx === undefined || mx <= n)) return __mkview(a, lo, hi - lo, Math.min(max, n) - lo, mx !== undefined);
+    else { const e = __rcflush(a); return __mkview(e.b, e.o + lo, hi - lo, max - lo); }
+  }
+  if (ArrayBuffer.isView(a)) {
+    const r = hi <= n ? a.subarray(lo, hi) : new a.constructor(a.buffer, a.byteOffset + lo * a.BYTES_PER_ELEMENT, hi - lo);
+    if (max - lo > hi - lo) __tcap.set(r, max - lo);
+    return r;
+  }
+  return __mkview(a, lo, hi - lo, max - lo);
+};
+var __reslice = __reslice || function(a, lo, hi) {
+  if (Array.isArray(a) && a[__sv] === undefined) {
+    const n = a.length;
+    if (hi === undefined) hi = n;
+    if (lo >= 0 && lo <= hi && hi <= n) {
+      if (lo === 0 && hi === n) return a;
+      const e = a[__rcap];
+      const r = a.slice(lo, hi);
+      if (e === undefined) {
+        __rcdef(r, { b: a, o: lo, c: n - lo, s: a.slice(lo, hi), so: 0 });
+        return r;
+      }
+      // A copy of a copy: write back the changed elements it drops and share
+      // the snapshot (copied on write, __rcown), so a pop costs no more than
+      // the copy itself.
+      if (lo > 0) __rcput(e, a, 0, lo);
+      __rcput(e, a, hi, n);
+      e.own = false;
+      __rcdef(r, { b: e.b, o: e.o + lo, c: e.c - lo, s: e.s, so: e.so + lo, own: false });
+      return r;
+    }
   }
-  return a ? [...a, ...b] : b;
+  return __slice(a, lo, hi);
+};
+var __mkslice = __mkslice || function(n, b) {
+  if (!(n >= 0 && n <= b.length)) throw new Error("runtime error: makeslice: cap out of range");
+  return __slice(b, 0, n);
 };`;
 
-export const HELPER_S = "var __s = __s || function(a) { return a || []; };";
+// `make([]T, n, cap)` argument checks with Go's messages: a negative length is
+// a len panic, a negative capacity (or one below the length) a cap panic.
+export const HELPER_MKLEN = `var __mkn = __mkn || function(n) {
+  if (!(n >= 0)) throw new Error("runtime error: makeslice: len out of range");
+  return n;
+};
+var __mkc = __mkc || function(c) {
+  if (!(c >= 0)) throw new Error("runtime error: makeslice: cap out of range");
+  return c;
+};`;
 
-// In-place stable sort driven by Go's less(i, j) index comparator. The
-// comparator reads the live slice, so elements are moved as it runs
-// (binary insertion: O(n log n) compares, O(n^2) moves, fine for typed arrays).
-export const HELPER_SORT_SLICE = `var __sortSlice = __sortSlice || function(s, less) {
-  if (!s) return;
-  for (let i = 1; i < s.length; i++) {
-    let lo = 0, hi = i;
-    while (lo < hi) { const mid = (lo + hi) >>> 1; if (less(i, mid)) hi = mid; else lo = mid + 1; }
-    if (lo === i) continue;
-    const v = s[i];
-    for (let k = i; k > lo; k--) s[k] = s[k - 1];
-    s[lo] = v;
+// string(rune): an out-of-range rune or a surrogate is U+FFFD.
+export const HELPER_RUNESTR = `var __rstr = __rstr || function(c) {
+  return String.fromCodePoint(c >= 0 && c <= 0x10ffff && !(c >= 0xd800 && c <= 0xdfff) ? c : 0xfffd);
+};`;
+
+export const HELPER_APPEND = `var __tn = __tn || function(c) {
+  return Object.hasOwn(c, "__tnil") ? c.__tnil : Object.defineProperty(c, "__tnil", { value: Object.defineProperty(new c(0), "__nilt", { value: true }) }).__tnil;
+};
+// Append the elements of the array-like b to a typed array.
+var __tapp = __tapp || function(a, b) {
+  const c = __tcap.get(a);
+  if (c !== undefined && a.length + b.length <= c) {
+    const r = new a.constructor(a.buffer, a.byteOffset, a.length + b.length);
+    r.set(b, a.length);
+    if (c > r.length) __tcap.set(r, c);
+    return r;
+  }
+  // Grow with spare capacity so repeated appends cost O(1) amortized.
+  const n = a.length + b.length;
+  const cap = Math.max(n, a.length * 2);
+  const res = new a.constructor(new a.constructor(cap).buffer, 0, n);
+  res.set(a);
+  res.set(b, a.length);
+  __tcap.set(res, cap);
+  return res;
+};
+var __append = __append || function(a, ...b) {
+  if (b.length === 0) return a !== null && a !== undefined && a.__nilt === true ? null : a;
+  if (a && ArrayBuffer.isView(a)) return __tapp(a, b);
+  const s = a ? a[__sv] : undefined;
+  if (s !== undefined && s.n + b.length <= s.c) {
+    for (let i = 0; i < b.length; i++) s.b[s.o + s.n + i] = b[i];
+    return __mkview(s.b, s.o, s.n + b.length, s.c);
+  }
+  if (s === undefined && a) {
+    const e = a[__rcap];
+    if (e !== undefined && a.length + b.length <= e.c) {
+      __rcflush(a);
+      for (let i = 0; i < b.length; i++) e.b[e.o + a.length + i] = b[i];
+      return __mkview(e.b, e.o, a.length + b.length, e.c);
+    }
   }
+  return a ? [...a, ...b] : b;
+};
+// append(a, b...) of a typed array with one source: no argument spread.
+var __appendv = __appendv || function(a, b) {
+  if (b.length === 0) return a !== null && a !== undefined && a.__nilt === true ? null : a;
+  return __tapp(a, b);
 };`;
 
+// `s = append(s, x)` in the json codecs, where the slice is a local that no
+// other slice shares: a plain array grows in place.  A view with spare
+// capacity, a reslice copy or a typed array takes the general __append.
+export const HELPER_PUSHS =
+	"var __pushs = __pushs || function(a, x) { if (a == null) return [x]; if (!Array.isArray(a) || a[__sv] !== undefined || a[__rcap] !== undefined) return __append(a, x); a.push(x); return a; };";
+
+export const HELPER_S = "var __s = __s || function(a) { return a || []; };";
+
 // Copy of a struct value whose class is not statically known.
 export const HELPER_SCLONE = `var __sclone = __sclone || function(x) {
   if (x === null || typeof x !== "object") return x;
@@ -41,11 +296,46 @@ export const HELPER_SCLONE = `var __sclone = __sclone || function(x) {
   return Object.assign(Object.create(Object.getPrototypeOf(x)), x);
 };`;
 
+// Variadic prologue.  `f(xs...)` to a Go-compiled variadic function passes
+// `{ __sp: xs }`, so the parameter is the caller's slice itself (or nil).
+export const HELPER_VA = `var __va = __va || function(a, nilEmpty) {
+  const f = a.length === 1 ? a[0] : undefined;
+  if (a.length === 0 && nilEmpty) return null;
+  return f !== null && typeof f === "object" && f.__sp !== undefined ? f.__sp : a;
+};`;
+
+// Copy of a value whose type is a type parameter.  `z` is the argument's
+// zero-value factory: an object zero means a struct or array (copied by
+// value); anything else (scalars, pointers, interfaces) is returned as is.
+export const HELPER_VCLONE = `var __vclone = __vclone || function __vclone(z, x) {
+  if (x === null || typeof x !== "object") return x;
+  const zero = z?.();
+  if (zero === null || zero === undefined || typeof zero !== "object") return x;
+  const cp = (v) => {
+    if (v === null || typeof v !== "object") return v;
+    if (Array.isArray(v)) return v.map(cp);
+    if (typeof v.__clone === "function") return v.__clone();
+    return Object.assign(Object.create(Object.getPrototypeOf(v)), v);
+  };
+  return cp(x);
+};`;
+
+// == on type-parameter operands: structs and arrays compare by value, other
+// type arguments with ===.  Decided at run time from the zero-value factory.
+export const HELPER_GEQ = `var __geq = __geq || function(z, a, b) {
+  if (a === b) return true;
+  if (z?.k === "iface") return __ifeq(a, b);
+  if (a === null || b === null || typeof a !== "object" || typeof b !== "object") return false;
+  const zero = z?.();
+  if (zero === null || zero === undefined || typeof zero !== "object") return false;
+  return __equal(a, b);
+};`;
+
 // Interface boxing: tag struct values (__v) vs struct pointers (__p) so type
 // switches can tell T from *T; tags are non-enumerable so __equal/JSON ignore them.
-export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x, ptrFields) {
+export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x, ptrFields, fresh) {
   if (x === null || typeof x !== "object") return x;
-  const c = typeof x.__clone === "function" ? x.__clone() : Object.assign(Object.create(Object.getPrototypeOf(x)), x);
+  const c = fresh === true ? x : typeof x.__clone === "function" ? x.__clone() : Object.assign(Object.create(Object.getPrototypeOf(x)), x);
   Object.defineProperty(c, "__v", { value: true, configurable: true });
   if (Array.isArray(ptrFields)) {
     for (const f of ptrFields) {
@@ -60,10 +350,11 @@ export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x, ptrFields) {
       }
     }
   }
-  for (const k of Object.keys(c)) {
-    if (c[k] !== null && typeof c[k] === "object" && !Array.isArray(c[k]) && !ArrayBuffer.isView(c[k])) {
-      if (!c[k].__v && !c[k].__p && (!Array.isArray(ptrFields) || !ptrFields.includes(k))) {
-        Object.defineProperty(c[k], "__v", { value: true, configurable: true });
+  for (const k in c) {
+    const v = c[k];
+    if (v !== null && typeof v === "object" && !Array.isArray(v) && !ArrayBuffer.isView(v)) {
+      if (!v.__v && !v.__p && Object.isExtensible(v) && (!Array.isArray(ptrFields) || !ptrFields.includes(k))) {
+        Object.defineProperty(v, "__v", { value: true, configurable: true });
       }
     }
   }
@@ -72,7 +363,7 @@ export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x, ptrFields) {
 var __ifp = __ifp || function(x, ptrFields, seen) {
   if (x === null || typeof x !== "object") return x;
   if (x.__p !== true && Object.isExtensible(x))
-    Object.defineProperty(x, "__p", { value: true, configurable: true });
+    Object.defineProperty(x, "__p", { value: true, configurable: true, writable: true });
   if (Array.isArray(ptrFields)) {
     seen = seen || new Set();
     if (seen.has(x)) return x;
@@ -91,6 +382,31 @@ var __ifp = __ifp || function(x, ptrFields, seen) {
   }
   return x;
 };
+var __mknil = __mknil || function(C) {
+  const s = Object.create(C.prototype);
+  Object.defineProperty(s, "__nilp", { value: true });
+  Object.defineProperty(s, "__p", { value: true });
+  const vm = C.__vm || [];
+  for (const k of Object.getOwnPropertyNames(C.prototype)) {
+    const f = C.prototype[k];
+    if (k === "constructor" || k === "toString" || k.startsWith("__") || typeof f !== "function") continue;
+    Object.defineProperty(s, k, { value: vm.includes(k)
+      ? function() { throw new Error("runtime error: invalid memory address or nil pointer dereference"); }
+      : function(...a) { return f.apply(null, a); } });
+  }
+  Object.defineProperty(C, "__nil", { value: s });
+  return s;
+};
+var __ifn = __ifn || function(x, C) {
+  return x === null ? (Object.hasOwn(C, "__nil") ? C.__nil : __mknil(C)) : x;
+};
+var __pbs = __pbs || function(p) {
+  var e = p !== null && typeof p === "object" ? p.value : undefined;
+  return e !== null && typeof e === "object" && e.value === e ? e : p;
+};
+var __unnil = __unnil || function(x) {
+  return x != null && x.__nilp === true ? null : x;
+};
 var __ifm = __ifm || function(x) {
   if (x === null || x === undefined) return x;
   if (typeof x !== "object") return x;
@@ -122,29 +438,411 @@ var __ifps = __ifps || function(x) {
     Object.defineProperty(x, "__ptr_slice", { value: true, configurable: true });
   }
   return x;
+};
+var __ity = __ity || function(x, t, ptr) {
+  // The frozen nil map cannot carry a tag: a copy of it keeps its map type.
+  if (x !== null && x !== undefined && x.__nilm === true && x.__t === undefined)
+    return Object.freeze(Object.defineProperties({}, { __map: { value: true }, __nilm: { value: true }, __t: { value: t } }));
+  if (x === null || x === undefined) {
+    // A nil slice keeps its type as an empty tagged array (not a nil interface).
+    if (!ptr && t.charCodeAt(0) !== 91) return x;
+    const n = ptr ? {} : [];
+    if (!ptr) Object.defineProperty(n, "__nils", { value: true });
+    Object.defineProperty(n, "__nilp", { value: true });
+    Object.defineProperty(n, "__t", { value: t });
+    return n;
+  }
+  if ((typeof x === "object" || typeof x === "function") && Object.isExtensible(x))
+    Object.defineProperty(x, "__t", { value: t, configurable: true, writable: true });
+  return x;
+};
+var __isty = __isty || function(v, t, k, c, n) {
+  if (v === null || v === undefined || (typeof v !== "object" && typeof v !== "function")) return false;
+  if (k === "func") return typeof v === "function" && (v.__t === undefined || t === "" || v.__t === t);
+  if (v.__t !== undefined && t !== "") return v.__t === t;
+  if (v.__nilp === true) return false;
+  if (k === "named" || k === "struct") return false;
+  if (k === "ptr") {
+    if (!(typeof v === "object" && "value" in v && v.value !== v && typeof v.__gfUnbox !== "function" && !(v instanceof Array))) return false;
+    // An untagged pointer (to a type parameter's variable): the pointee's
+    // shape picks the pointer type; a nil slice or map is decoded as an any.
+    if (t.charCodeAt(0) === 42) {
+      var pt = t.slice(1), pe = v.value;
+      if (pe === null || pe === undefined) return pt === "interface {}";
+      if (typeof pe === "number") return pt === "float64";
+      if (typeof pe === "string") return pt === "string";
+      if (typeof pe === "boolean") return pt === "bool";
+      if (typeof pe === "bigint") return pt === "int64";
+      if (ArrayBuffer.isView(pe)) return pt.startsWith("[]");
+      if (typeof pe === "object" && !Array.isArray(pe)) return pt === "interface {}";
+    }
+    return true;
+  }
+  if (k === "map") return typeof v === "object" && (v.__map === true || Object.getPrototypeOf(v) === Object.prototype);
+  if (k === "array") return Array.isArray(v) && v.length === n;
+  if (c) return v instanceof c;
+  if (!Array.isArray(v)) return false;
+  // An untagged array (a value of a type parameter's type): its first element
+  // must at least have the shape of the tag's element type.
+  if (k === "slice" && v.length > 0 && t.startsWith("[]")) {
+    var x = t.slice(2), e = v[0];
+    if (x === "bool") return typeof e === "boolean";
+    if (x === "string") return typeof e === "string";
+    if (x === "int64" || x === "uint64") return typeof e === "bigint";
+    if (/^(u?int(8|16|32)?|uintptr|float(32|64))$/.test(x)) return typeof e === "number";
+  }
+  return true;
+};
+var __dtn = __dtn || function(v) {
+  if (v === null || v === undefined) return "nil";
+  switch (typeof v) {
+    case "string": return "string";
+    case "boolean": return "bool";
+    case "number": return Number.isInteger(v) ? "int" : "float64";
+    case "bigint": return "int64";
+  }
+  if (v.__t !== undefined) return v.__t;
+  if (Array.isArray(v)) return "[]interface {}";
+  const c = v.constructor;
+  if (c && c !== Object && typeof c.name === "string" && c.name !== "") {
+    const ptr = c.name.endsWith("$Ptr");
+    const n = ptr ? c.name.slice(0, -4) : c.name;
+    const i = n.indexOf("$$");
+    const q = i < 0 ? "main." + n : n.slice(i + 2) + "." + n.slice(0, i);
+    return (ptr || v.__v !== true && typeof v.__gfUnbox !== "function" ? "*" : "") + q;
+  }
+  return typeof v === "function" ? "func()" : "map[string]interface {}";
+};
+var __tafail = __tafail || function(src, v, target, methods) {
+  if (methods) {
+    if (v === null || v === undefined) return new Error("interface conversion: interface is nil, not " + target);
+    const m = methods.find((n) => typeof v[n] !== "function") ?? methods[0];
+    return new Error("interface conversion: " + __dtn(v) + " is not " + target + ": missing method " + m);
+  }
+  return new Error("interface conversion: " + src + " is " + __dtn(v) + ", not " + target);
 };`;
 
 // Nil-interface method call guard (strict mode only): matches Go's panic
 // message instead of a JS TypeError.
+// 64-bit shifts: count is converted to BigInt; negative count panics;
+// wraps with BigInt.asIntN / BigInt.asUintN.
+export const HELPER_SHIFT = `var __shc = __shc || function(n) {
+  if (n < 0) throw new Error("runtime error: negative shift amount");
+  return n;
+};
+var __shl64 = __shl64 || function(x, n, u) {
+  var b = BigInt(n);
+  if (b < 0n) throw new Error("runtime error: negative shift amount");
+  if (typeof x === "bigint") {
+    if (b >= 64n) return 0n;
+    var bx = u ? BigInt.asUintN(64, x) : BigInt.asIntN(64, x);
+    var r = bx << b;
+    return u ? BigInt.asUintN(64, r) : BigInt.asIntN(64, r);
+  }
+  if (b >= 64n) return 0;
+  var nb = Number(b);
+  var r = x * 2 ** nb;
+  if (Number.isSafeInteger(r)) return r;
+  var bxx = BigInt(Math.trunc(x)) << b;
+  return Number(u ? BigInt.asUintN(64, bxx) : BigInt.asIntN(64, bxx));
+};
+var __shr64 = __shr64 || function(x, n, u) {
+  var b = BigInt(n);
+  if (b < 0n) throw new Error("runtime error: negative shift amount");
+  if (typeof x === "bigint") {
+    var bx = u ? BigInt.asUintN(64, x) : BigInt.asIntN(64, x);
+    if (b >= 64n) return u || bx >= 0n ? 0n : -1n;
+    var r = bx >> b;
+    return u ? BigInt.asUintN(64, r) : BigInt.asIntN(64, r);
+  }
+  if (b >= 64n) return u || x >= 0 ? 0 : -1;
+  return Math.floor(x / 2 ** Number(b));
+};`;
+
+export const HELPER_TO64 = `var __to_i64 = __to_i64 || function(v) {
+  if (typeof v === "bigint") return BigInt.asIntN(64, v);
+  return Number.isFinite(v) ? BigInt.asIntN(64, BigInt(Math.trunc(v))) : -9223372036854775808n;
+};
+var __to_u64 = __to_u64 || function(v) {
+  if (typeof v === "bigint") return BigInt.asUintN(64, v);
+  return Number.isFinite(v) ? BigInt.asUintN(64, BigInt(Math.trunc(v))) : 9223372036854775808n;
+};`;
+
 export const HELPER_NIL_CALL = `var __nilcall = __nilcall || function(x) {
   if (x == null) throw new Error("runtime error: invalid memory address or nil pointer dereference");
   return x;
 };`;
 
+// Strict-mode index checks (`both` packages): Go's out-of-range panic for
+// slices, arrays and strings.  `__at` reads an element; `__ix` returns the
+// checked index for writes, compound assignments and string reads.  A nil
+// slice (`null`) has length 0.
+export const HELPER_BOUNDS = `var __ixerr = __ixerr || function(i, n) {
+  throw new Error(i < 0 ? "runtime error: index out of range [" + i + "]" : "runtime error: index out of range [" + i + "] with length " + n);
+};
+var __at = __at || function(a, i) {
+  if (a != null && i >= 0 && i < a.length) return a[i];
+  return __ixerr(i, a == null ? 0 : a.length);
+};
+var __ix = __ix || function(a, i) {
+  if (a != null && i >= 0 && i < a.length) return i;
+  return __ixerr(i, a == null ? 0 : a.length);
+};
+var __lv;`;
+
+// Generic zero values (generics are erased in JS): a generic function takes
+// one zero-value factory per type parameter as leading arguments, and an
+// instance of a generic struct keeps its factories under the `__tz` symbol
+// (a symbol, so field iteration, equality and JSON never see it).  Shared
+// factories for the common zero values avoid a closure per call.
+export const HELPER_GENERICS = `var __tz = __tz || Symbol.for("gofront.typeArgs");
+var __zn = __zn || (() => null);
+var __z0 = __z0 || (() => 0);
+var __zs = __zs || (() => "");
+var __zf = __zf || (() => false);
+var __z64 = __z64 || Object.assign(() => 0n, { k: "int64" });
+var __zu64 = __zu64 || Object.assign(() => 0n, { k: "uint64" });
+var __tbox = __tbox || function(f, x) {
+  return f && f.b ? f.b(x) : x;
+};
+var __ti = __ti || function(f, k, id, is, u, b, fb) {
+  const g = () => f();
+  g.k = k; g.id = id; g.is = is; g.u = u; g.b = b; g.fb = fb;
+  return g;
+};
+var __tar = __tar || function(f, op, a, b) {
+  const k = f?.k;
+  const dz = () => { throw new Error("runtime error: integer divide by zero"); };
+  const ns = () => { throw new Error("runtime error: negative shift amount"); };
+  if (typeof a === "bigint") {
+    const sh = op === "<<" || op === ">>";
+    if (sh) { b = Number(b); if (b < 0) ns(); }
+    else if (typeof b !== "bigint") b = BigInt(b);
+    const w = k === "uint64" ? (v) => BigInt.asUintN(64, v) : (v) => BigInt.asIntN(64, v);
+    switch (op) {
+      case "+": return w(a + b);
+      case "-": return w(a - b);
+      case "*": return w(a * b);
+      case "/": return b === 0n ? dz() : w(a / b);
+      case "%": return b === 0n ? dz() : w(a % b);
+      case "&": return w(a & b);
+      case "|": return w(a | b);
+      case "^": return w(a ^ b);
+      case "&^": return w(a & ~b);
+      case "<<": return b >= 64 ? 0n : w(a << BigInt(b));
+      default: return b >= 64 ? (k === "uint64" || a >= 0n ? 0n : -1n) : w(a >> BigInt(b));
+    }
+  }
+  let bits = 0, signed = true;
+  switch (k) {
+    case "int8": bits = 8; break;
+    case "int16": bits = 16; break;
+    case "int32": case "rune": bits = 32; break;
+    case "uint8": case "byte": bits = 8; signed = false; break;
+    case "uint16": bits = 16; signed = false; break;
+    case "uint32": bits = 32; signed = false; break;
+  }
+  const w = bits === 0 ? (v) => v
+    : bits === 32 ? (signed ? (v) => v | 0 : (v) => v >>> 0)
+    : signed ? (v) => (v << (32 - bits)) >> (32 - bits)
+    : (v) => v & ((1 << bits) - 1);
+  const int = bits !== 0 || k === "int" || k === "uint" || k === "uintptr";
+  switch (op) {
+    case "+": return k === "float32" ? Math.fround(a + b) : w(a + b);
+    case "-": return k === "float32" ? Math.fround(a - b) : w(a - b);
+    case "*": return k === "float32" ? Math.fround(a * b) : bits === 0 ? a * b : w(Math.imul(a, b));
+    case "/": return int ? (b === 0 ? dz() : w(Math.trunc(a / b))) : k === "float32" ? Math.fround(a / b) : a / b;
+    case "%": return int && b === 0 ? dz() : w(a % b);
+    case "&": return bits === 0 ? a & b : w(a & b);
+    case "|": return bits === 0 ? a | b : w(a | b);
+    case "^": return bits === 0 ? a ^ b : w(a ^ b);
+    case "&^": return bits === 0 ? a & ~b : w(a & ~b);
+  }
+  b = Number(b);
+  if (b < 0) ns();
+  if (bits === 0) return op === "<<" ? a << b : a >> b;
+  if (b >= bits) return op === ">>" && signed && a < 0 ? -1 : 0;
+  return op === "<<" ? w(a << b) : signed ? a >> b : a >>> b;
+};
+var __tid = __tid || function(...ids) {
+  return ids.every((i) => i !== undefined) ? ids.join(",") : undefined;
+};
+var __tconv = __tconv || function(f, v) {
+  switch (f?.k) {
+    case "int64": return typeof v === "bigint" ? BigInt.asIntN(64, v) : (typeof v === "number" ? BigInt.asIntN(64, BigInt(Math.trunc(v))) : v);
+    case "uint64": return typeof v === "bigint" ? BigInt.asUintN(64, v) : (typeof v === "number" ? BigInt.asUintN(64, BigInt(Math.trunc(v))) : v);
+    case "int": case "uint": case "uintptr": return Math.trunc(Number(typeof v === "bigint" ? Number(v) : v));
+    case "int8": return (Number(typeof v === "bigint" ? Number(v) : v) << 24) >> 24;
+    case "int16": return (Number(typeof v === "bigint" ? Number(v) : v) << 16) >> 16;
+    case "int32": case "rune": return Number(typeof v === "bigint" ? Number(v) : v) | 0;
+    case "uint8": case "byte": return Number(typeof v === "bigint" ? Number(v) : v) & 0xFF;
+    case "uint16": return Number(typeof v === "bigint" ? Number(v) : v) & 0xFFFF;
+    case "uint32": return Number(typeof v === "bigint" ? Number(v) : v) >>> 0;
+    case "float32": return Math.fround(Number(typeof v === "bigint" ? Number(v) : v));
+    case "float64": return Number(typeof v === "bigint" ? Number(v) : v);
+    default: return typeof v === "number" && f && (f() === 0n || typeof f() === "bigint") ? BigInt(v) : v;
+  }
+};`;
+
+// Strict-mode nil maps: the zero value of a map type is one frozen empty
+// object, so reads, `len` and `range` behave as on an empty map, and every
+// write goes through `__mw`, which panics with Go's message.
+export const HELPER_NIL_MAP = `var __nilmap = __nilmap || Object.freeze(Object.defineProperties({}, { __map: { value: true }, __nilm: { value: true } }));
+var __mw = __mw || function(m) {
+  if (m == null || m.__nilm === true) throw new Error("assignment to entry in nil map");
+  return m;
+};
+var __isnm = __isnm || function(m) {
+  return m == null || m.__nilm === true || (m.__nm === true && Object.keys(m).length === 0);
+};`;
+
+// js-package nil maps: the zero value is a fresh `{}` carrying a hidden tag;
+// `m == nil` holds while it stays empty (writes are allowed, as in plain JS).
+export const HELPER_NM = `var __nm = __nm || function() { return Object.defineProperty({}, "__nm", { value: true }); };
+var __isnm = __isnm || function(m) {
+  return m == null || m.__nilm === true || (m.__nm === true && Object.keys(m).length === 0);
+};`;
+
+// Struct map keys: a JS object key is a string, so a struct key is coerced
+// through `toString` to an injective encoding, and the key value is kept in
+// a table so ranging and fmt can recover it.
+export const HELPER_STRUCT_KEY = `var __kt = __kt || new Map();
+var __kcl = __kcl || function(o) {
+  if (o === null || typeof o !== "object") return o;
+  if (typeof o.__clone === "function") return o.__clone();
+  if (ArrayBuffer.isView(o)) return o.slice();
+  if (Array.isArray(o)) return o.map(__kcl);
+  const c = Object.create(Object.getPrototypeOf(o));
+  for (const f of Object.keys(o)) c[f] = __kcl(o[f]);
+  return c;
+};
+var __sk = __sk || function(o) {
+  const s = "\\u0001" + JSON.stringify(o, (k, v) => typeof v === "bigint" ? v.toString() + "n" : typeof v === "number" && !Number.isFinite(v) ? { $f: String(v) } : v);
+  if (!__kt.has(s)) __kt.set(s, __kcl(o));
+  return s;
+};
+// Pointer keys compare by identity: a per-object id (a pointer to an element
+// is its container plus index) keys the property, and the pointer is kept
+// in the table so ranging and fmt can recover it.
+var __pids = __pids || new WeakMap();
+var __pidn = __pidn || { n: 0 };
+var __pid = __pid || function(o) {
+  let id = __pids.get(o);
+  if (id === undefined) __pids.set(o, id = ++__pidn.n);
+  return id;
+};
+var __pk = __pk || function(p) {
+  if (p === null || p === undefined) return "\\u0001nil";
+  const s = "\\u0001*" + (p.__target !== undefined && p.__target !== null ? __pid(p.__target) + ":" + p.__index : __pid(p));
+  if (!__kt.has(s)) __kt.set(s, p);
+  return s;
+};
+var __ik = __ik || function(k, tag) {
+  const t = typeof k;
+  if (k === null || k === undefined) return "\\u0001nil";
+  if (tag !== undefined) {
+    if (tag === "*") return __pk(k);
+    if (tag.charCodeAt(0) === 33) throw new Error("runtime error: hash of unhashable type " + tag.slice(1));
+    if (t === "number" || t === "bigint") {
+      const s = "\\u0001" + tag + ":" + String(k);
+      if (!__kt.has(s)) __kt.set(s, k);
+      return s;
+    }
+  }
+  if (t === "number" || t === "boolean" || t === "bigint") return "\\u0001" + t + ":" + String(k);
+  // A slice, map or func in an \`any\` carries its type tag: Go cannot hash it.
+  if ((t === "object" || t === "function") && typeof k.__t === "string" && /^(\\[\\]|map\\[|func\\()/.test(k.__t))
+    throw new Error("runtime error: hash of unhashable type " + k.__t.replace(/ void$/, ""));
+  if (k !== null && t === "object" && typeof k.__gfUnbox === "function" && !k.constructor.name.endsWith("$Ptr")) {
+    const v = k.__gfUnbox(), vt = typeof v;
+    if (vt === "string" || vt === "number" || vt === "boolean" || vt === "bigint") {
+      const s = "\\u0001" + k.constructor.name + ":" + vt + ":" + String(v);
+      if (!__kt.has(s)) __kt.set(s, k);
+      return s;
+    }
+  }
+  return k;
+};
+// A key typed by a type parameter whose factory is \`f\`: interface type
+// arguments key by dynamic type; \`box\` (an \`any\`-keyed map) boxes a named
+// basic value first, other keys are left as they are.
+var __ikt = __ikt || function(f, k, box) {
+  if (f?.k === "iface") return __ik(k);
+  return box ? __ik(f?.b ? f.b(k) : k) : k;
+};
+var __kd = __kd || function(s, copy) {
+  if (typeof s !== "string" || s.charCodeAt(0) !== 1) return s;
+  const k = __kt.get(s);
+  if (s === "\\u0001nil") return null;
+  if (k !== undefined && s.charCodeAt(1) === 42) return k;
+  if (k === undefined) {
+    if (s.startsWith("\\u0001number:")) return Number(s.slice(8));
+    if (s.startsWith("\\u0001boolean:")) return s.slice(9) === "true";
+    if (s.startsWith("\\u0001bigint:")) return BigInt(s.slice(8));
+    return s;
+  }
+  return copy ? __kcl(k) : k;
+};
+var __kdt = __kdt || function(f, s) {
+  if (typeof s !== "string") return s;
+  const z = f?.();
+  switch (typeof z) {
+    case "number": return Number(s);
+    case "bigint": return BigInt(s);
+    case "boolean": return s === "true";
+    case "string": return s;
+    default: return __kd(s, true);
+  }
+};
+// Interface keys of different dynamic types sort by type first: nil, named
+// types, strings, bools, numbers.
+var __krank = __krank || function(v) {
+  if (v === null || v === undefined) return 0;
+  const t = typeof v;
+  if (t === "object" && typeof v.__gfUnbox === "function") return 1;
+  return t === "string" ? 2 : t === "boolean" ? 3 : t === "number" || t === "bigint" ? 4 : 5;
+};
+var __kcmp = __kcmp || function(a, b) {
+  const ra = __krank(a), rb = __krank(b);
+  if (ra !== rb) return ra - rb;
+  if (ra === 1) {
+    const na = a.constructor.name, nb = b.constructor.name;
+    if (na !== nb) return na < nb ? -1 : 1;
+    a = a.__gfUnbox();
+    b = b.__gfUnbox();
+  }
+  if (a !== null && b !== null && typeof a === "object" && typeof b === "object") {
+    for (const f of Object.keys(a)) {
+      const c = __kcmp(a[f], b[f]);
+      if (c !== 0) return c;
+    }
+    return 0;
+  }
+  return a < b ? -1 : a > b ? 1 : 0;
+};`;
+
 // Interface equality: named non-struct values are boxed in interfaces, so two
 // boxes are equal when they share a type and hold the same value (as in Go).
 export const HELPER_IFEQ = `var __ifeq = __ifeq || function(a, b) {
   if (a === b) return true;
   if (a === null || a === undefined || b === null || b === undefined) return a == null && b == null;
+  if (a.__nilp === true && b.__nilp === true && a.__t !== undefined) return a.__t === b.__t;
   if (typeof a === "object" && typeof b === "object" && a.constructor === b.constructor && typeof a.__gfUnbox === "function") {
     return a.__gfUnbox() === b.__gfUnbox();
   }
+  // Struct values boxed by __ifv compare field by field.
+  if (typeof a === "object" && typeof b === "object" && a.__v === true && b.__v === true && a.constructor === b.constructor) {
+    return __equal(a, b);
+  }
   return false;
 };`;
 
 export const HELPER_EQUAL = `var __equal = __equal || function __equal(a, b) {
-  if (a === b) return true;
+  if (a === b && !Array.isArray(a)) return true;
   if (a === null || b === null) return false;
+  if (a.__target !== undefined && b.__target !== undefined) {
+    return a.__target === b.__target && a.__index === b.__index;
+  }
   if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
   if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
     if (a.byteLength !== b.byteLength || a.length !== b.length) return false;
@@ -174,10 +872,22 @@ export const HELPER_CDIV = `var __cdiv = __cdiv || function(a, b) {
   return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d };
 };`;
 
-// Panic/defer runtime.  \`stack\` holds the in-flight panic of every frame
-// currently running its defers; \`armed\` is set right before a deferred
+export const HELPER_PTREQ = `var __ptreq = __ptreq || function __ptreq(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.__target !== undefined && b.__target !== undefined) {
+    return a.__target === b.__target && a.__index === b.__index;
+  }
+  return false;
+};`;
+
+// Panic/defer runtime.  `stack` holds the in-flight panic of every frame
+// currently running its defers; `armed` is set right before a deferred
 // function is invoked and consumed by that function's prologue, so recover()
 // only takes effect when called directly by the deferred function (Go spec).
+// panic(v): a string panics with that message; any other value is kept in
+// the thrown error's pv field so recover() returns it unchanged (an error's
+// message is its Error()).
 export const HELPER_PANIC = `var __gopanic = __gopanic || { stack: [], armed: false };
 var __runDefers = __runDefers || function(defers, frame) {
   for (let i = defers.length - 1; i >= 0; i--) {
@@ -194,664 +904,52 @@ var __runDefers = __runDefers || function(defers, frame) {
     if (!frame.pn.recovered) throw frame.pn.err;
   }
 };
+var __gopanicv = __gopanicv || function(v) {
+  if (typeof v === "string") {
+    // The value rides in pv so recover() returns the string itself, never a
+    // runtime error value, however the message reads.
+    const se = new Error(v);
+    se.pv = { v };
+    throw se;
+  }
+  let msg;
+  try { msg = typeof v?.Error === "function" ? v.Error() : String(v); } catch { msg = String(v); }
+  const e = new Error(msg);
+  e.pv = { v };
+  throw e;
+};
 var __recover = __recover || function(ok) {
   if (!ok) return null;
   const s = __gopanic.stack;
   const top = s.length > 0 ? s[s.length - 1] : null;
   if (top === null || top.recovered) return null;
   top.recovered = true;
-  return top.err?.message ?? String(top.err);
-};`;
-
-export const HELPER_SPRINTF = `var __sprintf = __sprintf || function(f, ...a) {
-  let i = 0;
-  const ptrMap = new WeakMap();
-  const ptrSet = new WeakSet();
-  let ptrCounter = 1;
-  const getPtr = (o) => {
-    let p = ptrMap.get(o);
-    if (!p) {
-      p = "0x" + (ptrCounter++).toString(16);
-      ptrMap.set(o, p);
-    }
-    return p;
-  };
-  const markPtr = (o) => {
-    if (o !== null && typeof o === "object") ptrSet.add(o);
-  };
-  const isPointer = (o) => {
-    return o !== null && typeof o === "object" && (o.__p === true || ptrSet.has(o));
-  };
-  const formatV = (val, isPlus, isTopLevel) => {
-    if (val === null || val === undefined) return "<nil>";
-    if (typeof val === "boolean") return String(val);
-    if (typeof val === "number" || typeof val === "bigint") return String(val);
-    if (typeof val === "string") return val;
-    if (typeof val === "object") {
-      if (val._d instanceof Date) {
-        return typeof __timeFmt === "function" ? __timeFmt(val, "2006-01-02 15:04:05.999999999 -0700 MST") : String(val._d);
-      }
-      if ("re" in val && "im" in val) {
-        const sign = val.im >= 0 ? "+" : "";
-        return "(" + val.re + sign + val.im + "i)";
-      }
-      if (typeof val.Error === "function") {
-        return String(val.Error());
-      }
-      if (typeof val.__gfUnbox === "function") return formatV(val.__gfUnbox(), isPlus, isTopLevel);
-      if (Array.isArray(val) || ArrayBuffer.isView(val)) {
-        const isElemPtr = val.__ptr_slice === true;
-        const pf = val.__ptr_fields;
-        const parts = [];
-        for (let j = 0; j < val.length; j++) {
-          const item = val[j];
-          if (isElemPtr && item !== null && typeof item === "object") {
-            markPtr(item);
-          } else if (Array.isArray(pf) && item !== null && typeof item === "object") {
-            for (const f of pf) {
-              if (f.indexOf(".") !== -1) {
-                const fparts = f.split(".");
-                let cur = item;
-                for (let k = 0; k < fparts.length - 1; k++) cur = cur?.[fparts[k]];
-                const last = fparts[fparts.length - 1];
-                if (cur?.[last] !== null && typeof cur?.[last] === "object") markPtr(cur[last]);
-              } else if (item[f] !== null && typeof item[f] === "object") {
-                markPtr(item[f]);
-              }
-            }
-          }
-          parts.push(formatV(item, isPlus, false));
-        }
-        return "[" + parts.join(" ") + "]";
-      }
-      if (val instanceof Map || val.__map === true) {
-        const isElemPtr = val.__ptr_map === true;
-        const parts = [];
-        if (val instanceof Map) {
-          const entries = Array.from(val.entries()).sort(([k1], [k2]) => {
-            if (typeof k1 === "number" && typeof k2 === "number") return k1 - k2;
-            const na = Number(k1), nb = Number(k2);
-            if (!Number.isNaN(na) && !Number.isNaN(nb)) return na - nb;
-            return String(k1).localeCompare(String(k2));
-          });
-          for (const [k, v] of entries) {
-            if (isElemPtr && v !== null && typeof v === "object") {
-              markPtr(v);
-            }
-            parts.push(formatV(k, isPlus, false) + ":" + formatV(v, isPlus, false));
-          }
-        } else {
-          const keys = Object.keys(val).sort((a, b) => {
-            const na = Number(a), nb = Number(b);
-            if (!Number.isNaN(na) && !Number.isNaN(nb)) return na - nb;
-            return a.localeCompare(b);
-          });
-          for (const k of keys) {
-            const v = val[k];
-            if (isElemPtr && v !== null && typeof v === "object") {
-              markPtr(v);
-            }
-            parts.push(formatV(k, isPlus, false) + ":" + formatV(v, isPlus, false));
-          }
-        }
-        return "map[" + parts.join(" ") + "]";
-      }
-      if ("value" in val && (val.__box === true || (!val.__struct && !("__v" in val) && Object.keys(val).length === 1 && (val.constructor === Object || !val.constructor || val.constructor?.name === "Object")))) {
-        return getPtr(val);
-      }
-      const isPtr = isPointer(val);
-      if (isPtr) {
-        if (!isTopLevel) {
-          return getPtr(val);
-        }
-        getPtr(val);
-      }
-      const prefix = isPtr ? "&{" : "{";
-      const keys = Object.keys(val);
-      const parts = [];
-      for (const k of keys) {
-        const fv = formatV(val[k], isPlus, false);
-        parts.push(isPlus ? k + ":" + fv : fv);
-      }
-      return prefix + parts.join(" ") + "}";
-    }
-    return String(val);
-  };
-  return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGwc%]/g, (m) => {
-    if (m === "%%") return "%";
-    const verb = m.slice(-1);
-    let v = a[i++];
-    // Boxed named values format as their underlying value; Error() still applies to %v/%s/%q/%w.
-    if (v && typeof v.__gfUnbox === "function" && !(typeof v.Error === "function" && "vsqw".includes(verb))) v = v.__gfUnbox();
-    const [, flags, width, prec] = m.match(/^%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)/) || [];
-    const zero = flags?.includes("0") && !flags?.includes("-");
-    const pad = (s, w, z) => {
-      w = parseInt(w) || 0;
-      if (!w) return s;
-      const p = (z ? "0" : " ").repeat(Math.max(0, w - s.length));
-      return flags.includes("-") ? s + p : p + s;
-    };
-    switch (verb) {
-      case "s": return pad(String(v == null ? "<nil>" : v), width, false);
-      case "c": return pad(String.fromCodePoint(Number(v)), width, false);
-      case "d": return pad(String(typeof v === "bigint" ? v : Math.trunc(Number(v))), width, zero);
-      case "v": {
-        const isPlus = flags?.includes("+") ?? false;
-        return pad(formatV(v, isPlus, true), width, false);
-      }
-      case "f": { const n = Number(v), p = prec !== "" ? parseInt(prec) : 6; return pad(n.toFixed(p), width, zero); }
-      case "t": return pad(String(!!v), width, false);
-      case "x": {
-        let hex;
-        if (Array.isArray(v) || ArrayBuffer.isView(v)) {
-          hex = Array.from(v).map((b) => (Number(b) & 0xff).toString(16).padStart(2, "0")).join("");
-        } else if (typeof v === "string") {
-          hex = Array.from(new TextEncoder().encode(v)).map((b) => b.toString(16).padStart(2, "0")).join("");
-        } else if (typeof v === "bigint") {
-          hex = BigInt.asUintN(64, v).toString(16);
-        } else if (Math.abs(Number(v)) > 0xffffffff) {
-          hex = (Math.trunc(Number(v) / 0x100000000) >>> 0).toString(16) + (Number(v) >>> 0).toString(16).padStart(8, "0");
-        } else {
-          hex = (Number(v) >>> 0).toString(16);
-        }
-        return pad(hex, width, zero);
-      }
-      case "X": {
-        let hex;
-        if (Array.isArray(v) || ArrayBuffer.isView(v)) {
-          hex = Array.from(v).map((b) => (Number(b) & 0xff).toString(16).padStart(2, "0").toUpperCase()).join("");
-        } else if (typeof v === "string") {
-          hex = Array.from(new TextEncoder().encode(v)).map((b) => b.toString(16).padStart(2, "0").toUpperCase()).join("");
-        } else if (typeof v === "bigint") {
-          hex = BigInt.asUintN(64, v).toString(16).toUpperCase();
-        } else if (Math.abs(Number(v)) > 0xffffffff) {
-          hex = (Math.trunc(Number(v) / 0x100000000) >>> 0).toString(16).toUpperCase() + (Number(v) >>> 0).toString(16).padStart(8, "0").toUpperCase();
-        } else {
-          hex = (Number(v) >>> 0).toString(16).toUpperCase();
-        }
-        return pad(hex, width, zero);
-      }
-      case "o": return pad((typeof v === "bigint" ? BigInt.asUintN(64, v).toString(8) : (Number(v) >>> 0).toString(8)), width, zero);
-      case "b": return pad((typeof v === "bigint" ? BigInt.asUintN(64, v).toString(2) : (Number(v) >>> 0).toString(2)), width, zero);
-      case "q": return pad('"' + String(v == null ? "" : v).replace(/\\\\/g, "\\\\\\\\").replace(/"/g, '\\\\"') + '"', width, false);
-      case "e": case "E": { const n = Number(v), p = prec !== "" ? parseInt(prec) : 6; return pad(n.toExponential(p), width, zero); }
-      case "g": case "G": { const n = Number(v); return pad(prec !== "" ? n.toPrecision(parseInt(prec)) : String(n), width, zero); }
-      case "w": return pad(String(v == null ? "<nil>" : typeof v === "object" && v.Error ? v.Error() : v), width, false);
-      default: return m;
-    }
-  });
+  const e = top.err;
+  if (e && e.pv) return e.pv.v;
+  // A JS TypeError from using null as a pointer is Go's nil dereference.
+  if (e && e.name === "TypeError" && /of null|undefined or null/.test(e.message))
+    return __error("runtime error: invalid memory address or nil pointer dereference");
+  const msg = e?.message ?? String(e);
+  // A Go runtime panic recovers as an error value (runtime.Error).
+  if (/^(runtime error: |assignment to entry in nil map$|interface conversion: )/.test(msg)) return __error(msg);
+  return msg;
 };`;
 
+// A runtime error value (\`fmt.Errorf\`, parse failures, io.EOF).  A wrapped
+// cause is exposed through \`Unwrap() error\`; an array of causes (several %w
+// verbs) through \`Unwrap() []error\`, tagged \`__multi\` so type assertions tell
+// the two apart.
 export const HELPER_ERROR = `var __error = __error || function(msg, cause) {
-  return { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null };
+  const e = { Error() { return msg; }, toString() { return msg; }, _msg: msg, _cause: cause ?? null };
+  if (Array.isArray(cause)) {
+    e.Unwrap = function() { return cause; };
+    e.Unwrap.__multi = true;
+  } else if (cause !== undefined && cause !== null) {
+    e.Unwrap = function() { return cause; };
+  }
+  return e;
 };`;
 
-export const HELPER_STRCONV_ERROR = `var __strconv_err_syntax = __strconv_err_syntax || __error("invalid syntax");
-var __strconv_err_range = __strconv_err_range || __error("value out of range");`;
-
-export const HELPER_PATH_ERROR = `var __path_err_bad_pattern = __path_err_bad_pattern || __error("syntax error in pattern");`;
-
-export const HELPER_IO_EOF = `var __io_eof = __io_eof || __error("EOF");`;
-
-export const HELPER_ERROR_IS = `var __errorIs = __errorIs || function __errorIs(err, target) {
-  if (err === null || err === undefined) return false;
-  if (err === target) return true;
-  if (typeof err === "object" && typeof target === "object" && target !== null &&
-      typeof err.__gfUnbox === "function" && err.constructor === target.constructor &&
-      err.__gfUnbox() === target.__gfUnbox()) return true;
-  if (typeof err === "object" && typeof target === "object" &&
-      err._msg !== undefined && target._msg !== undefined &&
-      err._msg === target._msg) return true;
-  if (typeof err.Is === "function" && err.Is(target)) return true;
-  if (Array.isArray(err._errs)) {
-    for (const sub of err._errs) {
-      if (__errorIs(sub, target)) return true;
-    }
-  }
-  if (typeof err.Unwrap === "function") {
-    const unwrapped = err.Unwrap();
-    if (Array.isArray(unwrapped)) {
-      for (const sub of unwrapped) {
-        if (__errorIs(sub, target)) return true;
-      }
-    } else if (unwrapped !== null && unwrapped !== undefined) {
-      if (__errorIs(unwrapped, target)) return true;
-    }
-  }
-  if (err._cause !== undefined && err._cause !== null) {
-    return __errorIs(err._cause, target);
-  }
-  return false;
-};`;
-
-export const HELPER_ERROR_AS = `var __errorAs = __errorAs || function(err, target, matcher, extract) {
-  if (err === null || err === undefined || target === null || typeof target !== "object") return false;
-  let cur = err;
-  while (cur !== null && cur !== undefined) {
-    const unboxed = cur?.value ?? cur;
-    if (typeof cur.As === "function" && cur.As(target)) return true;
-    if (matcher ? matcher(unboxed) : (unboxed !== err && typeof unboxed === "object" && !("_msg" in unboxed && "_cause" in unboxed))) {
-      if ("value" in target) {
-        target.value = extract ? extract(unboxed) : unboxed;
-      } else {
-        Object.assign(target, unboxed);
-      }
-      return true;
-    }
-    if (Array.isArray(cur._errs)) {
-      for (const sub of cur._errs) {
-        if (__errorAs(sub, target, matcher, extract)) return true;
-      }
-    }
-    if (typeof cur.Unwrap === "function") {
-      const unwrapped = cur.Unwrap();
-      if (Array.isArray(unwrapped)) {
-        for (const sub of unwrapped) {
-          if (__errorAs(sub, target, matcher, extract)) return true;
-        }
-      } else if (unwrapped !== null && unwrapped !== undefined) {
-        if (__errorAs(unwrapped, target, matcher, extract)) return true;
-      }
-    }
-    cur = cur?._cause ?? null;
-  }
-  return false;
-};`;
-
-export const HELPER_ERROR_JOIN = `var __errorJoin = __errorJoin || function(...errs) {
-  const filtered = [];
-  for (const e of errs) {
-    if (Array.isArray(e)) {
-      for (const sub of e) if (sub !== null && sub !== undefined) filtered.push(sub);
-    } else if (e !== null && e !== undefined) {
-      filtered.push(e);
-    }
-  }
-  if (filtered.length === 0) return null;
-  const msg = filtered.map(e => (typeof e === "object" && typeof e.Error === "function") ? e.Error() : String(e)).join("\\n");
-  const joined = __error(msg);
-  joined._errs = filtered;
-  joined.Unwrap = function() { return filtered; };
-  return joined;
-};`;
-
-// Go-semantics strconv parsers shared by the JS backend and the wasm runtime
-// imports (boundary.js), so both targets agree.  Each parser returns
-// [value, errorMessage | null]; integer values are BigInt (the wasm side
-// needs i64, the JS side converts with Number()).
-export const HELPER_STRCONV = `var __strconv_atoi = __strconv_atoi || function(s) {
-  if (!/^[+-]?[0-9]+$/.test(s)) return [0n, 'strconv.Atoi: parsing "' + s + '": invalid syntax'];
-  const v = BigInt(s);
-  if (v > 9223372036854775807n || v < -9223372036854775808n) {
-    return [v > 0n ? 9223372036854775807n : -9223372036854775808n, 'strconv.Atoi: parsing "' + s + '": value out of range'];
-  }
-  return [v, null];
-};
-var __strconv_parse_int = __strconv_parse_int || function(s, base, bits) {
-  let str = s, neg = false;
-  if (str[0] === "-" || str[0] === "+") { neg = str[0] === "-"; str = str.slice(1); }
-  if (base === 0) {
-    if (/^0[xX]/.test(str)) { base = 16; str = str.slice(2); }
-    else if (/^0[bB]/.test(str)) { base = 2; str = str.slice(2); }
-    else if (/^0[oO]/.test(str)) { base = 8; str = str.slice(2); }
-    else if (/^0[0-9]/.test(str)) { base = 8; str = str.slice(1); }
-    else base = 10;
-    str = str.replaceAll("_", "");
-  }
-  if (base < 2 || base > 36) return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid base ' + base];
-  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
-  if (str === "" || [...str.toLowerCase()].some((c) => !digits.includes(c))) {
-    return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid syntax'];
-  }
-  let v = 0n; const B = BigInt(base);
-  for (const c of str.toLowerCase()) v = v * B + BigInt(digits.indexOf(c));
-  if (neg) v = -v;
-  const w = bits === 0 ? 64 : bits;
-  const max = (1n << BigInt(w - 1)) - 1n, min = -(1n << BigInt(w - 1));
-  if (v > max || v < min) return [v > max ? max : min, 'strconv.ParseInt: parsing "' + s + '": value out of range'];
-  return [v, null];
-};
-var __strconv_parse_uint = __strconv_parse_uint || function(s, base, bits) {
-  let str = s;
-  if (str[0] === "+") { str = str.slice(1); }
-  if (str[0] === "-") {
-    return [0n, 'strconv.ParseUint: parsing "' + s + '": invalid syntax'];
-  }
-  if (base === 0) {
-    if (/^0[xX]/.test(str)) { base = 16; str = str.slice(2); }
-    else if (/^0[bB]/.test(str)) { base = 2; str = str.slice(2); }
-    else if (/^0[oO]/.test(str)) { base = 8; str = str.slice(2); }
-    else if (/^0[0-9]/.test(str)) { base = 8; str = str.slice(1); }
-    else base = 10;
-    str = str.replaceAll("_", "");
-  }
-  if (base < 2 || base > 36) return [0n, 'strconv.ParseUint: parsing "' + s + '": invalid base ' + base];
-  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
-  if (str === "" || [...str.toLowerCase()].some((c) => !digits.includes(c))) {
-    return [0n, 'strconv.ParseUint: parsing "' + s + '": invalid syntax'];
-  }
-  let v = 0n; const B = BigInt(base);
-  for (const c of str.toLowerCase()) v = v * B + BigInt(digits.indexOf(c));
-  const w = bits === 0 ? 64 : bits;
-  const max = w >= 64 ? 18446744073709551615n : (1n << BigInt(w)) - 1n;
-  if (v > max) return [max, 'strconv.ParseUint: parsing "' + s + '": value out of range'];
-  return [v, null];
-};
-var __strconv_parse_float = __strconv_parse_float || function(s) {
-  const str = s.replaceAll("_", "");
-  if (/^[+-]?(inf|infinity)$/i.test(str)) return [str[0] === "-" ? -Infinity : Infinity, null];
-  if (/^[+-]?nan$/i.test(str)) return [NaN, null];
-  if (str === "" || !/^[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?$|^[+-]?0[xX][0-9a-fA-F]+$/.test(str)) {
-    return [0, 'strconv.ParseFloat: parsing "' + s + '": invalid syntax'];
-  }
-  return [Number(str), null];
-};
-var __strconv_parse_bool = __strconv_parse_bool || function(s) {
-  if (["1", "t", "T", "TRUE", "true", "True"].includes(s)) return [true, null];
-  if (["0", "f", "F", "FALSE", "false", "False"].includes(s)) return [false, null];
-  return [false, 'strconv.ParseBool: parsing "' + s + '": invalid syntax'];
-};
-var __strconv_format_float = __strconv_format_float || function(f, fmtc, prec) {
-  const c = String.fromCharCode(fmtc);
-  if (!Number.isFinite(f)) return f !== f ? "NaN" : (f > 0 ? "+Inf" : "-Inf");
-  if (c === "f") return prec < 0 ? String(f) : f.toFixed(prec);
-  if (c === "e" || c === "E") {
-    const r = prec < 0 ? f.toExponential() : f.toExponential(prec);
-    const o = r.replace(/e([+-])(\\d)$/, "e$10$2");
-    return c === "E" ? o.toUpperCase() : o;
-  }
-  if (c === "g" || c === "G") {
-    const r = prec < 0 ? String(f) : f.toPrecision(prec);
-    return c === "G" ? r.toUpperCase() : r;
-  }
-  return String(f);
-};`;
-
-export const HELPER_PATH_CLEAN = `var __pathClean = __pathClean || function(p) {
-  if (!p) return ".";
-  const abs = p.startsWith("/");
-  const parts = p.split("/").reduce((acc, s) => {
-    if (s === "" || s === ".") return acc;
-    if (s === "..") {
-      if (acc.length && acc[acc.length - 1] !== "..") acc.pop();
-      else if (!abs) acc.push("..");
-    } else acc.push(s);
-    return acc;
-  }, []);
-  return (abs ? "/" : "") + (parts.join("/") || ".");
-};
-var __pathMatch = __pathMatch || function(pat, name) {
-  let rx = "^";
-  let hasErr = false;
-  let i = 0;
-  while (i < pat.length) {
-    const c = pat[i];
-    if (c === "\\\\") {
-      if (i + 1 >= pat.length) { hasErr = true; break; }
-      const next = pat[++i];
-      if (/[.^$*+?()|{}\\[\\]\\\\]/.test(next)) rx += "\\\\" + next;
-      else rx += next;
-      i++;
-    } else if (c === "*") {
-      rx += "[^/]*";
-      i++;
-    } else if (c === "?") {
-      rx += "[^/]";
-      i++;
-    } else if (c === "[") {
-      i++;
-      let negated = false;
-      if (i < pat.length && pat[i] === "^") {
-        negated = true;
-        i++;
-      }
-      if (i >= pat.length || pat[i] === "]") {
-        return [false, true];
-      }
-      let classContent = "";
-      let closed = false;
-      while (i < pat.length) {
-        let ch = pat[i];
-        if (ch === "]") {
-          closed = true;
-          i++;
-          break;
-        }
-        if (ch === "\\\\") {
-          if (i + 1 >= pat.length) { hasErr = true; break; }
-          ch = pat[++i];
-        }
-        if (ch === "/") {
-          return [false, true];
-        }
-        i++;
-        if (i + 1 < pat.length && pat[i] === "-" && pat[i + 1] !== "]") {
-          i++;
-          let end = pat[i];
-          if (end === "\\\\") {
-            if (i + 1 >= pat.length) { hasErr = true; break; }
-            end = pat[++i];
-          }
-          if (end === "/") return [false, true];
-          i++;
-          if (ch.charCodeAt(0) > end.charCodeAt(0)) return [false, true];
-          if (ch.charCodeAt(0) <= 47 && 47 <= end.charCodeAt(0)) return [false, true];
-          const isSpec = (c) => c === "-" || c === "^" || c === "\\\\" || c === "[" || c === "]";
-          const escCh = isSpec(ch) ? "\\\\" + ch : ch;
-          const escEnd = isSpec(end) ? "\\\\" + end : end;
-          classContent += escCh + "-" + escEnd;
-        } else {
-          const isSpec = (c) => c === "-" || c === "^" || c === "\\\\" || c === "[" || c === "]";
-          const escCh = isSpec(ch) ? "\\\\" + ch : ch;
-          classContent += escCh;
-        }
-      }
-      if (!closed || hasErr) return [false, true];
-      if (negated) {
-        rx += "[^/" + classContent + "]";
-      } else {
-        rx += "[" + classContent + "]";
-      }
-    } else if (/[.^$*+?()|{}\\[\\]\\\\]/.test(c)) {
-      rx += "\\\\" + c;
-      i++;
-    } else {
-      rx += c;
-      i++;
-    }
-  }
-  if (hasErr) return [false, true];
-  try {
-    const re = new RegExp(rx + "$");
-    return [re.test(name), false];
-  } catch (e) {
-    return [false, true];
-  }
-};`;
-
-export const HELPER_TIME_FMT = `var __timeFmt = __timeFmt || function(d, layout) {
-  const dt = d instanceof Date ? d : (d?._d ?? d);
-  const isUtc = d?._offset === 0;
-  const pad = (n, w = 2) => String(n).padStart(w, "0");
-  const DAYS = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"];
-  const MONTHS = ["January","February","March","April","May","June","July","August","September","October","November","December"];
-  const getFullYear = () => isUtc ? dt.getUTCFullYear() : dt.getFullYear();
-  const getMonth = () => isUtc ? dt.getUTCMonth() : dt.getMonth();
-  const getDate = () => isUtc ? dt.getUTCDate() : dt.getDate();
-  const getDay = () => isUtc ? dt.getUTCDay() : dt.getDay();
-  const getHours = () => isUtc ? dt.getUTCHours() : dt.getHours();
-  const getMinutes = () => isUtc ? dt.getUTCMinutes() : dt.getMinutes();
-  const getSeconds = () => isUtc ? dt.getUTCSeconds() : dt.getSeconds();
-  const getMilliseconds = () => isUtc ? dt.getUTCMilliseconds() : dt.getMilliseconds();
-  const getTimezoneOffset = () => isUtc ? 0 : dt.getTimezoneOffset();
-  return layout.replace(/2006|06|Monday|Mon|January|Jan|01|02|15|PM|pm|03|04|05|Z07:00|-07:00|-0700|MST|\\.(?:0+|9+)|1|2|3|4|5/g, t => {
-    if (t.startsWith(".")) {
-      const isZeroPad = t.includes("0");
-      const maxLen = t.length - 1;
-      const ms = getMilliseconds();
-      let frac = pad(ms, 3);
-      if (maxLen > 3) frac = frac.padEnd(maxLen, "0");
-      else frac = frac.slice(0, maxLen);
-      if (!isZeroPad) {
-        frac = frac.replace(/0+$/, "");
-        return frac.length > 0 ? "." + frac : "";
-      } else {
-        return "." + frac;
-      }
-    }
-    switch (t) {
-      case "2006": return getFullYear();
-      case "06":   return String(getFullYear()).slice(-2);
-      case "Monday": return DAYS[getDay()];
-      case "Mon":    return DAYS[getDay()].slice(0, 3);
-      case "January": return MONTHS[getMonth()];
-      case "Jan":     return MONTHS[getMonth()].slice(0, 3);
-      case "01": return pad(getMonth() + 1);
-      case "1":  return String(getMonth() + 1);
-      case "02": return pad(getDate());
-      case "2":  return String(getDate());
-      case "15": return pad(getHours());
-      case "PM": return getHours() < 12 ? "AM" : "PM";
-      case "pm": return getHours() < 12 ? "am" : "pm";
-      case "03": return pad(getHours() % 12 || 12);
-      case "3":  return String(getHours() % 12 || 12);
-      case "04": return pad(getMinutes());
-      case "4":  return String(getMinutes());
-      case "05": return pad(getSeconds());
-      case "5":  return String(getSeconds());
-      case "Z07:00": {
-        const o = -getTimezoneOffset();
-        return o === 0 ? "Z" : (o > 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + ":" + pad(Math.abs(o) % 60);
-      }
-      case "-07:00": {
-        const o = -getTimezoneOffset();
-        return (o >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + ":" + pad(Math.abs(o) % 60);
-      }
-      case "-0700": {
-        const o = -getTimezoneOffset();
-        return (o >= 0 ? "+" : "-") + pad(Math.floor(Math.abs(o) / 60)) + pad(Math.abs(o) % 60);
-      }
-      case "MST": return isUtc ? "UTC" : "LOCAL";
-      default: return t;
-    }
-  });
-};`;
-
-export const HELPER_TIME_PARSE = `var __timeParse = __timeParse || function(layout, value) {
-  try {
-    const d = new Date(value);
-    if (isNaN(d.getTime())) throw 0;
-    return [{ _d: d }, null];
-  } catch {
-    return [{ _d: new Date(0) }, { Error() { return "parsing time: cannot parse"; }, toString() { return "parsing time: cannot parse"; }, _msg: "parsing time: cannot parse", _cause: null }];
-  }
-};`;
-
-export const HELPER_TESTING = `var __GoFront_FailNow = __GoFront_FailNow || class extends Error {
-  constructor() { super("FailNow"); this.name = "__GoFront_FailNow"; }
-};
-var __GoFront_SkipNow = __GoFront_SkipNow || class extends Error {
-  constructor() { super("SkipNow"); this.name = "__GoFront_SkipNow"; }
-};
-var __GoFront_T = __GoFront_T || class {
-  constructor(name = "", parent = null) {
-    this._name = name;
-    this._parent = parent;
-    this.failed = false;
-    this.skipped = false;
-    this._logs = [];
-    this._start = typeof performance !== "undefined" ? performance.now() : Date.now();
-  }
-  Name() { return this._name; }
-  Fail() {
-    this.failed = true;
-    if (this._parent) this._parent.Fail();
-  }
-  Failed() { return this.failed; }
-  FailNow() {
-    this.Fail();
-    throw new __GoFront_FailNow();
-  }
-  Log(...args) {
-    const msg = args.map(a => {
-      if (typeof a === "object" && a !== null) {
-        try { return JSON.stringify(a); } catch { return String(a); }
-      }
-      return String(a);
-    }).join(" ");
-    this._logs.push(msg);
-  }
-  Logf(format, ...args) {
-    const msg = typeof __sprintf === "function" ? __sprintf(format, ...args) : format;
-    this._logs.push(msg);
-  }
-  Error(...args) {
-    this.Fail();
-    this.Log(...args);
-  }
-  Errorf(format, ...args) {
-    this.Fail();
-    this.Logf(format, ...args);
-  }
-  Fatal(...args) {
-    this.Log(...args);
-    this.FailNow();
-  }
-  Fatalf(format, ...args) {
-    this.Logf(format, ...args);
-    this.FailNow();
-  }
-  Skip(...args) {
-    this.skipped = true;
-    if (args.length > 0) this.Log(...args);
-    throw new __GoFront_SkipNow();
-  }
-  Skipf(format, ...args) {
-    this.skipped = true;
-    this.Logf(format, ...args);
-    throw new __GoFront_SkipNow();
-  }
-  Skipped() { return this.skipped; }
-  Helper() {}
-  Run(name, fn) {
-    const subName = this._name ? \`\${this._name}/\${name}\` : name;
-    const subT = new __GoFront_T(subName, this);
-    if (typeof globalThis.__onSubtestStart === "function") globalThis.__onSubtestStart(subName);
-    try {
-      const res = fn(subT);
-      if (res && typeof res.then === "function") {
-        return res.then(() => {
-          if (typeof globalThis.__onSubtestEnd === "function") globalThis.__onSubtestEnd(subT);
-          return !subT.failed;
-        }).catch(e => {
-          if (e instanceof __GoFront_FailNow) {
-            // expected
-          } else if (e instanceof __GoFront_SkipNow) {
-            // expected
-          } else {
-            subT.Fail();
-            subT.Log("panic: " + (e?.message ?? String(e)));
-          }
-          if (typeof globalThis.__onSubtestEnd === "function") globalThis.__onSubtestEnd(subT);
-          return false;
-        });
-      }
-    } catch (e) {
-      if (e instanceof __GoFront_FailNow) {
-        // expected on FailNow
-      } else if (e instanceof __GoFront_SkipNow) {
-        // expected on Skip
-      } else {
-        subT.Fail();
-        subT.Log("panic: " + (e?.message ?? String(e)));
-      }
-    }
-    if (typeof globalThis.__onSubtestEnd === "function") globalThis.__onSubtestEnd(subT);
-    return !subT.failed;
-  }
-};
-var __testing_T = __GoFront_T;`;
-
 export const HELPER_INJECT_STYLES = `var __injectStyles = __injectStyles || function(css) {
   if (typeof document === "undefined" || !document || !document.head || !css) return;
   let s = document.getElementById("gofront-styles");
@@ -863,986 +961,119 @@ export const HELPER_INJECT_STYLES = `var __injectStyles = __injectStyles || func
   s.textContent += "\\n" + css;
 };`;
 
-export const HELPER_DURATION = `var __durationString = __durationString || function(d) {
-  d = BigInt(d);
-  if (d === 0n) return "0s";
-  let neg = false;
-  if (d < 0n) { neg = true; d = -d; }
-  let s = "";
-  const totalSec = d / 1000000000n;
-  const sec = totalSec % 60n;
-  const min = (totalSec / 60n) % 60n;
-  const hr = totalSec / 3600n;
-
-  if (hr > 0n) s += hr + "h";
-  const remAfterHr = d % 3600000000000n;
-  if (min > 0n || (hr > 0n && remAfterHr > 0n)) s += min + "m";
-  if (totalSec > 0n) {
-    const frac = d % 1000000000n;
-    if (sec > 0n || frac > 0n || (hr === 0n && min === 0n)) {
-      if (frac === 0n) {
-        s += sec + "s";
-      } else {
-        let fracStr = frac.toString().padStart(9, "0").replace(/0+$/, "");
-        s += sec + "." + fracStr + "s";
-      }
-    }
-  } else {
-    const ms = (d / 1000000n) % 1000n;
-    const us = (d / 1000n) % 1000n;
-    const ns = d % 1000n;
-    if (ms > 0n) {
-      const frac = d % 1000000n;
-      if (frac === 0n) s += ms + "ms";
-      else {
-        let fracStr = frac.toString().padStart(6, "0").replace(/0+$/, "");
-        s += ms + "." + fracStr + "ms";
-      }
-    } else if (us > 0n) {
-      const frac = d % 1000n;
-      if (frac === 0n) s += us + "µs";
-      else {
-        let fracStr = frac.toString().padStart(3, "0").replace(/0+$/, "");
-        s += us + "." + fracStr + "µs";
-      }
-    } else {
-      s += ns + "ns";
+// internal/jsonrt's encoder writes into `e.buf[0:e.n]`; these helpers append
+// to it directly (see the jsonrt natives in natives.js).
+export const HELPER_JSONRT = `var __jte = __jte || new TextEncoder();
+var __jroom = __jroom || function(e, k) {
+  var need = e.n + k;
+  if (need > e.buf.length) {
+    var nb = new Uint8Array(Math.max(need, e.buf.length * 2));
+    nb.set(e.buf.subarray(0, e.n));
+    e.buf = nb;
+  }
+};
+var __jput = __jput || function(e, s) {
+  var l = s.length, i = 0;
+  __jroom(e, l);
+  var buf = e.buf, n = e.n;
+  for (; i < l; i++) {
+    var c = s.charCodeAt(i);
+    if (c > 127) break;
+    buf[n + i] = c;
+  }
+  e.n = n + i;
+  if (i < l) {
+    var u = __jte.encode(s.slice(i));
+    __jroom(e, u.length);
+    e.buf.set(u, e.n);
+    e.n += u.length;
+  }
+};
+var __jint = __jint || function(e, v) { __jput(e, String(v)); };
+var __jfloat = __jfloat || function(e, f, bits) {
+  if (bits === 32) {
+    var g = Math.fround(f);
+    for (var p = 1; p <= 9; p++) {
+      var t = g.toPrecision(p);
+      if (Math.fround(+t) === g) { f = +t; break; }
     }
   }
-  return neg ? "-" + s : s;
-};`;
-
-export const HELPER_SYNC = `var __sync_mutex = __sync_mutex || function() {
-  return { Lock() {}, Unlock() {}, TryLock() { return true; } };
-};
-var __sync_rwmutex = __sync_rwmutex || function() {
-  return { Lock() {}, Unlock() {}, RLock() {}, RUnlock() {}, TryLock() { return true; }, TryRLock() { return true; } };
-};
-var __sync_once = __sync_once || function() {
-  return { done: 0, Do(f) { if (!this.done) { this.done = 1; f(); } } };
-};
-var __sync_waitgroup = __sync_waitgroup || function() {
-  return { counter: 0, Add(d) { this.counter = (this.counter || 0) + d; }, Done() { this.counter = (this.counter || 0) - 1; }, Wait() {} };
-};`;
-
-export const HELPER_CRYPTO_RAND = `var __crypto_rand_read = __crypto_rand_read || function(b) {
-  if (!b || b.length === 0) return [0, null];
-  const u8 = ArrayBuffer.isView(b) ? b : new Uint8Array(b.length);
-  const c = typeof crypto !== "undefined" ? crypto : (typeof globalThis !== "undefined" ? globalThis.crypto : null);
-  const CHUNK = 65536;
-  if (c && typeof c.getRandomValues === "function") {
-    for (let offset = 0; offset < u8.length; offset += CHUNK) {
-      const slice = u8.subarray(offset, Math.min(offset + CHUNK, u8.length));
-      c.getRandomValues(slice);
-    }
-  } else {
-    for (let i = 0; i < u8.length; i++) u8[i] = Math.floor(Math.random() * 256);
-  }
-  if (!ArrayBuffer.isView(b)) {
-    for (let i = 0; i < u8.length; i++) b[i] = u8[i];
-  }
-  return [b.length, null];
+  __jput(e, String(f));
 };
-var __crypto_rand_reader = __crypto_rand_reader || {
-  Read: function(b) { return __crypto_rand_read(b); }
-};`;
-
-export const HELPER_SHA256 = `var __sha256 = __sha256 || (function() {
-  const K = [
-    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-  ];
-  function rotr(x, n) { return (x >>> n) | (x << (32 - n)); }
-  function block(H, M) {
-    const W = new Int32Array(64);
-    for (let i = 0; i < 16; i++) {
-      W[i] = (M[i * 4] << 24) | (M[i * 4 + 1] << 16) | (M[i * 4 + 2] << 8) | M[i * 4 + 3];
-    }
-    for (let i = 16; i < 64; i++) {
-      const s0 = rotr(W[i - 15], 7) ^ rotr(W[i - 15], 18) ^ (W[i - 15] >>> 3);
-      const s1 = rotr(W[i - 2], 17) ^ rotr(W[i - 2], 19) ^ (W[i - 2] >>> 10);
-      W[i] = (W[i - 16] + s0 + W[i - 7] + s1) | 0;
-    }
-    let [a, b, c, d, e, f, g, h] = H;
-    for (let i = 0; i < 64; i++) {
-      const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
-      const ch = (e & f) ^ (~e & g);
-      const t1 = (h + S1 + ch + K[i] + W[i]) | 0;
-      const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
-      const maj = (a & b) ^ (a & c) ^ (b & c);
-      const t2 = (S0 + maj) | 0;
-      h = g; g = f; f = e; e = (d + t1) | 0;
-      d = c; c = b; b = a; a = (t1 + t2) | 0;
-    }
-    H[0] = (H[0] + a) | 0; H[1] = (H[1] + b) | 0; H[2] = (H[2] + c) | 0; H[3] = (H[3] + d) | 0;
-    H[4] = (H[4] + e) | 0; H[5] = (H[5] + f) | 0; H[6] = (H[6] + g) | 0; H[7] = (H[7] + h) | 0;
-  }
-  function digest(bytes) {
-    const H = new Int32Array([
-      0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
-      0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-    ]);
-    const len = bytes ? bytes.length : 0;
-    const padLen = (len % 64 < 56) ? (56 - (len % 64)) : (120 - (len % 64));
-    const total = len + padLen + 8;
-    const buf = new Uint8Array(total);
-    if (bytes) {
-      if (ArrayBuffer.isView(bytes)) buf.set(bytes);
-      else for (let i = 0; i < len; i++) buf[i] = bytes[i];
-    }
-    buf[len] = 0x80;
-    const bits = BigInt(len) * 8n;
-    for (let i = 0; i < 8; i++) {
-      buf[total - 1 - i] = Number((bits >> BigInt(i * 8)) & 0xffn);
-    }
-    for (let i = 0; i < total; i += 64) {
-      block(H, buf.subarray(i, i + 64));
-    }
-    const out = new Uint8Array(32);
-    for (let i = 0; i < 8; i++) {
-      out[i * 4] = (H[i] >>> 24) & 0xff;
-      out[i * 4 + 1] = (H[i] >>> 16) & 0xff;
-      out[i * 4 + 2] = (H[i] >>> 8) & 0xff;
-      out[i * 4 + 3] = H[i] & 0xff;
-    }
-    return out;
-  }
-  class Hash {
-    constructor() { this.Reset(); }
-    Reset() { this.buf = []; }
-    Write(p) {
-      if (p) {
-        for (let i = 0; i < p.length; i++) this.buf.push(p[i]);
-      }
-      return [p ? p.length : 0, null];
-    }
-    Sum(b) {
-      const d = digest(this.buf);
-      if (!b || b.length === 0) return d;
-      const res = new Uint8Array(b.length + d.length);
-      res.set(b, 0);
-      res.set(d, b.length);
-      return res;
-    }
-    Size() { return 32; }
-    BlockSize() { return 64; }
-  }
-  return {
-    Sum256: digest,
-    New: () => new Hash()
-  };
-})();`;
-
-export const HELPER_BINARY = `var __binary_le = __binary_le || {
-  Uint16: function(b) { return (b[0] | (b[1] << 8)) & 0xffff; },
-  Uint32: function(b) { return ((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0); },
-  Uint64: function(b) {
-    const lo = BigInt((b[0] | (b[1] << 8) | (b[2] << 16) | (b[3] << 24)) >>> 0);
-    const hi = BigInt((b[4] | (b[5] << 8) | (b[6] << 16) | (b[7] << 24)) >>> 0);
-    return Number(lo | (hi << 32n));
-  },
-  PutUint16: function(b, v) { b[0] = v & 0xff; b[1] = (v >> 8) & 0xff; },
-  PutUint32: function(b, v) { b[0] = v & 0xff; b[1] = (v >> 8) & 0xff; b[2] = (v >> 16) & 0xff; b[3] = (v >>> 24) & 0xff; },
-  PutUint64: function(b, v) {
-    const bv = BigInt(v);
-    for (let i = 0n; i < 8n; i++) b[Number(i)] = Number((bv >> (i * 8n)) & 0xffn);
-  },
-  AppendUint16: function(b, v) {
-    const len = b ? b.length : 0;
-    const res = new Uint8Array(len + 2);
-    if (len > 0) res.set(b, 0);
-    res[len] = v & 0xff;
-    res[len + 1] = (v >> 8) & 0xff;
-    return res;
-  },
-  AppendUint32: function(b, v) {
-    const len = b ? b.length : 0;
-    const res = new Uint8Array(len + 4);
-    if (len > 0) res.set(b, 0);
-    res[len] = v & 0xff;
-    res[len + 1] = (v >> 8) & 0xff;
-    res[len + 2] = (v >> 16) & 0xff;
-    res[len + 3] = (v >>> 24) & 0xff;
-    return res;
-  },
-  AppendUint64: function(b, v) {
-    const len = b ? b.length : 0;
-    const res = new Uint8Array(len + 8);
-    if (len > 0) res.set(b, 0);
-    const bv = BigInt(v);
-    for (let i = 0n; i < 8n; i++) res[len + Number(i)] = Number((bv >> (i * 8n)) & 0xffn);
-    return res;
-  },
-  String: function() { return "LittleEndian"; }
-};
-var __binary_be = __binary_be || {
-  Uint16: function(b) { return ((b[0] << 8) | b[1]) & 0xffff; },
-  Uint32: function(b) { return (((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]) >>> 0); },
-  Uint64: function(b) {
-    const hi = BigInt(((b[0] << 24) | (b[1] << 16) | (b[2] << 8) | b[3]) >>> 0);
-    const lo = BigInt(((b[4] << 24) | (b[5] << 16) | (b[6] << 8) | b[7]) >>> 0);
-    return Number((hi << 32n) | lo);
-  },
-  PutUint16: function(b, v) { b[0] = (v >> 8) & 0xff; b[1] = v & 0xff; },
-  PutUint32: function(b, v) { b[0] = (v >>> 24) & 0xff; b[1] = (v >> 16) & 0xff; b[2] = (v >> 8) & 0xff; b[3] = v & 0xff; },
-  PutUint64: function(b, v) {
-    const bv = BigInt(v);
-    for (let i = 0n; i < 8n; i++) b[Number(7n - i)] = Number((bv >> (i * 8n)) & 0xffn);
-  },
-  AppendUint16: function(b, v) {
-    const len = b ? b.length : 0;
-    const res = new Uint8Array(len + 2);
-    if (len > 0) res.set(b, 0);
-    res[len] = (v >> 8) & 0xff;
-    res[len + 1] = v & 0xff;
-    return res;
-  },
-  AppendUint32: function(b, v) {
-    const len = b ? b.length : 0;
-    const res = new Uint8Array(len + 4);
-    if (len > 0) res.set(b, 0);
-    res[len] = (v >>> 24) & 0xff;
-    res[len + 1] = (v >> 16) & 0xff;
-    res[len + 2] = (v >> 8) & 0xff;
-    res[len + 3] = v & 0xff;
-    return res;
-  },
-  AppendUint64: function(b, v) {
-    const len = b ? b.length : 0;
-    const res = new Uint8Array(len + 8);
-    if (len > 0) res.set(b, 0);
-    const bv = BigInt(v);
-    for (let i = 0n; i < 8n; i++) res[len + Number(i)] = Number((bv >> ((7n - i) * 8n)) & 0xffn);
-    return res;
-  },
-  String: function() { return "BigEndian"; }
-};
-var __binary_size = __binary_size || function(v) {
-  if (typeof v === "number" || typeof v === "bigint") return 8;
-  if (Array.isArray(v) || ArrayBuffer.isView(v)) return v.length;
-  if (v && typeof v === "object") {
-    let s = 0;
-    for (const k of Object.keys(v)) { if (!k.startsWith("_") && typeof v[k] !== "function") s += __binary_size(v[k]); }
-    return s;
-  }
-  return -1;
-};
-var __binary_read = __binary_read || function(r, order, data, sz, typeTag) {
-  const targetR = r?.value ?? r;
-  const readChunk = function(buf) {
-    if (typeof targetR?.Read === "function") return targetR.Read(buf);
-    if (Array.isArray(targetR?._buf)) {
-      const n = Math.min(buf.length, targetR._buf.length);
-      for (let i = 0; i < n; i++) buf[i] = targetR._buf.shift();
-      return [n, n < buf.length ? __io_eof : null];
-    }
-    return [0, __error("binary.Read: unsupported reader")];
-  };
-  const isBox = data && typeof data === "object" && Object.prototype.hasOwnProperty.call(data, "value") && (data.__box === true || (Object.keys(data).length <= 2 && (data.constructor === Object || !data.constructor || data.constructor?.name === "Object")));
-  const target = isBox ? data : null;
-  if (!target && data && typeof data === "object" && !Array.isArray(data) && !ArrayBuffer.isView(data)) {
-    for (const k of Object.keys(data)) {
-      if (k.startsWith("_") || typeof data[k] === "function") continue;
-      const fBox = { value: data[k], __box: true };
-      const err = __binary_read(r, order, fBox);
-      if (err) return err;
-      data[k] = fBox.value;
-    }
-    return null;
-  }
-  const s = sz || (target ? (typeof target.value === "bigint" ? 8 : (typeof target.value === "number" ? 4 : 4)) : __binary_size(data?.value ?? data));
-  if (s <= 0) return __error("binary.Read: invalid type");
-  const buf = new Uint8Array(s);
-  const [n, err] = readChunk(buf);
-  if (err) return err;
-  if (n < s) return __io_eof;
-  if (target) {
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    const isLe = order.String() === "LittleEndian";
-    if (typeTag === "float32") target.value = view.getFloat32(0, isLe);
-    else if (typeTag === "float64") target.value = view.getFloat64(0, isLe);
-    else if (typeTag === "int8") target.value = view.getInt8(0);
-    else if (typeTag === "uint8" || typeTag === "byte" || typeTag === "bool") target.value = view.getUint8(0);
-    else if (typeTag === "int16") target.value = view.getInt16(0, isLe);
-    else if (typeTag === "uint16") target.value = view.getUint16(0, isLe);
-    else if (typeTag === "int32" || typeTag === "rune") target.value = view.getInt32(0, isLe);
-    else if (typeTag === "uint32") target.value = view.getUint32(0, isLe);
-    else if (typeTag === "int64") target.value = Number(view.getBigInt64(0, isLe));
-    else if (typeTag === "uint64") target.value = Number(view.getBigUint64(0, isLe));
-    else if (s === 1) target.value = buf[0];
-    else if (s === 2) target.value = order.Uint16(buf);
-    else if (s === 4) target.value = order.Uint32(buf);
-    else if (s === 8) target.value = order.Uint64(buf);
-    return null;
-  }
-  if (Array.isArray(data) || ArrayBuffer.isView(data)) {
-    for (let i = 0; i < s; i++) data[i] = buf[i];
-    return null;
-  }
-  return null;
-};
-var __binary_write = __binary_write || function(w, order, data, sz, typeTag) {
-  const targetW = w?.value ?? w;
-  const writeChunk = function(chunk) {
-    if (typeof targetW?.Write === "function") return targetW.Write(chunk);
-    if (Array.isArray(targetW?._buf)) {
-      for (let i = 0; i < chunk.length; i++) targetW._buf.push(chunk[i]);
-      return [chunk.length, null];
-    }
-    if (typeof targetW?._buf === "string") {
-      targetW._buf += new TextDecoder().decode(chunk);
-      return [chunk.length, null];
-    }
-    return [0, __error("binary.Write: unsupported writer")];
-  };
-  const isBox = data && typeof data === "object" && Object.prototype.hasOwnProperty.call(data, "value") && (data.__box === true || (Object.keys(data).length <= 2 && (data.constructor === Object || !data.constructor || data.constructor?.name === "Object")));
-  const v = isBox ? data.value : data;
-  if (!isBox && typeof data === "object" && data !== null && !Array.isArray(data) && !ArrayBuffer.isView(data)) {
-    for (const k of Object.keys(data)) {
-      if (k.startsWith("_") || typeof data[k] === "function") continue;
-      const err = __binary_write(w, order, data[k]);
-      if (err) return err;
-    }
-    return null;
-  }
-  if (typeof v === "number" || typeof v === "bigint" || typeof v === "boolean") {
-    const s = sz || (typeof v === "bigint" ? 8 : (typeTag === "float64" ? 8 : 4));
-    const buf = new Uint8Array(s);
-    const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-    const isLe = order.String() === "LittleEndian";
-    if (typeTag === "float32") view.setFloat32(0, Number(v), isLe);
-    else if (typeTag === "float64") view.setFloat64(0, Number(v), isLe);
-    else if (s === 1) buf[0] = Number(v) & 0xff;
-    else if (s === 2) order.PutUint16(buf, Number(v));
-    else if (s === 4) order.PutUint32(buf, Number(v));
-    else order.PutUint64(buf, v);
-    const [, err] = writeChunk(buf);
-    return err;
-  }
-  if (Array.isArray(v) || ArrayBuffer.isView(v)) {
-    const [, err] = writeChunk(v);
-    return err;
-  }
-  return __error("binary.Write: unsupported type");
-};`;
-
-export const HELPER_HEX = `var __hex_encode_to_string = __hex_encode_to_string || function(src) {
-  if (!src || src.length === 0) return "";
-  let s = "";
-  for (let i = 0; i < src.length; i++) s += src[i].toString(16).padStart(2, "0");
-  return s;
-};
-var __hex_decode_string = __hex_decode_string || function(s) {
-  if (s.length % 2 !== 0) return [new Uint8Array(0), __error("encoding/hex: odd length hex string")];
-  const out = new Uint8Array(s.length / 2);
-  for (let i = 0; i < s.length; i += 2) {
-    const pair = s.slice(i, i + 2);
-    if (!/^[0-9a-fA-F]{2}$/.test(pair)) {
-      return [out.subarray(0, i / 2), __error("encoding/hex: invalid byte: " + pair)];
-    }
-    out[i / 2] = parseInt(pair, 16);
-  }
-  return [out, null];
-};
-var __hex_encode = __hex_encode || function(dst, src) {
-  const hex = __hex_encode_to_string(src);
-  for (let i = 0; i < hex.length; i++) dst[i] = hex.charCodeAt(i);
-  return hex.length;
-};
-var __hex_decode = __hex_decode || function(dst, src) {
-  const str = typeof src === "string" ? src : (src instanceof Uint8Array ? new TextDecoder().decode(src) : String.fromCharCode(...src));
-  const [res, err] = __hex_decode_string(str);
-  for (let i = 0; i < res.length; i++) dst[i] = res[i];
-  return [res.length, err];
-};`;
-
-export const HELPER_BASE64 = `var __base64_make = __base64_make || function(alphabet, padChar) {
-  const encMap = alphabet.split("");
-  const decMap = {};
-  for (let i = 0; i < 64; i++) decMap[alphabet[i]] = i;
-  return {
-    EncodeToString: function(src) {
-      if (!src || src.length === 0) return "";
-      let res = "";
-      let i = 0;
-      for (; i + 2 < src.length; i += 3) {
-        const n = (src[i] << 16) | (src[i + 1] << 8) | src[i + 2];
-        res += encMap[(n >> 18) & 63] + encMap[(n >> 12) & 63] + encMap[(n >> 6) & 63] + encMap[n & 63];
-      }
-      if (i < src.length) {
-        if (src.length - i === 1) {
-          const n = src[i] << 16;
-          res += encMap[(n >> 18) & 63] + encMap[(n >> 12) & 63];
-          if (padChar) res += padChar + padChar;
-        } else {
-          const n = (src[i] << 16) | (src[i + 1] << 8);
-          res += encMap[(n >> 18) & 63] + encMap[(n >> 12) & 63] + encMap[(n >> 6) & 63];
-          if (padChar) res += padChar;
-        }
-      }
-      return res;
-    },
-    DecodeString: function(s) {
-      let str = s.replace(/\\s+/g, "");
-      if (padChar) {
-        if (str.length % 4 !== 0) return [new Uint8Array(0), __error("illegal base64 data at input byte " + str.length)];
-        if (str.endsWith(padChar + padChar)) {
-          if (str.endsWith(padChar + padChar + padChar)) return [new Uint8Array(0), __error("illegal base64 data at input byte " + (str.length - 3))];
-          str = str.slice(0, -2);
-          if (str.length % 4 !== 2) return [new Uint8Array(0), __error("illegal base64 data at input byte " + str.length)];
-        } else if (str.endsWith(padChar)) {
-          str = str.slice(0, -1);
-          if (str.length % 4 !== 3) return [new Uint8Array(0), __error("illegal base64 data at input byte " + str.length)];
-        }
-      }
-      const out = [];
-      let i = 0;
-      for (; i + 3 < str.length; i += 4) {
-        const c0 = decMap[str[i]], c1 = decMap[str[i+1]], c2 = decMap[str[i+2]], c3 = decMap[str[i+3]];
-        if (c0 === undefined || c1 === undefined || c2 === undefined || c3 === undefined) return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
-        const n = (c0 << 18) | (c1 << 12) | (c2 << 6) | c3;
-        out.push((n >> 16) & 0xff, (n >> 8) & 0xff, n & 0xff);
-      }
-      const rem = str.length - i;
-      if (rem === 2) {
-        const c0 = decMap[str[i]], c1 = decMap[str[i+1]];
-        if (c0 === undefined || c1 === undefined) return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
-        out.push((c0 << 2) | (c1 >> 4));
-      } else if (rem === 3) {
-        const c0 = decMap[str[i]], c1 = decMap[str[i+1]], c2 = decMap[str[i+2]];
-        if (c0 === undefined || c1 === undefined || c2 === undefined) return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
-        out.push((c0 << 2) | (c1 >> 4), ((c1 & 15) << 4) | (c2 >> 2));
-      } else if (rem === 1) {
-        return [new Uint8Array(out), __error("illegal base64 data at input byte " + i)];
-      }
-      return [new Uint8Array(out), null];
-    },
-    Encode: function(dst, src) {
-      const s = this.EncodeToString(src);
-      for (let i = 0; i < s.length; i++) dst[i] = s.charCodeAt(i);
-    },
-    Decode: function(dst, src) {
-      const str = String.fromCharCode(...src);
-      const [res, err] = this.DecodeString(str);
-      for (let i = 0; i < res.length; i++) dst[i] = res[i];
-      return [res.length, err];
-    },
-    EncodedLen: function(n) { return padChar ? Math.ceil(n / 3) * 4 : Math.floor((n * 8 + 5) / 6); },
-    DecodedLen: function(n) { return padChar ? Math.floor(n * 3 / 4) : Math.floor(n * 6 / 8); },
-    WithPadding: function(p) { return __base64_make(alphabet, p === -1 ? "" : String.fromCharCode(p)); }
-  };
-};
-var __base64_std = __base64_std || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "=");
-var __base64_url = __base64_url || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", "=");
-var __base64_raw_std = __base64_raw_std || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", "");
-var __base64_raw_url = __base64_raw_url || __base64_make("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", "");`;
-
-export const HELPER_JSON = `var __json_esc = __json_esc || function(s) {
-  if (typeof s !== "string") s = String(s);
-  return JSON.stringify(s)
-    .replace(/[<>&]/g, function(c) {
-      return c === "<" ? "\\\\u003c" : (c === ">" ? "\\\\u003e" : "\\\\u0026");
-    })
-    .replace(/\\u2028/g, "\\\\u2028")
-    .replace(/\\u2029/g, "\\\\u2029");
-};
-var __json_err = __json_err || function(msg) {
-  return typeof __error === "function" ? __error("json: " + msg) : new Error("json: " + msg);
-};
-// Decode error context, as in Go: innermost struct being decoded plus the path
-// of JSON field names from the root. Reset by every __json_unmarshal call.
-var __json_structs = __json_structs || [];
-var __json_path = __json_path || [];
-var __json_ctx = __json_ctx || function(typeName) {
-  if (__json_path.length > 0 && __json_structs.length > 0) {
-    return "Go struct field " + __json_structs[__json_structs.length - 1] + "." + __json_path.join(".") + " of type " + typeName;
-  }
-  return "Go value of type " + typeName;
-};
-// The JSON source text of a number, for "cannot unmarshal number <literal>" messages.
-var __json_lit = __json_lit || function(v, raw) {
-  if (raw !== undefined && raw !== null) return String(raw).trim();
-  return typeof v === "string" ? v.replace(/__bigint$/, "") : String(v);
-};
-var __json_float_decode = __json_float_decode || function(v, bits, ctxType, raw) {
-  var n = __json_number_value(v);
-  if (typeof n !== "number") return __json_err("cannot unmarshal " + __json_type(v) + " into " + __json_ctx(ctxType));
-  var f = bits === 32 ? Math.fround(n) : n;
-  if (!isFinite(f)) return __json_err("cannot unmarshal number " + __json_lit(v, raw) + " into " + __json_ctx(ctxType));
-  return f;
-};
-// []byte accepts a base64 string or (like Go) an array of uint8 values.
-var __json_bytes_decode = __json_bytes_decode || function(v) {
-  if (Array.isArray(v)) {
-    var u8 = new Uint8Array(v.length);
-    for (var i = 0; i < v.length; i++) {
-      var b = __json_int_decode(v[i], "uint8", "uint8", __json_raw_child(v, i));
-      if (b && b._msg) return b;
-      u8[i] = b;
-    }
-    return u8;
-  }
-  if (typeof v !== "string") return __json_err("cannot unmarshal " + __json_type(v) + " into " + __json_ctx("[]uint8"));
-  return __json_b64_dec(v);
-};
-var __json_esc_noh = __json_esc_noh || function(s) {
-  return JSON.stringify(String(s)).replace(/\\u2028/g, "\\\\u2028").replace(/\\u2029/g, "\\\\u2029");
-};
-var __json_syntax_msg = __json_syntax_msg || function(s) {
-  var t = String(s).trim();
-  if (t === "") return "unexpected end of JSON input";
-  var m;
-  try { JSON.parse(t); } catch (e) { m = String(e && e.message); }
-  if (m && /end of JSON input|Unterminated/.test(m)) return "unexpected end of JSON input";
-  var pos = m && /after JSON at position (\\d+)/.exec(m);
-  if (pos) return "invalid character '" + t[Number(pos[1])] + "' after top-level value";
-  if ("{[\\"-0123456789tfn".indexOf(t[0]) < 0) return "invalid character '" + t[0] + "' looking for beginning of value";
-  return "invalid character in JSON value";
-};
-// Validates and compacts JSON text, escaping <, >, & and U+2028/U+2029 inside strings.
-var __json_compact = __json_compact || function(s) {
-  try { JSON.parse(s); } catch (e) { return null; }
-  var out = "", inStr = false, esc = false;
+var __jescRe = __jescRe || /[\\u0000-\\u001f"\\\\<>&\\u2028\\u2029\\ud800-\\udfff]/;
+var __jescRe2 = __jescRe2 || /[\\u0000-\\u001f"\\\\\\u2028\\u2029\\ud800-\\udfff]/;
+var __jesc = __jesc || function(s, html) {
+  var out = "", start = 0;
   for (var i = 0; i < s.length; i++) {
-    var c = s[i];
-    if (inStr) {
-      if (esc) { esc = false; out += c; continue; }
-      if (c === "\\\\") { esc = true; out += c; continue; }
-      if (c === '"') inStr = false;
-      if (c === "<") out += "\\\\u003c";
-      else if (c === ">") out += "\\\\u003e";
-      else if (c === "&") out += "\\\\u0026";
-      else if (c === "\\u2028") out += "\\\\u2028";
-      else if (c === "\\u2029") out += "\\\\u2029";
-      else out += c;
-      continue;
-    }
-    if (c === '"') { inStr = true; out += c; continue; }
-    if (c === " " || c === "\\t" || c === "\\n" || c === "\\r") continue;
-    out += c;
-  }
-  return out;
-};
-var __json_marshaler_out = __json_marshaler_out || function(res, typeName) {
-  var err = res && res[1];
-  if (err) throw new Error("json: error calling MarshalJSON for type " + typeName + ": " + (typeof err.Error === "function" ? err.Error() : String(err)));
-  var b = res ? res[0] : null;
-  var s = b === null || b === undefined ? "" : (typeof b === "string" ? b : new TextDecoder().decode(b));
-  var c = __json_compact(s);
-  if (c === null) throw new Error("json: error calling MarshalJSON for type " + typeName + ": " + __json_syntax_msg(s));
-  return c;
-};
-// Keeps user errors returned by UnmarshalJSON intact while fitting the decoders'
-// "_msg"-tagged error protocol; __json_unmarshal unwraps __userErr.
-var __json_user_err = __json_user_err || function(e) {
-  if (e && e._msg !== undefined) return e;
-  return { _msg: e && typeof e.Error === "function" ? e.Error() : String(e), __userErr: e };
-};
-// Decodes the JSON string payload of a ,string field. Returns { v } or an error.
-var __json_unquote = __json_unquote || function(val, kind, typeStr) {
-  if (val === null) return { v: null, lit: "null" };
-  if (typeof val !== "string" || val.endsWith("__bigint")) {
-    return __json_err("invalid use of ,string struct tag, trying to unmarshal unquoted value into " + typeStr);
-  }
-  var invalid = function() {
-    return __json_err("invalid use of ,string struct tag, trying to unmarshal " + JSON.stringify(val) + " into " + typeStr);
-  };
-  var inner;
-  try { inner = JSON.parse(__json_preserve_int64(val)); } catch (e) {
-    if (kind !== "string" && kind !== "bool" && /^-?[0-9]/.test(val)) return __json_err("cannot unmarshal number " + val + " into " + __json_ctx(typeStr));
-    return invalid();
-  }
-  if (inner === null) return { v: null, lit: val };
-  if (kind === "string") return typeof inner === "string" ? { v: inner, lit: val } : invalid();
-  if (kind === "bool") return typeof inner === "number" ? invalid() : { v: inner, lit: val };
-  return typeof inner === "boolean" ? invalid() : { v: inner, lit: val };
-};
-var __json_type = __json_type || function(v) {
-  if (v === null) return "null";
-  if (Array.isArray(v)) return "array";
-  var t = typeof v;
-  if (t === "number" || t === "bigint") return "number";
-  if (t === "string") return "string";
-  if (t === "boolean") return "bool";
-  if (t === "object") return "object";
-  return t;
-};
-var __json_raw_index = __json_raw_index || new WeakMap();
-var __json_parse_raw_node = __json_parse_raw_node || function(s) {
-  var i = 0;
-  function ws() { while (i < s.length && /[\\t\\n\\r ]/.test(s[i])) i++; }
-  function stringEnd() {
-    i++;
-    while (i < s.length) {
-      if (s[i] === "\\\\") i += 2;
-      else if (s[i++] === '"') break;
-    }
-  }
-  function value() {
-    ws();
-    var start = i;
-    var node = { children: null };
-    if (s[i] === "{") {
-      i++;
-      node.children = new Map();
-      ws();
-      while (s[i] !== "}") {
-        var keyStart = i;
-        stringEnd();
-        var key = JSON.parse(s.slice(keyStart, i));
-        ws();
-        i++;
-        var child = value();
-        node.children.set(key, child);
-        ws();
-        if (s[i] === ",") { i++; ws(); }
-        else break;
-      }
-      i++;
-    } else if (s[i] === "[") {
-      i++;
-      node.children = new Map();
-      ws();
-      var index = 0;
-      while (s[i] !== "]") {
-        node.children.set(String(index++), value());
-        ws();
-        if (s[i] === ",") { i++; ws(); }
-        else break;
-      }
-      i++;
-    } else if (s[i] === '"') {
-      stringEnd();
-    } else {
-      while (i < s.length && !/[\\t\\n\\r ,}\\]]/.test(s[i])) i++;
-    }
-    node.raw = s.slice(start, i);
-    return node;
-  }
-  return value();
-};
-var __json_bind_raw = __json_bind_raw || function(value, node) {
-  if (value === null || typeof value !== "object" || !node?.children) return;
-  __json_raw_index.set(value, node.children);
-  for (const [key, child] of node.children) __json_bind_raw(value[key], child);
-};
-var __json_raw_child = __json_raw_child || function(parent, key) {
-  return __json_raw_index.get(parent)?.get(String(key))?.raw;
-};
-var __json_raw_bytes = __json_raw_bytes || function(raw) {
-  return new TextEncoder().encode(raw ?? "null");
-};
-var __json_match_field = __json_match_field || function(obj, tagName, fieldName) {
-  if (Object.prototype.hasOwnProperty.call(obj, tagName)) return tagName;
-  if (Object.prototype.hasOwnProperty.call(obj, fieldName)) return fieldName;
-  var tagFold = tagName.toLowerCase();
-  var fieldFold = fieldName.toLowerCase();
-  for (const key of Object.keys(obj)) {
-    var keyFold = key.toLowerCase();
-    if (keyFold === tagFold || keyFold === fieldFold) return key;
-  }
-  return null;
-};
-var __json_float32 = __json_float32 || function(v) {
-  var f = Math.fround(v);
-  if (!isFinite(f)) throw new Error("json: unsupported value: " + f);
-  if (Object.is(f, -0)) return "-0";
-  var candidate;
-  for (var precision = 1; precision <= 9; precision++) {
-    candidate = f.toPrecision(precision);
-    if (Math.fround(Number(candidate)) === f) break;
-  }
-  var n = Number(candidate);
-  var expText = n.toExponential();
-  var match = /e([+-]?)(\\d+)$/.exec(expText);
-  var exponent = Number(match[2]) * (match[1] === "-" ? -1 : 1);
-  if (exponent < -6 || exponent >= 21) {
-    var mantissa = expText.slice(0, expText.indexOf("e"));
-    var sign = exponent >= 0 ? "+" : "-";
-    return mantissa + "e" + sign + String(Math.abs(exponent));
-  }
-  return n.toString();
-};
-var __json_number_value = __json_number_value || function(v) {
-  return typeof v === "string" && v.endsWith("__bigint") ? Number(v.slice(0, -8)) : v;
-};
-var __json_int_decode = __json_int_decode || function(v, typeName, ctxType, raw) {
-  var type = typeof v === "string" && v.endsWith("__bigint") ? "number" : __json_type(v);
-  var fail = function() {
-    return __json_err("cannot unmarshal " + (type === "number" ? "number " + __json_lit(v, raw) : type) + " into " + __json_ctx(ctxType));
-  };
-  if (type !== "number") return fail();
-  // Go parses integers with strconv.ParseInt: "1.0" and "1e2" are not integers.
-  if (raw !== undefined && raw !== null && !/^-?(0|[1-9][0-9]*)$/.test(String(raw).trim())) return fail();
-  var integer;
-  var signed = typeName === "int" || typeName.startsWith("int");
-  if (typeName === "int64" || typeName === "uint64") {
-    if (typeof v === "string" && v.endsWith("__bigint")) {
-      try { integer = BigInt(v.slice(0, -8)); } catch (_) {}
-    } else if (typeof v === "number" && Number.isSafeInteger(v)) {
-      integer = BigInt(v);
-    }
-    if (integer !== undefined) {
-      var min64 = typeName === "int64" ? -(1n << 63n) : 0n;
-      var max64 = typeName === "int64" ? (1n << 63n) - 1n : (1n << 64n) - 1n;
-      if (integer >= min64 && integer <= max64) return typeof v === "number" ? v : integer;
-    }
-    return fail();
-  }
-  if (typeof v === "number" && Number.isSafeInteger(v)) {
-    if (typeName === "int") return v;
-    var bits = typeName === "uint" ? 53 : Number(typeName.replace(/^(u?int|byte|rune)/, ""));
-    if (!bits) bits = typeName === "byte" ? 8 : typeName === "rune" ? 32 : 53;
-    var min = signed ? -(2 ** (bits - 1)) : 0;
-    var max = signed ? (2 ** (bits - 1)) - 1 : (2 ** bits) - 1;
-    if (v >= min && v <= max) return v;
-  }
-  return fail();
-};
-var __json_b64 = __json_b64 || function(u8) {
-  if (u8 === null || u8 === undefined) return "null";
-  if (typeof __base64_std !== "undefined") return '"' + __base64_std.EncodeToString(u8) + '"';
-  var bstr = "";
-  for (var i = 0; i < u8.length; i++) bstr += String.fromCharCode(u8[i]);
-  return '"' + (typeof btoa !== "undefined" ? btoa(bstr) : Buffer.from(u8).toString("base64")) + '"';
-};
-var __json_b64_dec = __json_b64_dec || function(str) {
-  if (typeof __base64_std !== "undefined") {
-    var res = __base64_std.DecodeString(str);
-    if (!res[1]) return res[0];
-  }
-  var bin = typeof atob !== "undefined" ? atob(str) : Buffer.from(str, "base64").toString("binary");
-  var u8 = new Uint8Array(bin.length);
-  for (var i = 0; i < bin.length; i++) u8[i] = bin.charCodeAt(i);
-  return u8;
-};
-var __json_is_zero = __json_is_zero || function(val, isStruct) {
-  if (isStruct) return false;
-  if (val === null || val === undefined || val === false || val === 0 || val === "") return true;
-  if (typeof val === "bigint") return val === 0n;
-  if (Array.isArray(val) || (ArrayBuffer.isView(val) && !val.__raw)) return val.length === 0;
-  if (val instanceof Map) return val.size === 0;
-  if (val && val.__map) return Object.keys(val).filter(function(k) { return !k.startsWith("__"); }).length === 0;
-  return false;
-};
-var __json_preserve_int64 = __json_preserve_int64 || function(str) {
-  return str.replace(/"(?:\\\\.|[^"\\\\])*"|(?<=[,:\\[{\\s]|^)(-?\\d{16,})(?=[,\\]}\\s]|$)/g, function(m, num) {
-    if (num) {
-      try {
-        var b = BigInt(num);
-        if (b > 9007199254740991n || b < -9007199254740991n) return '"' + num + '__bigint"';
-      } catch (e) {}
+    var c = s.charCodeAt(i), r = null;
+    if (c < 0x20) {
+      r = c === 8 ? "\\\\b" : c === 12 ? "\\\\f" : c === 10 ? "\\\\n" : c === 13 ? "\\\\r" : c === 9 ? "\\\\t" : "\\\\u00" + (c < 16 ? "0" : "") + c.toString(16);
+    } else if (c === 34) r = '\\\\"';
+    else if (c === 92) r = "\\\\\\\\";
+    else if (html && (c === 60 || c === 62 || c === 38)) r = "\\\\u00" + c.toString(16);
+    else if (c === 0x2028 || c === 0x2029) r = "\\\\u202" + (c & 15).toString(16);
+    else if (c >= 0xd800 && c <= 0xdfff) {
+      var d = i + 1 < s.length ? s.charCodeAt(i + 1) : 0;
+      if (c < 0xdc00 && d >= 0xdc00 && d <= 0xdfff) { i++; continue; }
+      r = "\\ufffd";
     }
-    return m;
-  });
-};
-var __json_enc_any = __json_enc_any || function(v) {
-  if (v === null || v === undefined) return "null";
-  var t = typeof v;
-  if (t === "boolean") return v ? "true" : "false";
-  if (t === "number") {
-    if (!isFinite(v)) throw new Error("json: unsupported value: " + v);
-    return String(v);
-  }
-  if (t === "bigint") return v.toString();
-  if (t === "string") return __json_esc(v);
-  if ((typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(v)) || v instanceof Uint8Array) {
-    if (v.__raw) {
-      var s = (typeof v === "string" ? v : new TextDecoder().decode(v)).trim();
-      return s.length > 0 ? s : "null";
-    }
-    return __json_b64(v);
-  }
-  if (Array.isArray(v)) {
-    var items = [];
-    for (var i = 0; i < v.length; i++) items.push(__json_enc_any(v[i]));
-    return "[" + items.join(",") + "]";
-  }
-  if (v instanceof Map) {
-    var mkeys = Array.from(v.keys()).map(String).sort();
-    var mentries = [];
-    for (var mi = 0; mi < mkeys.length; mi++) {
-      mentries.push(__json_esc(mkeys[mi]) + ":" + __json_enc_any(v.get(mkeys[mi])));
+    if (r !== null) { out += s.slice(start, i) + r; start = i + 1; }
+  }
+  return out + s.slice(start);
+};
+var __jtd = __jtd || new TextDecoder("utf-8", { ignoreBOM: true });
+var __jrstr = __jrstr || function(d, unquote) {
+  var data = d.data, p = d.pos + 1, start = p, n = data.length, esc = false;
+  for (; p < n; p++) {
+    var c = data[p];
+    if (c === 34) break;
+    if (c === 92) { esc = true; p++; }
+  }
+  d.pos = p + 1;
+  if (esc) return unquote(data.subarray(start, p));
+  if (p - start < 32) {
+    var s = "";
+    for (var i = start; i < p; i++) {
+      var b = data[i];
+      if (b > 127) return __jtd.decode(data.subarray(start, p));
+      s += String.fromCharCode(b);
     }
-    return "{" + mentries.join(",") + "}";
-  }
-  if (typeof v.__json_enc === "function") return v.__json_enc();
-  if (typeof v.MarshalJSON === "function" && !(v.__v === true && v.MarshalJSON.__ptrRecv)) {
-    return __json_marshaler_out(v.MarshalJSON(), v.constructor && v.constructor.name ? v.constructor.name : "value");
-  }
-  // Boxed named values (from an interface) encode as their value; *T boxes as the pointee.
-  if (typeof v.__gfUnbox === "function") {
-    var inner = v.__gfUnbox();
-    if (Object.prototype.hasOwnProperty.call(v, "_p")) inner = inner == null ? null : inner.value;
-    return __json_enc_any(inner);
-  }
-  if (typeof v === "object") {
-    var okeys = Object.keys(v).filter(function(k) { return !k.startsWith("__") || k === "__proto__"; });
-    if (!v.__map && v.constructor && v.constructor !== Object && v.constructor.name !== "Object") {
-      okeys = okeys.filter(function(k) { return !(k.length > 0 && k[0] >= "a" && k[0] <= "z"); });
-    }
-    okeys.sort();
-    var oentries = [];
-    for (var oi = 0; oi < okeys.length; oi++) {
-      oentries.push(__json_esc(okeys[oi]) + ":" + __json_enc_any(v[okeys[oi]]));
-    }
-    return "{" + oentries.join(",") + "}";
-  }
-  return "null";
-};
-var __json_dec_any = __json_dec_any || function(parsed) {
-  if (parsed === null) return null;
-  if (typeof parsed === "string") {
-    if (parsed.endsWith("__bigint")) return Number(parsed.slice(0, -8));
-    return parsed;
-  }
-  if (typeof parsed === "number" || typeof parsed === "boolean") return parsed;
-  if (Array.isArray(parsed)) {
-    var outSlice = [];
-    for (var i = 0; i < parsed.length; i++) outSlice.push(__json_dec_any(parsed[i]));
-    return outSlice;
-  }
-  if (typeof parsed === "object") {
-    var outMap = Object.create(null);
-    outMap.__map = true;
-    for (var k in parsed) {
-      if (Object.prototype.hasOwnProperty.call(parsed, k)) {
-        outMap[k] = __json_dec_any(parsed[k]);
-      }
-    }
-    return outMap;
+    return s;
   }
-  return parsed;
+  return __jtd.decode(data.subarray(start, p));
 };
-var __json_dec_any_target = __json_dec_any_target || function(parsed, target, box) {
-  var out = __json_dec_any(parsed);
-  if (box) box.value = out;
-  else if (target && typeof target === "object") {
-    for (const k of Object.keys(out)) Object.defineProperty(target, k, { value: out[k], writable: true, enumerable: true, configurable: true });
-  }
-  return null;
-};
-var __json_enc_slice = __json_enc_slice || function(slice, elemEnc) {
-  if (slice === null || slice === undefined) return "null";
-  var items = [];
-  for (var i = 0; i < slice.length; i++) items.push(elemEnc(slice[i]));
-  return "[" + items.join(",") + "]";
-};
-var __json_enc_map = __json_enc_map || function(m, valEnc) {
-  if (m === null || m === undefined) return "null";
-  if (m instanceof Map) {
-    var mkeys = Array.from(m.keys()).map(String).sort();
-    var mentries = [];
-    for (var i = 0; i < mkeys.length; i++) {
-      mentries.push(__json_esc(mkeys[i]) + ":" + valEnc(m.get(mkeys[i])));
-    }
-    return "{" + mentries.join(",") + "}";
-  }
-  var keys = Object.keys(m).filter(function(k) { return !k.startsWith("__") || k === "__proto__"; }).sort();
-  var entries = [];
-  for (var j = 0; j < keys.length; j++) {
-    entries.push(__json_esc(keys[j]) + ":" + valEnc(m[keys[j]]));
-  }
-  return "{" + entries.join(",") + "}";
-};
-var __json_marshal = __json_marshal || function(enc, val) {
-  try {
-    var str = enc(val);
-    return [new TextEncoder().encode(str), null];
-  } catch (e) {
-    return [new Uint8Array(0), typeof __error === "function" ? __error(e.message) : e];
+var __jrnum = __jrnum || function(d) {
+  var data = d.data, p = d.pos, start = p, n = data.length, s = "";
+  for (; p < n; p++) {
+    var c = data[p];
+    if (!((c >= 48 && c <= 57) || c === 45 || c === 43 || c === 46 || c === 101 || c === 69)) break;
+    s += String.fromCharCode(c);
   }
+  d.pos = p;
+  return s;
 };
-var __json_indent = __json_indent || function(jsonStr, prefix, indent) {
-  var out = "";
-  var depth = 0;
-  var inString = false;
-  var escaped = false;
-  for (var i = 0; i < jsonStr.length; i++) {
-    var c = jsonStr[i];
-    if (inString) {
-      out += c;
-      if (escaped) escaped = false;
-      else if (c === "\\\\") escaped = true;
-      else if (c === '"') inString = false;
-      continue;
+var __jvalid = __jvalid || function(data) {
+  if (data === null || data === undefined) return false;
+  var n = data.length;
+  if (n > 10000) {
+    // encoding/json stops at a nesting depth of 10000.
+    var depth = 0, inStr = false;
+    for (var i = 0; i < n; i++) {
+      var c = data[i];
+      if (inStr) { if (c === 92) i++; else if (c === 34) inStr = false; }
+      else if (c === 34) inStr = true;
+      else if (c === 91 || c === 123) { if (++depth > 10000) return false; }
+      else if (c === 93 || c === 125) depth--;
     }
-    if (c === '"') { inString = true; out += c; continue; }
-    if (c === "{" || c === "[") {
-      out += c;
-      depth++;
-      var next = jsonStr[i + 1];
-      if ((c === "{" && next === "}") || (c === "[" && next === "]")) {
-        out += next;
-        i++;
-        depth--;
-        continue;
-      }
-      out += "\\n" + prefix + indent.repeat(depth);
-    } else if (c === "}" || c === "]") {
-      depth--;
-      out += "\\n" + prefix + indent.repeat(depth) + c;
-    } else if (c === ",") {
-      out += ",\\n" + prefix + indent.repeat(depth);
-    } else if (c === ":") {
-      out += ": ";
-    } else if (c !== " " && c !== "\\t" && c !== "\\n" && c !== "\\r") {
-      out += c;
-    }
-  }
-  return out;
-};
-var __json_marshal_indent = __json_marshal_indent || function(enc, val, prefix, indent) {
-  var res = __json_marshal(enc, val);
-  if (res[1]) return res;
-  var rawStr = new TextDecoder().decode(res[0]);
-  var formatted = __json_indent(rawStr, prefix, indent);
-  return [new TextEncoder().encode(formatted), null];
-};
-var __json_valid = __json_valid || function(data) {
-  try {
-    var s = typeof data === "string" ? data : new TextDecoder().decode(((typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(data)) || data instanceof Uint8Array) ? data : new Uint8Array(data));
-    JSON.parse(s);
-    return true;
-  } catch (e) {
-    return false;
   }
+  try { JSON.parse(__jtd.decode(data)); return true; } catch (e) { return false; }
 };
-var __json_unmarshal = __json_unmarshal || function(dec, data, target) {
-  __json_structs.length = 0;
-  __json_path.length = 0;
-  if (target === null || target === undefined) {
-    return typeof __error === "function" ? __error("json: Unmarshal(nil)") : new Error("json: Unmarshal(nil)");
-  }
-  if (typeof target !== "object" || target.__v === true) {
-    return typeof __error === "function" ? __error("json: Unmarshal(non-pointer " + typeof target + ")") : new Error("json: Unmarshal(non-pointer " + typeof target + ")");
-  }
-  var str;
-  try {
-    str = typeof data === "string" ? data : new TextDecoder().decode(((typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView(data)) || data instanceof Uint8Array) ? data : new Uint8Array(data));
-  } catch (e) {
-    return typeof __error === "function" ? __error("invalid UTF-8 data") : e;
-  }
-  var safeStr = __json_preserve_int64(str);
-  var parsed;
-  try {
-    parsed = JSON.parse(safeStr);
-  } catch (e) {
-    return typeof __error === "function" ? __error(e.message) : e;
-  }
-  var rootRaw = __json_parse_raw_node(str);
-  __json_bind_raw(parsed, rootRaw);
-  var isBox = target && typeof target === "object" && (Object.prototype.hasOwnProperty.call(target, "value") || typeof target.__gfUnbox === "function");
-  var dest = isBox ? target.value : target;
-  var err = dec(parsed, dest, isBox ? target : null, data, rootRaw.raw);
-  if (err) return err.__userErr || err;
-  return null;
+var __jquote = __jquote || function(e, s) {
+  __jroom(e, 1);
+  e.buf[e.n++] = 34;
+  __jput(e, (e.EscapeHTML ? __jescRe : __jescRe2).test(s) ? __jesc(s, e.EscapeHTML) : s);
+  __jroom(e, 1);
+  e.buf[e.n++] = 34;
 };`;
 
 export const HELPER_SIMD = `var __simd_f32x4 = __simd_f32x4 || function(a, b, c, d) {
@@ -1881,6 +1112,59 @@ var __simd_with_lane = __simd_with_lane || function(a, i, v) {
   r[i] = Math.fround(v);
   return Object.freeze(r);
 };
+var __simd_map = __simd_map || function(a, f) {
+  return Object.freeze([Math.fround(f(a[0])), Math.fround(f(a[1])), Math.fround(f(a[2])), Math.fround(f(a[3]))]);
+};
+var __simd_neg = __simd_neg || function(a) { return __simd_map(a, function(x) { return -x; }); };
+var __simd_abs = __simd_abs || function(a) { return __simd_map(a, Math.abs); };
+var __simd_sqrt = __simd_sqrt || function(a) { return __simd_map(a, Math.sqrt); };
+var __simd_floor = __simd_floor || function(a) { return __simd_map(a, Math.floor); };
+var __simd_ceil = __simd_ceil || function(a) { return __simd_map(a, Math.ceil); };
+var __simd_trunc = __simd_trunc || function(a) { return __simd_map(a, Math.trunc); };
+var __simd_nearest = __simd_nearest || function(a) {
+  return __simd_map(a, function(x) {
+    if (!isFinite(x)) return x;
+    var f = Math.floor(x), d = x - f, r;
+    if (d < 0.5) r = f; else if (d > 0.5) r = f + 1; else r = (f % 2 === 0) ? f : f + 1;
+    return (r === 0 && (x < 0 || Object.is(x, -0))) ? -0 : r;
+  });
+};
+var __simd_muladd = __simd_muladd || function(a, b, c) {
+  return Object.freeze([Math.fround(Math.fround(a[0] * b[0]) + c[0]), Math.fround(Math.fround(a[1] * b[1]) + c[1]), Math.fround(Math.fround(a[2] * b[2]) + c[2]), Math.fround(Math.fround(a[3] * b[3]) + c[3])]);
+};
+var __simd_sum = __simd_sum || function(a) {
+  return Math.fround(Math.fround(Math.fround(a[0] + a[1]) + a[2]) + a[3]);
+};
+var __simd_cmp = __simd_cmp || function(a, b, f) {
+  return Object.freeze([f(a[0], b[0]), f(a[1], b[1]), f(a[2], b[2]), f(a[3], b[3])]);
+};
+var __simd_eq = __simd_eq || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x === y; }); };
+var __simd_ne = __simd_ne || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x !== y; }); };
+var __simd_lt = __simd_lt || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x < y; }); };
+var __simd_le = __simd_le || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x <= y; }); };
+var __simd_gt = __simd_gt || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x > y; }); };
+var __simd_ge = __simd_ge || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x >= y; }); };
+var __simd_equal = __simd_equal || function(a, b) {
+  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+};
+var __simd_mask_and = __simd_mask_and || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x && y; }); };
+var __simd_mask_or = __simd_mask_or || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x || y; }); };
+var __simd_mask_xor = __simd_mask_xor || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x !== y; }); };
+var __simd_mask_andnot = __simd_mask_andnot || function(a, b) { return __simd_cmp(a, b, function(x, y) { return x && !y; }); };
+var __simd_mask_not = __simd_mask_not || function(a) { return Object.freeze([!a[0], !a[1], !a[2], !a[3]]); };
+var __simd_mask_any = __simd_mask_any || function(a) { return a[0] || a[1] || a[2] || a[3]; };
+var __simd_mask_all = __simd_mask_all || function(a) { return a[0] && a[1] && a[2] && a[3]; };
+var __simd_mask_bits = __simd_mask_bits || function(a) { return (a[0] ? 1 : 0) | (a[1] ? 2 : 0) | (a[2] ? 4 : 0) | (a[3] ? 8 : 0); };
+var __simd_select = __simd_select || function(m, a, b) {
+  return Object.freeze([m[0] ? a[0] : b[0], m[1] ? a[1] : b[1], m[2] ? a[2] : b[2], m[3] ? a[3] : b[3]]);
+};
+var __simd_shuffle = __simd_shuffle || function(a, b, i0, i1, i2, i3) {
+  var c = [a[0], a[1], a[2], a[3], b[0], b[1], b[2], b[3]];
+  return Object.freeze([c[i0], c[i1], c[i2], c[i3]]);
+};
+var __simd_swizzle = __simd_swizzle || function(a, i0, i1, i2, i3) {
+  return Object.freeze([a[i0], a[i1], a[i2], a[i3]]);
+};
 var __simd_load = __simd_load || function(buf, i) {
   if (i < 0 || i + 4 > buf.length) throw new Error("panic: runtime error: index out of range");
   return Object.freeze([Math.fround(buf[i]), Math.fround(buf[i + 1]), Math.fround(buf[i + 2]), Math.fround(buf[i + 3])]);
@@ -1888,4 +1172,12 @@ var __simd_load = __simd_load || function(buf, i) {
 var __simd_store = __simd_store || function(buf, i, v) {
   if (i < 0 || i + 4 > buf.length) throw new Error("panic: runtime error: index out of range");
   buf[i] = v[0]; buf[i + 1] = v[1]; buf[i + 2] = v[2]; buf[i + 3] = v[3];
+};
+var __simd_load_slice = __simd_load_slice || function(xs, i) {
+  if (xs == null || i < 0 || i + 4 > xs.length) throw new Error("panic: runtime error: index out of range");
+  return Object.freeze([xs[i], xs[i + 1], xs[i + 2], xs[i + 3]]);
+};
+var __simd_store_slice = __simd_store_slice || function(xs, i, v) {
+  if (xs == null || i < 0 || i + 4 > xs.length) throw new Error("panic: runtime error: index out of range");
+  xs[i] = v[0]; xs[i + 1] = v[1]; xs[i + 2] = v[2]; xs[i + 3] = v[3];
 };`;