@steerprotocol/app-loader 3.0.6 → 3.1.0

package/lib/node.mjs

@@ -173,6 +173,160 @@ var RawTradeData = class {
   }
 };
 
+// src/internal/asyncHostCalls.ts
+function createAsyncHostCallSlot() {
+  let stagedHostCall = null;
+  let completedHostCall = null;
+  function stage(call) {
+    if (stagedHostCall || completedHostCall) {
+      throw new Error("Only one async host call can be staged per asyncify unwind.");
+    }
+    stagedHostCall = call;
+  }
+  async function complete() {
+    if (!stagedHostCall) {
+      throw new Error("Asyncify unwound without a staged host call.");
+    }
+    const call = stagedHostCall;
+    stagedHostCall = null;
+    if (call.kind === "fetch-buffer") {
+      completedHostCall = { kind: "fetch-buffer", value: await call.run() };
+      return;
+    }
+    if (call.kind === "ccxt-ohlcv") {
+      completedHostCall = { kind: "ccxt-ohlcv", value: await call.run() };
+      return;
+    }
+    completedHostCall = { kind: "panoptic-json", value: await call.run() };
+  }
+  function take(kind) {
+    if (!completedHostCall) {
+      throw new Error(`Asyncify rewind for ${kind} did not have a completed host result.`);
+    }
+    if (completedHostCall.kind !== kind) {
+      throw new Error(`Asyncify rewind expected ${kind} but found ${completedHostCall.kind}.`);
+    }
+    const call = completedHostCall;
+    completedHostCall = null;
+    return call;
+  }
+  function reset() {
+    stagedHostCall = null;
+    completedHostCall = null;
+  }
+  return { stage, complete, take, reset };
+}
+
+// src/internal/panoptic/protocol.ts
+var DEFAULT_MAX_REQUEST_BYTES = 512 * 1024;
+function parsePanopticRequest(value, maxBytes = DEFAULT_MAX_REQUEST_BYTES) {
+  if (utf8ByteLength(value) > maxBytes) {
+    throw new Error(`Invalid Panoptic request JSON: request exceeds maximum size ${maxBytes} bytes.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(`Invalid Panoptic request JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isJsonObject(parsed) || !isJsonValue(parsed)) {
+    throw new Error("Invalid Panoptic request JSON: expected a JSON-safe object envelope.");
+  }
+  return parsed;
+}
+function assertPanopticSuccessResponse(value) {
+  const keys = isJsonObject(value) ? Object.keys(value) : [];
+  if (!isJsonObject(value) || value.ok !== true || !("result" in value) || !isJsonValue(value.result) || keys.length !== 2 || !keys.includes("ok") || !keys.includes("result")) {
+    throw new Error("Panoptic runtime adapter returned an invalid success response.");
+  }
+}
+function panopticSuccess(result) {
+  return { ok: true, result };
+}
+function isJsonObject(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonRecord(value) {
+  return isJsonObject(value) && isJsonValue(value);
+}
+function requestArgs(request, method) {
+  if (!isJsonRecord(request.args)) {
+    throw new Error(`Panoptic ${method} args must be an object.`);
+  }
+  return request.args;
+}
+function sanitizePanopticError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.split("\n")[0].replace(/https?:\/\/[^\s)]+/gi, "[redacted-url]").replace(/\b(api[_-]?key|token|secret|authorization)=([^&\s]+)/gi, "$1=[redacted]").replace(/\b(authorization|proxy-authorization)\s*:\s*(bearer|basic)\s+[^\s,}]+/gi, "$1: $2 [redacted]").replace(/\b(bearer|basic)\s+[a-z0-9._~+/-]+=*/gi, "$1 [redacted]").replace(/"(api[_-]?key|token|secret|authorization)"\s*:\s*"[^"]*"/gi, '"$1":"[redacted]"').replace(/\b(api[_-]?key|token|secret)\s*:\s*([^\s,}]+)/gi, "$1: [redacted]").slice(0, 240);
+}
+function isJsonValue(value) {
+  if (value === null) return true;
+  const valueType = typeof value;
+  if (valueType === "string" || valueType === "number" || valueType === "boolean") {
+    return Number.isFinite(value) || valueType !== "number";
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  if (isJsonObject(value)) {
+    return Object.values(value).every(isJsonValue);
+  }
+  return false;
+}
+function utf8ByteLength(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const codePoint = value.codePointAt(i) || 0;
+    if (codePoint <= 127) {
+      bytes += 1;
+    } else if (codePoint <= 2047) {
+      bytes += 2;
+    } else if (codePoint <= 65535) {
+      bytes += 3;
+    } else {
+      bytes += 4;
+      i += 1;
+    }
+  }
+  return bytes;
+}
+
+// src/internal/panopticHostImport.ts
+function createPanopticHostImport(options) {
+  return (methodPtr, paramsJsonPtr) => {
+    if (options.getAsyncifyState() === options.rewindingState) {
+      options.stopRewind();
+      const completed = options.hostCalls.take("panoptic-json");
+      return options.lowerString(completed.value, "wasm");
+    }
+    const method = options.liftString(methodPtr);
+    const paramsJson = options.liftString(paramsJsonPtr) || "{}";
+    options.hostCalls.stage({
+      kind: "panoptic-json",
+      run: async () => {
+        if (!method) {
+          throw new Error("Panoptic method not provided.");
+        }
+        const request = parsePanopticRequest(paramsJson);
+        const response = await callPanopticOrThrow(options.runtime, method, request);
+        assertPanopticSuccessResponse(response);
+        return JSON.stringify({ ok: true, result: response.result });
+      }
+    });
+    options.startUnwind();
+  };
+}
+async function callPanopticOrThrow(runtime, method, request) {
+  if (!runtime.callPanoptic) {
+    throw new Error("Panoptic runtime adapter is not available in this runtime.");
+  }
+  return runtime.callPanoptic(method, request);
+}
+
 // src/internal/instantiate.ts
 function instantiate(module, imports = {}, runtime = {}) {
   let WASM_MEMORY;
@@ -181,9 +335,7 @@ function instantiate(module, imports = {}, runtime = {}) {
   let ASYNCIFY_PTR = 0;
   let ASYNCIFY_MEM;
   let ASYNCIFY_INITIALIZED = false;
-  let fetchFn = null;
-  let ccxtFn = null;
-  let detachedValue = null;
+  const hostCalls = createAsyncHostCallSlot();
   let executeInFlight = false;
   const pinScopes = [];
   const adaptedImports = Object.assign(
@@ -281,31 +433,50 @@ function instantiate(module, imports = {}, runtime = {}) {
           const currentState = WASM_EXPORTS.asyncify_get_state();
           if (currentState === 2 /* Rewinding */) {
             WASM_EXPORTS.asyncify_stop_rewind();
+            const completed = hostCalls.take("ccxt-ohlcv");
             const ptr = __lowerStaticArray(
               (pointer, value) => {
-                __setU32(pointer, __lowerStaticArray(__setF64, 7, 3, value, Float64Array));
+                __setU32(pointer, __lowerStaticArray(__setF64, 7, 3, value, Float64Array, "wasm"));
               },
               8,
               2,
-              detachedValue
+              completed.value,
+              null,
+              "host"
             );
             return ptr;
           }
           const _exchange = __liftString(exchangeId);
           const _symbol = __liftString(symbol);
           const _timeframe = __liftString(timeframe);
-          ccxtFn = async () => {
-            if (!_exchange || !_symbol || !_timeframe)
-              throw new Error("Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.");
-            const ccxt = await getCcxtOrThrow(runtime);
-            const data = await new ccxt[_exchange]({
-              apiKey: "",
-              secret: ""
-            }).fetchOHLCV(_symbol, _timeframe, since, limit);
-            return data;
-          };
+          hostCalls.stage({
+            kind: "ccxt-ohlcv",
+            run: async () => {
+              if (!_exchange || !_symbol || !_timeframe)
+                throw new Error("Exchange, Symbol, or Timeframe not provided when fetching OHCLV data.");
+              const ccxt = await getCcxtOrThrow(runtime);
+              const data = await new ccxt[_exchange]({
+                apiKey: "",
+                secret: ""
+              }).fetchOHLCV(_symbol, _timeframe, since, limit);
+              return data;
+            }
+          });
           WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
-        }
+        },
+        panoptic_call: createPanopticHostImport({
+          runtime,
+          hostCalls,
+          // @ts-ignore
+          getAsyncifyState: () => WASM_EXPORTS.asyncify_get_state(),
+          rewindingState: 2 /* Rewinding */,
+          // @ts-ignore
+          stopRewind: () => WASM_EXPORTS.asyncify_stop_rewind(),
+          // @ts-ignore
+          startUnwind: () => WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR),
+          liftString: __liftString,
+          lowerString: __lowerString
+        })
       },
       "as-fetch": {
         /**
@@ -336,25 +507,28 @@ function instantiate(module, imports = {}, runtime = {}) {
           const currentState = WASM_EXPORTS.asyncify_get_state();
           if (currentState === 2 /* Rewinding */) {
             WASM_EXPORTS.asyncify_stop_rewind();
-            const ptr = __lowerBuffer(detachedValue);
-            detachedValue = null;
+            const completed = hostCalls.take("fetch-buffer");
+            const ptr = __lowerBuffer(completed.value, "wasm");
             return ptr;
           }
-          fetchFn = async () => {
-            const fetchImpl = await getFetchOrThrow(runtime);
-            const res = await fetchImpl(__liftString(url) || "", {
-              method: "POST",
-              mode: modeToString(mode) || "cors",
-              headers: __liftArray(
-                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
-                2,
-                headers
-              ) || [],
-              body: __liftBuffer(body)
-            });
-            const value = await res.arrayBuffer();
-            return value;
-          };
+          hostCalls.stage({
+            kind: "fetch-buffer",
+            run: async () => {
+              const fetchImpl = await getFetchOrThrow(runtime);
+              const res = await fetchImpl(__liftString(url) || "", {
+                method: "POST",
+                mode: modeToString(mode) || "cors",
+                headers: __liftArray(
+                  (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                  2,
+                  headers
+                ) || [],
+                body: __liftBuffer(body)
+              });
+              const value = await res.arrayBuffer();
+              return value;
+            }
+          });
           WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
         },
         /**
@@ -368,24 +542,27 @@ function instantiate(module, imports = {}, runtime = {}) {
           const currentState = WASM_EXPORTS.asyncify_get_state();
           if (currentState === 2 /* Rewinding */) {
             WASM_EXPORTS.asyncify_stop_rewind();
-            const ptr = __lowerBuffer(detachedValue);
-            detachedValue = null;
+            const completed = hostCalls.take("fetch-buffer");
+            const ptr = __lowerBuffer(completed.value, "wasm");
             return ptr;
           }
-          fetchFn = async () => {
-            const fetchImpl = await getFetchOrThrow(runtime);
-            const res = await fetchImpl(__liftString(url) || "", {
-              method: "GET",
-              mode: modeToString(mode) || "cors",
-              headers: __liftArray(
-                (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
-                2,
-                headers
-              ) || []
-            });
-            const value = await res.arrayBuffer();
-            return value;
-          };
+          hostCalls.stage({
+            kind: "fetch-buffer",
+            run: async () => {
+              const fetchImpl = await getFetchOrThrow(runtime);
+              const res = await fetchImpl(__liftString(url) || "", {
+                method: "GET",
+                mode: modeToString(mode) || "cors",
+                headers: __liftArray(
+                  (pointer) => __liftArray((pointer2) => __liftString(__getU32(pointer2)), 2, __getU32(pointer)),
+                  2,
+                  headers
+                ) || []
+              });
+              const value = await res.arrayBuffer();
+              return value;
+            }
+          });
           WASM_EXPORTS.asyncify_start_unwind(ASYNCIFY_PTR);
         },
         /**
@@ -516,16 +693,7 @@ function instantiate(module, imports = {}, runtime = {}) {
           if (ASYNCIFY_INITIALIZED) {
             while (WASM_EXPORTS.asyncify_get_state() === 1 /* Unwinding */) {
               WASM_EXPORTS.asyncify_stop_unwind();
-              if (fetchFn) {
-                const pendingFetch = fetchFn;
-                fetchFn = null;
-                detachedValue = await pendingFetch();
-              }
-              if (ccxtFn) {
-                const pendingCcxt = ccxtFn;
-                ccxtFn = null;
-                detachedValue = await pendingCcxt();
-              }
+              await hostCalls.complete();
               WASM_EXPORTS.asyncify_start_rewind(ASYNCIFY_PTR);
               result = executeWithReplayArgs(replayArgs);
             }
@@ -536,9 +704,7 @@ function instantiate(module, imports = {}, runtime = {}) {
           for (let i = scope.length - 1; i >= 0; i--) {
             WASM_EXPORTS.__unpin(scope[i]);
           }
-          fetchFn = null;
-          ccxtFn = null;
-          detachedValue = null;
+          hostCalls.reset();
           executeInFlight = false;
         }
       },
@@ -632,10 +798,10 @@ function instantiate(module, imports = {}, runtime = {}) {
     while (end - start > 1024) string += String.fromCharCode(...memoryU16.subarray(start, start += 1024));
     return string + String.fromCharCode(...memoryU16.subarray(start, end));
   }
-  function __lowerString(value) {
+  function __lowerString(value, owner = "host") {
     if (value == null) return 0;
     const length = value.length;
-    const ptr = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << 1, 2) >>> 0));
+    const ptr = allocateLoweredPointer(length << 1, 2, owner);
     const memoryU16 = new Uint16Array(WASM_MEMORY.buffer);
     for (let i = 0; i < length; ++i) memoryU16[(ptr >>> 1) + i] = value.charCodeAt(i);
     return ptr;
@@ -644,9 +810,9 @@ function instantiate(module, imports = {}, runtime = {}) {
     if (!ptr) return null;
     return WASM_MEMORY.buffer.slice(ptr, ptr + new Uint32Array(WASM_MEMORY.buffer)[ptr - 4 >>> 2]);
   }
-  function __lowerBuffer(value) {
+  function __lowerBuffer(value, owner = "host") {
     if (value == null) return 0;
-    const ptr = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(value.byteLength, 1) >>> 0));
+    const ptr = allocateLoweredPointer(value.byteLength, 1, owner);
     new Uint8Array(WASM_MEMORY.buffer).set(new Uint8Array(value), ptr);
     return ptr;
   }
@@ -658,10 +824,10 @@ function instantiate(module, imports = {}, runtime = {}) {
     for (let i = 0; i < length; ++i) values[i] = liftElement(dataStart + (i << align >>> 0));
     return values;
   }
