@settlemint/dalp-sdk 3.1.19-main.35909219019 → 3.1.19-main.35922421643

package/dist/auth.js

@@ -10,7 +10,7 @@ import {
   makeCookieStore2,
   createCookieStoreFetch2,
   SDK_USER_AGENT2
-} from "./chunk-695n870t.js";
+} from "./chunk-kvsyvt7m.js";
 
 // src/auth/live.ts
 import { apiKeyClient } from "@better-auth/api-key/client";

package/dist/bundler.js

@@ -1,9 +1,9 @@
 import"./chunk-j4sxrfzz.js";
-import"./chunk-0bf7c9q3.js";
+import"./chunk-0t9a8vn8.js";
 import"./chunk-xp3fx2yt.js";
 import {
   buildDalpClient
-} from "./chunk-9y1cjngw.js";
+} from "./chunk-d4agy53b.js";
 
 // src/bundler.ts
 import { getAddress, hexToBigInt, isHex } from "viem";

package/dist/{chunk-0bf7c9q3.js → chunk-0t9a8vn8.js}

@@ -512,8 +512,17 @@ function withConditionalRequests(base) {
 }
 
 // src/proxy/flat-args.ts
+function asFlatObject(value) {
+  return value === null || value === undefined || typeof value !== "object" ? {} : { ...value };
+}
+function assertPathParams(route, path) {
+  const missing = route.params.filter((name) => path[name] === undefined);
+  if (missing.length > 0) {
+    throw new TypeError(`Missing path parameter${missing.length === 1 ? "" : "s"} ${missing.map((name) => `\`${name}\``).join(", ")} for ${route.method} ${route.path}`);
+  }
+}
 function splitFlatArgs(route, input) {
-  const source = input === null || input === undefined || typeof input !== "object" ? {} : input;
+  const source = asFlatObject(input);
   const path = {};
   const query = {};
   const rest = {};
@@ -528,10 +537,7 @@ function splitFlatArgs(route, input) {
       rest[key] = value;
     }
   }
-  const missing = route.params.filter((name) => path[name] === undefined);
-  if (missing.length > 0) {
-    throw new TypeError(`Missing path parameter${missing.length === 1 ? "" : "s"} ${missing.map((name) => `\`${name}\``).join(", ")} for ${route.method} ${route.path}`);
-  }
+  assertPathParams(route, path);
   if (!route.hasPayload) {
     return { path, query: rest, body: undefined };
   }
@@ -546,6 +552,25 @@ function splitFlatArgs(route, input) {
   }
   return { path, query, body: rest };
 }
+function splitRequestParts(route, parts) {
+  const source = asFlatObject(parts);
+  const path = asFlatObject(source["params"]);
+  const query = asFlatObject(source["query"]);
+  assertPathParams(route, path);
+  if (!route.hasPayload) {
+    return { path, query, body: undefined };
+  }
+  const body = asFlatObject(source["body"]);
+  for (const name of route.bodyParams) {
+    if (body[name] === undefined && path[name] !== undefined) {
+      body[name] = path[name];
+    }
+  }
+  return { path, query, body };
+}
+function splitRequestInput(route, input) {
+  return "parts" in input ? splitRequestParts(route, input.parts) : splitFlatArgs(route, input.flat);
+}
 function buildPath(route, path) {
   return route.path.replaceAll(/:([A-Za-z0-9_]+)/gu, (_match, name) => {
     const value = path[name];
@@ -647,7 +672,7 @@ function callHeaders(transport, options) {
   return headers;
 }
 function prepareRequest(transport, route, input, options) {
-  const split = splitFlatArgs(route, input);
+  const split = splitRequestInput(route, input);
   const query = serializeDalpQuery(split.query);
   const url = `${transport.baseUrl}/api/v2${buildPath(route, split.path)}${query === "" ? "" : `?${query}`}`;
   const headers = callHeaders(transport, options);
@@ -732,6 +757,448 @@ async function readResponse(response) {
   return payload;
 }
 
+// src/proxy/response-decode.ts
+var MALFORMED_SUCCESS_ERROR_CODE2 = "sdk.response.MALFORMED_SUCCESS";
+function kindOf(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "integer" : "number";
+  }
+  return typeof value;
+}
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function matchesType(type, value) {
+  switch (type) {
+    case "string": {
+      return typeof value === "string";
+    }
+    case "number": {
+      return typeof value === "number";
+    }
+    case "integer": {
+      return Number.isInteger(value);
+    }
+    case "boolean": {
+      return typeof value === "boolean";
+    }
+    case "null": {
+      return value === null;
+    }
+    case "array": {
+      return Array.isArray(value);
+    }
+    case "object": {
+      return isObject(value);
+    }
+    default: {
+      return false;
+    }
+  }
+}
+function jsonEqual(left, right) {
+  if (left === right) {
+    return true;
+  }
+  if (typeof left !== "object" || typeof right !== "object" || left === null || right === null) {
+    return false;
+  }
+  if (Array.isArray(left) !== Array.isArray(right)) {
+    return false;
+  }
+  const leftKeys = Object.keys(left);
+  if (leftKeys.length !== Object.keys(right).length) {
+    return false;
+  }
+  return leftKeys.every((key) => Object.hasOwn(right, key) && jsonEqual(Reflect.get(left, key), Reflect.get(right, key)));
+}
+function depthOf(path) {
+  let depth = 0;
+  for (const character of path) {
+    if (character === "." || character === "[") {
+      depth += 1;
+    }
+  }
+  return depth;
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern, "u");
+  } catch {
+    return new RegExp(pattern);
+  }
+}
+
+class ResponseSchemaChecker {
+  compiled = new Map;
+  patterns = new Map;
+  definitions;
+  constructor(definitions) {
+    this.definitions = definitions;
+  }
+  validate(node, value) {
+    return this.compile(node)(value);
+  }
+  explain(node, value, path = "$") {
+    if (this.validate(node, value)) {
+      return;
+    }
+    if (node.$ref !== undefined) {
+      return this.explain(this.definition(node.$ref), value, path);
+    }
+    const typeMismatch = this.explainType(node, value, path);
+    if (typeMismatch !== undefined) {
+      return typeMismatch;
+    }
+    return this.explainValue(node, value, path) ?? this.explainObject(node, value, path) ?? this.explainArray(node, value, path) ?? this.explainComposition(node, value, path) ?? {
+      path,
+      expected: "a value matching the schema",
+      received: kindOf(value)
+    };
+  }
+  definition(name) {
+    const node = this.definitions[name];
+    if (node === undefined) {
+      throw new TypeError(`DALP SDK response schema references the missing definition ${name}`);
+    }
+    return node;
+  }
+  pattern(source) {
+    let compiled = this.patterns.get(source);
+    if (compiled === undefined) {
+      compiled = compilePattern(source);
+      this.patterns.set(source, compiled);
+    }
+    return compiled;
+  }
+  compile(node) {
+    const cached = this.compiled.get(node);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const built = this.build(node);
+    this.compiled.set(node, built);
+    return built;
+  }
+  build(node) {
+    const checks = [];
+    if (node.$ref !== undefined) {
+      const name = node.$ref;
+      let target;
+      checks.push((value) => (target ??= this.compile(this.definition(name)))(value));
+    }
+    if (node.type !== undefined) {
+      const types = typeof node.type === "string" ? [node.type] : node.type;
+      checks.push(types.length === 1 ? (value) => matchesType(types[0], value) : (value) => types.some((type) => matchesType(type, value)));
+    }
+    this.buildValueChecks(node, checks);
+    this.buildObjectChecks(node, checks);
+    this.buildArrayChecks(node, checks);
+    this.buildCompositionChecks(node, checks);
+    if (checks.length === 0) {
+      return () => true;
+    }
+    if (checks.length === 1) {
+      return checks[0];
+    }
+    return (value) => {
+      for (const check of checks) {
+        if (!check(value)) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  buildValueChecks(node, checks) {
+    if (node.enum !== undefined) {
+      const members = node.enum;
+      const primitives = new Set(members.filter((member) => member === null || typeof member !== "object"));
+      checks.push((value) => primitives.has(value) || members.some((member) => typeof member === "object" && jsonEqual(member, value)));
+    }
+    if ("const" in node) {
+      const expected = node.const;
+      checks.push((value) => jsonEqual(expected, value));
+    }
+    const { pattern, minLength, maxLength, minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf } = node;
+    if (pattern !== undefined) {
+      const regex = this.pattern(pattern);
+      checks.push((value) => typeof value !== "string" || regex.test(value));
+    }
+    if (minLength !== undefined) {
+      checks.push((value) => typeof value !== "string" || value.length >= minLength);
+    }
+    if (maxLength !== undefined) {
+      checks.push((value) => typeof value !== "string" || value.length <= maxLength);
+    }
+    if (minimum !== undefined) {
+      checks.push((value) => typeof value !== "number" || value >= minimum);
+    }
+    if (maximum !== undefined) {
+      checks.push((value) => typeof value !== "number" || value <= maximum);
+    }
+    if (exclusiveMinimum !== undefined) {
+      checks.push((value) => typeof value !== "number" || value > exclusiveMinimum);
+    }
+    if (exclusiveMaximum !== undefined) {
+      checks.push((value) => typeof value !== "number" || value < exclusiveMaximum);
+    }
+    if (multipleOf !== undefined) {
+      checks.push((value) => typeof value !== "number" || Number.isInteger(value / multipleOf));
+    }
+  }
+  buildObjectChecks(node, checks) {
+    const { properties, required, additionalProperties, propertyNames } = node;
+    if (required !== undefined && required.length > 0) {
+      checks.push((value) => !isObject(value) || required.every((key) => Object.hasOwn(value, key)));
+    }
+    if (properties !== undefined) {
+      const entries = Object.entries(properties).map(([key, child]) => [key, this.compile(child)]);
+      checks.push((value) => {
+        if (!isObject(value)) {
+          return true;
+        }
+        for (const [key, check] of entries) {
+          if (Object.hasOwn(value, key) && !check(Reflect.get(value, key))) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (typeof additionalProperties === "object") {
+      const declared = new Set(Object.keys(properties ?? {}));
+      const check = this.compile(additionalProperties);
+      checks.push((value) => {
+        if (!isObject(value)) {
+          return true;
+        }
+        for (const key in value) {
+          if (Object.hasOwn(value, key) && !declared.has(key) && !check(Reflect.get(value, key))) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (propertyNames !== undefined) {
+      const check = this.compile(propertyNames);
+      checks.push((value) => !isObject(value) || Object.keys(value).every(check));
+    }
+  }
+  buildArrayChecks(node, checks) {
+    const { items, prefixItems, minItems, maxItems } = node;
+    const prefix = (prefixItems ?? []).map((child) => this.compile(child));
+    if (prefix.length > 0) {
+      checks.push((value) => !Array.isArray(value) || prefix.every((check, index) => index >= value.length || check(value[index])));
+    }
+    if (items !== undefined) {
+      const check = this.compile(items);
+      const from = prefix.length;
+      checks.push((value) => {
+        if (!Array.isArray(value)) {
+          return true;
+        }
+        for (let index = from;index < value.length; index += 1) {
+          if (!check(value[index])) {
+            return false;
+          }
+        }
+        return true;
+      });
+    }
+    if (minItems !== undefined) {
+      checks.push((value) => !Array.isArray(value) || value.length >= minItems);
+    }
+    if (maxItems !== undefined) {
+      checks.push((value) => !Array.isArray(value) || value.length <= maxItems);
+    }
+  }
+  buildCompositionChecks(node, checks) {
+    if (node.allOf !== undefined) {
+      const all = node.allOf.map((child) => this.compile(child));
+      checks.push((value) => all.every((check) => check(value)));
+    }
+    if (node.anyOf !== undefined) {
+      const any = node.anyOf.map((child) => this.compile(child));
+      checks.push((value) => any.some((check) => check(value)));
+    }
+    if (node.oneOf !== undefined) {
+      const one = node.oneOf.map((child) => this.compile(child));
+      checks.push((value) => one.filter((check) => check(value)).length === 1);
+    }
+  }
+  explainType(node, value, path) {
+    if (node.type === undefined) {
+      return;
+    }
+    const types = typeof node.type === "string" ? [node.type] : node.type;
+    return types.some((type) => matchesType(type, value)) ? undefined : { path, expected: types.join(" | "), received: kindOf(value) };
+  }
+  explainValue(node, value, path) {
+    const checks = [];
+    this.buildValueChecks(node, checks);
+    if (checks.every((check) => check(value))) {
+      return;
+    }
+    let expected = "a value within the schema's bounds";
+    if (node.enum !== undefined) {
+      expected = `one of ${String(node.enum.length)} allowed values`;
+    } else if ("const" in node) {
+      expected = "the schema's constant value";
+    } else if (node.pattern !== undefined && typeof value === "string" && !this.pattern(node.pattern).test(value)) {
+      expected = "a string matching the schema pattern";
+    }
+    return { path, expected, received: kindOf(value) };
+  }
+  explainObject(node, value, path) {
+    if (!isObject(value)) {
+      return;
+    }
+    for (const key of node.required ?? []) {
+      if (!Object.hasOwn(value, key)) {
+        return { path: `${path}.${key}`, expected: "a required property", received: "missing" };
+      }
+    }
+    const properties = node.properties ?? {};
+    for (const [key, child] of Object.entries(properties)) {
+      if (Object.hasOwn(value, key)) {
+        const mismatch = this.explain(child, Reflect.get(value, key), `${path}.${key}`);
+        if (mismatch !== undefined) {
+          return mismatch;
+        }
+      }
+    }
+    const extra = node.additionalProperties;
+    for (const key of Object.keys(value)) {
+      if (node.propertyNames !== undefined && !this.validate(node.propertyNames, key)) {
+        return { path: `${path}.{key}`, expected: "a property name matching the schema", received: "string" };
+      }
+      if (typeof extra === "object" && !Object.hasOwn(properties, key)) {
+        const mismatch = this.explain(extra, Reflect.get(value, key), `${path}.{key}`);
+        if (mismatch !== undefined) {
+          return mismatch;
+        }
+      }
+    }
+    return;
+  }
+  explainArray(node, value, path) {
+    if (!Array.isArray(value)) {
+      return;
+    }
+    const { minItems, maxItems, prefixItems = [], items } = node;
+    if (minItems !== undefined && value.length < minItems || maxItems !== undefined && value.length > maxItems) {
+      return { path, expected: "an array length within the schema's bounds", received: "array" };
+    }
+    for (const [index, element] of value.entries()) {
+      const child = index < prefixItems.length ? prefixItems[index] : items;
+      const mismatch = child === undefined ? undefined : this.explain(child, element, `${path}[${String(index)}]`);
+      if (mismatch !== undefined) {
+        return mismatch;
+      }
+    }
+    return;
+  }
+  explainComposition(node, value, path) {
+    for (const child of node.allOf ?? []) {
+      const mismatch = this.explain(child, value, path);
+      if (mismatch !== undefined) {
+        return mismatch;
+      }
+    }
+    const variants = node.anyOf ?? node.oneOf;
+    if (variants === undefined || variants.some((child) => this.validate(child, value))) {
+      return;
+    }
+    const tagged = variants.filter((child) => this.tagsMatch(child, value));
+    const candidates = tagged.length === 1 ? tagged : variants;
+    let deepest;
+    for (const child of candidates) {
+      const mismatch = this.explain(child, value, path);
+      if (mismatch !== undefined && (deepest === undefined || depthOf(mismatch.path) > depthOf(deepest.path))) {
+        deepest = mismatch;
+      }
+    }
+    return deepest !== undefined && (tagged.length === 1 || deepest.path !== path) ? deepest : { path, expected: `one of ${String(variants.length)} variants`, received: kindOf(value) };
+  }
+  tagsMatch(node, value) {
+    const resolved = node.$ref === undefined ? node : this.definition(node.$ref);
+    if (!isObject(value) || resolved.properties === undefined) {
+      return false;
+    }
+    let tags = 0;
+    for (const [key, child] of Object.entries(resolved.properties)) {
+      const property = child.$ref === undefined ? child : this.definition(child.$ref);
+      const tag = property.enum?.length === 1 ? property.enum[0] : property.const;
+      if (tag === undefined) {
+        continue;
+      }
+      if (!jsonEqual(tag, Reflect.get(value, key))) {
+        return false;
+      }
+      tags += 1;
+    }
+    return tags > 0;
+  }
+}
+function malformedSuccess(routeId, status, mismatch) {
+  return makeDalpApiError2(new DalpSdkError2({
+    code: MALFORMED_SUCCESS_ERROR_CODE2,
+    category: "dependency",
+    status,
+    retryable: false,
+    message: `DALP API responded ${String(status)} to ${routeId} with a body that does not match the route's schema at ${mismatch.path}`,
+    why: `The success body failed the ${routeId} response schema: ${mismatch.path} should be ${mismatch.expected}, but it is ${mismatch.received}.`,
+    fix: "Check that the SDK version matches the platform version. If they match, report the route id and field path: the platform served a body its own contract does not allow.",
+    details: { routeId, status, path: mismatch.path, expected: mismatch.expected, received: mismatch.received }
+  }));
+}
+
+class ResponseDecoder {
+  checker;
+  table;
+  constructor(table) {
+    this.table = table;
+    this.checker = new ResponseSchemaChecker(table.definitions);
+  }
+  decode(routeId, status, payload) {
+    const statuses = this.table.routes[routeId];
+    const schema = statuses?.[String(status)];
+    if (schema === undefined || schema === null) {
+      throw malformedSuccess(routeId, status, {
+        path: "$",
+        expected: statuses === undefined ? "a route the SDK knows" : `a status the route declares (${Object.keys(statuses).join(", ")})`,
+        received: statuses === undefined ? "an unknown route" : `status ${String(status)}`
+      });
+    }
+    if (this.checker.validate(schema, payload)) {
+      return payload;
+    }
+    throw malformedSuccess(routeId, status, this.checker.explain(schema, payload) ?? { path: "$", expected: "the route's schema", received: kindOf(payload) });
+  }
+}
+var shared;
+async function importResponseDecoder() {
+  const { data } = await import("./chunk-74chbmzc.js");
+  return new ResponseDecoder(data);
+}
+async function loadResponseDecoder() {
+  shared ??= importResponseDecoder();
+  try {
+    return await shared;
+  } catch (error) {
+    shared = undefined;
+    throw error;
+  }
+}
+
 // src/proxy/sse.ts
 var RESERVED_STREAM_FAILURE_EVENT2 = "effect/httpapi/stream/failure";
 var STREAM_FAILED_ERROR_CODE2 = "sdk.stream.FAILED";
