@thru/programs 0.2.22 → 0.2.24

package/dist/multicall/index.cjs

@@ -0,0 +1,2579 @@
+'use strict';
+
+var helpers = require('@thru/sdk/helpers');
+
+// src/multicall/index.ts
+
+// src/multicall/abi/thru/common/primitives/types.ts
+var __tnWarnings = /* @__PURE__ */ new Set();
+var __tnHasNativeBigInt = typeof BigInt === "function";
+var __tnHasBigIntDataView = typeof DataView !== "undefined" && typeof DataView.prototype.getBigInt64 === "function" && typeof DataView.prototype.getBigUint64 === "function" && typeof DataView.prototype.setBigInt64 === "function" && typeof DataView.prototype.setBigUint64 === "function";
+var __tnConsole = typeof globalThis !== "undefined" ? globalThis.console : void 0;
+function __tnLogWarn(message) {
+  if (__tnConsole && typeof __tnConsole.warn === "function") {
+    __tnConsole.warn(message);
+  }
+}
+function __tnWarnOnce(message) {
+  if (!__tnWarnings.has(message)) {
+    __tnWarnings.add(message);
+    __tnLogWarn(message);
+  }
+}
+function __tnResolveBuilderInput(input, context) {
+  if (input instanceof Uint8Array) {
+    return new Uint8Array(input);
+  }
+  if (input && typeof input.build === "function") {
+    const built = input.build();
+    if (!(built instanceof Uint8Array)) {
+      throw new Error(`${context}: builder did not return Uint8Array`);
+    }
+    return new Uint8Array(built);
+  }
+  throw new Error(`${context}: expected Uint8Array or builder`);
+}
+function __tnCreateFamWriter(parent, fieldName, assign) {
+  let hasWritten = false;
+  return {
+    write(payload) {
+      const bytes = __tnResolveBuilderInput(
+        payload,
+        `flexible array '${fieldName}'`
+      );
+      const copy = new Uint8Array(bytes);
+      assign(copy);
+      hasWritten = true;
+      return {
+        finish() {
+          return parent;
+        }
+      };
+    },
+    finish() {
+      if (!hasWritten) {
+        throw new Error(
+          `flexible array '${fieldName}' requires write() before finish()`
+        );
+      }
+      return parent;
+    }
+  };
+}
+var __tnMask32 = __tnHasNativeBigInt ? (BigInt(1) << BigInt(32)) - BigInt(1) : 4294967295;
+var __tnSignBit32 = __tnHasNativeBigInt ? BigInt(1) << BigInt(31) : 2147483648;
+function __tnToBigInt(value) {
+  if (__tnHasNativeBigInt) {
+    return typeof value === "bigint" ? value : BigInt(value);
+  }
+  if (typeof value === "bigint") return value;
+  if (!Number.isFinite(value)) {
+    throw new Error("IR runtime received non-finite numeric input");
+  }
+  if (!Number.isSafeInteger(value)) {
+    __tnWarnOnce(
+      `[thru-net] Precision loss while polyfilling BigInt (value=${value})`
+    );
+  }
+  return value;
+}
+function __tnBigIntToNumber(value, context) {
+  if (__tnHasNativeBigInt) {
+    const converted = Number(value);
+    if (!Number.isFinite(converted)) {
+      throw new Error(`${context} overflowed Number range`);
+    }
+    return converted;
+  }
+  return value;
+}
+function __tnBigIntEquals(lhs, rhs) {
+  if (__tnHasNativeBigInt) return lhs === rhs;
+  return lhs === rhs;
+}
+function __tnBigIntGreaterThan(lhs, rhs) {
+  if (__tnHasNativeBigInt) return lhs > rhs;
+  return lhs > rhs;
+}
+function __tnRaiseIrError(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  throw err;
+}
+function __tnCheckedAdd(lhs, rhs) {
+  if (__tnHasNativeBigInt) {
+    const result = lhs + rhs;
+    if (result < BigInt(0)) {
+      __tnRaiseIrError(
+        "tn.ir.overflow",
+        "IR runtime detected negative size via addition"
+      );
+    }
+    return result;
+  }
+  const left = lhs;
+  const right = rhs;
+  const sum = left + right;
+  if (sum < 0 || !Number.isFinite(sum)) {
+    __tnRaiseIrError(
+      "tn.ir.overflow",
+      "IR runtime detected invalid addition result"
+    );
+  }
+  if (!Number.isSafeInteger(sum)) {
+    __tnWarnOnce("[thru-net] Precision loss while polyfilling BigInt addition");
+  }
+  return sum;
+}
+function __tnCheckedMul(lhs, rhs) {
+  if (__tnHasNativeBigInt) {
+    const result = lhs * rhs;
+    if (result < BigInt(0)) {
+      __tnRaiseIrError(
+        "tn.ir.overflow",
+        "IR runtime detected negative size via multiplication"
+      );
+    }
+    return result;
+  }
+  const left = lhs;
+  const right = rhs;
+  const product = left * right;
+  if (product < 0 || !Number.isFinite(product)) {
+    __tnRaiseIrError(
+      "tn.ir.overflow",
+      "IR runtime detected invalid multiplication result"
+    );
+  }
+  if (!Number.isSafeInteger(product)) {
+    __tnWarnOnce(
+      "[thru-net] Precision loss while polyfilling BigInt multiplication"
+    );
+  }
+  return product;
+}
+function __tnAlign(value, alignment) {
+  if (alignment <= 1) return value;
+  const alignBig = __tnToBigInt(alignment);
+  if (__tnHasNativeBigInt) {
+    const remainder2 = value % alignBig;
+    if (__tnBigIntEquals(remainder2, __tnToBigInt(0))) {
+      return value;
+    }
+    const delta = alignBig - remainder2;
+    return __tnCheckedAdd(value, delta);
+  }
+  const current = __tnBigIntToNumber(value, "IR align");
+  const alignNum = alignment >>> 0;
+  const remainder = current % alignNum;
+  const next = remainder === 0 ? current : current + (alignNum - remainder);
+  return __tnToBigInt(next);
+}
+function __tnSplitUint64(value) {
+  if (__tnHasNativeBigInt) {
+    const low2 = Number(value & __tnMask32);
+    const high2 = Number(value >> BigInt(32) & __tnMask32);
+    return { high: high2, low: low2 };
+  }
+  const num = __tnBigIntToNumber(value, "DataView.setBigUint64");
+  const low = num >>> 0;
+  const high = Math.floor(num / 4294967296) >>> 0;
+  return { high, low };
+}
+function __tnSplitInt64(value) {
+  if (__tnHasNativeBigInt) {
+    const low2 = Number(value & __tnMask32);
+    let high2 = Number(value >> BigInt(32) & __tnMask32);
+    if ((BigInt(high2) & __tnSignBit32) !== BigInt(0)) {
+      high2 -= 4294967296;
+    }
+    return { high: high2, low: low2 };
+  }
+  const num = __tnBigIntToNumber(value, "DataView.setBigInt64");
+  const low = num >>> 0;
+  const high = Math.floor(num / 4294967296);
+  return { high, low };
+}
+function __tnPolyfillReadUint64(view, offset, littleEndian) {
+  const low = littleEndian ? view.getUint32(offset, true) : view.getUint32(offset + 4, false);
+  const high = littleEndian ? view.getUint32(offset + 4, true) : view.getUint32(offset, false);
+  if (__tnHasNativeBigInt) {
+    return BigInt(high) << BigInt(32) | BigInt(low);
+  }
+  const value = high * 4294967296 + low;
+  if (!Number.isSafeInteger(value)) {
+    __tnWarnOnce(
+      "[thru-net] Precision loss while polyfilling DataView.getBigUint64"
+    );
+  }
+  return value;
+}
+function __tnPolyfillReadInt64(view, offset, littleEndian) {
+  const low = littleEndian ? view.getUint32(offset, true) : view.getUint32(offset + 4, false);
+  const high = littleEndian ? view.getInt32(offset + 4, true) : view.getInt32(offset, false);
+  if (__tnHasNativeBigInt) {
+    return BigInt(high) << BigInt(32) | BigInt(low);
+  }
+  const value = high * 4294967296 + low;
+  if (!Number.isSafeInteger(value)) {
+    __tnWarnOnce(
+      "[thru-net] Precision loss while polyfilling DataView.getBigInt64"
+    );
+  }
+  return value;
+}
+function __tnPolyfillWriteUint64(view, offset, value, littleEndian) {
+  const parts = __tnSplitUint64(value);
+  if (littleEndian) {
+    view.setUint32(offset, parts.low, true);
+    view.setUint32(offset + 4, parts.high, true);
+  } else {
+    view.setUint32(offset, parts.high, false);
+    view.setUint32(offset + 4, parts.low, false);
+  }
+}
+function __tnPolyfillWriteInt64(view, offset, value, littleEndian) {
+  const parts = __tnSplitInt64(value);
+  if (littleEndian) {
+    view.setUint32(offset, parts.low >>> 0, true);
+    view.setInt32(offset + 4, parts.high | 0, true);
+  } else {
+    view.setInt32(offset, parts.high | 0, false);
+    view.setUint32(offset + 4, parts.low >>> 0, false);
+  }
+}
+if (typeof DataView !== "undefined" && !__tnHasBigIntDataView) {
+  const proto = DataView.prototype;
+  if (typeof proto.getBigUint64 !== "function") {
+    proto.getBigUint64 = function(offset, littleEndian) {
+      __tnWarnOnce(
+        "[thru-net] Polyfilling DataView.getBigUint64; precision may be lost"
+      );
+      return __tnPolyfillReadUint64(this, offset, !!littleEndian);
+    };
+  }
+  if (typeof proto.getBigInt64 !== "function") {
+    proto.getBigInt64 = function(offset, littleEndian) {
+      __tnWarnOnce(
+        "[thru-net] Polyfilling DataView.getBigInt64; precision may be lost"
+      );
+      return __tnPolyfillReadInt64(this, offset, !!littleEndian);
+    };
+  }
+  if (typeof proto.setBigUint64 !== "function") {
+    proto.setBigUint64 = function(offset, value, littleEndian) {
+      __tnWarnOnce(
+        "[thru-net] Polyfilling DataView.setBigUint64; precision may be lost"
+      );
+      __tnPolyfillWriteUint64(this, offset, value, !!littleEndian);
+    };
+  }
+  if (typeof proto.setBigInt64 !== "function") {
+    proto.setBigInt64 = function(offset, value, littleEndian) {
+      __tnWarnOnce(
+        "[thru-net] Polyfilling DataView.setBigInt64; precision may be lost"
+      );
+      __tnPolyfillWriteInt64(this, offset, value, !!littleEndian);
+    };
+  }
+  if (!__tnHasNativeBigInt) {
+    __tnWarnOnce(
+      "[thru-net] BigInt is unavailable; falling back to lossy 64-bit polyfill"
+    );
+  }
+}
+var __tnFootprintRegistry = {};
+var __tnValidateRegistry = {};
+var __tnDynamicValidateRegistry = {};
+function __tnRegisterFootprint(typeName, fn) {
+  __tnFootprintRegistry[typeName] = fn;
+}
+function __tnRegisterValidate(typeName, fn) {
+  __tnValidateRegistry[typeName] = fn;
+}
+function __tnRegisterDynamicValidate(typeName, fn) {
+  __tnDynamicValidateRegistry[typeName] = fn;
+}
+function __tnInvokeFootprint(typeName, params) {
+  const fn = __tnFootprintRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing footprint for ${typeName}`);
+  return fn(params);
+}
+function __tnInvokeValidate(typeName, buffer, params) {
+  const fn = __tnValidateRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing validate helper for ${typeName}`);
+  return fn(buffer, params);
+}
+function __tnInvokeDynamicValidate(typeName, buffer) {
+  const fn = __tnDynamicValidateRegistry[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
+function __tnEvalFootprint(node, ctx) {
+  return __tnEvalIrNode(node, ctx, __tnToBigInt(0));
+}
+function __tnTryEvalIr(node, ctx) {
+  try {
+    return { ok: true, value: __tnEvalIrNode(node, ctx, __tnToBigInt(0)) };
+  } catch (err) {
+    return { ok: false, code: __tnNormalizeIrError(err) };
+  }
+}
+function __tnIsEvalError(result) {
+  return result.ok === false;
+}
+function __tnValidateIrTree(ir, buffer, params) {
+  const evalResult = __tnTryEvalIr(ir.root, {
+    params,
+    buffer,
+    typeName: ir.typeName
+  });
+  if (__tnIsEvalError(evalResult)) {
+    return { ok: false, code: evalResult.code };
+  }
+  const required = evalResult.value;
+  const available = __tnToBigInt(buffer.length);
+  if (__tnBigIntGreaterThan(required, available)) {
+    return { ok: false, code: "tn.buffer_too_small", consumed: required };
+  }
+  return { ok: true, consumed: required };
+}
+function __tnEvalIrNode(node, ctx, baseOffset) {
+  switch (node.op) {
+    case "zero":
+      return __tnToBigInt(0);
+    case "const":
+      return node.value;
+    case "field": {
+      const val = ctx.params[node.param];
+      if (val === void 0) {
+        const prefix = ctx.typeName ? `${ctx.typeName}: ` : "";
+        __tnRaiseIrError(
+          "tn.ir.missing_param",
+          `${prefix}Missing IR parameter '${node.param}'`
+        );
+      }
+      return val;
+    }
+    case "add": {
+      const left = __tnEvalIrNode(node.left, ctx, baseOffset);
+      const right = __tnEvalIrNode(
+        node.right,
+        ctx,
+        __tnCheckedAdd(baseOffset, left)
+      );
+      return __tnCheckedAdd(left, right);
+    }
+    case "mul":
+      return __tnCheckedMul(
+        __tnEvalIrNode(node.left, ctx, baseOffset),
+        __tnEvalIrNode(node.right, ctx, baseOffset)
+      );
+    case "align":
+      return __tnAlign(__tnEvalIrNode(node.node, ctx, baseOffset), node.alignment);
+    case "switch": {
+      const tagVal = ctx.params[node.tag];
+      if (tagVal === void 0) {
+        const prefix = ctx.typeName ? `${ctx.typeName}: ` : "";
+        __tnRaiseIrError(
+          "tn.ir.missing_param",
+          `${prefix}Missing IR switch tag '${node.tag}'`
+        );
+      }
+      const tagNumber = Number(tagVal);
+      for (const caseNode of node.cases) {
+        if (caseNode.value === tagNumber) {
+          return __tnEvalIrNode(caseNode.node, ctx, baseOffset);
+        }
+      }
+      if (node.default) return __tnEvalIrNode(node.default, ctx, baseOffset);
+      __tnRaiseIrError(
+        "tn.ir.invalid_tag",
+        `Unhandled IR switch value ${tagNumber} for '${node.tag}'`
+      );
+    }
+    case "call": {
+      const nestedParams = /* @__PURE__ */ Object.create(null);
+      for (const arg of node.args) {
+        const val = ctx.params[arg.source];
+        if (val === void 0) {
+          const prefix = ctx.typeName ? `${ctx.typeName}: ` : "";
+          __tnRaiseIrError(
+            "tn.ir.missing_param",
+            `${prefix}Missing IR parameter '${arg.source}' for nested call`
+          );
+        }
+        nestedParams[arg.name] = val;
+      }
+      if (ctx.buffer) {
+        const nestedOffset = __tnBigIntToNumber(baseOffset, "IR nested offset");
+        const nestedResult = __tnInvokeValidate(
+          node.typeName,
+          ctx.buffer.subarray(nestedOffset),
+          nestedParams
+        );
+        if (!nestedResult.ok) {
+          const nestedCode = nestedResult.code ?? `tn.ir.runtime_error: ${node.typeName}`;
+          const prefixed = nestedCode.startsWith("tn.") ? nestedCode : `tn.ir.runtime_error: ${node.typeName} -> ${nestedCode}`;
+          __tnRaiseIrError(
+            prefixed,
+            `Nested validator ${node.typeName} failed`
+          );
+        }
+        if (nestedResult.consumed !== void 0) {
+          return nestedResult.consumed;
+        }
+      }
+      return __tnInvokeFootprint(node.typeName, nestedParams);
+    }
+    case "sumOverArray": {
+      if (!ctx.buffer) {
+        __tnRaiseIrError(
+          "tn.ir.missing_buffer",
+          `Jagged array '${node.fieldName}' requires buffer-backed validation`
+        );
+      }
+      const count = __tnBigIntToNumber(
+        __tnEvalIrNode(node.count, ctx, baseOffset),
+        `Jagged array '${node.fieldName}' count`
+      );
+      let cursor = __tnBigIntToNumber(baseOffset, "IR jagged array offset");
+      let total = __tnToBigInt(0);
+      for (let i = 0; i < count; i++) {
+        const result = __tnInvokeDynamicValidate(
+          node.elementTypeName,
+          ctx.buffer.subarray(cursor)
+        );
+        if (!result.ok || result.consumed === void 0) {
+          const code = result.code ?? "tn.ir.runtime_error";
+          __tnRaiseIrError(
+            code,
+            `Jagged array '${node.fieldName}' element ${i} failed validation`
+          );
+        }
+        cursor += __tnBigIntToNumber(result.consumed, "IR jagged element size");
+        total = __tnCheckedAdd(total, result.consumed);
+      }
+      return total;
+    }
+    default:
+      __tnRaiseIrError(
+        "tn.ir.runtime_error",
+        `Unsupported IR node ${node.op}`
+      );
+  }
+}
+function __tnNormalizeIrError(err) {
+  if (err && typeof err === "object" && "code" in err) {
+    const maybeCode = err.code;
+    if (typeof maybeCode === "string" && maybeCode.length > 0) {
+      return maybeCode;
+    }
+  }
+  const message = err && typeof err === "object" && "message" in err ? String(err.message ?? "") : typeof err === "string" ? err : "";
+  if (message.includes("Missing IR parameter")) return "tn.ir.missing_param";
+  if (message.includes("Unhandled IR switch value")) return "tn.ir.invalid_tag";
+  if (message.includes("invalid") || message.includes("overflow") || message.includes("negative size")) {
+    return "tn.ir.overflow";
+  }
+  if (message.length > 0) return `tn.ir.runtime_error: ${message}`;
+  return "tn.ir.runtime_error";
+}
+var __tn_ir_Date = {
+  typeName: "Date",
+  root: { op: "const", value: 6n }
+};
+var Date = class _Date {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Date.__tnCreateView requires a Uint8Array");
+    return new _Date(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new DateBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Date.from_array(buffer);
+  }
+  get_year() {
+    const offset = 0;
+    return this.view.getInt32(offset, true);
+  }
+  set_year(value) {
+    const offset = 0;
+    this.view.setInt32(offset, value, true);
+  }
+  get year() {
+    return this.get_year();
+  }
+  set year(value) {
+    this.set_year(value);
+  }
+  get_month() {
+    const offset = 4;
+    return this.view.getUint8(offset);
+  }
+  set_month(value) {
+    const offset = 4;
+    this.view.setUint8(offset, value);
+  }
+  get month() {
+    return this.get_month();
+  }
+  set month(value) {
+    this.set_month(value);
+  }
+  get_day() {
+    const offset = 5;
+    return this.view.getUint8(offset);
+  }
+  set_day(value) {
+    const offset = 5;
+    this.view.setUint8(offset, value);
+  }
+  get day() {
+    return this.get_day();
+  }
+  set day(value) {
+    this.set_day(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Date.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Date, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Date");
+    }
+    return __tnBigIntToNumber(irResult, "Date::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 6) return { ok: false, code: "tn.buffer_too_small", consumed: 6 };
+    return { ok: true, consumed: 6 };
+  }
+  static new(year, month, day) {
+    const buffer = new Uint8Array(6);
+    const view = new DataView(buffer.buffer);
+    view.setInt32(0, year, true);
+    view.setUint8(4, month);
+    view.setUint8(5, day);
+    return new _Date(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Date(buffer);
+  }
+};
+var DateBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(6);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_year(value) {
+    this.view.setInt32(0, value, true);
+    return this;
+  }
+  set_month(value) {
+    this.view.setUint8(4, value);
+    return this;
+  }
+  set_day(value) {
+    this.view.setUint8(5, value);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Date.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Date");
+    return view;
+  }
+};
+__tnRegisterFootprint("Date", (params) => Date.__tnInvokeFootprint(params));
+__tnRegisterValidate("Date", (buffer, params) => Date.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Date", (buffer) => {
+  const result = Date.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_Duration = {
+  typeName: "Duration",
+  root: { op: "const", value: 12n }
+};
+var Duration = class _Duration {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Duration.__tnCreateView requires a Uint8Array");
+    return new _Duration(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new DurationBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Duration.from_array(buffer);
+  }
+  get_seconds() {
+    const offset = 0;
+    return this.view.getBigInt64(offset, true);
+  }
+  set_seconds(value) {
+    const offset = 0;
+    this.view.setBigInt64(offset, value, true);
+  }
+  get seconds() {
+    return this.get_seconds();
+  }
+  set seconds(value) {
+    this.set_seconds(value);
+  }
+  get_nanos() {
+    const offset = 8;
+    return this.view.getInt32(offset, true);
+  }
+  set_nanos(value) {
+    const offset = 8;
+    this.view.setInt32(offset, value, true);
+  }
+  get nanos() {
+    return this.get_nanos();
+  }
+  set nanos(value) {
+    this.set_nanos(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Duration.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Duration, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Duration");
+    }
+    return __tnBigIntToNumber(irResult, "Duration::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 12) return { ok: false, code: "tn.buffer_too_small", consumed: 12 };
+    return { ok: true, consumed: 12 };
+  }
+  static new(seconds, nanos) {
+    const buffer = new Uint8Array(12);
+    const view = new DataView(buffer.buffer);
+    view.setBigInt64(0, seconds, true);
+    view.setInt32(8, nanos, true);
+    return new _Duration(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Duration(buffer);
+  }
+};
+var DurationBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(12);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_seconds(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigInt64(0, cast, true);
+    return this;
+  }
+  set_nanos(value) {
+    this.view.setInt32(8, value, true);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Duration.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Duration");
+    return view;
+  }
+};
+__tnRegisterFootprint("Duration", (params) => Duration.__tnInvokeFootprint(params));
+__tnRegisterValidate("Duration", (buffer, params) => Duration.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Duration", (buffer) => {
+  const result = Duration.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_FixedPoint = {
+  typeName: "FixedPoint",
+  root: { op: "const", value: 9n }
+};
+var FixedPoint = class _FixedPoint {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("FixedPoint.__tnCreateView requires a Uint8Array");
+    return new _FixedPoint(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new FixedPointBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _FixedPoint.from_array(buffer);
+  }
+  get_mantissa() {
+    const offset = 0;
+    return this.view.getBigInt64(offset, true);
+  }
+  set_mantissa(value) {
+    const offset = 0;
+    this.view.setBigInt64(offset, value, true);
+  }
+  get mantissa() {
+    return this.get_mantissa();
+  }
+  set mantissa(value) {
+    this.set_mantissa(value);
+  }
+  get_scale() {
+    const offset = 8;
+    return this.view.getUint8(offset);
+  }
+  set_scale(value) {
+    const offset = 8;
+    this.view.setUint8(offset, value);
+  }
+  get scale() {
+    return this.get_scale();
+  }
+  set scale(value) {
+    this.set_scale(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_FixedPoint.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_FixedPoint, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for FixedPoint");
+    }
+    return __tnBigIntToNumber(irResult, "FixedPoint::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 9) return { ok: false, code: "tn.buffer_too_small", consumed: 9 };
+    return { ok: true, consumed: 9 };
+  }
+  static new(mantissa, scale) {
+    const buffer = new Uint8Array(9);
+    const view = new DataView(buffer.buffer);
+    view.setBigInt64(0, mantissa, true);
+    view.setUint8(8, scale);
+    return new _FixedPoint(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _FixedPoint(buffer);
+  }
+};
+var FixedPointBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(9);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_mantissa(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigInt64(0, cast, true);
+    return this;
+  }
+  set_scale(value) {
+    this.view.setUint8(8, value);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = FixedPoint.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build FixedPoint");
+    return view;
+  }
+};
+__tnRegisterFootprint("FixedPoint", (params) => FixedPoint.__tnInvokeFootprint(params));
+__tnRegisterValidate("FixedPoint", (buffer, params) => FixedPoint.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("FixedPoint", (buffer) => {
+  const result = FixedPoint.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_Hash = {
+  typeName: "Hash",
+  root: { op: "const", value: 32n }
+};
+var Hash = class _Hash {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Hash.__tnCreateView requires a Uint8Array");
+    return new _Hash(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new HashBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Hash.from_array(buffer);
+  }
+  get_bytes() {
+    const offset = 0;
+    const result = [];
+    for (let i = 0; i < 32; i++) {
+      result.push(this.view.getUint8(offset + i * 1));
+    }
+    return result;
+  }
+  set_bytes(value) {
+    const offset = 0;
+    if (value.length !== 32) {
+      throw new Error("Array length must be 32");
+    }
+    for (let i = 0; i < 32; i++) {
+      this.view.setUint8(offset + i * 1, value[i]);
+    }
+  }
+  get bytes() {
+    return this.get_bytes();
+  }
+  set bytes(value) {
+    this.set_bytes(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Hash.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Hash, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Hash");
+    }
+    return __tnBigIntToNumber(irResult, "Hash::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 32) return { ok: false, code: "tn.buffer_too_small", consumed: 32 };
+    return { ok: true, consumed: 32 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Hash(buffer);
+  }
+};
+var HashBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(32);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_bytes(values) {
+    if (values.length !== 32) throw new Error("bytes expects 32 elements");
+    for (let i = 0; i < values.length; i++) {
+      const byteOffset = 0 + i * 1;
+      this.view.setUint8(byteOffset, values[i]);
+    }
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Hash.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Hash");
+    return view;
+  }
+};
+__tnRegisterFootprint("Hash", (params) => Hash.__tnInvokeFootprint(params));
+__tnRegisterValidate("Hash", (buffer, params) => Hash.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Hash", (buffer) => {
+  const result = Hash.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_InstructionData = {
+  typeName: "InstructionData",
+  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "add", left: { op: "align", alignment: 2, node: { op: "const", value: 2n } }, right: { op: "align", alignment: 8, node: { op: "const", value: 8n } } }, right: { op: "align", alignment: 1, node: { op: "mul", left: { op: "field", param: "data.data_size" }, right: { op: "const", value: 1n } } } } }
+};
+var _InstructionData = class _InstructionData {
+  constructor(buffer, params, fieldContext) {
+    this.buffer = buffer;
+    this.__tnFieldContext = null;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    this.__tnFieldContext = fieldContext ?? null;
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _InstructionData.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("InstructionData: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("InstructionData.__tnCreateView requires a Uint8Array");
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _InstructionData.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("InstructionData.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _InstructionData(new Uint8Array(buffer), params, opts?.fieldContext);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
+  }
+  withFieldContext(context) {
+    this.__tnFieldContext = context;
+    return this;
+  }
+  __tnResolveFieldRef(path) {
+    const getterName = `get_${path.replace(/[.]/g, "_")}`;
+    const getter = this[getterName];
+    if (typeof getter === "function") {
+      const value = getter.call(this);
+      return typeof value === "bigint" ? __tnBigIntToNumber(value, "InstructionData::__tnResolveFieldRef") : value;
+    }
+    if (this.__tnFieldContext && Object.prototype.hasOwnProperty.call(this.__tnFieldContext, path)) {
+      const contextValue = this.__tnFieldContext[path];
+      return typeof contextValue === "bigint" ? __tnBigIntToNumber(contextValue, "InstructionData::__tnResolveFieldRef") : contextValue;
+    }
+    throw new Error("InstructionData: field reference '" + path + "' is not available; provide fieldContext when creating this view");
+  }
+  static builder() {
+    return new InstructionDataBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    const params = builder.dynamicParams();
+    return _InstructionData.from_array(buffer, { params });
+  }
+  static __tnExtractParams(view, buffer) {
+    if (buffer.length < 10) {
+      return null;
+    }
+    const __tnParam_data_data_size = __tnToBigInt(view.getBigUint64(2, true));
+    const __tnExtractedParams = _InstructionData.Params.fromValues({
+      data_data_size: __tnParam_data_data_size
+    });
+    return { params: __tnExtractedParams, derived: null };
+  }
+  get_program_idx() {
+    const offset = 0;
+    return this.view.getUint16(offset, true);
+  }
+  set_program_idx(value) {
+    const offset = 0;
+    this.view.setUint16(offset, value, true);
+  }
+  get program_idx() {
+    return this.get_program_idx();
+  }
+  set program_idx(value) {
+    this.set_program_idx(value);
+  }
+  get_data_size() {
+    const offset = 2;
+    return this.view.getBigUint64(offset, true);
+  }
+  set_data_size(value) {
+    const offset = 2;
+    this.view.setBigUint64(offset, value, true);
+  }
+  get data_size() {
+    return this.get_data_size();
+  }
+  set data_size(value) {
+    this.set_data_size(value);
+  }
+  get_data_length() {
+    return this.__tnResolveFieldRef("data_size");
+  }
+  get_data_at(index) {
+    const offset = 10;
+    return this.view.getUint8(offset + index * 1);
+  }
+  get_data() {
+    const len = this.get_data_length();
+    const result = [];
+    for (let i = 0; i < len; i++) {
+      result.push(this.get_data_at(i));
+    }
+    return result;
+  }
+  set_data_at(index, value) {
+    const offset = 10;
+    this.view.setUint8(offset + index * 1, value);
+  }
+  set_data(value) {
+    const len = Math.min(this.get_data_length(), value.length);
+    for (let i = 0; i < len; i++) {
+      this.set_data_at(i, value[i]);
+    }
+  }
+  get data() {
+    return this.get_data();
+  }
+  set data(value) {
+    this.set_data(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_InstructionData.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_InstructionData, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr(data_data_size) {
+    const params = _InstructionData.Params.fromValues({
+      data_data_size
+    });
+    return this.footprintIrFromParams(params);
+  }
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["data.data_size"] = params.data_data_size;
+    return record;
+  }
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for InstructionData");
+    return __tnBigIntToNumber(irResult, "InstructionData::footprintFromParams");
+  }
+  static footprintFromValues(input) {
+    const params = _InstructionData.params(input);
+    return this.footprintFromParams(params);
+  }
+  static footprint(params) {
+    return this.footprintFromParams(params);
+  }
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      const extracted = this.__tnExtractParams(view, buffer);
+      if (!extracted) return { ok: false, code: "tn.param_extraction_failed" };
+      params = extracted.params;
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber(irResult.consumed, "InstructionData::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber(irResult.consumed, "InstructionData::validate") : void 0;
+    return { ok: true, consumed, params };
+  }
+  static from_array(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      const derived = this.__tnExtractParams(view, buffer);
+      if (!derived) return null;
+      params = derived.params;
+    }
+    const validation = this.validate(buffer, { params });
+    if (!validation.ok) {
+      return null;
+    }
+    const cached = validation.params ?? params;
+    const state = new _InstructionData(buffer, cached);
+    return state;
+  }
+};
+_InstructionData.flexibleArrayWriters = Object.freeze([
+  { field: "data", method: "data", sizeField: "data_size", paramKey: "data_size", elementSize: 1 }
+]);
+exports.InstructionData = _InstructionData;
+((InstructionData2) => {
+  InstructionData2.ParamKeys = Object.freeze({
+    data_data_size: "data.data_size"
+  });
+  InstructionData2.Params = {
+    fromValues(input) {
+      return {
+        data_data_size: __tnToBigInt(input.data_data_size)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return InstructionData2.Params.fromValues(input);
+  }
+  InstructionData2.params = params;
+})(exports.InstructionData || (exports.InstructionData = {}));
+var InstructionDataBuilder = class {
+  constructor() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
+    this.__tnFam_data = null;
+    this.__tnFam_dataCount = null;
+    this.buffer = new Uint8Array(10);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  __tnInvalidate() {
+    this.__tnCachedParams = null;
+    this.__tnLastBuffer = null;
+    this.__tnLastParams = null;
+  }
+  set_program_idx(value) {
+    this.view.setUint16(0, value, true);
+    this.__tnInvalidate();
+    return this;
+  }
+  set_data_size(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigUint64(2, cast, true);
+    this.__tnInvalidate();
+    return this;
+  }
+  data() {
+    if (!this.__tnFamWriter_data) {
+      this.__tnFamWriter_data = __tnCreateFamWriter(this, "data", (payload) => {
+        const bytes = new Uint8Array(payload);
+        const elementCount = bytes.length;
+        this.__tnFam_data = bytes;
+        this.__tnFam_dataCount = elementCount;
+        this.set_data_size(elementCount);
+        this.__tnInvalidate();
+      });
+    }
+    return this.__tnFamWriter_data;
+  }
+  build() {
+    const params = this.__tnComputeParams();
+    const size = exports.InstructionData.footprintFromParams(params);
+    const buffer = new Uint8Array(size);
+    this.__tnWriteInto(buffer);
+    this.__tnValidateOrThrow(buffer, params);
+    return buffer;
+  }
+  buildInto(target, offset = 0) {
+    const params = this.__tnComputeParams();
+    const size = exports.InstructionData.footprintFromParams(params);
+    if (target.length - offset < size) throw new Error("InstructionDataBuilder: target buffer too small");
+    const slice = target.subarray(offset, offset + size);
+    this.__tnWriteInto(slice);
+    this.__tnValidateOrThrow(slice, params);
+    return target;
+  }
+  finish() {
+    const buffer = this.build();
+    const params = this.__tnLastParams ?? this.__tnComputeParams();
+    const view = exports.InstructionData.from_array(buffer, { params });
+    if (!view) throw new Error("InstructionDataBuilder: failed to finalize view");
+    return view;
+  }
+  finishView() {
+    return this.finish();
+  }
+  dynamicParams() {
+    return this.__tnComputeParams();
+  }
+  __tnComputeParams() {
+    if (this.__tnCachedParams) return this.__tnCachedParams;
+    const params = exports.InstructionData.Params.fromValues({
+      data_data_size: (() => {
+        if (this.__tnFam_dataCount === null) throw new Error("InstructionDataBuilder: field 'data' must be written before computing params");
+        return __tnToBigInt(this.__tnFam_dataCount);
+      })()
+    });
+    this.__tnCachedParams = params;
+    return params;
+  }
+  __tnWriteInto(target) {
+    target.set(this.buffer, 0);
+    let cursor = this.buffer.length;
+    const __tnLocal_data_bytes = this.__tnFam_data;
+    if (!__tnLocal_data_bytes) throw new Error("InstructionDataBuilder: field 'data' must be written before build");
+    target.set(__tnLocal_data_bytes, cursor);
+    cursor += __tnLocal_data_bytes.length;
+  }
+  __tnValidateOrThrow(buffer, params) {
+    const result = exports.InstructionData.validate(buffer, { params });
+    if (!result.ok) {
+      throw new Error(`${exports.InstructionData}Builder: builder produced invalid buffer (code=${result.code ?? "unknown"})`);
+    }
+    this.__tnLastParams = result.params ?? params;
+    this.__tnLastBuffer = buffer;
+  }
+};
+__tnRegisterFootprint("InstructionData", (params) => exports.InstructionData.__tnInvokeFootprint(params));
+__tnRegisterValidate("InstructionData", (buffer, params) => exports.InstructionData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("InstructionData", (buffer) => {
+  const result = exports.InstructionData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_Pubkey = {
+  typeName: "Pubkey",
+  root: { op: "const", value: 32n }
+};
+var Pubkey = class _Pubkey {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Pubkey.__tnCreateView requires a Uint8Array");
+    return new _Pubkey(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new PubkeyBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Pubkey.from_array(buffer);
+  }
+  get_bytes() {
+    const offset = 0;
+    const result = [];
+    for (let i = 0; i < 32; i++) {
+      result.push(this.view.getUint8(offset + i * 1));
+    }
+    return result;
+  }
+  set_bytes(value) {
+    const offset = 0;
+    if (value.length !== 32) {
+      throw new Error("Array length must be 32");
+    }
+    for (let i = 0; i < 32; i++) {
+      this.view.setUint8(offset + i * 1, value[i]);
+    }
+  }
+  get bytes() {
+    return this.get_bytes();
+  }
+  set bytes(value) {
+    this.set_bytes(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Pubkey.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Pubkey, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Pubkey");
+    }
+    return __tnBigIntToNumber(irResult, "Pubkey::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 32) return { ok: false, code: "tn.buffer_too_small", consumed: 32 };
+    return { ok: true, consumed: 32 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Pubkey(buffer);
+  }
+};
+var PubkeyBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(32);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_bytes(values) {
+    if (values.length !== 32) throw new Error("bytes expects 32 elements");
+    for (let i = 0; i < values.length; i++) {
+      const byteOffset = 0 + i * 1;
+      this.view.setUint8(byteOffset, values[i]);
+    }
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Pubkey.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Pubkey");
+    return view;
+  }
+};
+__tnRegisterFootprint("Pubkey", (params) => Pubkey.__tnInvokeFootprint(params));
+__tnRegisterValidate("Pubkey", (buffer, params) => Pubkey.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Pubkey", (buffer) => {
+  const result = Pubkey.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_Signature = {
+  typeName: "Signature",
+  root: { op: "const", value: 64n }
+};
+var Signature = class _Signature {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Signature.__tnCreateView requires a Uint8Array");
+    return new _Signature(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new SignatureBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Signature.from_array(buffer);
+  }
+  get_bytes() {
+    const offset = 0;
+    const result = [];
+    for (let i = 0; i < 64; i++) {
+      result.push(this.view.getUint8(offset + i * 1));
+    }
+    return result;
+  }
+  set_bytes(value) {
+    const offset = 0;
+    if (value.length !== 64) {
+      throw new Error("Array length must be 64");
+    }
+    for (let i = 0; i < 64; i++) {
+      this.view.setUint8(offset + i * 1, value[i]);
+    }
+  }
+  get bytes() {
+    return this.get_bytes();
+  }
+  set bytes(value) {
+    this.set_bytes(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Signature.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Signature, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Signature");
+    }
+    return __tnBigIntToNumber(irResult, "Signature::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 64) return { ok: false, code: "tn.buffer_too_small", consumed: 64 };
+    return { ok: true, consumed: 64 };
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Signature(buffer);
+  }
+};
+var SignatureBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(64);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_bytes(values) {
+    if (values.length !== 64) throw new Error("bytes expects 64 elements");
+    for (let i = 0; i < values.length; i++) {
+      const byteOffset = 0 + i * 1;
+      this.view.setUint8(byteOffset, values[i]);
+    }
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Signature.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Signature");
+    return view;
+  }
+};
+__tnRegisterFootprint("Signature", (params) => Signature.__tnInvokeFootprint(params));
+__tnRegisterValidate("Signature", (buffer, params) => Signature.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Signature", (buffer) => {
+  const result = Signature.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+var __tn_ir_Timestamp = {
+  typeName: "Timestamp",
+  root: { op: "const", value: 8n }
+};
+var Timestamp = class _Timestamp {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("Timestamp.__tnCreateView requires a Uint8Array");
+    return new _Timestamp(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new TimestampBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _Timestamp.from_array(buffer);
+  }
+  get_seconds() {
+    const offset = 0;
+    return this.view.getBigInt64(offset, true);
+  }
+  set_seconds(value) {
+    const offset = 0;
+    this.view.setBigInt64(offset, value, true);
+  }
+  get seconds() {
+    return this.get_seconds();
+  }
+  set seconds(value) {
+    this.set_seconds(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint(__tn_ir_Timestamp.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree(__tn_ir_Timestamp, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for Timestamp");
+    }
+    return __tnBigIntToNumber(irResult, "Timestamp::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 8) return { ok: false, code: "tn.buffer_too_small", consumed: 8 };
+    return { ok: true, consumed: 8 };
+  }
+  static new(seconds) {
+    const buffer = new Uint8Array(8);
+    const view = new DataView(buffer.buffer);
+    view.setBigInt64(0, seconds, true);
+    return new _Timestamp(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _Timestamp(buffer);
+  }
+};
+var TimestampBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(8);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_seconds(value) {
+    const cast = __tnToBigInt(value);
+    this.view.setBigInt64(0, cast, true);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = Timestamp.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build Timestamp");
+    return view;
+  }
+};
+__tnRegisterFootprint("Timestamp", (params) => Timestamp.__tnInvokeFootprint(params));
+__tnRegisterValidate("Timestamp", (buffer, params) => Timestamp.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate("Timestamp", (buffer) => {
+  const result = Timestamp.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt(result.consumed) };
+});
+
+// src/multicall/abi/thru/program/multicall/types.ts
+var __tnWarnings2 = /* @__PURE__ */ new Set();
+var __tnHasNativeBigInt2 = typeof BigInt === "function";
+var __tnHasBigIntDataView2 = typeof DataView !== "undefined" && typeof DataView.prototype.getBigInt64 === "function" && typeof DataView.prototype.getBigUint64 === "function" && typeof DataView.prototype.setBigInt64 === "function" && typeof DataView.prototype.setBigUint64 === "function";
+var __tnConsole2 = typeof globalThis !== "undefined" ? globalThis.console : void 0;
+function __tnLogWarn2(message) {
+  if (__tnConsole2 && typeof __tnConsole2.warn === "function") {
+    __tnConsole2.warn(message);
+  }
+}
+function __tnWarnOnce2(message) {
+  if (!__tnWarnings2.has(message)) {
+    __tnWarnings2.add(message);
+    __tnLogWarn2(message);
+  }
+}
+var __tnMask322 = __tnHasNativeBigInt2 ? (BigInt(1) << BigInt(32)) - BigInt(1) : 4294967295;
+var __tnSignBit322 = __tnHasNativeBigInt2 ? BigInt(1) << BigInt(31) : 2147483648;
+function __tnToBigInt2(value) {
+  if (__tnHasNativeBigInt2) {
+    return typeof value === "bigint" ? value : BigInt(value);
+  }
+  if (typeof value === "bigint") return value;
+  if (!Number.isFinite(value)) {
+    throw new Error("IR runtime received non-finite numeric input");
+  }
+  if (!Number.isSafeInteger(value)) {
+    __tnWarnOnce2(
+      `[thru-net] Precision loss while polyfilling BigInt (value=${value})`
+    );
+  }
+  return value;
+}
+function __tnBigIntToNumber2(value, context) {
+  if (__tnHasNativeBigInt2) {
+    const converted = Number(value);
+    if (!Number.isFinite(converted)) {
+      throw new Error(`${context} overflowed Number range`);
+    }
+    return converted;
+  }
+  return value;
+}
+function __tnBigIntEquals2(lhs, rhs) {
+  if (__tnHasNativeBigInt2) return lhs === rhs;
+  return lhs === rhs;
+}
+function __tnBigIntGreaterThan2(lhs, rhs) {
+  if (__tnHasNativeBigInt2) return lhs > rhs;
+  return lhs > rhs;
+}
+function __tnRaiseIrError2(code, message) {
+  const err = new Error(message);
+  err.code = code;
+  throw err;
+}
+function __tnCheckedAdd2(lhs, rhs) {
+  if (__tnHasNativeBigInt2) {
+    const result = lhs + rhs;
+    if (result < BigInt(0)) {
+      __tnRaiseIrError2(
+        "tn.ir.overflow",
+        "IR runtime detected negative size via addition"
+      );
+    }
+    return result;
+  }
+  const left = lhs;
+  const right = rhs;
+  const sum = left + right;
+  if (sum < 0 || !Number.isFinite(sum)) {
+    __tnRaiseIrError2(
+      "tn.ir.overflow",
+      "IR runtime detected invalid addition result"
+    );
+  }
+  if (!Number.isSafeInteger(sum)) {
+    __tnWarnOnce2("[thru-net] Precision loss while polyfilling BigInt addition");
+  }
+  return sum;
+}
+function __tnCheckedMul2(lhs, rhs) {
+  if (__tnHasNativeBigInt2) {
+    const result = lhs * rhs;
+    if (result < BigInt(0)) {
+      __tnRaiseIrError2(
+        "tn.ir.overflow",
+        "IR runtime detected negative size via multiplication"
+      );
+    }
+    return result;
+  }
+  const left = lhs;
+  const right = rhs;
+  const product = left * right;
+  if (product < 0 || !Number.isFinite(product)) {
+    __tnRaiseIrError2(
+      "tn.ir.overflow",
+      "IR runtime detected invalid multiplication result"
+    );
+  }
+  if (!Number.isSafeInteger(product)) {
+    __tnWarnOnce2(
+      "[thru-net] Precision loss while polyfilling BigInt multiplication"
+    );
+  }
+  return product;
+}
+function __tnAlign2(value, alignment) {
+  if (alignment <= 1) return value;
+  const alignBig = __tnToBigInt2(alignment);
+  if (__tnHasNativeBigInt2) {
+    const remainder2 = value % alignBig;
+    if (__tnBigIntEquals2(remainder2, __tnToBigInt2(0))) {
+      return value;
+    }
+    const delta = alignBig - remainder2;
+    return __tnCheckedAdd2(value, delta);
+  }
+  const current = __tnBigIntToNumber2(value, "IR align");
+  const alignNum = alignment >>> 0;
+  const remainder = current % alignNum;
+  const next = remainder === 0 ? current : current + (alignNum - remainder);
+  return __tnToBigInt2(next);
+}
+function __tnSplitUint642(value) {
+  if (__tnHasNativeBigInt2) {
+    const low2 = Number(value & __tnMask322);
+    const high2 = Number(value >> BigInt(32) & __tnMask322);
+    return { high: high2, low: low2 };
+  }
+  const num = __tnBigIntToNumber2(value, "DataView.setBigUint64");
+  const low = num >>> 0;
+  const high = Math.floor(num / 4294967296) >>> 0;
+  return { high, low };
+}
+function __tnSplitInt642(value) {
+  if (__tnHasNativeBigInt2) {
+    const low2 = Number(value & __tnMask322);
+    let high2 = Number(value >> BigInt(32) & __tnMask322);
+    if ((BigInt(high2) & __tnSignBit322) !== BigInt(0)) {
+      high2 -= 4294967296;
+    }
+    return { high: high2, low: low2 };
+  }
+  const num = __tnBigIntToNumber2(value, "DataView.setBigInt64");
+  const low = num >>> 0;
+  const high = Math.floor(num / 4294967296);
+  return { high, low };
+}
+function __tnPolyfillReadUint642(view, offset, littleEndian) {
+  const low = littleEndian ? view.getUint32(offset, true) : view.getUint32(offset + 4, false);
+  const high = littleEndian ? view.getUint32(offset + 4, true) : view.getUint32(offset, false);
+  if (__tnHasNativeBigInt2) {
+    return BigInt(high) << BigInt(32) | BigInt(low);
+  }
+  const value = high * 4294967296 + low;
+  if (!Number.isSafeInteger(value)) {
+    __tnWarnOnce2(
+      "[thru-net] Precision loss while polyfilling DataView.getBigUint64"
+    );
+  }
+  return value;
+}
+function __tnPolyfillReadInt642(view, offset, littleEndian) {
+  const low = littleEndian ? view.getUint32(offset, true) : view.getUint32(offset + 4, false);
+  const high = littleEndian ? view.getInt32(offset + 4, true) : view.getInt32(offset, false);
+  if (__tnHasNativeBigInt2) {
+    return BigInt(high) << BigInt(32) | BigInt(low);
+  }
+  const value = high * 4294967296 + low;
+  if (!Number.isSafeInteger(value)) {
+    __tnWarnOnce2(
+      "[thru-net] Precision loss while polyfilling DataView.getBigInt64"
+    );
+  }
+  return value;
+}
+function __tnPolyfillWriteUint642(view, offset, value, littleEndian) {
+  const parts = __tnSplitUint642(value);
+  if (littleEndian) {
+    view.setUint32(offset, parts.low, true);
+    view.setUint32(offset + 4, parts.high, true);
+  } else {
+    view.setUint32(offset, parts.high, false);
+    view.setUint32(offset + 4, parts.low, false);
+  }
+}
+function __tnPolyfillWriteInt642(view, offset, value, littleEndian) {
+  const parts = __tnSplitInt642(value);
+  if (littleEndian) {
+    view.setUint32(offset, parts.low >>> 0, true);
+    view.setInt32(offset + 4, parts.high | 0, true);
+  } else {
+    view.setInt32(offset, parts.high | 0, false);
+    view.setUint32(offset + 4, parts.low >>> 0, false);
+  }
+}
+if (typeof DataView !== "undefined" && !__tnHasBigIntDataView2) {
+  const proto = DataView.prototype;
+  if (typeof proto.getBigUint64 !== "function") {
+    proto.getBigUint64 = function(offset, littleEndian) {
+      __tnWarnOnce2(
+        "[thru-net] Polyfilling DataView.getBigUint64; precision may be lost"
+      );
+      return __tnPolyfillReadUint642(this, offset, !!littleEndian);
+    };
+  }
+  if (typeof proto.getBigInt64 !== "function") {
+    proto.getBigInt64 = function(offset, littleEndian) {
+      __tnWarnOnce2(
+        "[thru-net] Polyfilling DataView.getBigInt64; precision may be lost"
+      );
+      return __tnPolyfillReadInt642(this, offset, !!littleEndian);
+    };
+  }
+  if (typeof proto.setBigUint64 !== "function") {
+    proto.setBigUint64 = function(offset, value, littleEndian) {
+      __tnWarnOnce2(
+        "[thru-net] Polyfilling DataView.setBigUint64; precision may be lost"
+      );
+      __tnPolyfillWriteUint642(this, offset, value, !!littleEndian);
+    };
+  }
+  if (typeof proto.setBigInt64 !== "function") {
+    proto.setBigInt64 = function(offset, value, littleEndian) {
+      __tnWarnOnce2(
+        "[thru-net] Polyfilling DataView.setBigInt64; precision may be lost"
+      );
+      __tnPolyfillWriteInt642(this, offset, value, !!littleEndian);
+    };
+  }
+  if (!__tnHasNativeBigInt2) {
+    __tnWarnOnce2(
+      "[thru-net] BigInt is unavailable; falling back to lossy 64-bit polyfill"
+    );
+  }
+}
+var __tnFootprintRegistry2 = {};
+var __tnValidateRegistry2 = {};
+var __tnDynamicValidateRegistry2 = {};
+function __tnRegisterFootprint2(typeName, fn) {
+  __tnFootprintRegistry2[typeName] = fn;
+}
+function __tnRegisterValidate2(typeName, fn) {
+  __tnValidateRegistry2[typeName] = fn;
+}
+function __tnRegisterDynamicValidate2(typeName, fn) {
+  __tnDynamicValidateRegistry2[typeName] = fn;
+}
+function __tnInvokeFootprint2(typeName, params) {
+  const fn = __tnFootprintRegistry2[typeName];
+  if (!fn) throw new Error(`IR runtime missing footprint for ${typeName}`);
+  return fn(params);
+}
+function __tnInvokeValidate2(typeName, buffer, params) {
+  const fn = __tnValidateRegistry2[typeName];
+  if (!fn) throw new Error(`IR runtime missing validate helper for ${typeName}`);
+  return fn(buffer, params);
+}
+function __tnInvokeDynamicValidate2(typeName, buffer) {
+  const fn = __tnDynamicValidateRegistry2[typeName];
+  if (!fn) throw new Error(`IR runtime missing dynamic validate helper for ${typeName}`);
+  return fn(buffer);
+}
+function __tnEvalFootprint2(node, ctx) {
+  return __tnEvalIrNode2(node, ctx, __tnToBigInt2(0));
+}
+function __tnTryEvalIr2(node, ctx) {
+  try {
+    return { ok: true, value: __tnEvalIrNode2(node, ctx, __tnToBigInt2(0)) };
+  } catch (err) {
+    return { ok: false, code: __tnNormalizeIrError2(err) };
+  }
+}
+function __tnIsEvalError2(result) {
+  return result.ok === false;
+}
+function __tnValidateIrTree2(ir, buffer, params) {
+  const evalResult = __tnTryEvalIr2(ir.root, {
+    params,
+    buffer,
+    typeName: ir.typeName
+  });
+  if (__tnIsEvalError2(evalResult)) {
+    return { ok: false, code: evalResult.code };
+  }
+  const required = evalResult.value;
+  const available = __tnToBigInt2(buffer.length);
+  if (__tnBigIntGreaterThan2(required, available)) {
+    return { ok: false, code: "tn.buffer_too_small", consumed: required };
+  }
+  return { ok: true, consumed: required };
+}
+function __tnEvalIrNode2(node, ctx, baseOffset) {
+  switch (node.op) {
+    case "zero":
+      return __tnToBigInt2(0);
+    case "const":
+      return node.value;
+    case "field": {
+      const val = ctx.params[node.param];
+      if (val === void 0) {
+        const prefix = ctx.typeName ? `${ctx.typeName}: ` : "";
+        __tnRaiseIrError2(
+          "tn.ir.missing_param",
+          `${prefix}Missing IR parameter '${node.param}'`
+        );
+      }
+      return val;
+    }
+    case "add": {
+      const left = __tnEvalIrNode2(node.left, ctx, baseOffset);
+      const right = __tnEvalIrNode2(
+        node.right,
+        ctx,
+        __tnCheckedAdd2(baseOffset, left)
+      );
+      return __tnCheckedAdd2(left, right);
+    }
+    case "mul":
+      return __tnCheckedMul2(
+        __tnEvalIrNode2(node.left, ctx, baseOffset),
+        __tnEvalIrNode2(node.right, ctx, baseOffset)
+      );
+    case "align":
+      return __tnAlign2(__tnEvalIrNode2(node.node, ctx, baseOffset), node.alignment);
+    case "switch": {
+      const tagVal = ctx.params[node.tag];
+      if (tagVal === void 0) {
+        const prefix = ctx.typeName ? `${ctx.typeName}: ` : "";
+        __tnRaiseIrError2(
+          "tn.ir.missing_param",
+          `${prefix}Missing IR switch tag '${node.tag}'`
+        );
+      }
+      const tagNumber = Number(tagVal);
+      for (const caseNode of node.cases) {
+        if (caseNode.value === tagNumber) {
+          return __tnEvalIrNode2(caseNode.node, ctx, baseOffset);
+        }
+      }
+      if (node.default) return __tnEvalIrNode2(node.default, ctx, baseOffset);
+      __tnRaiseIrError2(
+        "tn.ir.invalid_tag",
+        `Unhandled IR switch value ${tagNumber} for '${node.tag}'`
+      );
+    }
+    case "call": {
+      const nestedParams = /* @__PURE__ */ Object.create(null);
+      for (const arg of node.args) {
+        const val = ctx.params[arg.source];
+        if (val === void 0) {
+          const prefix = ctx.typeName ? `${ctx.typeName}: ` : "";
+          __tnRaiseIrError2(
+            "tn.ir.missing_param",
+            `${prefix}Missing IR parameter '${arg.source}' for nested call`
+          );
+        }
+        nestedParams[arg.name] = val;
+      }
+      if (ctx.buffer) {
+        const nestedOffset = __tnBigIntToNumber2(baseOffset, "IR nested offset");
+        const nestedResult = __tnInvokeValidate2(
+          node.typeName,
+          ctx.buffer.subarray(nestedOffset),
+          nestedParams
+        );
+        if (!nestedResult.ok) {
+          const nestedCode = nestedResult.code ?? `tn.ir.runtime_error: ${node.typeName}`;
+          const prefixed = nestedCode.startsWith("tn.") ? nestedCode : `tn.ir.runtime_error: ${node.typeName} -> ${nestedCode}`;
+          __tnRaiseIrError2(
+            prefixed,
+            `Nested validator ${node.typeName} failed`
+          );
+        }
+        if (nestedResult.consumed !== void 0) {
+          return nestedResult.consumed;
+        }
+      }
+      return __tnInvokeFootprint2(node.typeName, nestedParams);
+    }
+    case "sumOverArray": {
+      if (!ctx.buffer) {
+        __tnRaiseIrError2(
+          "tn.ir.missing_buffer",
+          `Jagged array '${node.fieldName}' requires buffer-backed validation`
+        );
+      }
+      const count = __tnBigIntToNumber2(
+        __tnEvalIrNode2(node.count, ctx, baseOffset),
+        `Jagged array '${node.fieldName}' count`
+      );
+      let cursor = __tnBigIntToNumber2(baseOffset, "IR jagged array offset");
+      let total = __tnToBigInt2(0);
+      for (let i = 0; i < count; i++) {
+        const result = __tnInvokeDynamicValidate2(
+          node.elementTypeName,
+          ctx.buffer.subarray(cursor)
+        );
+        if (!result.ok || result.consumed === void 0) {
+          const code = result.code ?? "tn.ir.runtime_error";
+          __tnRaiseIrError2(
+            code,
+            `Jagged array '${node.fieldName}' element ${i} failed validation`
+          );
+        }
+        cursor += __tnBigIntToNumber2(result.consumed, "IR jagged element size");
+        total = __tnCheckedAdd2(total, result.consumed);
+      }
+      return total;
+    }
+    default:
+      __tnRaiseIrError2(
+        "tn.ir.runtime_error",
+        `Unsupported IR node ${node.op}`
+      );
+  }
+}
+function __tnNormalizeIrError2(err) {
+  if (err && typeof err === "object" && "code" in err) {
+    const maybeCode = err.code;
+    if (typeof maybeCode === "string" && maybeCode.length > 0) {
+      return maybeCode;
+    }
+  }
+  const message = err && typeof err === "object" && "message" in err ? String(err.message ?? "") : typeof err === "string" ? err : "";
+  if (message.includes("Missing IR parameter")) return "tn.ir.missing_param";
+  if (message.includes("Unhandled IR switch value")) return "tn.ir.invalid_tag";
+  if (message.includes("invalid") || message.includes("overflow") || message.includes("negative size")) {
+    return "tn.ir.overflow";
+  }
+  if (message.length > 0) return `tn.ir.runtime_error: ${message}`;
+  return "tn.ir.runtime_error";
+}
+__tnRegisterFootprint2("InstructionData", (params) => exports.InstructionData.__tnInvokeFootprint(params));
+__tnRegisterValidate2("InstructionData", (buffer, params) => exports.InstructionData.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("InstructionData", (buffer) => {
+  const result = exports.InstructionData.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
+var __tn_ir_MulticallArgs = {
+  typeName: "MulticallArgs",
+  root: { op: "align", alignment: 1, node: { op: "add", left: { op: "align", alignment: 2, node: { op: "const", value: 2n } }, right: { op: "align", alignment: 1, node: { op: "sumOverArray", count: { op: "field", param: "calls.calls_count" }, elementTypeName: "InstructionData", fieldName: "calls" } } } }
+};
+exports.MulticallArgs = class _MulticallArgs {
+  constructor(buffer, params, fieldContext) {
+    this.buffer = buffer;
+    this.__tnFieldContext = null;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    this.__tnFieldContext = fieldContext ?? null;
+    if (params) {
+      this.__tnParams = params;
+    } else {
+      const derived = _MulticallArgs.__tnExtractParams(this.view, buffer);
+      if (!derived) {
+        throw new Error("MulticallArgs: failed to derive dynamic parameters");
+      }
+      this.__tnParams = derived.params;
+    }
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("MulticallArgs.__tnCreateView requires a Uint8Array");
+    let params = opts?.params ?? null;
+    if (!params) {
+      const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+      const derived = _MulticallArgs.__tnExtractParams(view, buffer);
+      if (!derived) throw new Error("MulticallArgs.__tnCreateView: failed to derive params");
+      params = derived.params;
+    }
+    const instance = new _MulticallArgs(new Uint8Array(buffer), params, opts?.fieldContext);
+    return instance;
+  }
+  dynamicParams() {
+    return this.__tnParams;
+  }
+  withFieldContext(context) {
+    this.__tnFieldContext = context;
+    return this;
+  }
+  __tnResolveFieldRef(path) {
+    const getterName = `get_${path.replace(/[.]/g, "_")}`;
+    const getter = this[getterName];
+    if (typeof getter === "function") {
+      const value = getter.call(this);
+      return typeof value === "bigint" ? __tnBigIntToNumber2(value, "MulticallArgs::__tnResolveFieldRef") : value;
+    }
+    if (this.__tnFieldContext && Object.prototype.hasOwnProperty.call(this.__tnFieldContext, path)) {
+      const contextValue = this.__tnFieldContext[path];
+      return typeof contextValue === "bigint" ? __tnBigIntToNumber2(contextValue, "MulticallArgs::__tnResolveFieldRef") : contextValue;
+    }
+    throw new Error("MulticallArgs: field reference '" + path + "' is not available; provide fieldContext when creating this view");
+  }
+  static __tnExtractParams(view, buffer) {
+    if (buffer.length < 2) {
+      return null;
+    }
+    const __tnParam_calls_calls_count = __tnToBigInt2(view.getUint16(0, true));
+    const __tnExtractedParams = _MulticallArgs.Params.fromValues({
+      calls_calls_count: __tnParam_calls_calls_count
+    });
+    return { params: __tnExtractedParams, derived: null };
+  }
+  get_calls_count() {
+    const offset = 0;
+    return this.view.getUint16(offset, true);
+  }
+  set_calls_count(value) {
+    const offset = 0;
+    this.view.setUint16(offset, value, true);
+  }
+  get calls_count() {
+    return this.get_calls_count();
+  }
+  set calls_count(value) {
+    this.set_calls_count(value);
+  }
+  /** Returns the number of elements in the jagged array. */
+  get_calls_length() {
+    return this.__tnResolveFieldRef("calls_count");
+  }
+  /** Returns the element at the given index, or null if out of bounds.
+   * Note: This is O(n) as jagged arrays require sequential traversal. */
+  get_calls_at(index) {
+    const count = this.get_calls_length();
+    if (index < 0 || index >= count) {
+      return null;
+    }
+    const offset = 2;
+    let cursor = offset;
+    for (let i = 0; i < index; i++) {
+      const elem = exports.InstructionData.from_array(this.buffer.subarray(cursor));
+      if (!elem) {
+        throw new Error("MulticallArgs: invalid element at index " + i + " in jagged array 'calls'");
+      }
+      const validation = exports.InstructionData.validate(this.buffer.subarray(cursor));
+      if (!validation.ok || validation.consumed === void 0) {
+        throw new Error("MulticallArgs: failed to get footprint for element at index " + i);
+      }
+      cursor += validation.consumed;
+    }
+    return exports.InstructionData.from_array(this.buffer.subarray(cursor));
+  }
+  /** Returns a generator over the jagged array elements.
+   * This is more efficient than repeated calls to `get_calls_at()` for sequential access. */
+  *callsIter() {
+    const count = this.get_calls_length();
+    const offset = 2;
+    let cursor = offset;
+    for (let i = 0; i < count; i++) {
+      const elem = exports.InstructionData.from_array(this.buffer.subarray(cursor));
+      if (!elem) {
+        throw new Error("MulticallArgs: invalid element at index " + i + " in jagged array 'calls'");
+      }
+      yield elem;
+      const validation = exports.InstructionData.validate(this.buffer.subarray(cursor));
+      if (!validation.ok || validation.consumed === void 0) {
+        throw new Error("MulticallArgs: failed to get footprint for element at index " + i);
+      }
+      cursor += validation.consumed;
+    }
+  }
+  get_calls() {
+    return Array.from(this.callsIter());
+  }
+  set_calls(_value) {
+    throw new Error("MulticallArgs: jagged array 'calls' cannot be set in-place");
+  }
+  /** Returns the total byte size of all elements in the jagged array. */
+  get_calls_size() {
+    const count = this.get_calls_length();
+    const offset = 2;
+    let cursor = offset;
+    for (let i = 0; i < count; i++) {
+      const elem = exports.InstructionData.from_array(this.buffer.subarray(cursor));
+      if (!elem) {
+        throw new Error("MulticallArgs: invalid element at index " + i + " in jagged array 'calls'");
+      }
+      const validation = exports.InstructionData.validate(this.buffer.subarray(cursor));
+      if (!validation.ok || validation.consumed === void 0) {
+        throw new Error("MulticallArgs: failed to get footprint for element at index " + i);
+      }
+      cursor += validation.consumed;
+    }
+    return cursor - offset;
+  }
+  get calls() {
+    return this.get_calls();
+  }
+  set calls(value) {
+    this.set_calls(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint2(__tn_ir_MulticallArgs.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree2(__tn_ir_MulticallArgs, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr(calls_calls_count) {
+    const params = _MulticallArgs.Params.fromValues({
+      calls_calls_count
+    });
+    return this.footprintIrFromParams(params);
+  }
+  static __tnPackParams(params) {
+    const record = /* @__PURE__ */ Object.create(null);
+    record["calls.calls_count"] = params.calls_calls_count;
+    return record;
+  }
+  static footprintIrFromParams(params) {
+    const __tnParams = this.__tnPackParams(params);
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static footprintFromParams(params) {
+    const irResult = this.footprintIrFromParams(params);
+    const maxSafe = __tnToBigInt2(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan2(irResult, maxSafe)) throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for MulticallArgs");
+    return __tnBigIntToNumber2(irResult, "MulticallArgs::footprintFromParams");
+  }
+  static footprintFromValues(input) {
+    const params = _MulticallArgs.params(input);
+    return this.footprintFromParams(params);
+  }
+  static footprint(params) {
+    return this.footprintFromParams(params);
+  }
+  static validate(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return { ok: false, code: "tn.invalid_buffer" };
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      const extracted = this.__tnExtractParams(view, buffer);
+      if (!extracted) return { ok: false, code: "tn.param_extraction_failed" };
+      params = extracted.params;
+    }
+    const __tnParamsRec = this.__tnPackParams(params);
+    const irResult = this.__tnValidateInternal(buffer, __tnParamsRec);
+    if (!irResult.ok) {
+      return { ok: false, code: irResult.code, consumed: irResult.consumed ? __tnBigIntToNumber2(irResult.consumed, "MulticallArgs::validate") : void 0, params };
+    }
+    const consumed = irResult.consumed ? __tnBigIntToNumber2(irResult.consumed, "MulticallArgs::validate") : void 0;
+    return { ok: true, consumed, params };
+  }
+  static from_array(buffer, opts) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    let params = opts?.params ?? null;
+    if (!params) {
+      const derived = this.__tnExtractParams(view, buffer);
+      if (!derived) return null;
+      params = derived.params;
+    }
+    const validation = this.validate(buffer, { params });
+    if (!validation.ok) {
+      return null;
+    }
+    const cached = validation.params ?? params;
+    const state = new _MulticallArgs(buffer, cached);
+    return state;
+  }
+};
+((MulticallArgs2) => {
+  MulticallArgs2.ParamKeys = Object.freeze({
+    calls_calls_count: "calls.calls_count"
+  });
+  MulticallArgs2.Params = {
+    fromValues(input) {
+      return {
+        calls_calls_count: __tnToBigInt2(input.calls_calls_count)
+      };
+    },
+    fromBuilder(source) {
+      if (source.dynamicParams) {
+        return source.dynamicParams();
+      }
+      if (source.params) {
+        return source.params;
+      }
+      return source;
+    }
+  };
+  function params(input) {
+    return MulticallArgs2.Params.fromValues(input);
+  }
+  MulticallArgs2.params = params;
+})(exports.MulticallArgs || (exports.MulticallArgs = {}));
+__tnRegisterFootprint2("MulticallArgs", (params) => exports.MulticallArgs.__tnInvokeFootprint(params));
+__tnRegisterValidate2("MulticallArgs", (buffer, params) => exports.MulticallArgs.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("MulticallArgs", (buffer) => {
+  const result = exports.MulticallArgs.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
+var __tn_ir_MulticallError = {
+  typeName: "MulticallError",
+  root: { op: "const", value: 8n }
+};
+var MulticallError = class _MulticallError {
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.view = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+  }
+  static __tnCreateView(buffer, opts) {
+    if (!buffer || buffer.length === void 0) throw new Error("MulticallError.__tnCreateView requires a Uint8Array");
+    return new _MulticallError(new Uint8Array(buffer));
+  }
+  static builder() {
+    return new MulticallErrorBuilder();
+  }
+  static fromBuilder(builder) {
+    const buffer = builder.build();
+    return _MulticallError.from_array(buffer);
+  }
+  get_code() {
+    const offset = 0;
+    return this.view.getBigUint64(offset, true);
+  }
+  set_code(value) {
+    const offset = 0;
+    this.view.setBigUint64(offset, value, true);
+  }
+  get code() {
+    return this.get_code();
+  }
+  set code(value) {
+    this.set_code(value);
+  }
+  static __tnFootprintInternal(__tnParams) {
+    return __tnEvalFootprint2(__tn_ir_MulticallError.root, { params: __tnParams });
+  }
+  static __tnValidateInternal(buffer, __tnParams) {
+    return __tnValidateIrTree2(__tn_ir_MulticallError, buffer, __tnParams);
+  }
+  static __tnInvokeFootprint(__tnParams) {
+    return this.__tnFootprintInternal(__tnParams);
+  }
+  static __tnInvokeValidate(buffer, __tnParams) {
+    return this.__tnValidateInternal(buffer, __tnParams);
+  }
+  static footprintIr() {
+    return this.__tnFootprintInternal(/* @__PURE__ */ Object.create(null));
+  }
+  static footprint() {
+    const irResult = this.footprintIr();
+    const maxSafe = __tnToBigInt2(Number.MAX_SAFE_INTEGER);
+    if (__tnBigIntGreaterThan2(irResult, maxSafe)) {
+      throw new Error("footprint exceeds Number.MAX_SAFE_INTEGER for MulticallError");
+    }
+    return __tnBigIntToNumber2(irResult, "MulticallError::footprint");
+  }
+  static validate(buffer, _opts) {
+    if (buffer.length < 8) return { ok: false, code: "tn.buffer_too_small", consumed: 8 };
+    return { ok: true, consumed: 8 };
+  }
+  static new(code) {
+    const buffer = new Uint8Array(8);
+    const view = new DataView(buffer.buffer);
+    view.setBigUint64(0, code, true);
+    return new _MulticallError(buffer);
+  }
+  static from_array(buffer) {
+    if (!buffer || buffer.length === void 0) {
+      return null;
+    }
+    new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+    const validation = this.validate(buffer);
+    if (!validation.ok) {
+      return null;
+    }
+    return new _MulticallError(buffer);
+  }
+};
+var MulticallErrorBuilder = class {
+  constructor() {
+    this.buffer = new Uint8Array(8);
+    this.view = new DataView(this.buffer.buffer, this.buffer.byteOffset, this.buffer.byteLength);
+  }
+  set_code(value) {
+    const cast = __tnToBigInt2(value);
+    this.view.setBigUint64(0, cast, true);
+    return this;
+  }
+  build() {
+    return this.buffer.slice();
+  }
+  buildInto(target, offset = 0) {
+    if (target.length - offset < this.buffer.length) throw new Error("target buffer too small");
+    target.set(this.buffer, offset);
+    return target;
+  }
+  finish() {
+    const view = MulticallError.from_array(this.buffer.slice());
+    if (!view) throw new Error("failed to build MulticallError");
+    return view;
+  }
+};
+__tnRegisterFootprint2("MulticallError", (params) => MulticallError.__tnInvokeFootprint(params));
+__tnRegisterValidate2("MulticallError", (buffer, params) => MulticallError.__tnInvokeValidate(buffer, params));
+__tnRegisterDynamicValidate2("MulticallError", (buffer) => {
+  const result = MulticallError.validate(buffer);
+  return { ok: result.ok, code: result.code, consumed: result.consumed === void 0 ? void 0 : __tnToBigInt2(result.consumed) };
+});
+
+// src/multicall/index.ts
+var MULTICALL_PROGRAM_PUBKEY = new Uint8Array([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  9
+]);
+var MULTICALL_PROGRAM_ADDRESS = helpers.encodeAddress(MULTICALL_PROGRAM_PUBKEY);
+function writeU16LE(target, offset, value) {
+  target[offset] = value & 255;
+  target[offset + 1] = value >> 8 & 255;
+}
+function assertProgramIdx(programIdx) {
+  if (!Number.isInteger(programIdx) || programIdx < 0 || programIdx > 65535) {
+    throw new Error("programIdx must be 0-65535");
+  }
+}
+function buildInstructionData(call) {
+  assertProgramIdx(call.programIdx);
+  if (!(call.instructionData instanceof Uint8Array)) {
+    throw new Error("instructionData must be a Uint8Array");
+  }
+  const builder = new InstructionDataBuilder();
+  builder.set_program_idx(call.programIdx);
+  builder.data().write(call.instructionData).finish();
+  const buffer = builder.build();
+  const view = exports.InstructionData.from_array(buffer);
+  if (!view) {
+    throw new Error("generated InstructionData failed validation");
+  }
+  return buffer;
+}
+function buildMulticallInstruction(calls) {
+  if (!Array.isArray(calls)) throw new Error("calls must be an array");
+  if (calls.length > 65535) throw new Error("calls length must be 0-65535");
+  const encodedCalls = calls.map(buildInstructionData);
+  const totalLength = 2 + encodedCalls.reduce((sum, call) => sum + call.length, 0);
+  const output = new Uint8Array(totalLength);
+  let offset = 0;
+  writeU16LE(output, offset, calls.length);
+  offset += 2;
+  for (const call of encodedCalls) {
+    output.set(call, offset);
+    offset += call.length;
+  }
+  const validation = exports.MulticallArgs.validate(output);
+  if (!validation.ok || validation.consumed !== output.length) {
+    throw new Error(
+      `generated MulticallArgs failed validation (code=${validation.code ?? "unknown"})`
+    );
+  }
+  return output;
+}
+
+exports.InstructionDataBuilder = InstructionDataBuilder;
+exports.MULTICALL_PROGRAM_ADDRESS = MULTICALL_PROGRAM_ADDRESS;
+exports.MULTICALL_PROGRAM_PUBKEY = MULTICALL_PROGRAM_PUBKEY;
+exports.MulticallError = MulticallError;
+exports.buildMulticallInstruction = buildMulticallInstruction;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map