-  function __lowerStaticArray(lowerElement, id, align, values, typedConstructor = null) {
+  function __lowerStaticArray(lowerElement, id, align, values, typedConstructor = null, owner = "host") {
     if (values == null) return 0;
     const length = values.length;
-    const buffer = trackPinnedPointer(WASM_EXPORTS.__pin(WASM_EXPORTS.__new(length << align, id)) >>> 0) >>> 0;
+    const buffer = allocateLoweredPointer(length << align, id, owner) >>> 0;
     if (typedConstructor) {
       new typedConstructor(WASM_MEMORY.buffer, buffer, length).set(values);
     } else {
@@ -669,6 +835,13 @@ function instantiate(module, imports = {}, runtime = {}) {
     }
     return buffer;
   }
+  function allocateLoweredPointer(size, id, owner) {
+    const ptr = WASM_EXPORTS.__new(size, id) >>> 0;
+    if (owner === "wasm") {
+      return ptr;
+    }
+    return trackPinnedPointer(WASM_EXPORTS.__pin(ptr) >>> 0);
+  }
   function __setU32(ptr, value) {
     try {
       WASM_DV.setUint32(ptr, value, true);
@@ -715,18 +888,3407 @@ function modeToString(mode) {
   return null;
 }
 
+// src/internal/panoptic/deps.ts
+var PANOPTIC_MODULE_SPECIFIERS = {
+  sdk: "@panoptic-eng/sdk",
+  sdkV2: "@panoptic-eng/sdk/v2",
+  uniswap: "@panoptic-eng/sdk/uniswap",
+  viem: "viem"
+};
+var dynamicImport = null;
+var runtimeImport = null;
+var moduleCache = /* @__PURE__ */ new Map();
+function createPanopticDependencies() {
+  return {
+    sdk: () => loadPanopticModuleRecord("sdk"),
+    sdkV2: () => loadPanopticModuleRecord("sdkV2"),
+    uniswap: () => loadPanopticModuleRecord("uniswap"),
+    viem: () => loadPanopticModuleRecord("viem")
+  };
+}
+async function loadPanopticModule(key) {
+  const cached = moduleCache.get(key);
+  if (cached) {
+    return cached;
+  }
+  const specifier = PANOPTIC_MODULE_SPECIFIERS[key];
+  const loaded = getRuntimeImport()(specifier).catch(() => {
+    moduleCache.delete(key);
+    throw missingPanopticDependencyError(specifier);
+  });
+  moduleCache.set(key, loaded);
+  return loaded;
+}
+async function loadPanopticModuleRecord(key) {
+  const loadedModule = await loadPanopticModule(key);
+  if (!isRecord(loadedModule)) {
+    return {};
+  }
+  return loadedModule;
+}
+function missingPanopticDependencyError(specifier) {
+  return new Error(
+    `Panoptic runtime dependency "${specifier}" is not available. Install the optional Panoptic dependencies before calling Panoptic methods.`
+  );
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getRuntimeImport() {
+  if (runtimeImport) {
+    return runtimeImport;
+  }
+  if (!dynamicImport) {
+    dynamicImport = new Function("s", "return import(s)");
+  }
+  return dynamicImport;
+}
+
+// src/internal/panopticSerialization.ts
+var DEFAULT_MAX_ARRAY_ITEMS = 256;
+var DEFAULT_MAX_OBJECT_KEYS = 128;
+var DEFAULT_MAX_DEPTH = 32;
+var DEFAULT_MAX_REQUEST_BYTES2 = 512 * 1024;
+var DEFAULT_MAX_RESPONSE_BYTES = 512 * 1024;
+var DEFAULT_MAX_CALLDATA_BYTES = 256 * 1024;
+var DEFAULT_MAX_STRING_BYTES = 64 * 1024;
+var DEFAULT_MAX_DECIMAL_DIGITS = 96;
+function normalizePanopticAddress(value, fieldName = "address") {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)) {
+    throw new Error(`Panoptic ${fieldName} must be a 20-byte hex address.`);
+  }
+  return value.toLowerCase();
+}
+function normalizePanopticHex(value, fieldName = "hex", maxBytes = DEFAULT_MAX_CALLDATA_BYTES) {
+  if (typeof value === "string" && value.length > maxBytes * 2 + 2) {
+    throw new Error(`Panoptic ${fieldName} exceeds maximum hex size ${maxBytes} bytes.`);
+  }
+  if (typeof value !== "string" || !/^0x(?:[0-9a-fA-F]{2})*$/.test(value)) {
+    throw new Error(`Panoptic ${fieldName} must be an even-length hex string.`);
+  }
+  return value.toLowerCase();
+}
+function normalizePanopticDecimalString(value, fieldName = "value", maxDigits = DEFAULT_MAX_DECIMAL_DIGITS) {
+  if (typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value)) {
+    assertDecimalDigitLength(value, fieldName, maxDigits);
+    return BigInt(value).toString(10);
+  }
+  throw new Error(`Panoptic ${fieldName} must be an unsigned decimal string.`);
+}
+function projectPanopticSerializableValue(value, limits = {}, label = "result") {
+  const normalized = normalizeSerializableValue(value, normalizeLimits(limits), label, 0, /* @__PURE__ */ new WeakSet());
+  assertSerializedSize(normalized, limits.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES, label, "response");
+  return normalized;
+}
+function normalizeSerializableValue(value, limits, path, depth, seen) {
+  if (depth > limits.maxDepth) {
+    throw new Error(`Panoptic ${path} exceeds maximum JSON depth.`);
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") {
+    enforceHexSizeIfNeeded(value, limits, path);
+    if (typeof value === "string" && utf8ByteLength2(value) > limits.maxStringBytes) {
+      throw new Error(`Panoptic ${path} exceeds maximum string length ${limits.maxStringBytes} bytes.`);
+    }
+    return value;
+  }
+  if (typeof value === "bigint") {
+    return value.toString(10);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Panoptic ${path} must be a finite number.`);
+    }
+    return value;
+  }
+  if (value instanceof Uint8Array) {
+    if (value.byteLength > limits.maxCalldataBytes) {
+      throw new Error(`Panoptic ${path} exceeds maximum encoded calldata size ${limits.maxCalldataBytes} bytes.`);
+    }
+    return bytesToHex(value);
+  }
+  if (value instanceof ArrayBuffer) {
+    if (value.byteLength > limits.maxCalldataBytes) {
+      throw new Error(`Panoptic ${path} exceeds maximum encoded calldata size ${limits.maxCalldataBytes} bytes.`);
+    }
+    return bytesToHex(new Uint8Array(value));
+  }
+  if (Array.isArray(value)) {
+    if (value.length > limits.maxArrayItems) {
+      throw new Error(`Panoptic ${path} exceeds maximum array length ${limits.maxArrayItems}.`);
+    }
+    return value.map((item, index) => normalizeSerializableValue(item, limits, `${path}[${index}]`, depth + 1, seen));
+  }
+  if (typeof value === "object" && value !== null) {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new Error(`Panoptic ${path} must be explicitly projected before crossing the wasm boundary.`);
+    }
+    if (seen.has(value)) {
+      throw new Error(`Panoptic ${path} contains a circular reference.`);
+    }
+    seen.add(value);
+    const entries = Object.entries(value);
+    if (entries.length > limits.maxObjectKeys) {
+      throw new Error(`Panoptic ${path} exceeds maximum object key count ${limits.maxObjectKeys}.`);
+    }
+    const normalized = /* @__PURE__ */ Object.create(null);
+    for (const [key, entryValue] of entries) {
+      if (isUnsafeObjectKey(key)) {
+        throw new Error(`Panoptic ${path}.${key} is not supported as an object key.`);
+      }
+      if (entryValue === void 0 || typeof entryValue === "function" || typeof entryValue === "symbol") {
+        throw new Error(`Panoptic ${path}.${key} is not serializable.`);
+      }
+      normalized[key] = normalizeSerializableValue(entryValue, limits, `${path}.${key}`, depth + 1, seen);
+    }
+    seen.delete(value);
+    return normalized;
+  }
+  throw new Error(`Panoptic ${path} is not serializable.`);
+}
+function normalizeLimits(limits) {
+  return {
+    maxArrayItems: limits.maxArrayItems ?? DEFAULT_MAX_ARRAY_ITEMS,
+    maxObjectKeys: limits.maxObjectKeys ?? DEFAULT_MAX_OBJECT_KEYS,
+    maxDepth: limits.maxDepth ?? DEFAULT_MAX_DEPTH,
+    maxRequestBytes: limits.maxRequestBytes ?? DEFAULT_MAX_REQUEST_BYTES2,
+    maxResponseBytes: limits.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES,
+    maxCalldataBytes: limits.maxCalldataBytes ?? DEFAULT_MAX_CALLDATA_BYTES,
+    maxStringBytes: limits.maxStringBytes ?? DEFAULT_MAX_STRING_BYTES,
+    maxDecimalDigits: limits.maxDecimalDigits ?? DEFAULT_MAX_DECIMAL_DIGITS
+  };
+}
+function assertSerializedSize(value, maxBytes, label, kind) {
+  const serialized = JSON.stringify(value);
+  if (utf8ByteLength2(serialized) > maxBytes) {
+    throw new Error(`Panoptic ${label} exceeds maximum ${kind} size ${maxBytes} bytes.`);
+  }
+}
+function utf8ByteLength2(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i++) {
+    const codePoint = value.codePointAt(i) || 0;
+    if (codePoint > 65535) {
+      i += 1;
+    }
+    if (codePoint <= 127) {
+      bytes += 1;
+    } else if (codePoint <= 2047) {
+      bytes += 2;
+    } else if (codePoint <= 65535) {
+      bytes += 3;
+    } else {
+      bytes += 4;
+    }
+  }
+  return bytes;
+}
+function enforceHexSizeIfNeeded(value, limits, path) {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]*$/.test(value)) {
+    return;
+  }
+  const byteLength = Math.max(0, (value.length - 2) / 2);
+  if (byteLength > limits.maxCalldataBytes) {
+    throw new Error(`Panoptic ${path} exceeds maximum encoded calldata size ${limits.maxCalldataBytes} bytes.`);
+  }
+}
+function bytesToHex(bytes) {
+  let hex = "0x";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return hex;
+}
+function assertDecimalDigitLength(value, fieldName, maxDigits) {
+  if (value.length > maxDigits) {
+    throw new Error(`Panoptic ${fieldName} exceeds maximum decimal digit length ${maxDigits}.`);
+  }
+}
+function isUnsafeObjectKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+
+// src/internal/panopticSources.ts
+var DEFAULT_OPERATION_TIMEOUT_MS = 1e4;
+var DEFAULT_OPERATION_RETRIES = 2;
+var DEFAULT_CLIENT_CACHE_MAX_ENTRIES = 16;
+var publicClientCache = /* @__PURE__ */ new Map();
+function resolvePanopticSource(context, registry) {
+  if (!context?.sourceId && !context?.chainId && !context?.rpcUrl) {
+    throw new Error("Panoptic source context must include sourceId or chainId.");
+  }
+  if (!registry?.sources?.length) {
+    throw new Error("Panoptic source registry is not configured.");
+  }
+  const requestedChainId = context.chainId ? normalizeDecimalString(context.chainId, "chainId") : null;
+  const source = selectRegistrySource(context.sourceId, requestedChainId, registry);
+  const sourceChainId = normalizeDecimalString(source.chainId, "source.chainId");
+  if (requestedChainId && sourceChainId !== requestedChainId) {
+    throw new Error(
+      `Panoptic source "${source.sourceId}" is configured for chain ${sourceChainId}, not requested chain ${requestedChainId}.`
+    );
+  }
+  const registryRpcUrl = normalizeRegistryRpcUrl(source, registry);
+  const rpcUrl = context.rpcUrl ? normalizeOverrideRpcUrl(context.rpcUrl, source, registry) : registryRpcUrl;
+  return {
+    source,
+    chainId: sourceChainId,
+    rpcUrl,
+    normalizedRpcUrl: rpcUrl,
+    overrideApplied: !!context.rpcUrl && rpcUrl !== registryRpcUrl
+  };
+}
+async function preparePanopticSourceContext(request, viemModule, registry, operationOptions = {}, cacheOptions = {}) {
+  const source = resolvePanopticSource(request.context, registry);
+  const client = getPanopticPublicClient(viemModule, source, cacheOptions);
+  await runPanopticOperation(
+    "Panoptic RPC chain verification",
+    () => verifyPanopticSourceChain(client, source.chainId),
+    operationOptions
+  );
+  const blockNumber = request.context?.blockNumber ? normalizeDecimalString(request.context.blockNumber, "blockNumber") : await runPanopticOperation("Panoptic RPC block pinning", () => readPanopticBlockNumber(client), operationOptions);
+  return {
+    source,
+    client,
+    blockNumber,
+    sourceMeta: buildSourceMeta(source, blockNumber)
+  };
+}
+function getPanopticPublicClient(viemModule, source, options = {}) {
+  const viem = viemModule;
+  if (typeof viem.createPublicClient !== "function" || typeof viem.http !== "function") {
+    throw new Error('Panoptic runtime dependency "viem" does not provide createPublicClient and http.');
+  }
+  const maxEntries = normalizeClientCacheMaxEntries(options.maxEntries);
+  const cacheKey = buildPublicClientCacheKey(source);
+  const cached = publicClientCache.get(cacheKey);
+  if (cached) {
+    publicClientCache.delete(cacheKey);
+    publicClientCache.set(cacheKey, cached);
+    return cached;
+  }
+  const clientOptions = getNormalizedClientOptions(source);
+  const client = viem.createPublicClient({
+    ...clientOptions,
+    chain: {
+      id: Number(source.chainId),
+      name: source.source.label || source.source.sourceId,
+      nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+      rpcUrls: { default: { http: [source.normalizedRpcUrl] } }
+    },
+    transport: viem.http(source.normalizedRpcUrl)
+  });
+  publicClientCache.set(cacheKey, client);
+  evictPublicClientCache(maxEntries);
+  return client;
+}
+async function verifyPanopticSourceChain(client, expectedChainId) {
+  const actualChainId = normalizeChainIdValue(await readPanopticChainId(client), "rpc.chainId");
+  if (actualChainId !== expectedChainId) {
+    throw new Error(`Panoptic RPC chain mismatch: expected ${expectedChainId}, received ${actualChainId}.`);
+  }
+}
+async function readPanopticBlockNumber(client) {
+  const blockNumber = await callClient(client, "getBlockNumber", { method: "eth_blockNumber" });
+  return normalizeChainIdValue(blockNumber, "rpc.blockNumber");
+}
+function buildSourceMeta(source, blockNumber) {
+  return {
+    chainId: source.chainId,
+    blockNumber,
+    rpcSourceId: source.source.sourceId,
+    ...source.source.subgraph?.sourceId ? { subgraphSourceId: source.source.subgraph.sourceId } : {}
+  };
+}
+async function runPanopticOperation(label, operation, options = {}) {
+  const retries = options.retries ?? DEFAULT_OPERATION_RETRIES;
+  let lastError;
+  for (let attempt = 1; attempt <= retries + 1; attempt++) {
+    const startedAt = Date.now();
+    try {
+      throwIfAborted(options.signal);
+      const result = await withTimeout(operation(), label, options.timeoutMs ?? DEFAULT_OPERATION_TIMEOUT_MS);
+      options.onAudit?.({ label, status: "success", attempt, durationMs: Date.now() - startedAt });
+      return result;
+    } catch (error) {
+      lastError = error;
+      options.onAudit?.({
+        label,
+        status: "failure",
+        attempt,
+        durationMs: Date.now() - startedAt,
+        error: sanitizeOperationError(error)
+      });
+      if (attempt > retries || isNonRetryablePanopticOperationError(error)) {
+        break;
+      }
+    }
+  }
+  throw new Error(`${label} failed: ${sanitizeOperationError(lastError)}`);
+}
+function buildPublicClientCacheKey(source) {
+  return `${source.chainId}:${source.normalizedRpcUrl}:${stableStringify(getNormalizedClientOptions(source))}`;
+}
+function getNormalizedClientOptions(source) {
+  if (!isJsonObject2(source.source.clientOptions)) {
+    return {};
+  }
+  const normalized = projectPanopticSerializableValue(
+    source.source.clientOptions,
+    { maxDepth: 8, maxObjectKeys: 64, maxResponseBytes: 32 * 1024 },
+    "source.clientOptions"
+  );
+  if (!isJsonObject2(normalized)) {
+    return {};
+  }
+  return normalized;
+}
+function selectRegistrySource(sourceId, requestedChainId, registry) {
+  if (sourceId) {
+    const source = registry.sources.find((candidate) => candidate.sourceId === sourceId);
+    if (!source) {
+      throw new Error(`Panoptic source "${sourceId}" is not configured.`);
+    }
+    return source;
+  }
+  const candidates = registry.sources.filter(
+    (source) => normalizeDecimalString(source.chainId, "source.chainId") === requestedChainId
+  );
+  if (candidates.length === 0) {
+    throw new Error(`No Panoptic source is configured for chain ${requestedChainId}.`);
+  }
+  if (candidates.length > 1) {
+    throw new Error(`Multiple Panoptic sources are configured for chain ${requestedChainId}; sourceId is required.`);
+  }
+  return candidates[0];
+}
+function normalizeOverrideRpcUrl(value, source, registry) {
+  if (!source.overrideable) {
+    throw new Error(`Panoptic source "${source.sourceId}" does not allow RPC URL overrides.`);
+  }
+  const normalized = normalizeRpcUrl(value);
+  const overrideUrl = new URL(normalized);
+  const registryUrl = new URL(normalizeRegistryRpcUrl(source, registry));
+  const allowLocalhost = !!(registry.devMode && source.allowLocalhostOverrides);
+  if (isLocalOrPrivateHostname(overrideUrl.hostname) && !allowLocalhost) {
+    throw new Error("Panoptic RPC URL override uses a localhost or private host without explicit dev-mode permission.");
+  }
+  if (overrideUrl.protocol !== "https:" && !(allowLocalhost && overrideUrl.protocol === "http:")) {
+    throw new Error("Panoptic RPC URL override must use https.");
+  }
+  const allowedHosts = /* @__PURE__ */ new Set([
+    registryUrl.hostname.toLowerCase(),
+    ...(registry.allowedOverrideHosts || []).map((host) => host.toLowerCase()),
+    ...(source.allowedOverrideHosts || []).map((host) => host.toLowerCase())
+  ]);
+  if (!hostMatchesAllowedList(overrideUrl.hostname, allowedHosts)) {
+    throw new Error(`Panoptic RPC URL override host "${overrideUrl.hostname}" is not allowed.`);
+  }
+  return normalized;
+}
+function normalizeRegistryRpcUrl(source, registry) {
+  const normalized = normalizeRpcUrl(source.rpcUrl);
+  const url = new URL(normalized);
+  const allowLocalhost = !!(registry.devMode && source.allowLocalhostOverrides);
+  if (isLocalOrPrivateHostname(url.hostname) && !allowLocalhost) {
+    throw new Error("Panoptic registry RPC URL uses a localhost or private host without explicit dev-mode permission.");
+  }
+  if (url.protocol !== "https:" && !(allowLocalhost && url.protocol === "http:")) {
+    throw new Error("Panoptic registry RPC URL must use https.");
+  }
+  return normalized;
+}
+function normalizeRpcUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Panoptic RPC URL must be an absolute URL.");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error("Panoptic RPC URL must use http or https.");
+  }
+  if (url.hash) {
+    throw new Error("Panoptic RPC URL must not include a fragment.");
+  }
+  url.protocol = url.protocol.toLowerCase();
+  url.hostname = url.hostname.toLowerCase();
+  if (url.pathname === "/" && !url.search) {
+    return `${url.protocol}//${url.host}`;
+  }
+  return url.toString();
+}
+function normalizeDecimalString(value, fieldName) {
+  if (!/^(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`Panoptic ${fieldName} must be a decimal string.`);
+  }
+  return BigInt(value).toString(10);
+}
+function normalizeChainIdValue(value, fieldName) {
+  if (typeof value === "bigint") {
+    return value.toString(10);
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return value.toString(10);
+  }
+  if (typeof value === "string") {
+    if (/^0x[0-9a-f]+$/i.test(value)) {
+      return BigInt(value).toString(10);
+    }
+    return normalizeDecimalString(value, fieldName);
+  }
+  throw new Error(`Panoptic ${fieldName} must be a decimal string, hex string, bigint, or safe integer.`);
+}
+async function readPanopticChainId(client) {
+  return callClient(client, "getChainId", { method: "eth_chainId" });
+}
+async function callClient(client, methodName, request) {
+  if (isRecord2(client) && typeof client[methodName] === "function") {
+    return client[methodName]();
+  }
+  if (isRecord2(client) && typeof client.request === "function") {
+    return client.request(request);
+  }
+  throw new Error(`Panoptic viem client does not provide ${methodName} or request.`);
+}
+function evictPublicClientCache(maxEntries) {
+  while (publicClientCache.size > maxEntries) {
+    const oldestKey = publicClientCache.keys().next().value;
+    if (oldestKey === void 0) {
+      break;
+    }
+    publicClientCache.delete(oldestKey);
+  }
+}
+function normalizeClientCacheMaxEntries(maxEntries) {
+  if (maxEntries === void 0) {
+    return DEFAULT_CLIENT_CACHE_MAX_ENTRIES;
+  }
+  if (!Number.isInteger(maxEntries) || maxEntries < 1) {
+    throw new Error("Panoptic client cache maxEntries must be a positive integer.");
+  }
+  return maxEntries;
+}
+function hostMatchesAllowedList(hostname, allowedHosts) {
+  const normalized = hostname.toLowerCase();
+  for (const allowedHost of allowedHosts) {
+    if (allowedHost.startsWith("*.") && normalized.endsWith(allowedHost.slice(1))) {
+      return true;
+    }
+    if (normalized === allowedHost) {
+      return true;
+    }
+  }
+  return false;
+}
+function isLocalOrPrivateHostname(hostname) {
+  const normalized = hostname.toLowerCase().replace(/^\[|\]$/g, "");
+  if (normalized === "localhost" || normalized === "::" || normalized === "::1" || normalized === "0:0:0:0:0:0:0:0" || normalized === "0:0:0:0:0:0:0:1") {
+    return true;
+  }
+  if (normalized.startsWith("::ffff:")) {
+    return true;
+  }
+  const ipv4Parts = normalized.split(".").map((part) => Number(part));
+  if (ipv4Parts.length === 4 && ipv4Parts.every((part) => Number.isInteger(part) && part >= 0 && part <= 255)) {
+    const [first, second] = ipv4Parts;
+    return first === 0 || first === 10 || first === 127 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 169 && second === 254;
+  }
+  return normalized.startsWith("fc") || normalized.startsWith("fd") || normalized.startsWith("fe8") || normalized.startsWith("fe9") || normalized.startsWith("fea") || normalized.startsWith("feb");
+}
+async function withTimeout(promise, label, timeoutMs) {
+  let timeout = null;
+  try {
+    return await Promise.race([
+      promise,
+      new Promise((_, reject) => {
+        timeout = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms.`)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+  }
+}
+function throwIfAborted(signal) {
+  if (signal?.aborted) {
+    throw new Error("Panoptic operation was aborted.");
+  }
+}
+function sanitizeOperationError(error) {
+  return sanitizePanopticError(error);
+}
+function isNonRetryablePanopticOperationError(error) {
+  return sanitizeOperationError(error).startsWith('Panoptic runtime dependency "');
+}
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map(stableStringify).join(",")}]`;
+  }
+  if (isJsonObject2(value)) {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function isJsonObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/internal/panopticJsonArgs.ts
+function decimalValue(value, label) {
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`Panoptic ${label} must be a decimal string.`);
+  }
+  return BigInt(value);
+}
+function signedDecimalValue(value, label) {
+  if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`Panoptic ${label} must be a signed decimal string.`);
+  }
+  return BigInt(value);
+}
+function stringValue(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`Panoptic ${label} must be a string.`);
+  }
+  return value;
+}
+function booleanValue(value, label) {
+  if (typeof value !== "boolean") {
+    throw new Error(`Panoptic ${label} must be a boolean.`);
+  }
+  return value;
+}
+function numberValue(value, label) {
+  if (typeof value !== "number") {
+    throw new Error(`Panoptic ${label} must be a number.`);
+  }
+  return value;
+}
+function decimalArg(args, fieldName) {
+  return decimalValue(args[fieldName], `args.${fieldName}`);
+}
+function signedDecimalArg(args, fieldName) {
+  return signedDecimalValue(args[fieldName], `args.${fieldName}`);
+}
+function optionalDecimalArg(args, fieldName) {
+  return args[fieldName] === void 0 ? void 0 : decimalArg(args, fieldName);
+}
+function optionalSignedDecimalArg(args, fieldName) {
+  return args[fieldName] === void 0 ? void 0 : signedDecimalArg(args, fieldName);
+}
+function optionalBooleanArg(args, fieldName) {
+  return args[fieldName] === void 0 ? void 0 : booleanValue(args[fieldName], `args.${fieldName}`);
+}
+function decimalArrayArg(args, fieldName) {
+  return decimalArrayValue(args[fieldName], `args.${fieldName}`);
+}
+function optionalDecimalArrayArg(args, fieldName) {
+  return args[fieldName] === void 0 ? void 0 : decimalArrayArg(args, fieldName);
+}
+function signedDecimalArrayArg(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => signedDecimalValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function decimalMatrixArg(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (row, rowIndex) => decimalArrayValue(row, `args.${fieldName}[${rowIndex}]`)
+  );
+}
+function optionalStringArrayArg(args, fieldName) {
+  if (args[fieldName] === void 0) {
+    return void 0;
+  }
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => stringValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function decimalArrayValue(value, label) {
+  return arrayValue(value, label).map((item, index) => decimalValue(item, `${label}[${index}]`));
+}
+function arrayValue(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Panoptic ${label} must be an array.`);
+  }
+  return value;
+}
+function recordValue(value, label) {
+  if (!isJsonRecord2(value)) {
+    throw new Error(`Panoptic ${label} must be an object.`);
+  }
+  return value;
+}
+function isJsonRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/internal/panopticDtos.ts
+function collateralAddressesValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    collateralToken0: stringValue(record.collateralToken0, `${label}.collateralToken0`),
+    collateralToken1: stringValue(record.collateralToken1, `${label}.collateralToken1`)
+  };
+}
+function poolInfoArrayArg(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => poolInfoValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function poolInfoValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    pool: stringValue(record.pool, `${label}.pool`),
+    token0: stringValue(record.token0, `${label}.token0`),
+    token1: stringValue(record.token1, `${label}.token1`),
+    maxPriceDeviation: numberValue(record.maxPriceDeviation, `${label}.maxPriceDeviation`)
+  };
+}
+function poolMetadataValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    poolKeyBytes: stringValue(record.poolKeyBytes, `${label}.poolKeyBytes`),
+    poolId: decimalValue(record.poolId, `${label}.poolId`),
+    collateralToken0Address: stringValue(record.collateralToken0Address, `${label}.collateralToken0Address`),
+    collateralToken1Address: stringValue(record.collateralToken1Address, `${label}.collateralToken1Address`),
+    riskEngineAddress: stringValue(record.riskEngineAddress, `${label}.riskEngineAddress`),
+    token0Asset: stringValue(record.token0Asset, `${label}.token0Asset`),
+    token1Asset: stringValue(record.token1Asset, `${label}.token1Asset`),
+    token0Symbol: stringValue(record.token0Symbol, `${label}.token0Symbol`),
+    token1Symbol: stringValue(record.token1Symbol, `${label}.token1Symbol`),
+    token0Decimals: decimalValue(record.token0Decimals, `${label}.token0Decimals`),
+    token1Decimals: decimalValue(record.token1Decimals, `${label}.token1Decimals`),
+    token0Name: stringValue(record.token0Name, `${label}.token0Name`),
+    token1Name: stringValue(record.token1Name, `${label}.token1Name`),
+    underlyingPoolId: stringValue(record.underlyingPoolId, `${label}.underlyingPoolId`),
+    isV4: booleanValue(record.isV4, `${label}.isV4`),
+    tickSpacing: decimalValue(record.tickSpacing, `${label}.tickSpacing`),
+    fee: decimalValue(record.fee, `${label}.fee`),
+    sfpmAddress: stringValue(record.sfpmAddress, `${label}.sfpmAddress`)
+  };
+}
+function tokenIdLegArrayArg(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => tokenIdLegValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function tokenIdLegValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    index: decimalValue(record.index, `${label}.index`),
+    asset: decimalValue(record.asset, `${label}.asset`),
+    optionRatio: decimalValue(record.optionRatio, `${label}.optionRatio`),
+    isLong: booleanValue(record.isLong, `${label}.isLong`),
+    tokenType: decimalValue(record.tokenType, `${label}.tokenType`),
+    riskPartner: decimalValue(record.riskPartner, `${label}.riskPartner`),
+    strike: signedDecimalValue(record.strike, `${label}.strike`),
+    width: decimalValue(record.width, `${label}.width`),
+    tickLower: signedDecimalValue(record.tickLower, `${label}.tickLower`),
+    tickUpper: signedDecimalValue(record.tickUpper, `${label}.tickUpper`)
+  };
+}
+function storedPositionArrayArg(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => storedPositionValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function storedPositionValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    tokenId: decimalValue(record.tokenId, `${label}.tokenId`),
+    legs: arrayValue(record.legs, `${label}.legs`).map((leg, index) => tokenIdLegValue(leg, `${label}.legs[${index}]`)),
+    tickAtMint: signedDecimalValue(record.tickAtMint, `${label}.tickAtMint`),
+    positionSize: decimalValue(record.positionSize, `${label}.positionSize`)
+  };
+}
+function vaultCandidatesByPoolArrayArg(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => vaultCandidatesByPoolValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function vaultCandidatesByPoolValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    poolAddress: stringValue(record.poolAddress, `${label}.poolAddress`),
+    candidates: decimalArrayValue(record.candidates, `${label}.candidates`)
+  };
+}
+function uniswapAddressesValue(value, label) {
+  const record = recordValue(value, label);
+  return {
+    universalRouter: stringValue(record.universalRouter, `${label}.universalRouter`),
+    v4Quoter: stringValue(record.v4Quoter, `${label}.v4Quoter`),
+    poolManager: stringValue(record.poolManager, `${label}.poolManager`),
+    permit2: stringValue(record.permit2, `${label}.permit2`)
+  };
+}
+
+// src/internal/panopticScalars.ts
+var UINT48_MAX = (BigInt(1) << BigInt(48)) - BigInt(1);
+var UINT128_MAX = (BigInt(1) << BigInt(128)) - BigInt(1);
+var UINT160_MAX = (BigInt(1) << BigInt(160)) - BigInt(1);
+var UINT256_MAX = (BigInt(1) << BigInt(256)) - BigInt(1);
+var INT24_MIN = -(BigInt(1) << BigInt(23));
+var INT24_MAX = (BigInt(1) << BigInt(23)) - BigInt(1);
+function uint48Arg(args, fieldName) {
+  return unsignedDecimalValue(args[fieldName], `args.${fieldName}`, UINT48_MAX, "uint48");
+}
+function uint128Arg(args, fieldName) {
+  return unsignedDecimalValue(args[fieldName], `args.${fieldName}`, UINT128_MAX, "uint128");
+}
+function uint160Arg(args, fieldName) {
+  return unsignedDecimalValue(args[fieldName], `args.${fieldName}`, UINT160_MAX, "uint160");
+}
+function uint256Arg(args, fieldName) {
+  return unsignedDecimalValue(args[fieldName], `args.${fieldName}`, UINT256_MAX, "uint256");
+}
+function optionalUint256Arg(args, fieldName) {
+  return args[fieldName] === void 0 ? void 0 : unsignedDecimalValue(args[fieldName], `args.${fieldName}`, UINT256_MAX, "uint256");
+}
+function uint256ArrayArg(args, fieldName) {
+  const value = args[fieldName];
+  if (!Array.isArray(value)) {
+    throw new Error(`Panoptic args.${fieldName} must be an array.`);
+  }
+  return value.map((item, index) => unsignedDecimalValue(item, `args.${fieldName}[${index}]`, UINT256_MAX, "uint256"));
+}
+function int24Arg(args, fieldName) {
+  return signedDecimalValue2(args[fieldName], `args.${fieldName}`, INT24_MIN, INT24_MAX, "int24");
+}
+function optionalInt24Arg(args, fieldName) {
+  return args[fieldName] === void 0 ? void 0 : signedDecimalValue2(args[fieldName], `args.${fieldName}`, INT24_MIN, INT24_MAX, "int24");
+}
+function unsignedDecimalValue(value, label, maxValue, rangeLabel) {
+  if (typeof value !== "string" || !/^(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`Panoptic ${label} must be an unsigned decimal string.`);
+  }
+  const parsed = BigInt(value);
+  if (parsed > maxValue) {
+    throw new Error(`Panoptic ${label} exceeds ${rangeLabel} range.`);
+  }
+  return parsed;
+}
+function signedDecimalValue2(value, label, minValue, maxValue, rangeLabel) {
+  if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`Panoptic ${label} must be a signed decimal string.`);
+  }
+  const parsed = BigInt(value);
+  if (parsed < minValue || parsed > maxValue) {
+    throw new Error(`Panoptic ${label} exceeds ${rangeLabel} range.`);
+  }
+  return parsed;
+}
+
+// src/internal/panoptic/support.ts
+function rejectContext(request, method) {
+  if (request.context !== void 0) {
+    throw new Error(`Panoptic ${method} is a pure method and does not accept runtime context.`);
+  }
+}
+function requireSourceContext(request, method) {
+  if (request.context) {
+    rejectExtraContextKeys(request, method);
+  }
+  if (!request.context?.sourceId && !request.context?.chainId) {
+    throw new Error(`Panoptic ${method} requires context.sourceId or context.chainId.`);
+  }
+}
+function rejectExtraContextKeys(request, method) {
+  const context = request.context;
+  if (!context) {
+    return;
+  }
+  const allowed = /* @__PURE__ */ new Set(["chainId", "sourceId", "blockNumber", "account", "panopticSubgraphId", "rpcUrl"]);
+  for (const key of Object.keys(context)) {
+    if (!allowed.has(key)) {
+      throw new Error(`Panoptic ${method} context.${key} is not supported by the schema.`);
+    }
+  }
+}
+function rejectExtraKeys(args, allowedKeys, method) {
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(args)) {
+    if (!allowed.has(key)) {
+      throw new Error(`Panoptic ${method} args.${key} is not supported by the schema.`);
+    }
+  }
+}
+function requireString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`Panoptic ${label} must be a string.`);
+  }
+  return value;
+}
+function requirePlainResult(value, label) {
+  if (!isRecord4(value)) {
+    throw new Error(`Panoptic ${label} must be an object.`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new Error(`Panoptic ${label} must be a plain object.`);
+  }
+  return value;
+}
+function requireSdkFunction(sdkModule, name, label) {
+  const defaultExport = isRecord4(sdkModule.default) ? sdkModule.default : void 0;
+  const sdkExport = sdkModule[name] ?? defaultExport?.[name];
+  if (typeof sdkExport !== "function") {
+    throw new Error(`Panoptic runtime dependency "${label}" does not provide ${name}.`);
+  }
+  return sdkExport;
+}
+async function prepareRuntimeSourceContext(deps, request, options) {
+  return preparePanopticSourceContext(
+    request,
+    await deps.viem(),
+    options.sourceRegistry,
+    options.operation,
+    options.clientCache
+  );
+}
+function withSource(value, sourceContext, blockNumberRole, label, blockNumber, reconciled) {
+  const projectedValue = omitSdkMeta(requirePlainResult(value, label));
+  const sourceMeta = buildMethodSourceMeta(sourceContext, blockNumberRole, blockNumber, reconciled);
+  return {
+    ...projectedValue,
+    source: sourceMeta
+  };
+}
+function isRecord4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function omitSdkMeta(value) {
+  const { _meta: _ignored, ...publicValue } = value;
+  void _ignored;
+  return publicValue;
+}
+function buildMethodSourceMeta(sourceContext, blockNumberRole, blockNumber, reconciled) {
+  const { blockNumber: preparedBlockNumber, ...baseMeta } = sourceContext.sourceMeta;
+  const sourceBlockNumber = blockNumber || preparedBlockNumber;
+  return {
+    ...baseMeta,
+    ...blockNumberRole === "preflight" ? { preflightBlockNumber: sourceBlockNumber } : { blockNumber: sourceBlockNumber },
+    blockNumberRole,
+    ...reconciled === void 0 ? {} : { reconciled }
+  };
+}
+
+// src/internal/panoptic/reads/account.ts
+async function getPosition({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseTokenIdRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetPosition = await loadSdkV2Function(deps, "getPosition");
+  return withSource(
+    await sdkGetPosition({
+      ...ownerReadParams(sourceContext, input.account),
+      poolAddress: input.poolAddress,
+      tokenId: input.tokenId
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getPositions({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseTokenIdsRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetPositions = await loadSdkV2Function(deps, "getPositions");
+  return withSource(
+    await sdkGetPositions({
+      ...ownerReadParams(sourceContext, input.account),
+      poolAddress: input.poolAddress,
+      tokenIds: input.tokenIds
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getOpenPositionIds({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseOpenPositionIdsRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetOpenPositionIds = await loadSdkV2Function(deps, "getOpenPositionIds");
+  const tokenIds = await sdkGetOpenPositionIds({
+    client: sourceContext.client,
+    chainId: BigInt(sourceContext.source.chainId),
+    poolAddress: input.poolAddress,
+    account: input.account,
+    lastDispatchTxHash: input.lastDispatchTxHash
+  });
+  return withSource({ tokenIds }, sourceContext, "preflight", `${method} result`, void 0, false);
+}
+async function getAccountCollateral({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseAccountCollateralRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetAccountCollateral = await loadSdkV2Function(deps, "getAccountCollateral");
+  return withSource(
+    await sdkGetAccountCollateral({
+      ...accountReadParams(sourceContext, input.account),
+      poolAddress: input.poolAddress,
+      collateralAddresses: input.collateralAddresses
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getAccountSummaryBasic({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseAccountSummaryBasicRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetAccountSummaryBasic = await loadSdkV2Function(deps, "getAccountSummaryBasic");
+  return withSource(
+    await sdkGetAccountSummaryBasic({
+      ...accountReadParams(sourceContext, input.account, true),
+      poolAddress: input.poolAddress,
+      tokenIds: input.tokenIds,
+      poolMetadata: input.poolMetadata
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getAccountSummaryRisk({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseAccountSummaryRiskRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetAccountSummaryRisk = await loadSdkV2Function(deps, "getAccountSummaryRisk");
+  return withSource(
+    await sdkGetAccountSummaryRisk({
+      ...accountReadParams(sourceContext, input.account, true),
+      poolAddress: input.poolAddress,
+      tokenIds: input.tokenIds,
+      queryAddress: input.queryAddress,
+      atTick: input.atTick,
+      includePendingPremium: input.includePendingPremium,
+      poolMetadata: input.poolMetadata
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getNetLiquidationValue({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseNetLiquidationValueRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetNetLiquidationValue = await loadSdkV2Function(deps, "getNetLiquidationValue");
+  return withSource(
+    await sdkGetNetLiquidationValue({
+      ...accountReadParams(sourceContext, input.account),
+      poolAddress: input.poolAddress,
+      tokenIds: input.tokenIds,
+      queryAddress: input.queryAddress,
+      atTick: input.atTick,
+      includePendingPremium: input.includePendingPremium
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getNetLiquidationValues({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseNetLiquidationValuesRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetNetLiquidationValues = await loadSdkV2Function(deps, "getNetLiquidationValues");
+  return withSource(
+    await sdkGetNetLiquidationValues({
+      ...accountReadParams(sourceContext, input.account),
+      poolAddress: input.poolAddress,
+      tokenIds: input.tokenIds,
+      queryAddress: input.queryAddress,
+      atTicks: input.atTicks,
+      includePendingPremium: input.includePendingPremium
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function getLiquidationPrices({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseLiquidationPricesRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetLiquidationPrices = await loadSdkV2Function(deps, "getLiquidationPrices");
+  return withSource(
+    await sdkGetLiquidationPrices({
+      ...accountReadParams(sourceContext, input.account),
+      poolAddress: input.poolAddress,
+      tokenIds: input.tokenIds,
+      queryAddress: input.queryAddress
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+function parseTokenIdRequest(request, method) {
+  const { account, args } = accountArgs(request, method, ["poolAddress", "tokenId"]);
+  return { account, poolAddress: poolAddress(args.poolAddress, method), tokenId: uint256Arg(args, "tokenId") };
+}
+function parseTokenIdsRequest(request, method) {
+  const { account, args } = accountArgs(request, method, ["poolAddress", "tokenIds"]);
+  return { account, poolAddress: poolAddress(args.poolAddress, method), tokenIds: uint256ArrayArg(args, "tokenIds") };
+}
+function parseOpenPositionIdsRequest(request, method) {
+  rejectLatestOnlyBlockNumber(request, method);
+  const { account, args } = accountArgs(request, method, ["poolAddress", "lastDispatchTxHash"]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    lastDispatchTxHash: normalizePanopticHex(
+      requireArgString(args, "lastDispatchTxHash", method),
+      `${method} args.lastDispatchTxHash`
+    )
+  };
+}
+function parseAccountCollateralRequest(request, method) {
+  const { account, args } = accountArgs(request, method, ["poolAddress", "collateralAddresses"]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    ...args.collateralAddresses === void 0 ? {} : {
+      collateralAddresses: collateralAddressesValue(args.collateralAddresses, `${method} args.collateralAddresses`)
+    }
+  };
+}
+function parseAccountSummaryBasicRequest(request, method) {
+  const { account, args } = accountArgs(request, method, ["poolAddress", "tokenIds", "poolMetadata"]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    tokenIds: uint256ArrayArg(args, "tokenIds"),
+    ...args.poolMetadata === void 0 ? {} : { poolMetadata: poolMetadataValue(args.poolMetadata, `${method} args.poolMetadata`) }
+  };
+}
+function parseAccountSummaryRiskRequest(request, method) {
+  const { account, args } = accountArgs(request, method, [
+    "poolAddress",
+    "tokenIds",
+    "queryAddress",
+    "atTick",
+    "includePendingPremium",
+    "poolMetadata"
+  ]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    tokenIds: uint256ArrayArg(args, "tokenIds"),
+    queryAddress: normalizePanopticAddress(args.queryAddress, `${method} args.queryAddress`),
+    atTick: optionalSignedDecimalArg(args, "atTick"),
+    includePendingPremium: optionalBooleanArg(args, "includePendingPremium"),
+    ...args.poolMetadata === void 0 ? {} : { poolMetadata: poolMetadataValue(args.poolMetadata, `${method} args.poolMetadata`) }
+  };
+}
+function parseNetLiquidationValueRequest(request, method) {
+  const { account, args } = accountArgs(request, method, [
+    "poolAddress",
+    "tokenIds",
+    "queryAddress",
+    "atTick",
+    "includePendingPremium"
+  ]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    tokenIds: uint256ArrayArg(args, "tokenIds"),
+    queryAddress: normalizePanopticAddress(args.queryAddress, `${method} args.queryAddress`),
+    atTick: optionalSignedDecimalArg(args, "atTick"),
+    includePendingPremium: optionalBooleanArg(args, "includePendingPremium")
+  };
+}
+function parseNetLiquidationValuesRequest(request, method) {
+  const { account, args } = accountArgs(request, method, [
+    "poolAddress",
+    "tokenIds",
+    "queryAddress",
+    "atTicks",
+    "includePendingPremium"
+  ]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    tokenIds: uint256ArrayArg(args, "tokenIds"),
+    queryAddress: normalizePanopticAddress(args.queryAddress, `${method} args.queryAddress`),
+    atTicks: signedDecimalArrayArg(args, "atTicks"),
+    includePendingPremium: optionalBooleanArg(args, "includePendingPremium")
+  };
+}
+function parseLiquidationPricesRequest(request, method) {
+  const { account, args } = accountArgs(request, method, ["poolAddress", "tokenIds", "queryAddress"]);
+  return {
+    account,
+    poolAddress: poolAddress(args.poolAddress, method),
+    tokenIds: uint256ArrayArg(args, "tokenIds"),
+    queryAddress: normalizePanopticAddress(args.queryAddress, `${method} args.queryAddress`)
+  };
+}
+function accountArgs(request, method, allowedKeys) {
+  requireSourceContext(request, method);
+  const account = requireAccount(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, allowedKeys, method);
+  return { account, args };
+}
+function requireAccount(request, method) {
+  const account = request?.context?.account;
+  if (!account) {
+    throw new Error(`Panoptic ${method} requires context.account.`);
+  }
+  return normalizePanopticAddress(account, `${method} context.account`);
+}
+function rejectLatestOnlyBlockNumber(request, method) {
+  if (request.context?.blockNumber !== void 0) {
+    throw new Error(`Panoptic ${method} does not accept context.blockNumber because its block policy is latestOnly.`);
+  }
+}
+function ownerReadParams(sourceContext, account) {
+  return { client: sourceContext.client, blockNumber: BigInt(sourceContext.blockNumber), owner: account };
+}
+function accountReadParams(sourceContext, account, includeChainId = false) {
+  return {
+    client: sourceContext.client,
+    ...includeChainId ? { chainId: BigInt(sourceContext.source.chainId) } : {},
+    blockNumber: BigInt(sourceContext.blockNumber),
+    account
+  };
+}
+async function loadSdkV2Function(deps, name) {
+  return requireSdkFunction(await deps.sdkV2(), name, "@panoptic-eng/sdk/v2");
+}
+function poolAddress(value, method) {
+  return normalizePanopticAddress(value, `${method} args.poolAddress`);
+}
+function requireArgString(args, fieldName, method) {
+  const value = args[fieldName];
+  if (value === void 0) {
+    throw new Error(`Panoptic ${method} args.${fieldName} is required.`);
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Panoptic ${method} args.${fieldName} must be a string.`);
+  }
+  return value;
+}
+
+// src/internal/panoptic/reads/greeks.ts
+async function getPositionGreeks({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseGetPositionGreeksRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetPositionGreeks = await loadSdkFunction(deps, "getPositionGreeks");
+  const rawResult = await sdkGetPositionGreeks({
+    client: sourceContext.client,
+    blockNumber: BigInt(sourceContext.blockNumber),
+    poolAddress: input.poolAddress,
+    owner: input.account,
+    tokenId: input.tokenId,
+    atTick: input.atTick
+  });
+  return withSource(rawResult, sourceContext, "pinned", "greeks.getPositionGreeks result");
+}
+async function calculatePositionGreeks({ deps, method, request }) {
+  const input = parseCalculatePositionGreeksRequest(request, method);
+  const sdkV2 = await deps.sdkV2();
+  const sdkCalculatePositionGreeks = requireSdkFunction(sdkV2, "calculatePositionGreeks", "@panoptic-eng/sdk/v2");
+  const result = await sdkCalculatePositionGreeks(input);
+  if (input.swapAtMint !== void 0) {
+    const calculatePositionDeltaWithSwap = requireSdkFunction(
+      sdkV2,
+      "calculatePositionDeltaWithSwap",
+      "@panoptic-eng/sdk/v2"
+    );
+    const delta = await calculatePositionDeltaWithSwap(input);
+    if (isRecord3(result)) {
+      return { ...result, delta };
+    }
+  }
+  return result;
+}
+async function calculateAccountGreeksPure({ deps, method, request }) {
+  const input = parseCalculateAccountGreeksPureRequest(request, method);
+  const sdkCalculateAccountGreeksPure = await loadSdkFunction(deps, "calculateAccountGreeksPure");
+  return sdkCalculateAccountGreeksPure(input);
+}
+function parseGetPositionGreeksRequest(request, method) {
+  requireSourceContext(request, method);
+  const account = requireAccount2(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["poolAddress", "tokenId", "atTick"], method);
+  return {
+    account,
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    tokenId: uint256Arg(args, "tokenId"),
+    atTick: optionalSignedDecimalArg(args, "atTick")
+  };
+}
+function parseCalculatePositionGreeksRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(
+    args,
+    ["legs", "currentTick", "mintTick", "positionSize", "poolTickSpacing", "assetIndex", "swapAtMint"],
+    method
+  );
+  return {
+    legs: tokenIdLegArrayArg(args, "legs"),
+    currentTick: signedDecimalArg(args, "currentTick"),
+    mintTick: signedDecimalArg(args, "mintTick"),
+    positionSize: decimalArg(args, "positionSize"),
+    poolTickSpacing: decimalArg(args, "poolTickSpacing"),
+    ...args.assetIndex === void 0 ? {} : { assetIndex: optionalDecimalArg(args, "assetIndex") },
+    ...args.swapAtMint === void 0 ? {} : { swapAtMint: optionalBooleanArg(args, "swapAtMint") }
+  };
+}
+function parseCalculateAccountGreeksPureRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["positions", "tickSpacing", "atTicks", "collateralAssets", "assetIndex"], method);
+  return {
+    positions: storedPositionArrayArg(args, "positions"),
+    tickSpacing: decimalArg(args, "tickSpacing"),
+    atTicks: signedDecimalArrayArg(args, "atTicks"),
+    ...args.collateralAssets === void 0 ? {} : { collateralAssets: optionalDecimalArrayArg(args, "collateralAssets") },
+    ...args.assetIndex === void 0 ? {} : { assetIndex: optionalDecimalArg(args, "assetIndex") }
+  };
+}
+async function loadSdkFunction(deps, name) {
+  return requireSdkFunction(await deps.sdkV2(), name, "@panoptic-eng/sdk/v2");
+}
+function requireAccount2(request, method) {
+  const account = request.context?.account;
+  if (!account) {
+    throw new Error(`Panoptic ${method} requires context.account.`);
+  }
+  return normalizePanopticAddress(account, `${method} context.account`);
+}
+
+// src/internal/panoptic/reads/hypovault.ts
+async function buildVaultManagerInputAtBlock({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseBuildVaultManagerInputAtBlockRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkBuildManagerInputAtBlock = requireSdkFunction(
+    await deps.sdk(),
+    "buildManagerInputAtBlock",
+    "@panoptic-eng/sdk"
+  );
+  const managerInput = await sdkBuildManagerInputAtBlock({
+    viemClient: sourceContext.client,
+    poolInfos: input.poolInfos,
+    tokenIds: input.tokenIds,
+    underlyingToken: input.underlyingToken,
+    wethAddress: input.wethAddress,
+    blockNumber: BigInt(sourceContext.blockNumber),
+    erc4626Vaults: input.erc4626Vaults
+  });
+  return withSource({ managerInput }, sourceContext, "pinned", "hypovault.buildVaultManagerInputAtBlock result");
+}
+async function verifyVaultOpenTokenIdsAtBlock({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseVerifyVaultOpenTokenIdsAtBlockRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkVerifyVaultOpenTokenIdsAtBlock = requireSdkFunction(
+    await deps.sdk(),
+    "verifyVaultOpenTokenIdsAtBlock",
+    "@panoptic-eng/sdk"
+  );
+  const tokenIdsByPool = await sdkVerifyVaultOpenTokenIdsAtBlock({
+    viemClient: sourceContext.client,
+    vaultAddress: input.vaultAddress,
+    candidatesByPool: input.candidatesByPool,
+    blockNumber: BigInt(sourceContext.blockNumber)
+  });
+  return withSource({ tokenIdsByPool }, sourceContext, "pinned", "hypovault.verifyVaultOpenTokenIdsAtBlock result");
+}
+async function getOpenPositionIds2({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseGetOpenPositionIdsRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetOpenPositionIds = requireSdkFunction(await deps.sdkV2(), "getOpenPositionIds", "@panoptic-eng/sdk/v2");
+  const tokenIds = await sdkGetOpenPositionIds({
+    client: sourceContext.client,
+    chainId: BigInt(sourceContext.source.chainId),
+    poolAddress: input.poolAddress,
+    account: input.account,
+    lastDispatchTxHash: input.lastDispatchTxHash
+  });
+  return withSource({ tokenIds }, sourceContext, "preflight", "hypovault.getOpenPositionIds result", void 0, false);
+}
+async function getEpochContext({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseGetEpochContextRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const readContract = readContractFunction(sourceContext.client, method);
+  const [depositEpoch, withdrawalEpoch, totalSupply] = await Promise.all([
+    readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "depositEpoch",
+      args: [],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }),
+    readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "withdrawalEpoch",
+      args: [],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }),
+    readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "totalSupply",
+      args: [],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    })
+  ]);
+  const depositEpochNumber = toBigInt(depositEpoch, `${method} depositEpoch`);
+  const withdrawalEpochNumber = toBigInt(withdrawalEpoch, `${method} withdrawalEpoch`);
+  const [depositState, withdrawalState, queuedDeposit, queuedWithdrawal, block] = await Promise.all([
+    readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "depositEpochState",
+      args: [depositEpochNumber],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }),
+    readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "withdrawalEpochState",
+      args: [withdrawalEpochNumber],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }),
+    input.account ? readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "queuedDeposit",
+      args: [input.account, depositEpochNumber],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }) : void 0,
+    input.account ? readContract({
+      address: input.vaultAddress,
+      abi: HYPOVAULT_READ_ABI,
+      functionName: "queuedWithdrawal",
+      args: [input.account, withdrawalEpochNumber],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }) : void 0,
+    getBlockIfAvailable(sourceContext.client, sourceContext.blockNumber)
+  ]);
+  const deposit = depositEpochState(depositState, method);
+  const withdrawal = withdrawalEpochState(withdrawalState, method);
+  return withSource(
+    {
+      vaultAddress: input.vaultAddress,
+      ...input.account === void 0 ? {} : { account: input.account },
+      totalSupply: toBigInt(totalSupply, `${method} totalSupply`).toString(10),
+      ...block?.timestamp === void 0 ? {} : { currentTimestamp: block.timestamp.toString(10) },
+      deposit: {
+        epoch: depositEpochNumber.toString(10),
+        ...deposit,
+        pendingValue: nonnegativeDifference(deposit.assetsDeposited, deposit.assetsFulfilled).toString(10),
+        ...queuedDeposit === void 0 ? {} : { queuedDeposit: toBigInt(queuedDeposit, `${method} queuedDeposit`).toString(10) }
+      },
+      withdrawal: {
+        epoch: withdrawalEpochNumber.toString(10),
+        ...withdrawal,
+        pendingShares: nonnegativeDifference(withdrawal.sharesWithdrawn, withdrawal.sharesFulfilled).toString(10),
+        ...queuedWithdrawal === void 0 ? {} : { queuedWithdrawal: queuedWithdrawalState(queuedWithdrawal, method) }
+      }
+    },
+    sourceContext,
+    "pinned",
+    "hypovault.getEpochContext result"
+  );
+}
+async function getPositionsHashStatus({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseGetPositionsHashStatusRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const readContract = readContractFunction(sourceContext.client, method);
+  const positionsHash = normalizePanopticHex(
+    await readContract({
+      address: input.poolAddress,
+      abi: PANOPTIC_POOL_READ_ABI,
+      functionName: "positionsHash",
+      args: [input.account],
+      blockNumber: BigInt(sourceContext.blockNumber)
+    }),
+    `${method} positionsHash`
+  );
+  const tokenIds = input.tokenIds ?? await recoverTokenIds(deps, sourceContext, input, method);
+  const computedHash = tokenIds === void 0 ? void 0 : await computePositionsHash(await deps.viem(), tokenIds, method);
+  return withSource(
+    {
+      account: input.account,
+      poolAddress: input.poolAddress,
+      positionsHash,
+      ...tokenIds === void 0 ? {} : { tokenIds },
+      ...computedHash === void 0 ? {} : { computedHash, valid: computedHash === positionsHash }
+    },
+    sourceContext,
+    "pinned",
+    "hypovault.getPositionsHashStatus result"
+  );
+}
+function parseBuildVaultManagerInputAtBlockRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(
+    args,
+    ["vaultAddress", "underlyingToken", "poolInfos", "tokenIds", "managerAddress", "wethAddress", "erc4626Vaults"],
+    method
+  );
+  return {
+    vaultAddress: normalizePanopticAddress(args.vaultAddress, `${method} args.vaultAddress`),
+    underlyingToken: normalizePanopticAddress(args.underlyingToken, `${method} args.underlyingToken`),
+    poolInfos: poolInfoArrayArg(args, "poolInfos"),
+    tokenIds: decimalMatrixArg(args, "tokenIds"),
+    ...args.wethAddress === void 0 ? {} : { wethAddress: normalizePanopticAddress(args.wethAddress, `${method} args.wethAddress`) },
+    ...args.erc4626Vaults === void 0 ? {} : { erc4626Vaults: optionalStringArrayArg(args, "erc4626Vaults") }
+  };
+}
+function parseVerifyVaultOpenTokenIdsAtBlockRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["vaultAddress", "candidatesByPool"], method);
+  return {
+    vaultAddress: normalizePanopticAddress(args.vaultAddress, `${method} args.vaultAddress`),
+    candidatesByPool: vaultCandidatesByPoolArrayArg(args, "candidatesByPool")
+  };
+}
+function parseGetOpenPositionIdsRequest(request, method) {
+  requireSourceContext(request, method);
+  rejectLatestOnlyBlockNumber2(request, method);
+  const account = requireAccount3(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["poolAddress", "lastDispatchTxHash"], method);
+  return {
+    account,
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    lastDispatchTxHash: normalizePanopticHex(
+      requireArgString2(args, "lastDispatchTxHash", method),
+      `${method} args.lastDispatchTxHash`
+    )
+  };
+}
+function parseGetEpochContextRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["vaultAddress", "account"], method);
+  return {
+    vaultAddress: normalizePanopticAddress(args.vaultAddress, `${method} args.vaultAddress`),
+    ...args.account === void 0 ? {} : { account: normalizePanopticAddress(args.account, `${method} args.account`) }
+  };
+}
+function parseGetPositionsHashStatusRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["poolAddress", "account", "tokenIds", "lastDispatchTxHash"], method);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    account: normalizePanopticAddress(args.account ?? request.context?.account, `${method} args.account`),
+    ...args.tokenIds === void 0 ? {} : { tokenIds: decimalMatrixArg({ tokenIds: [args.tokenIds] }, "tokenIds")[0].map((id) => id.toString(10)) },
+    ...args.lastDispatchTxHash === void 0 ? {} : {
+      lastDispatchTxHash: normalizePanopticHex(
+        requireArgString2(args, "lastDispatchTxHash", method),
+        `${method} args.lastDispatchTxHash`
+      )
+    }
+  };
+}
+function requireAccount3(request, method) {
+  const account = request.context?.account;
+  if (!account) {
+    throw new Error(`Panoptic ${method} requires context.account.`);
+  }
+  return normalizePanopticAddress(account, `${method} context.account`);
+}
+function requireArgString2(args, fieldName, method) {
+  const value = args[fieldName];
+  if (value === void 0) {
+    throw new Error(`Panoptic ${method} args.${fieldName} is required.`);
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Panoptic ${method} args.${fieldName} must be a string.`);
+  }
+  return value;
+}
+function rejectLatestOnlyBlockNumber2(request, method) {
+  if (request.context?.blockNumber !== void 0) {
+    throw new Error(`Panoptic ${method} does not accept context.blockNumber because its block policy is latestOnly.`);
+  }
+}
+var HYPOVAULT_READ_ABI = [
+  { type: "function", name: "depositEpoch", stateMutability: "view", inputs: [], outputs: [{ type: "uint128" }] },
+  { type: "function", name: "withdrawalEpoch", stateMutability: "view", inputs: [], outputs: [{ type: "uint128" }] },
+  { type: "function", name: "totalSupply", stateMutability: "view", inputs: [], outputs: [{ type: "uint256" }] },
+  {
+    type: "function",
+    name: "depositEpochState",
+    stateMutability: "view",
+    inputs: [{ type: "uint256" }],
+    outputs: [
+      { name: "assetsDeposited", type: "uint128" },
+      { name: "assetsFulfilled", type: "uint128" },
+      { name: "sharesReceived", type: "uint128" }
+    ]
+  },
+  {
+    type: "function",
+    name: "withdrawalEpochState",
+    stateMutability: "view",
+    inputs: [{ type: "uint256" }],
+    outputs: [
+      { name: "sharesWithdrawn", type: "uint128" },
+      { name: "sharesFulfilled", type: "uint128" },
+      { name: "assetsPaid", type: "uint128" }
+    ]
+  },
+  {
+    type: "function",
+    name: "queuedDeposit",
+    stateMutability: "view",
+    inputs: [{ type: "address" }, { type: "uint256" }],
+    outputs: [{ type: "uint128" }]
+  },
+  {
+    type: "function",
+    name: "queuedWithdrawal",
+    stateMutability: "view",
+    inputs: [{ type: "address" }, { type: "uint256" }],
+    outputs: [
+      { name: "amount", type: "uint128" },
+      { name: "basis", type: "uint128" },
+      { name: "shouldRedeposit", type: "bool" }
+    ]
+  }
+];
+var PANOPTIC_POOL_READ_ABI = [
+  {
+    type: "function",
+    name: "positionsHash",
+    stateMutability: "view",
+    inputs: [{ type: "address" }],
+    outputs: [{ type: "bytes32" }]
+  }
+];
+function readContractFunction(client, method) {
+  if (!isRecord4(client) || typeof client.readContract !== "function") {
+    throw new Error(`Panoptic ${method} requires a viem public client with readContract.`);
+  }
+  return client.readContract;
+}
+async function getBlockIfAvailable(client, blockNumber) {
+  if (!isRecord4(client) || typeof client.getBlock !== "function") {
+    return void 0;
+  }
+  const block = await client.getBlock({
+    blockNumber: BigInt(blockNumber)
+  });
+  if (!isRecord4(block) || block.timestamp === void 0) {
+    return void 0;
+  }
+  return { timestamp: toBigInt(block.timestamp, "block.timestamp") };
+}
+function depositEpochState(value, method) {
+  return {
+    assetsDeposited: tupleBigInt(value, "assetsDeposited", 0, `${method} depositEpochState`).toString(10),
+    assetsFulfilled: tupleBigInt(value, "assetsFulfilled", 1, `${method} depositEpochState`).toString(10),
+    sharesReceived: tupleBigInt(value, "sharesReceived", 2, `${method} depositEpochState`).toString(10)
+  };
+}
+function withdrawalEpochState(value, method) {
+  return {
+    sharesWithdrawn: tupleBigInt(value, "sharesWithdrawn", 0, `${method} withdrawalEpochState`).toString(10),
+    sharesFulfilled: tupleBigInt(value, "sharesFulfilled", 1, `${method} withdrawalEpochState`).toString(10),
+    assetsPaid: tupleBigInt(value, "assetsPaid", 2, `${method} withdrawalEpochState`).toString(10)
+  };
+}
+function queuedWithdrawalState(value, method) {
+  return {
+    amount: tupleBigInt(value, "amount", 0, `${method} queuedWithdrawal`).toString(10),
+    basis: tupleBigInt(value, "basis", 1, `${method} queuedWithdrawal`).toString(10),
+    shouldRedeposit: tupleBoolean(value, "shouldRedeposit", 2, `${method} queuedWithdrawal`)
+  };
+}
+function tupleBigInt(value, field, index, label) {
+  if (Array.isArray(value)) {
+    return toBigInt(value[index], `${label}[${index}]`);
+  }
+  if (isRecord4(value)) {
+    return toBigInt(value[field], `${label}.${field}`);
+  }
+  throw new Error(`Panoptic ${label} must be a tuple-like value.`);
+}
+function tupleBoolean(value, field, index, label) {
+  const raw = Array.isArray(value) ? value[index] : isRecord4(value) ? value[field] : void 0;
+  if (typeof raw !== "boolean") {
+    throw new Error(`Panoptic ${label}.${field} must be a boolean.`);
+  }
+  return raw;
+}
+function toBigInt(value, label) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) return BigInt(value);
+  if (typeof value === "string" && /^(0|[1-9][0-9]*)$/.test(value)) return BigInt(value);
+  throw new Error(`Panoptic ${label} must be a uint-like value.`);
+}
+function nonnegativeDifference(left, right) {
+  const difference = BigInt(left) - BigInt(right);
+  return difference < BigInt(0) ? BigInt(0) : difference;
+}
+async function recoverTokenIds(deps, sourceContext, input, method) {
+  if (!input.lastDispatchTxHash) return void 0;
+  const sdkGetOpenPositionIds = requireSdkFunction(await deps.sdkV2(), "getOpenPositionIds", "@panoptic-eng/sdk/v2");
+  const tokenIds = await sdkGetOpenPositionIds({
+    client: sourceContext.client,
+    chainId: BigInt(sourceContext.source.chainId),
+    poolAddress: input.poolAddress,
+    account: input.account,
+    lastDispatchTxHash: input.lastDispatchTxHash
+  });
+  if (!Array.isArray(tokenIds)) {
+    throw new Error(`Panoptic ${method} getOpenPositionIds result must be an array.`);
+  }
+  return tokenIds.map((tokenId, index) => toBigInt(tokenId, `${method} tokenIds[${index}]`).toString(10));
+}
+async function computePositionsHash(viem, tokenIds, method) {
+  const keccak256 = requireSdkFunction(viem, "keccak256", "viem");
+  let hash = BigInt(0);
+  for (const [index, tokenId] of tokenIds.entries()) {
+    const encodedTokenId = `0x${BigInt(tokenId).toString(16).padStart(64, "0")}`;
+    const tokenHash = normalizePanopticHex(await keccak256(encodedTokenId), `${method} tokenIds[${index}] hash`);
+    hash ^= BigInt(tokenHash);
+  }
+  return `0x${hash.toString(16).padStart(64, "0")}`;
+}
+
+// src/internal/panoptic/reads/pool.ts
+async function getPool({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseGetPoolRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetPool = await loadSdkFunction2(deps, "getPool");
+  const rawResult = await sdkGetPool({
+    client: sourceContext.client,
+    chainId: BigInt(sourceContext.source.chainId),
+    blockNumber: BigInt(sourceContext.blockNumber),
+    poolAddress: input.poolAddress,
+    poolMetadata: input.poolMetadata,
+    stateViewAddress: input.stateViewAddress
+  });
+  return withSource(rawResult, sourceContext, "pinned", "pool.getPool result");
+}
+async function fetchPoolId({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parsePoolAddressRequest(["poolAddress"])(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkFetchPoolId = await loadSdkFunction2(deps, "fetchPoolId");
+  const rawResult = await sdkFetchPoolId({ client: sourceContext.client, poolAddress: input.poolAddress });
+  const sdkBlockNumber = readSdkResultBlockNumber(rawResult);
+  return withSource(
+    rawResult,
+    sourceContext,
+    sdkBlockNumber ? "sdkResult" : "preflight",
+    "pool.fetchPoolId result",
+    sdkBlockNumber || void 0,
+    sdkBlockNumber ? void 0 : false
+  );
+}
+async function getPoolMetadata({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parsePoolAddressRequest(["poolAddress"])(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetPoolMetadata = await loadSdkFunction2(deps, "getPoolMetadata");
+  return withSource(
+    await sdkGetPoolMetadata({ client: sourceContext.client, poolAddress: input.poolAddress }),
+    sourceContext,
+    "staticReference",
+    "pool.getPoolMetadata result"
+  );
+}
+async function getRiskParameters({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseRiskParametersRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetRiskParameters = await loadSdkFunction2(deps, "getRiskParameters");
+  return withSource(
+    await sdkGetRiskParameters({
+      client: sourceContext.client,
+      blockNumber: BigInt(sourceContext.blockNumber),
+      poolAddress: input.poolAddress,
+      builderCode: input.builderCode,
+      riskEngineAddress: input.riskEngineAddress
+    }),
+    sourceContext,
+    "pinned",
+    "pool.getRiskParameters result"
+  );
+}
+async function getUtilization({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseUtilizationRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetUtilization = await loadSdkFunction2(deps, "getUtilization");
+  return withSource(
+    await sdkGetUtilization({
+      client: sourceContext.client,
+      blockNumber: BigInt(sourceContext.blockNumber),
+      poolAddress: input.poolAddress,
+      collateralAddresses: input.collateralAddresses
+    }),
+    sourceContext,
+    "pinned",
+    "pool.getUtilization result"
+  );
+}
+async function getOracleState({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parsePoolAddressRequest(["poolAddress"])(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkGetOracleState = await loadSdkFunction2(deps, "getOracleState");
+  return withSource(
+    await sdkGetOracleState({
+      client: sourceContext.client,
+      blockNumber: BigInt(sourceContext.blockNumber),
+      poolAddress: input.poolAddress
+    }),
+    sourceContext,
+    "pinned",
+    "pool.getOracleState result"
+  );
+}
+async function getTickSpacing({ deps, method, request }) {
+  const input = parseGetTickSpacingRequest(request, method);
+  const sdkGetTickSpacing = await loadSdkFunction2(deps, "getTickSpacing");
+  return sdkGetTickSpacing(input.feeBps);
+}
+async function getPricesAtTick({ deps, method, request }) {
+  const input = parsePricesAtTickRequest(request, method);
+  const sdkGetPricesAtTick = await loadSdkFunction2(deps, "getPricesAtTick");
+  return sdkGetPricesAtTick(input.tick, input.decimals0, input.decimals1, input.precision);
+}
+function parseGetTickSpacingRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["feeBps"], method);
+  return { feeBps: uint256Arg(args, "feeBps") };
+}
+function parseGetPoolRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["poolAddress", "poolMetadata", "stateViewAddress"], method);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    ...args.poolMetadata === void 0 ? {} : { poolMetadata: poolMetadataValue(args.poolMetadata, `${method} args.poolMetadata`) },
+    ...args.stateViewAddress === void 0 ? {} : { stateViewAddress: normalizePanopticAddress(args.stateViewAddress, `${method} args.stateViewAddress`) }
+  };
+}
+function parsePoolAddressRequest(allowedKeys) {
+  return (request, method) => {
+    requireSourceContext(request, method);
+    rejectLatestOnlyBlockNumber3(request, method);
+    const args = requestArgs(request, method);
+    rejectExtraKeys(args, allowedKeys, method);
+    return { poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`) };
+  };
+}
+function parseRiskParametersRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["poolAddress", "builderCode", "riskEngineAddress"], method);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    builderCode: optionalUint256Arg(args, "builderCode"),
+    ...args.riskEngineAddress === void 0 ? {} : { riskEngineAddress: normalizePanopticAddress(args.riskEngineAddress, `${method} args.riskEngineAddress`) }
+  };
+}
+function parseUtilizationRequest(request, method) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["poolAddress", "collateralAddresses"], method);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    ...args.collateralAddresses === void 0 ? {} : {
+      collateralAddresses: collateralAddressesValue(args.collateralAddresses, `${method} args.collateralAddresses`)
+    }
+  };
+}
+function parsePricesAtTickRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["tick", "decimals0", "decimals1", "precision"], method);
+  return {
+    tick: signedDecimalValue(args.tick, `${method} args.tick`),
+    decimals0: uint256Arg(args, "decimals0"),
+    decimals1: uint256Arg(args, "decimals1"),
+    precision: uint256Arg(args, "precision")
+  };
+}
+async function loadSdkFunction2(deps, name) {
+  return requireSdkFunction(await deps.sdkV2(), name, "@panoptic-eng/sdk/v2");
+}
+function rejectLatestOnlyBlockNumber3(request, method) {
+  if (method === "pool.fetchPoolId" && request.context?.blockNumber !== void 0) {
+    throw new Error(`Panoptic ${method} does not accept context.blockNumber because its block policy is latestOnly.`);
+  }
+}
+function readSdkResultBlockNumber(value) {
+  if (!isRecord4(value) || !isRecord4(value._meta)) {
+    return null;
+  }
+  return normalizeBlockNumberValue(value._meta.blockNumber);
+}
+function normalizeBlockNumberValue(value) {
+  if (typeof value === "bigint") {
+    return value.toString(10);
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return value.toString(10);
+  }
+  if (typeof value === "string") {
+    if (/^0x[0-9a-f]+$/i.test(value)) {
+      return BigInt(value).toString(10);
+    }
+    if (/^(0|[1-9][0-9]*)$/.test(value)) {
+      return BigInt(value).toString(10);
+    }
+  }
+  return null;
+}
+
+// src/internal/panoptic/reads/uniswap.ts
+async function resolveSwapRoute({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseResolveSwapRouteRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkResolveSwapRoute = await loadUniswapFunction(deps, "resolveSwapRoute");
+  return withSource(
+    await sdkResolveSwapRoute({
+      ...pinnedParams(sourceContext),
+      poolAddress: input.poolAddress,
+      tokenIn: input.tokenIn
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function quoteSwapExactInViaRouter({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseQuoteSwapExactInRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkQuoteSwapExactInViaRouter = await loadUniswapFunction(deps, "quoteSwapExactInViaRouter");
+  return withSource(
+    await sdkQuoteSwapExactInViaRouter({
+      ...pinnedParams(sourceContext),
+      poolAddress: input.poolAddress,
+      tokenIn: input.tokenIn,
+      amountIn: input.amountIn,
+      slippageBps: input.slippageBps,
+      addresses: input.addresses
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function quoteSwapExactOutViaRouter({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseQuoteSwapExactOutRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkQuoteSwapExactOutViaRouter = await loadUniswapFunction(deps, "quoteSwapExactOutViaRouter");
+  return withSource(
+    await sdkQuoteSwapExactOutViaRouter({
+      ...pinnedParams(sourceContext),
+      poolAddress: input.poolAddress,
+      tokenIn: input.tokenIn,
+      amountOut: input.amountOut,
+      slippageBps: input.slippageBps,
+      addresses: input.addresses
+    }),
+    sourceContext,
+    "pinned",
+    `${method} result`
+  );
+}
+async function checkRouterApproval({
+  deps,
+  method,
+  request,
+  options
+}) {
+  const input = parseCheckApprovalRequest(request, method);
+  const sourceContext = await prepareRuntimeSourceContext(deps, request, options);
+  const sdkCheckRouterApproval = await loadUniswapFunction(deps, "checkRouterApproval");
+  return withSource(
+    await sdkCheckRouterApproval({
+      client: sourceContext.client,
+      chainId: BigInt(sourceContext.source.chainId),
+      tokenIn: input.tokenIn,
+      owner: input.owner,
+      amount: input.amount,
+      addresses: input.addresses
+    }),
+    sourceContext,
+    "preflight",
+    `${method} result`,
+    void 0,
+    false
+  );
+}
+function parseResolveSwapRouteRequest(request, method) {
+  const args = readArgs(request, method, ["poolAddress", "tokenIn"]);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    tokenIn: normalizePanopticAddress(args.tokenIn, `${method} args.tokenIn`)
+  };
+}
+function parseQuoteSwapExactInRequest(request, method) {
+  const args = readArgs(request, method, ["poolAddress", "tokenIn", "amountIn", "slippageBps", "addresses"]);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    tokenIn: normalizePanopticAddress(args.tokenIn, `${method} args.tokenIn`),
+    amountIn: decimalArg(args, "amountIn"),
+    slippageBps: decimalArg(args, "slippageBps"),
+    ...args.addresses === void 0 ? {} : { addresses: uniswapAddressesValue(args.addresses, `${method} args.addresses`) }
+  };
+}
+function parseQuoteSwapExactOutRequest(request, method) {
+  const args = readArgs(request, method, ["poolAddress", "tokenIn", "amountOut", "slippageBps", "addresses"]);
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    tokenIn: normalizePanopticAddress(args.tokenIn, `${method} args.tokenIn`),
+    amountOut: decimalArg(args, "amountOut"),
+    slippageBps: decimalArg(args, "slippageBps"),
+    ...args.addresses === void 0 ? {} : { addresses: uniswapAddressesValue(args.addresses, `${method} args.addresses`) }
+  };
+}
+function parseCheckApprovalRequest(request, method) {
+  requireSourceContext(request, method);
+  rejectLatestOnlyBlockNumber4(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["tokenIn", "owner", "amount", "addresses"], method);
+  return {
+    tokenIn: normalizePanopticAddress(args.tokenIn, `${method} args.tokenIn`),
+    owner: normalizePanopticAddress(args.owner, `${method} args.owner`),
+    amount: decimalArg(args, "amount"),
+    ...args.addresses === void 0 ? {} : { addresses: uniswapAddressesValue(args.addresses, `${method} args.addresses`) }
+  };
+}
+function readArgs(request, method, allowedKeys) {
+  requireSourceContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, allowedKeys, method);
+  return args;
+}
+function pinnedParams(sourceContext) {
+  return {
+    client: sourceContext.client,
+    chainId: BigInt(sourceContext.source.chainId),
+    blockNumber: BigInt(sourceContext.blockNumber)
+  };
+}
+function rejectLatestOnlyBlockNumber4(request, method) {
+  if (request.context?.blockNumber !== void 0) {
+    throw new Error(`Panoptic ${method} does not accept context.blockNumber because its block policy is latestOnly.`);
+  }
+}
+async function loadUniswapFunction(deps, name) {
+  return requireSdkFunction(await deps.uniswap(), name, "@panoptic-eng/sdk/uniswap");
+}
+
+// src/internal/panoptic/dynamicJobs/fragments.ts
+function makeDynamicJobFragment(input) {
+  return validateDynamicJobFragment(input, "fragment");
+}
+function validateDynamicJobFragment(value, label) {
+  if (!isRecord5(value)) {
+    throw new Error(`Panoptic ${label} must be an object.`);
+  }
+  rejectExtraKeys2(value, ["target", "userProvidedData", "strategyProvidedData", "value"], label);
+  const fragment = {
+    target: normalizePanopticAddress(value.target, `${label}.target`),
+    userProvidedData: normalizePanopticHex(value.userProvidedData, `${label}.userProvidedData`),
+    strategyProvidedData: normalizePanopticHex(value.strategyProvidedData, `${label}.strategyProvidedData`),
+    value: normalizePanopticDecimalString(value.value, `${label}.value`)
+  };
+  if (fragment.userProvidedData.length < 10 || (fragment.userProvidedData.length - 10) % 64 !== 0) {
+    throw new Error(`Panoptic ${label}.userProvidedData must be a 4-byte selector followed by zero or more ABI words.`);
+  }
+  if (fragment.value !== "0") {
+    throw new Error(`Panoptic ${label}.value must be 0 because DynamicJobs.executeJob does not forward native value.`);
+  }
+  return fragment;
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function rejectExtraKeys2(value, allowedKeys, label) {
+  const allowed = new Set(allowedKeys);
+  for (const key of Object.keys(value)) {
+    if (!allowed.has(key)) {
+      throw new Error(`Panoptic ${label}.${key} is not supported by DynamicJobFragment.`);
+    }
+  }
+}
+
+// src/internal/panoptic/fragments/support.ts
+function splitCalldata(value, method, options = {}) {
+  const record = isRecord6(value) ? value : void 0;
+  const rawCalldata = record ? record.data : value;
+  const calldata = normalizePanopticHex(rawCalldata, `${method} calldata`).toLowerCase();
+  const target = record?.to === void 0 ? void 0 : normalizePanopticAddress(record.to, `${method} SDK target`);
+  const staticArgWords = options.staticArgWords || 0;
+  const prefixLength = 10 + staticArgWords * 64;
+  if (calldata.length < 10) {
+    throw new Error(`Panoptic ${method} calldata must include a selector.`);
+  }
+  const selector = calldata.slice(0, 10);
+  const expectedSelector = options.expectedSelector?.toLowerCase();
+  if (expectedSelector && selector !== expectedSelector) {
+    throw new Error(
+      `Panoptic ${method} calldata selector ${selector} does not match expected selector ${expectedSelector}.`
+    );
+  }
+  if (calldata.length < prefixLength) {
+    throw new Error(`Panoptic ${method} calldata must include ${staticArgWords} static argument word(s).`);
+  }
+  const userProvidedData = calldata.slice(0, prefixLength);
+  const strategyProvidedData = `0x${calldata.slice(prefixLength)}`;
+  if (options.requireStrategyData !== false && strategyProvidedData === "0x") {
+    throw new Error(`Panoptic ${method} calldata must include ABI-encoded arguments.`);
+  }
+  return target ? { calldata, userProvidedData, strategyProvidedData, target } : { calldata, userProvidedData, strategyProvidedData };
+}
+function assertUserProvidedData(value, expected, method) {
+  if (value.toLowerCase() !== expected.toLowerCase()) {
+    throw new Error(`Panoptic ${method} generated calldata does not match the requested static argument prefix.`);
+  }
+}
+function addressAbiWord(address) {
+  return address.slice(2).toLowerCase().padStart(64, "0");
+}
+function uint256AbiWord(value) {
+  if (value < BigInt(0) || value >= BigInt(1) << BigInt(256)) {
+    throw new Error("Panoptic ABI uint256 value exceeds range.");
+  }
+  return value.toString(16).padStart(64, "0");
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/internal/panoptic/fragments/erc20.ts
+var ERC20_APPROVE_SELECTOR = "0x095ea7b3";
+async function approveFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseApproveRequest(request, method);
+  const encodeApproveFunctionData = requireSdkFunction(
+    await deps.sdk(),
+    "encodeApproveFunctionData",
+    "@panoptic-eng/sdk"
+  );
+  const calldata = await encodeApproveFunctionData({
+    spender: input.spender,
+    amount: input.amount
+  });
+  const split = splitCalldata(calldata, method, {
+    expectedSelector: ERC20_APPROVE_SELECTOR,
+    staticArgWords: 1
+  });
+  assertUserProvidedData(split.userProvidedData, `${ERC20_APPROVE_SELECTOR}${addressAbiWord(input.spender)}`, method);
+  return makeDynamicJobFragment({
+    target: input.token,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+function parseApproveRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["token", "spender", "amount"], method);
+  return {
+    token: normalizePanopticAddress(args.token, `${method} args.token`),
+    spender: normalizePanopticAddress(args.spender, `${method} args.spender`),
+    amount: uint256Arg(args, "amount")
+  };
+}
+
+// src/internal/panoptic/fragments/collateral.ts
+var DEPOSIT_SELECTOR = "0x6e553f65";
+var WITHDRAW_SELECTOR = "0xb460af94";
+var WITHDRAW_WITH_POSITIONS_SELECTOR = "0xe51161ba";
+var WITHDRAW_WITH_POSITIONS_ABI = [
+  {
+    type: "function",
+    name: "withdraw",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "assets", type: "uint256" },
+      { name: "receiver", type: "address" },
+      { name: "owner", type: "address" },
+      { name: "positionIdList", type: "uint256[]" },
+      { name: "usePremiaAsCollateral", type: "bool" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }]
+  }
+];
+async function depositFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseDepositRequest(request, method);
+  const encodeDepositFunctionData = requireSdkFunction(
+    await deps.sdk(),
+    "encodeDepositFunctionData",
+    "@panoptic-eng/sdk"
+  );
+  const split = splitCalldata(
+    await encodeDepositFunctionData({
+      assets: input.assets,
+      receiver: input.receiver
+    }),
+    method,
+    { expectedSelector: DEPOSIT_SELECTOR }
+  );
+  return makeDynamicJobFragment({
+    target: input.collateralTracker,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function withdrawFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseWithdrawRequest(request, method);
+  const encodeWithdrawFunctionData = requireSdkFunction(
+    await deps.sdk(),
+    "encodeWithdrawFunctionData",
+    "@panoptic-eng/sdk"
+  );
+  const split = splitCalldata(
+    await encodeWithdrawFunctionData({
+      assets: input.assets,
+      receiver: input.receiver,
+      owner: input.owner
+    }),
+    method,
+    { expectedSelector: WITHDRAW_SELECTOR }
+  );
+  return makeDynamicJobFragment({
+    target: input.collateralTracker,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function withdrawWithPositionsFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseWithdrawWithPositionsRequest(request, method);
+  const encodeFunctionData = requireSdkFunction(await deps.viem(), "encodeFunctionData", "viem");
+  const split = splitCalldata(
+    await encodeFunctionData({
+      abi: WITHDRAW_WITH_POSITIONS_ABI,
+      functionName: "withdraw",
+      args: [input.assets, input.receiver, input.owner, input.positionIdList, input.usePremiaAsCollateral]
+    }),
+    method,
+    { expectedSelector: WITHDRAW_WITH_POSITIONS_SELECTOR }
+  );
+  return makeDynamicJobFragment({
+    target: input.collateralTracker,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+function parseDepositRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["collateralTracker", "assets", "receiver"], method);
+  return {
+    collateralTracker: normalizePanopticAddress(args.collateralTracker, `${method} args.collateralTracker`),
+    assets: uint256Arg(args, "assets"),
+    receiver: normalizePanopticAddress(args.receiver, `${method} args.receiver`)
+  };
+}
+function parseWithdrawRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["collateralTracker", "assets", "receiver", "owner"], method);
+  return {
+    collateralTracker: normalizePanopticAddress(args.collateralTracker, `${method} args.collateralTracker`),
+    assets: uint256Arg(args, "assets"),
+    receiver: normalizePanopticAddress(args.receiver, `${method} args.receiver`),
+    owner: normalizePanopticAddress(args.owner, `${method} args.owner`)
+  };
+}
+function parseWithdrawWithPositionsRequest(request, method) {
+  const input = parseWithdrawWithPositionBase(request, method);
+  const { args, ...base } = input;
+  return {
+    ...base,
+    positionIdList: uint256ArrayArg(args, "positionIdList"),
+    usePremiaAsCollateral: booleanArg(args.usePremiaAsCollateral, `${method} args.usePremiaAsCollateral`)
+  };
+}
+function parseWithdrawWithPositionBase(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(
+    args,
+    ["collateralTracker", "assets", "receiver", "owner", "positionIdList", "usePremiaAsCollateral"],
+    method
+  );
+  return {
+    args,
+    collateralTracker: normalizePanopticAddress(args.collateralTracker, `${method} args.collateralTracker`),
+    assets: uint256Arg(args, "assets"),
+    receiver: normalizePanopticAddress(args.receiver, `${method} args.receiver`),
+    owner: normalizePanopticAddress(args.owner, `${method} args.owner`)
+  };
+}
+function booleanArg(value, label) {
+  if (typeof value !== "boolean") {
+    throw new Error(`Panoptic ${label} must be a boolean.`);
+  }
+  return value;
+}
+
+// src/internal/panoptic/fragments/hypovault.ts
+var FULFILL_DEPOSITS_SELECTOR = "0x50dcdee9";
+var FULFILL_WITHDRAWALS_SELECTOR = "0x69838516";
+var MANAGE_SELECTOR = "0xf6e715d0";
+var MANAGE_ABI = [
+  {
+    type: "function",
+    name: "manage",
+    stateMutability: "payable",
+    inputs: [
+      { name: "target", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+async function fulfillDepositsFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseFulfillDepositsRequest(request, method);
+  const encodeFulfillDepositsFunctionData = requireSdkFunction(
+    await deps.sdk(),
+    "encodeFulfillDepositsFunctionData",
+    "@panoptic-eng/sdk"
+  );
+  const split = splitCalldata(
+    await encodeFulfillDepositsFunctionData({
+      assetsToFulfill: input.assetsToFulfill,
+      managerInput: input.managerInput
+    }),
+    method,
+    { expectedSelector: FULFILL_DEPOSITS_SELECTOR }
+  );
+  return makeDynamicJobFragment({
+    target: input.vaultManager,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function fulfillWithdrawalsFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseFulfillWithdrawalsRequest(request, method);
+  const encodeFulfillWithdrawalsFunctionData = requireSdkFunction(
+    await deps.sdk(),
+    "encodeFulfillWithdrawalsFunctionData",
+    "@panoptic-eng/sdk"
+  );
+  const split = splitCalldata(
+    await encodeFulfillWithdrawalsFunctionData({
+      sharesToFulfill: input.sharesToFulfill,
+      maxAssetsReceived: input.maxAssetsReceived,
+      managerInput: input.managerInput
+    }),
+    method,
+    { expectedSelector: FULFILL_WITHDRAWALS_SELECTOR }
+  );
+  return makeDynamicJobFragment({
+    target: input.vaultManager,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function manageCalldataParts({ deps, method, request, options }) {
+  void options;
+  const input = parseManageRequest(request, method, false);
+  const split = splitCalldata(await encodeManageCalldata(deps, input), method, { expectedSelector: MANAGE_SELECTOR });
+  return {
+    functionName: "manage",
+    calldata: split.calldata,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  };
+}
+async function manageFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseManageRequest(request, method, true);
+  const split = splitCalldata(await encodeManageCalldata(deps, input), method, { expectedSelector: MANAGE_SELECTOR });
+  return makeDynamicJobFragment({
+    target: input.manager,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function encodeManageCalldata(deps, input) {
+  const encodeFunctionData = requireSdkFunction(await deps.viem(), "encodeFunctionData", "viem");
+  return encodeFunctionData({
+    abi: MANAGE_ABI,
+    functionName: "manage",
+    args: [input.innerTarget, input.innerData, input.value]
+  });
+}
+function parseFulfillDepositsRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["vaultManager", "assetsToFulfill", "managerInput"], method);
+  return {
+    vaultManager: normalizePanopticAddress(args.vaultManager, `${method} args.vaultManager`),
+    assetsToFulfill: uint256Arg(args, "assetsToFulfill"),
+    managerInput: normalizePanopticHex(args.managerInput, `${method} args.managerInput`)
+  };
+}
+function parseFulfillWithdrawalsRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["vaultManager", "sharesToFulfill", "maxAssetsReceived", "managerInput"], method);
+  return {
+    vaultManager: normalizePanopticAddress(args.vaultManager, `${method} args.vaultManager`),
+    sharesToFulfill: uint256Arg(args, "sharesToFulfill"),
+    maxAssetsReceived: uint256Arg(args, "maxAssetsReceived"),
+    managerInput: normalizePanopticHex(args.managerInput, `${method} args.managerInput`)
+  };
+}
+function parseManageRequest(request, method, requireManager) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(
+    args,
+    requireManager ? ["manager", "innerTarget", "innerData", "value"] : ["innerTarget", "innerData", "value"],
+    method
+  );
+  return {
+    ...requireManager ? { manager: normalizePanopticAddress(args.manager, `${method} args.manager`) } : {},
+    innerTarget: normalizePanopticAddress(args.innerTarget, `${method} args.innerTarget`),
+    innerData: normalizePanopticHex(args.innerData, `${method} args.innerData`),
+    value: args.value === void 0 ? BigInt(0) : uint256Arg(args, "value")
+  };
+}
+
+// src/internal/panoptic/fragments/merkle.ts
+var MANAGE_VAULT_WITH_MERKLE_VERIFICATION_SELECTOR = "0x244b0f6a";
+var MANAGE_VAULT_WITH_MERKLE_VERIFICATION_ABI = [
+  {
+    type: "function",
+    name: "manageVaultWithMerkleVerification",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "manageProofs", type: "bytes32[][]" },
+      { name: "decodersAndSanitizers", type: "address[]" },
+      { name: "targets", type: "address[]" },
+      { name: "targetData", type: "bytes[]" },
+      { name: "values", type: "uint256[]" }
+    ],
+    outputs: []
+  }
+];
+async function manageVaultWithVerificationFragment({ deps, method, request, options }) {
+  void options;
+  const input = parseManageVaultWithVerificationRequest(request, method);
+  const encodeFunctionData = requireSdkFunction(await deps.viem(), "encodeFunctionData", "viem");
+  const split = splitCalldata(
+    await encodeFunctionData({
+      abi: MANAGE_VAULT_WITH_MERKLE_VERIFICATION_ABI,
+      functionName: "manageVaultWithMerkleVerification",
+      args: [input.proofs, input.decoders, input.innerTargets, input.innerDatas, input.values]
+    }),
+    method,
+    { expectedSelector: MANAGE_VAULT_WITH_MERKLE_VERIFICATION_SELECTOR }
+  );
+  return makeDynamicJobFragment({
+    target: input.manager,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+function findLeaf({ request, method }) {
+  const input = parseFindLeafRequest(request, method);
+  const leaf = findArtifactLeaf(input.artifact, input.query, method);
+  return projectLeafWithProof(input.artifact, leaf, method);
+}
+function buildManageArgs({ request, method }) {
+  const input = parseBuildManageArgsRequest(request, method);
+  const proofs = [];
+  const decoders = [];
+  const innerTargets = [];
+  const innerDatas = [];
+  const values = [];
+  const leaves = [];
+  for (const [index, action] of input.actions.entries()) {
+    const label = `${method} args.actions[${index}]`;
+    const leaf = findArtifactLeaf(input.artifact, action.query, label);
+    const projected = projectLeafWithProof(input.artifact, leaf, label);
+    proofs.push(projected.proof);
+    decoders.push(projected.decoder);
+    innerTargets.push(projected.target);
+    innerDatas.push(action.data);
+    values.push(action.value);
+    leaves.push(projected);
+  }
+  return {
+    proofs,
+    decoders,
+    innerTargets,
+    innerDatas,
+    values,
+    leaves
+  };
+}
+function parseManageVaultWithVerificationRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["manager", "proofs", "decoders", "innerTargets", "innerDatas", "values"], method);
+  const proofs = bytes32MatrixArg(args, "proofs", method);
+  const decoders = addressArrayArg(args, "decoders", method);
+  const innerTargets = addressArrayArg(args, "innerTargets", method);
+  const innerDatas = hexArrayArg(args, "innerDatas", method);
+  const values = uint256Array(args, "values");
+  const length = proofs.length;
+  for (const [field, value] of [
+    ["decoders", decoders],
+    ["innerTargets", innerTargets],
+    ["innerDatas", innerDatas],
+    ["values", values]
+  ]) {
+    if (value.length !== length) {
+      throw new Error(`Panoptic ${method} args.${field} length must match args.proofs length.`);
+    }
+  }
+  if (length === 0) {
+    throw new Error(`Panoptic ${method} args.proofs must include at least one proof.`);
+  }
+  return {
+    manager: normalizePanopticAddress(args.manager, `${method} args.manager`),
+    proofs,
+    decoders,
+    innerTargets,
+    innerDatas,
+    values
+  };
+}
+function parseFindLeafRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(
+    args,
+    ["artifact", "action", "description", "functionSignature", "functionSelector", "target"],
+    method
+  );
+  return {
+    artifact: recordValue(args.artifact, `args.artifact`),
+    query: parseLeafQuery(args, method, "args")
+  };
+}
+function parseBuildManageArgsRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["artifact", "actions"], method);
+  return {
+    artifact: recordValue(args.artifact, `args.artifact`),
+    actions: arrayValue(args.actions, "args.actions").map((item, index) => {
+      const action = recordValue(item, `args.actions[${index}]`);
+      rejectExtraKeys(
+        action,
+        ["action", "description", "functionSignature", "functionSelector", "target", "data", "value"],
+        method
+      );
+      return {
+        query: parseLeafQuery(action, method, `args.actions[${index}]`),
+        data: normalizePanopticHex(action.data, `${method} args.actions[${index}].data`),
+        value: action.value === void 0 ? BigInt(0) : decimalValue(action.value, `args.actions[${index}].value`)
+      };
+    })
+  };
+}
+function parseLeafQuery(args, method, label) {
+  const query = {
+    ...args.action === void 0 ? {} : { action: stringValue(args.action, `${label}.action`) },
+    ...args.description === void 0 ? {} : { description: stringValue(args.description, `${label}.description`) },
+    ...args.functionSignature === void 0 ? {} : { functionSignature: stringValue(args.functionSignature, `${label}.functionSignature`) },
+    ...args.functionSelector === void 0 ? {} : { functionSelector: normalizePanopticHex(args.functionSelector, `${method} ${label}.functionSelector`) },
+    ...args.target === void 0 ? {} : { target: normalizePanopticAddress(args.target, `${method} ${label}.target`) }
+  };
+  if (Object.keys(query).length === 0) {
+    throw new Error(`Panoptic ${method} ${label} must include at least one leaf selector.`);
+  }
+  return query;
+}
+function findArtifactLeaf(artifact, query, method) {
+  const leaves = artifactLeafs(artifact, method);
+  const matches = leaves.filter((leaf) => leafMatches(leaf, query, method));
+  if (matches.length === 0) {
+    throw new Error(`Panoptic ${method} could not find a matching Merkle leaf.`);
+  }
+  if (matches.length > 1) {
+    throw new Error(`Panoptic ${method} found multiple matching Merkle leaves; provide a more specific selector.`);
+  }
+  return matches[0];
+}
+function artifactLeafs(artifact, method) {
+  const rawLeaves = artifact.leafs ?? artifact.uniqueLeafs ?? (isJsonRecord3(artifact.artifact) ? artifact.artifact.leafs : void 0);
+  return arrayValue(rawLeaves, `${method} artifact.leafs`).map(
+    (item, index) => recordValue(item, `${method} artifact.leafs[${index}]`)
+  );
+}
+function leafMatches(leaf, query, method) {
+  if (query.action !== void 0 && leafString(leaf, "Action", method) !== query.action) return false;
+  if (query.description !== void 0 && leafString(leaf, "Description", method) !== query.description) return false;
+  if (query.functionSignature !== void 0 && leafString(leaf, "FunctionSignature", method) !== query.functionSignature)
+    return false;
+  if (query.functionSelector !== void 0 && normalizePanopticHex(leaf.FunctionSelector, `${method} leaf.FunctionSelector`) !== query.functionSelector)
+    return false;
+  if (query.target !== void 0 && normalizePanopticAddress(leaf.TargetAddress, `${method} leaf.TargetAddress`) !== query.target)
+    return false;
+  return true;
+}
+function projectLeafWithProof(artifact, leaf, method) {
+  const action = leafString(leaf, "Action", method);
+  const leafDigest = normalizePanopticHex(leaf.LeafDigest, `${method} leaf.LeafDigest`);
+  return {
+    action,
+    description: leafString(leaf, "Description", method),
+    leafDigest,
+    decoder: normalizePanopticAddress(leaf.DecoderAndSanitizerAddress, `${method} leaf.DecoderAndSanitizerAddress`),
+    target: normalizePanopticAddress(leaf.TargetAddress, `${method} leaf.TargetAddress`),
+    functionSignature: leafString(leaf, "FunctionSignature", method),
+    functionSelector: normalizePanopticHex(leaf.FunctionSelector, `${method} leaf.FunctionSelector`),
+    canSendValue: leaf.CanSendValue === true,
+    proof: proofForLeaf(artifact, action, leafDigest, method)
+  };
+}
+function proofForLeaf(artifact, action, leafDigest, method) {
+  const byAction = isJsonRecord3(artifact.proofsByAction) ? artifact.proofsByAction[action] : void 0;
+  const byDigest = isJsonRecord3(artifact.proofsByDigest) ? artifact.proofsByDigest[leafDigest] : void 0;
+  const proof = byAction ?? byDigest;
+  return proof === void 0 ? [] : arrayValue(proof, `${method} proof`).map((item, index) => bytes32Value(item, `${method} proof[${index}]`));
+}
+function leafString(leaf, field, method) {
+  return stringValue(leaf[field], `${method} leaf.${field}`);
+}
+function bytes32Value(value, label) {
+  const hex = normalizePanopticHex(value, label);
+  if (hex.length !== 66) {
+    throw new Error(`Panoptic ${label} must be bytes32.`);
+  }
+  return hex;
+}
+function bytes32MatrixArg(args, fieldName, method) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (row, rowIndex) => arrayValue(row, `args.${fieldName}[${rowIndex}]`).map((item, index) => {
+      const proof = normalizePanopticHex(item, `${method} args.${fieldName}[${rowIndex}][${index}]`);
+      if (proof.length !== 66) {
+        throw new Error(`Panoptic ${method} args.${fieldName}[${rowIndex}][${index}] must be bytes32.`);
+      }
+      return proof;
+    })
+  );
+}
+function addressArrayArg(args, fieldName, method) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => normalizePanopticAddress(item, `${method} args.${fieldName}[${index}]`)
+  );
+}
+function hexArrayArg(args, fieldName, method) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => normalizePanopticHex(item, `${method} args.${fieldName}[${index}]`)
+  );
+}
+function uint256Array(args, fieldName) {
+  return arrayValue(args[fieldName], `args.${fieldName}`).map(
+    (item, index) => decimalValue(item, `args.${fieldName}[${index}]`)
+  );
+}
+function isJsonRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/internal/panoptic/fragments/panoptic.ts
+var PANOPTIC_DISPATCH_SELECTOR = "0xc25813aa";
+var MAX_EXISTING_POSITION_IDS = 64;
+var UINT128_MAX2 = (BigInt(1) << BigInt(128)) - BigInt(1);
+var INT24_MIN2 = -(BigInt(1) << BigInt(23));
+var INT24_MAX2 = (BigInt(1) << BigInt(23)) - BigInt(1);
+var DISPATCH_EXPLICIT_ABI = [
+  {
+    type: "function",
+    name: "dispatch",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "positionIdList", type: "uint256[]" },
+      { name: "finalPositionIdList", type: "uint256[]" },
+      { name: "positionSizes", type: "uint128[]" },
+      { name: "tickAndSpreadLimits", type: "int24[3][]" },
+      { name: "usePremiaAsCollateral", type: "bool" },
+      { name: "builderCode", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+async function dispatchCalldataParts({ deps, request, method }) {
+  const input = parseDispatchRequest(request, method);
+  const sdkV2 = await deps.sdkV2();
+  const buildOpenPositionCalldata = requireSdkFunction(sdkV2, "buildOpenPositionCalldata", "@panoptic-eng/sdk/v2");
+  const poolAddress2 = requireString(input.poolAddress, `${method} args.poolAddress`);
+  const split = splitDispatchCalldata(
+    await buildOpenPositionCalldata(buildOpenPositionParams(input, poolAddress2)),
+    method
+  );
+  return {
+    functionName: "dispatch",
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    calldata: split.calldata
+  };
+}
+async function dispatchFragment({ deps, request, options, method }) {
+  void options;
+  const input = parseDispatchRequest(request, method);
+  const sdkV2 = await deps.sdkV2();
+  const buildOpenPositionCalldata = requireSdkFunction(sdkV2, "buildOpenPositionCalldata", "@panoptic-eng/sdk/v2");
+  const targetAddress = input.poolAddress;
+  const split = splitDispatchCalldata(
+    await buildOpenPositionCalldata(buildOpenPositionParams(input, input.poolAddress)),
+    method
+  );
+  if (split.target && split.target !== targetAddress) {
+    throw new Error(`Panoptic ${method} SDK returned a target that does not match args.poolAddress.`);
+  }
+  return makeDynamicJobFragment({
+    target: targetAddress,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function dispatchExplicitCalldataParts({ deps, request, method }) {
+  const input = parseExplicitDispatchRequest(request, method);
+  const split = splitDispatchCalldata(await encodeExplicitDispatchCalldata(deps, input), method);
+  return {
+    functionName: "dispatch",
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    calldata: split.calldata,
+    value: "0"
+  };
+}
+async function dispatchExplicitFragment({ deps, request, options, method }) {
+  void options;
+  const input = parseExplicitDispatchRequest(request, method);
+  const split = splitDispatchCalldata(await encodeExplicitDispatchCalldata(deps, input), method);
+  return makeDynamicJobFragment({
+    target: input.poolAddress,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function encodeExplicitDispatchCalldata(deps, input) {
+  const encodeFunctionData = requireSdkFunction(await deps.viem(), "encodeFunctionData", "viem");
+  return encodeFunctionData({
+    abi: DISPATCH_EXPLICIT_ABI,
+    functionName: "dispatch",
+    args: [
+      input.positionIdList,
+      input.finalPositionIdList,
+      input.positionSizes,
+      input.tickAndSpreadLimits,
+      input.usePremiaAsCollateral,
+      input.builderCode
+    ]
+  });
+}
+function parseDispatchRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, dispatchKeys, method);
+  return parseDispatchCommon(args, method);
+}
+function parseExplicitDispatchRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, explicitDispatchKeys, method);
+  const positionIdList = positionIdsArg(args, "positionIdList", method);
+  const positionSizes = uint128ArrayArg(args, "positionSizes", method);
+  const tickAndSpreadLimits = int24TripleArrayArg(args.tickAndSpreadLimits, `${method} args.tickAndSpreadLimits`);
+  if (positionSizes.length !== positionIdList.length) {
+    throw new Error(`Panoptic ${method} args.positionSizes length must match args.positionIdList length.`);
+  }
+  if (tickAndSpreadLimits.length !== positionIdList.length) {
+    throw new Error(`Panoptic ${method} args.tickAndSpreadLimits length must match args.positionIdList length.`);
+  }
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    positionIdList,
+    finalPositionIdList: uint256ArrayArg(args, "finalPositionIdList"),
+    positionSizes,
+    tickAndSpreadLimits,
+    usePremiaAsCollateral: requiredBooleanArg(args.usePremiaAsCollateral, `${method} args.usePremiaAsCollateral`),
+    builderCode: optionalUint256Arg(args, "builderCode") ?? BigInt(0)
+  };
+}
+function parseDispatchCommon(args, method) {
+  return {
+    poolAddress: normalizePanopticAddress(args.poolAddress, `${method} args.poolAddress`),
+    existingPositionIds: positionIdsArg(args, "existingPositionIds", method),
+    tokenId: uint256Arg(args, "tokenId"),
+    positionSize: uint128Arg(args, "positionSize"),
+    tickLimitLow: int24Arg(args, "tickLimitLow"),
+    tickLimitHigh: int24Arg(args, "tickLimitHigh"),
+    spreadLimit: optionalInt24Arg(args, "spreadLimit"),
+    swapAtMint: optionalBooleanArg2(args, "swapAtMint", method),
+    usePremiaAsCollateral: optionalBooleanArg2(args, "usePremiaAsCollateral", method),
+    builderCode: optionalUint256Arg(args, "builderCode")
+  };
+}
+function buildOpenPositionParams(input, poolAddress2) {
+  return {
+    poolAddress: poolAddress2,
+    existingPositionIds: input.existingPositionIds,
+    tokenId: input.tokenId,
+    positionSize: input.positionSize,
+    tickLimitLow: input.tickLimitLow,
+    tickLimitHigh: input.tickLimitHigh,
+    spreadLimit: input.spreadLimit,
+    swapAtMint: input.swapAtMint,
+    usePremiaAsCollateral: input.usePremiaAsCollateral,
+    builderCode: input.builderCode
+  };
+}
+function positionIdsArg(args, fieldName, method) {
+  const positionIds = uint256ArrayArg(args, fieldName);
+  if (positionIds.length > MAX_EXISTING_POSITION_IDS) {
+    throw new Error(`Panoptic ${method} args.${fieldName} must contain at most ${MAX_EXISTING_POSITION_IDS} items.`);
+  }
+  return positionIds;
+}
+function splitDispatchCalldata(value, method) {
+  return splitCalldata(value, method, { expectedSelector: PANOPTIC_DISPATCH_SELECTOR });
+}
+function optionalBooleanArg2(args, fieldName, method) {
+  const value = args[fieldName];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw new Error(`Panoptic ${method} args.${fieldName} must be a boolean.`);
+  }
+  return value;
+}
+function requiredBooleanArg(value, label) {
+  if (typeof value !== "boolean") {
+    throw new Error(`Panoptic ${label} must be a boolean.`);
+  }
+  return value;
+}
+function uint128ArrayArg(args, fieldName, method) {
+  const values = uint256ArrayArg(args, fieldName);
+  for (const [index, value] of values.entries()) {
+    if (value > UINT128_MAX2) {
+      throw new Error(`Panoptic ${method} args.${fieldName}[${index}] exceeds uint128 range.`);
+    }
+  }
+  return values;
+}
+function int24TripleArrayArg(value, label) {
+  if (!Array.isArray(value)) {
+    throw new Error(`Panoptic ${label} must be an array.`);
+  }
+  return value.map((row, rowIndex) => {
+    if (!Array.isArray(row) || row.length !== 3) {
+      throw new Error(`Panoptic ${label}[${rowIndex}] must be an int24 triple.`);
+    }
+    return row.map((item, index) => signedInt24Value(item, `${label}[${rowIndex}][${index}]`));
+  });
+}
+function signedInt24Value(value, label) {
+  if (typeof value !== "string" || !/^-?(0|[1-9][0-9]*)$/.test(value)) {
+    throw new Error(`Panoptic ${label} must be a signed decimal string.`);
+  }
+  const parsed = BigInt(value);
+  if (parsed < INT24_MIN2 || parsed > INT24_MAX2) {
+    throw new Error(`Panoptic ${label} exceeds int24 range.`);
+  }
+  return parsed;
+}
+var dispatchKeys = [
+  "poolAddress",
+  "existingPositionIds",
+  "tokenId",
+  "positionSize",
+  "tickLimitLow",
+  "tickLimitHigh",
+  "spreadLimit",
+  "swapAtMint",
+  "usePremiaAsCollateral",
+  "builderCode"
+];
+var explicitDispatchKeys = [
+  "poolAddress",
+  "positionIdList",
+  "finalPositionIdList",
+  "positionSizes",
+  "tickAndSpreadLimits",
+  "usePremiaAsCollateral",
+  "builderCode"
+];
+
+// src/internal/panoptic/fragments/permit2.ts
+var PERMIT2_APPROVE_ABI = [
+  {
+    type: "function",
+    name: "approve",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint160" },
+      { name: "expiration", type: "uint48" }
+    ],
+    outputs: []
+  }
+];
+var PERMIT2_APPROVE_SELECTOR = "0x87517c45";
+async function approveFragment2({ deps, method, request, options }) {
+  void options;
+  const input = parseApproveRequest2(request, method);
+  const encodeFunctionData = requireSdkFunction(await deps.viem(), "encodeFunctionData", "viem");
+  const calldata = await encodeFunctionData({
+    abi: PERMIT2_APPROVE_ABI,
+    functionName: "approve",
+    args: [input.token, input.spender, input.amount, input.expiration]
+  });
+  const split = splitCalldata(calldata, method, {
+    expectedSelector: PERMIT2_APPROVE_SELECTOR,
+    staticArgWords: 2
+  });
+  assertUserProvidedData(
+    split.userProvidedData,
+    `${PERMIT2_APPROVE_SELECTOR}${addressAbiWord(input.token)}${addressAbiWord(input.spender)}`,
+    method
+  );
+  return makeDynamicJobFragment({
+    target: input.permit2,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+function parseApproveRequest2(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["permit2", "token", "spender", "amount", "expiration"], method);
+  return {
+    permit2: normalizePanopticAddress(args.permit2, `${method} args.permit2`),
+    token: normalizePanopticAddress(args.token, `${method} args.token`),
+    spender: normalizePanopticAddress(args.spender, `${method} args.spender`),
+    amount: uint160Arg(args, "amount"),
+    expiration: uint48Arg(args, "expiration")
+  };
+}
+
+// src/internal/panoptic/fragments/uniswap.ts
+var UNIVERSAL_ROUTER_EXECUTE_SELECTOR = "0x24856bc3";
+var UNIVERSAL_ROUTER_EXECUTE_DEADLINE_SELECTOR = "0x3593564c";
+var V3_SWAP_EXACT_IN_COMMAND = "0x00";
+var V3_EXACT_IN_INPUT_ABI = [
+  { name: "recipient", type: "address" },
+  { name: "amountIn", type: "uint256" },
+  { name: "amountOutMinimum", type: "uint256" },
+  { name: "path", type: "bytes" },
+  { name: "payerIsUser", type: "bool" }
+];
+var UNIVERSAL_ROUTER_EXECUTE_ABI = [
+  {
+    type: "function",
+    name: "execute",
+    stateMutability: "payable",
+    inputs: [
+      { name: "commands", type: "bytes" },
+      { name: "inputs", type: "bytes[]" }
+    ],
+    outputs: []
+  }
+];
+var UNIVERSAL_ROUTER_EXECUTE_DEADLINE_ABI = [
+  {
+    type: "function",
+    name: "execute",
+    stateMutability: "payable",
+    inputs: [
+      { name: "commands", type: "bytes" },
+      { name: "inputs", type: "bytes[]" },
+      { name: "deadline", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+async function buildV3ExactInExecuteCalldataParts({ deps, request, method, options }) {
+  void options;
+  const input = parseV3ExactInRequest(request, method);
+  const calldata = await buildV3ExactInCalldata(deps, input);
+  const split = splitCalldata(calldata, method, {
+    expectedSelector: input.deadline === void 0 ? UNIVERSAL_ROUTER_EXECUTE_SELECTOR : UNIVERSAL_ROUTER_EXECUTE_DEADLINE_SELECTOR
+  });
+  return {
+    functionName: input.deadline === void 0 ? "execute(bytes,bytes[])" : "execute(bytes,bytes[],uint256)",
+    calldata: split.calldata,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  };
+}
+async function buildV3ExactInExecuteFragment({ deps, request, method, options }) {
+  void options;
+  const input = parseV3ExactInRequest(request, method);
+  if (!input.router) {
+    throw new Error(`Panoptic ${method} requires args.router.`);
+  }
+  const calldata = await buildV3ExactInCalldata(deps, input);
+  const split = splitCalldata(calldata, method, {
+    expectedSelector: input.deadline === void 0 ? UNIVERSAL_ROUTER_EXECUTE_SELECTOR : UNIVERSAL_ROUTER_EXECUTE_DEADLINE_SELECTOR
+  });
+  return makeDynamicJobFragment({
+    target: input.router,
+    userProvidedData: split.userProvidedData,
+    strategyProvidedData: split.strategyProvidedData,
+    value: "0"
+  });
+}
+async function buildV3ExactInCalldata(deps, input) {
+  const viem = await deps.viem();
+  const encodeAbiParameters = requireSdkFunction(viem, "encodeAbiParameters", "viem");
+  const encodeFunctionData = requireSdkFunction(viem, "encodeFunctionData", "viem");
+  const path = encodeV3Path(input.tokenIn, input.fee, input.tokenOut);
+  const exactInInput = await encodeAbiParameters(V3_EXACT_IN_INPUT_ABI, [
+    input.recipient,
+    input.amountIn,
+    input.amountOutMin,
+    path,
+    input.payerIsUser
+  ]);
+  if (input.deadline === void 0) {
+    return encodeFunctionData({
+      abi: UNIVERSAL_ROUTER_EXECUTE_ABI,
+      functionName: "execute",
+      args: [V3_SWAP_EXACT_IN_COMMAND, [exactInInput]]
+    });
+  }
+  return encodeFunctionData({
+    abi: UNIVERSAL_ROUTER_EXECUTE_DEADLINE_ABI,
+    functionName: "execute",
+    args: [V3_SWAP_EXACT_IN_COMMAND, [exactInInput], input.deadline]
+  });
+}
+function parseV3ExactInRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(
+    args,
+    ["router", "tokenIn", "tokenOut", "fee", "recipient", "amountIn", "amountOutMin", "payerIsUser", "deadline"],
+    method
+  );
+  return {
+    ...args.router === void 0 ? {} : { router: normalizePanopticAddress(args.router, `${method} args.router`) },
+    tokenIn: normalizePanopticAddress(args.tokenIn, `${method} args.tokenIn`),
+    tokenOut: normalizePanopticAddress(args.tokenOut, `${method} args.tokenOut`),
+    fee: uint24Arg(args.fee, `${method} args.fee`),
+    recipient: normalizePanopticAddress(args.recipient, `${method} args.recipient`),
+    amountIn: decimalValue(args.amountIn, "args.amountIn"),
+    amountOutMin: decimalValue(args.amountOutMin, "args.amountOutMin"),
+    payerIsUser: booleanValue(args.payerIsUser, "args.payerIsUser"),
+    deadline: optionalDecimalArg(args, "deadline")
+  };
+}
+function uint24Arg(value, label) {
+  const parsed = decimalValue(value, label);
+  if (parsed > BigInt(16777215)) {
+    throw new Error(`Panoptic ${label} exceeds uint24 range.`);
+  }
+  return parsed;
+}
+function encodeV3Path(tokenIn, fee, tokenOut) {
+  return `0x${tokenIn.slice(2)}${fee.toString(16).padStart(6, "0")}${tokenOut.slice(2)}`.toLowerCase();
+}
+
+// src/internal/panoptic/fragments/weth.ts
+var WETH_DEPOSIT_SELECTOR = "0xd0e30db0";
+var WETH_WITHDRAW_SELECTOR = "0x2e1a7d4d";
+function depositCalldataParts({ request, method }) {
+  const input = parseAmountRequest(request, method);
+  return {
+    functionName: "deposit",
+    calldata: WETH_DEPOSIT_SELECTOR,
+    userProvidedData: WETH_DEPOSIT_SELECTOR,
+    strategyProvidedData: "0x",
+    value: input.amount.toString(10)
+  };
+}
+function withdrawCalldataParts({ request, method }) {
+  const input = parseAmountRequest(request, method);
+  const strategyProvidedData = `0x${uint256AbiWord(input.amount)}`;
+  return {
+    functionName: "withdraw",
+    calldata: `${WETH_WITHDRAW_SELECTOR}${strategyProvidedData.slice(2)}`,
+    userProvidedData: WETH_WITHDRAW_SELECTOR,
+    strategyProvidedData,
+    value: "0"
+  };
+}
+function hypovaultWethDepositInnerCall({ request, method }) {
+  const input = parseWethTargetAmountRequest(request, method);
+  return {
+    functionName: "deposit",
+    target: input.weth,
+    data: WETH_DEPOSIT_SELECTOR,
+    value: input.amount.toString(10)
+  };
+}
+function hypovaultWethWithdrawInnerCall({ request, method }) {
+  const input = parseWethTargetAmountRequest(request, method);
+  const data = `${WETH_WITHDRAW_SELECTOR}${uint256AbiWord(input.amount)}`;
+  return {
+    functionName: "withdraw",
+    target: input.weth,
+    data,
+    value: "0"
+  };
+}
+function parseAmountRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["amount"], method);
+  return { amount: uint256Arg(args, "amount") };
+}
+function parseWethTargetAmountRequest(request, method) {
+  rejectContext(request, method);
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["weth", "amount"], method);
+  return {
+    weth: normalizePanopticAddress(args.weth, `${method} args.weth`),
+    amount: uint256Arg(args, "amount")
+  };
+}
+
+// src/internal/panoptic/dynamicJobs/renderExecuteJob.ts
+function renderExecuteJob({ request, method }) {
+  const { fragments } = parseRenderExecuteJobRequest(request, method);
+  return {
+    functionName: "executeJob(address[],bytes[],bytes[])",
+    typesArray: ["address[]", "bytes[]", "bytes[]"],
+    valuesArray: [
+      fragments.map((fragment) => fragment.target),
+      fragments.map((fragment) => fragment.userProvidedData),
+      fragments.map((fragment) => fragment.strategyProvidedData)
+    ]
+  };
+}
+function parseRenderExecuteJobRequest(request, method) {
+  const args = requestArgs(request, method);
+  rejectExtraKeys(args, ["fragments"], method);
+  if (!Array.isArray(args.fragments)) {
+    throw new Error(`Panoptic ${method} args.fragments must be an array.`);
+  }
+  if (args.fragments.length === 0) {
+    throw new Error(`Panoptic ${method} args.fragments must include at least one fragment.`);
+  }
+  if (args.fragments.length > 64) {
+    throw new Error(`Panoptic ${method} args.fragments exceeds maximum array length 64.`);
+  }
+  return {
+    fragments: args.fragments.map(
+      (fragment, index) => validateDynamicJobFragment(fragment, `${method} args.fragments[${index}]`)
+    )
+  };
+}
+
+// src/internal/panoptic/handlers.ts
+var RPC_HANDLERS = Object.freeze({
+  "account.getAccountCollateral": getAccountCollateral,
+  "account.getAccountSummaryBasic": getAccountSummaryBasic,
+  "account.getAccountSummaryRisk": getAccountSummaryRisk,
+  "account.getLiquidationPrices": getLiquidationPrices,
+  "account.getNetLiquidationValue": getNetLiquidationValue,
+  "account.getNetLiquidationValues": getNetLiquidationValues,
+  "account.getOpenPositionIds": getOpenPositionIds,
+  "account.getPosition": getPosition,
+  "account.getPositions": getPositions,
+  "greeks.getPositionGreeks": getPositionGreeks,
+  "hypovault.buildVaultManagerInputAtBlock": buildVaultManagerInputAtBlock,
+  "hypovault.getEpochContext": getEpochContext,
+  "hypovault.getOpenPositionIds": getOpenPositionIds2,
+  "hypovault.getPositionsHashStatus": getPositionsHashStatus,
+  "hypovault.verifyVaultOpenTokenIdsAtBlock": verifyVaultOpenTokenIdsAtBlock,
+  "pool.fetchPoolId": fetchPoolId,
+  "pool.getOracleState": getOracleState,
+  "pool.getPool": getPool,
+  "pool.getPoolMetadata": getPoolMetadata,
+  "pool.getRiskParameters": getRiskParameters,
+  "pool.getUtilization": getUtilization,
+  "uniswap.checkRouterApproval": checkRouterApproval,
+  "uniswap.quoteSwapExactInViaRouter": quoteSwapExactInViaRouter,
+  "uniswap.quoteSwapExactOutViaRouter": quoteSwapExactOutViaRouter,
+  "uniswap.resolveSwapRoute": resolveSwapRoute
+});
+var LOCAL_HANDLERS = Object.freeze({
+  "collateral.depositFragment": depositFragment,
+  "collateral.withdrawFragment": withdrawFragment,
+  "collateral.withdrawWithPositionsFragment": withdrawWithPositionsFragment,
+  "dynamicJobs.renderExecuteJob": renderExecuteJob,
+  "erc20.approveFragment": approveFragment,
+  "greeks.calculateAccountGreeksPure": calculateAccountGreeksPure,
+  "greeks.calculatePositionGreeks": calculatePositionGreeks,
+  "hypovault.fulfillDepositsFragment": fulfillDepositsFragment,
+  "hypovault.fulfillWithdrawalsFragment": fulfillWithdrawalsFragment,
+  "hypovault.manageCalldataParts": manageCalldataParts,
+  "hypovault.manageFragment": manageFragment,
+  "hypovault.wethDepositInnerCall": hypovaultWethDepositInnerCall,
+  "hypovault.wethWithdrawInnerCall": hypovaultWethWithdrawInnerCall,
+  "merkle.buildManageArgs": buildManageArgs,
+  "merkle.findLeaf": findLeaf,
+  "merkle.manageVaultWithVerificationFragment": manageVaultWithVerificationFragment,
+  "panoptic.dispatchCalldataParts": dispatchCalldataParts,
+  "panoptic.dispatchExplicitCalldataParts": dispatchExplicitCalldataParts,
+  "panoptic.dispatchExplicitFragment": dispatchExplicitFragment,
+  "panoptic.dispatchFragment": dispatchFragment,
+  "permit2.approveFragment": approveFragment2,
+  "pool.getPricesAtTick": getPricesAtTick,
+  "pool.getTickSpacing": getTickSpacing,
+  "uniswap.buildV3ExactInExecuteCalldataParts": buildV3ExactInExecuteCalldataParts,
+  "uniswap.buildV3ExactInExecuteFragment": buildV3ExactInExecuteFragment,
+  "weth.depositCalldataParts": depositCalldataParts,
+  "weth.withdrawCalldataParts": withdrawCalldataParts
+});
+var HANDLERS = Object.freeze({
+  ...RPC_HANDLERS,
+  ...LOCAL_HANDLERS
+});
+var STABLE_PANOPTIC_METHOD_NAMES = Object.freeze(Object.keys(HANDLERS).sort());
+function getPanopticHandler(method) {
+  return Object.prototype.hasOwnProperty.call(HANDLERS, method) ? HANDLERS[method] : void 0;
+}
+function getPanopticHandlerNames() {
+  return [...STABLE_PANOPTIC_METHOD_NAMES].sort();
+}
+async function executePanopticHandler(input) {
+  const runHandler = () => Promise.resolve(
+    input.handler({
+      deps: input.deps,
+      method: input.method,
+      request: input.request,
+      options: input.options || {},
+      operationOptions: input.operationOptions
+    })
+  );
+  const rawResult = Object.prototype.hasOwnProperty.call(RPC_HANDLERS, input.method) ? await runPanopticOperation(`Panoptic handler ${input.method}`, runHandler, input.operationOptions) : await runHandler();
+  const result = projectPanopticSerializableValue(rawResult, input.responseLimits, `${input.method} result`);
+  return panopticSuccess(result);
+}
+
+// src/internal/panopticRuntime.ts
+var PANOPTIC_RUNTIME_METHOD_NAMES = Object.freeze(getPanopticHandlerNames());
+var RENAMED_METHODS = /* @__PURE__ */ new Map([
+  ["dynamicJobs.renderRegisteredExecuteJob", "dynamicJobs.renderExecuteJob"],
+  ["hypovault.encodeFulfillDeposits", "hypovault.fulfillDepositsFragment"],
+  ["hypovault.encodeFulfillWithdrawals", "hypovault.fulfillWithdrawalsFragment"],
+  ["router.checkApproval", "uniswap.checkRouterApproval"],
+  ["panoptic.dispatchArgs", "panoptic.dispatchCalldataParts"]
+]);
+var UNSUPPORTED_PLANNED_METHODS = /* @__PURE__ */ new Map([
+  ["greeks.getAccountGreeks", "requires a serializable storage snapshot DTO"],
+  ["hypovault.resolveVaultHistoricalCandidatesByPool", "requires host-owned subgraph paging and reconciliation policy"],
+  ["merkle.encodeManageVaultWithMerkleVerification", "requires Merkle artifact provenance and nested target policy"]
+]);
+for (const method of PANOPTIC_RUNTIME_METHOD_NAMES) {
+  if (!getPanopticHandler(method)) {
+    throw new Error(`Panoptic stable runtime method is not backed by a handler: ${method}`);
+  }
+}
+async function callNodePanoptic(method, request, options = {}) {
+  const handler = getPanopticHandler(method);
+  if (handler) {
+    return executePanopticHandler({
+      method,
+      handler,
+      request,
+      deps: createPanopticDependencies(),
+      options,
+      operationOptions: options.operation
+    });
+  }
+  if (isLegacyCalldataMethod(method)) {
+    throw new Error(
+      `Panoptic runtime method is not part of the stable DynamicJobs RuntimeAdapter API: ${method}. Use protocol fragment namespaces instead.`
+    );
+  }
+  const renamedMethod = RENAMED_METHODS.get(method);
+  if (renamedMethod) {
+    throw new Error(
+      `Panoptic runtime method has been renamed for the stable DynamicJobs RuntimeAdapter API: ${method}. Use ${renamedMethod}.`
+    );
+  }
+  const unsupportedReason = UNSUPPORTED_PLANNED_METHODS.get(method);
+  if (unsupportedReason) {
+    throw new Error(
+      `Panoptic runtime method is not part of the stable DynamicJobs RuntimeAdapter API: ${method} (${unsupportedReason}).`
+    );
+  }
+  throw new Error(`Unsupported Panoptic runtime method: ${method}`);
+}
+function createNodePanopticAdapter(options = {}) {
+  return (method, request) => callNodePanoptic(method, request, options);
+}
+function isLegacyCalldataMethod(method) {
+  return method.startsWith("calldata.");
+}
+
 // src/node.ts
-function loadWasmSync(input, imports = {}) {
+function loadWasmSync(input, imports = {}, options = {}) {
   return instantiate(new WebAssembly.Module(input), imports, {
     getFetch: getNodeFetch,
-    getCcxt
+    getCcxt,
+    callPanoptic: createNodePanopticAdapter(options.panoptic)
   });
 }
-async function loadWasm(input, imports = {}) {
+async function loadWasm(input, imports = {}, options = {}) {
   const module = typeof input === "string" ? await compileFromString(input) : await WebAssembly.compile(input);
   return instantiate(module, imports, {
     getFetch: getNodeFetch,
-    getCcxt
+    getCcxt,
+    callPanoptic: createNodePanopticAdapter(options.panoptic)
   });
 }
 async function compileFromString(input) {