@@ -742,7 +1209,7 @@ function parseFrame(raw) {
     return raw.data;
   }
 }
-function dispatchFrame(raw) {
+function dispatchFrame(raw, decodeFrame) {
   if (raw.event === RESERVED_STREAM_FAILURE_EVENT2) {
     throw makeDalpApiError2(new DalpSdkError2({
       code: STREAM_FAILED_ERROR_CODE2,
@@ -754,7 +1221,8 @@ function dispatchFrame(raw) {
       details: { cause: raw.data }
     }));
   }
-  return parseFrame(raw);
+  const frame = parseFrame(raw);
+  return decodeFrame === undefined ? frame : decodeFrame(frame);
 }
 function readBlock(block) {
   let event = "message";
@@ -776,7 +1244,7 @@ function readBlock(block) {
   return data.length === 0 ? undefined : { event, data: data.join(`
 `) };
 }
-async function* decodeEventStream2(body) {
+async function* decodeEventStream2(body, decodeFrame) {
   const reader = body.getReader();
   const decoder = new TextDecoder;
   let buffer = "";
@@ -797,7 +1265,7 @@ async function* decodeEventStream2(body) {
         const raw = readBlock(buffer.slice(0, boundary));
         buffer = buffer.slice(boundary + 2);
         if (raw !== undefined) {
-          yield dispatchFrame(raw);
+          yield dispatchFrame(raw, decodeFrame);
         }
         boundary = buffer.indexOf(`
 
@@ -806,13 +1274,13 @@ async function* decodeEventStream2(body) {
     }
     const trailing = readBlock(buffer);
     if (trailing !== undefined) {
-      yield dispatchFrame(trailing);
+      yield dispatchFrame(trailing, decodeFrame);
     }
   } finally {
     await reader.cancel().catch(() => {});
   }
 }
-async function* openEventStream(transport, route, input, options, signal, closed) {
+async function* openEventStream(transport, route, routeId, input, options, signal, closed) {
   const prepared = prepareRequest(transport, route, input, options);
   prepared.headers.set("Accept", "text/event-stream");
   const response = await transport.fetch(prepared.url, {
@@ -829,15 +1297,17 @@ async function* openEventStream(transport, route, input, options, signal, closed
   if (response.body === null) {
     return;
   }
+  const decoder = await loadResponseDecoder();
+  const { status } = response;
   try {
-    yield* decodeEventStream2(response.body);
+    yield* decodeEventStream2(response.body, (frame) => decoder.decode(routeId, status, frame));
   } catch (error) {
     if (!closed.byConsumer) {
       throw error;
     }
   }
 }
-function streamRequest(transport, route, input, options) {
+function streamRequest(transport, route, routeId, input, options) {
   const closing = new AbortController;
   const callerSignal = options?.signal;
   if (callerSignal !== undefined) {
@@ -848,7 +1318,7 @@ function streamRequest(transport, route, input, options) {
     }
   }
   const closed = { byConsumer: false };
-  const frames = openEventStream(transport, route, input, options, closing.signal, closed);
+  const frames = openEventStream(transport, route, routeId, input, options, closing.signal, closed);
   const close = () => {
     closed.byConsumer = true;
     closing.abort();
@@ -874,7 +1344,7 @@ function streamRequest(transport, route, input, options) {
 }
 
 // src/proxy/fetch-executor.ts
-async function sendRequest(transport, route, input, options) {
+async function sendRequest(transport, route, routeId, input, options) {
   const prepared = prepareRequest(transport, route, input, options);
   const response = await transport.fetch(prepared.url, {
     method: prepared.method,
@@ -883,10 +1353,12 @@ async function sendRequest(transport, route, input, options) {
     ...prepared.body === undefined ? {} : { body: prepared.body },
     ...options?.signal === undefined ? {} : { signal: options.signal }
   });
-  return readResponse(response);
+  const payload = await readResponse(response);
+  const decoder = await loadResponseDecoder();
+  return decoder.decode(routeId, response.status, payload);
 }
 function createFetchExecutor(transport) {
-  return (route, _id, input, options) => route.serializer === "sse" ? streamRequest(transport, route, input, options) : sendRequest(transport, route, input, options);
+  return (route, id, input, options) => route.serializer === "sse" ? streamRequest(transport, route, id, { flat: input }, options) : sendRequest(transport, route, id, { flat: input }, options);
 }
 
 // src/proxy/tanstack.ts
@@ -915,16 +1387,16 @@ function createTanstackFactories(transport) {
   return {
     queryOptions: (route, id, input, options) => ({
       queryKey: queryKeyFor2(id, input),
-      queryFn: (context) => sendRequest(transport, route, input, {
+      queryFn: (context) => sendRequest(transport, route, id, { flat: input }, {
         ...options,
         ...context.signal === undefined ? {} : { signal: context.signal }
       })
     }),
     mutationOptions: (route, id, options) => ({
       mutationKey: ["dalp", id],
-      mutationFn: (input) => sendRequest(transport, route, input, { settlementTimeoutMs: UI_SETTLEMENT_TIMEOUT_MS2, ...options })
+      mutationFn: (input) => sendRequest(transport, route, id, { flat: input }, { settlementTimeoutMs: UI_SETTLEMENT_TIMEOUT_MS2, ...options })
     })
   };
 }
 
-export { DalpApiError2, isDalpApiError2, findDalpSdkError2, makeDalpApiError2, createDalpContextHeaders2, createTransport, RESERVED_STREAM_FAILURE_EVENT2, STREAM_FAILED_ERROR_CODE2, decodeEventStream2, streamRequest, sendRequest, createFetchExecutor, canonicalize2, queryKeyFor2, UI_SETTLEMENT_TIMEOUT_MS2, createTanstackFactories };
+export { DalpApiError2, isDalpApiError2, findDalpSdkError2, makeDalpApiError2, createDalpContextHeaders2, createTransport, MALFORMED_SUCCESS_ERROR_CODE2, RESERVED_STREAM_FAILURE_EVENT2, STREAM_FAILED_ERROR_CODE2, decodeEventStream2, streamRequest, sendRequest, createFetchExecutor, canonicalize2, queryKeyFor2, UI_SETTLEMENT_TIMEOUT_MS2, createTanstackFactories };