@settlemint/dalp-sdk 3.1.15 → 3.1.16-main.33748846737

package/dist/chunk-def7rqy6.js

@@ -0,0 +1,946 @@
+import {
+  PAUSED_POLL_INTERVAL_MAX_MS,
+  readsAsFundingPaused
+} from "./chunk-fjnq61hj.js";
+import {
+  Secret,
+  normalizeDalpBaseUrl,
+  secret,
+  unwrapSecret
+} from "./chunk-h12fatty.js";
+import {
+  DalpSdkError,
+  createDalpSdkConfigurationError
+} from "./chunk-y0d2c7kp.js";
+
+// src/errors/find-current-error.ts
+var readProperty = (target, key) => Reflect.get(target, key);
+var findCurrentError = (error, maxNodes = 20) => {
+  const queue = [error];
+  const seen = new Set;
+  let visited = 0;
+  while (queue.length > 0 && visited < maxNodes) {
+    const current = queue.shift();
+    if (current === null || current === undefined || seen.has(current)) {
+      continue;
+    }
+    seen.add(current);
+    visited += 1;
+    if (current instanceof DalpSdkError) {
+      return current;
+    }
+    if (typeof current !== "object") {
+      continue;
+    }
+    queue.push(readProperty(current, "cause"));
+    const reasons = readProperty(current, "reasons");
+    if (Array.isArray(reasons)) {
+      for (const reason of reasons) {
+        if (typeof reason === "object" && reason !== null) {
+          queue.push(readProperty(reason, "error"), readProperty(reason, "defect"));
+        }
+      }
+    }
+  }
+  return;
+};
+
+// src/errors/api-error.ts
+class DalpApiError extends Error {
+  id;
+  code;
+  category;
+  status;
+  retryable;
+  why;
+  fix;
+  retryAfterSeconds;
+  constructor(options) {
+    super(options.message, { cause: options.cause });
+    this.name = "DalpApiError";
+    this.id = options.id;
+    this.code = options.code;
+    this.category = options.category;
+    this.status = options.status;
+    this.retryable = options.retryable;
+    this.why = options.why;
+    this.fix = options.fix;
+    this.retryAfterSeconds = options.retryAfterSeconds;
+  }
+  static make(options) {
+    return new DalpApiError(options);
+  }
+}
+var isDalpApiError = (error) => error instanceof DalpApiError;
+var findDalpSdkError = findCurrentError;
+var API_ERROR_CATEGORIES = new Set([
+  "client",
+  "auth",
+  "permission",
+  "domain",
+  "contract",
+  "dependency",
+  "operational",
+  "config",
+  "unknown"
+]);
+var mapSdkErrorCategory = (category) => {
+  if (category === "sdk.configuration") {
+    return "config";
+  }
+  if (API_ERROR_CATEGORIES.has(category)) {
+    return category;
+  }
+  return "operational";
+};
+var makeDalpApiError = (error) => {
+  const sdkError = findDalpSdkError(error);
+  if (sdkError === undefined) {
+    return new DalpApiError({
+      message: "DALP API request failed",
+      cause: error,
+      code: "sdk.transport.REQUEST_FAILED",
+      category: "dependency",
+      retryable: true,
+      why: "The DALP API request failed before the server returned a structured response.",
+      fix: "Check network connectivity and retry the request."
+    });
+  }
+  return new DalpApiError({
+    message: sdkError.message,
+    cause: sdkError,
+    code: sdkError.code,
+    category: mapSdkErrorCategory(sdkError.category),
+    retryable: sdkError.retryable,
+    why: sdkError.why,
+    fix: sdkError.fix,
+    status: sdkError.status,
+    retryAfterSeconds: sdkError.retryAfterSeconds
+  });
+};
+
+// src/client/query-serializer.ts
+function appendQueryValue(search, path, value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  if (value instanceof Date) {
+    search.append(path, value.toISOString());
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const [index, item] of value.entries()) {
+      const itemPath = typeof item === "object" && item !== null ? `${path}[${String(index)}]` : path;
+      appendQueryValue(search, itemPath, item);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [key, item] of Object.entries(value)) {
+      appendQueryValue(search, `${path}[${key}]`, item);
+    }
+    return;
+  }
+  search.append(path, String(value));
+}
+function serializeDalpQuery(query) {
+  const search = new URLSearchParams;
+  if (typeof query === "object" && query !== null) {
+    for (const [key, value] of Object.entries(query)) {
+      appendQueryValue(search, key, value);
+    }
+  }
+  return search.toString();
+}
+
+// src/client/request-compression.ts
+var DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES = 1024;
+var DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES = 16777216;
+var NO_BODY_METHODS = new Set(["GET", "HEAD"]);
+function bufferedBodySize(body) {
+  if (typeof body === "string") {
+    return Buffer.byteLength(body);
+  }
+  if (body instanceof ArrayBuffer || ArrayBuffer.isView(body)) {
+    return body.byteLength;
+  }
+  if (body instanceof Blob) {
+    return body.size;
+  }
+  return;
+}
+function isCompressibleMediaType(contentType) {
+  const mediaType = contentType?.split(";")[0]?.trim().toLowerCase();
+  if (mediaType === undefined || mediaType === "") {
+    return false;
+  }
+  return mediaType === "application/json" || mediaType.endsWith("+json") || mediaType.startsWith("text/");
+}
+async function cancelReaderBestEffort(reader) {
+  try {
+    await reader.cancel();
+  } catch {}
+}
+async function readRequestBodyWithinCap(request, maxBodyBytes) {
+  let body;
+  try {
+    const { body: clonedBody } = request.clone();
+    body = clonedBody;
+  } catch {
+    return;
+  }
+  if (body === null) {
+    return Buffer.alloc(0);
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const next = await reader.read();
+      if (next.done) {
+        return Buffer.concat(chunks, totalBytes);
+      }
+      totalBytes += next.value.byteLength;
+      if (totalBytes > maxBodyBytes) {
+        cancelReaderBestEffort(reader);
+        return;
+      }
+      chunks.push(next.value);
+    }
+  } catch {
+    return;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function withRequestBodyCompression(fetchImpl, options) {
+  const minBodyBytes = options?.minBodyBytes ?? DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES;
+  const maxBodyBytes = options?.maxBodyBytes ?? DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES;
+  const requestCompressionFetch = async (input, init) => {
+    if (init?.compress !== undefined) {
+      return fetchImpl(input, init);
+    }
+    let request;
+    if (input instanceof Request) {
+      request = init === undefined ? input : new Request(input, init);
+    }
+    const method = (request?.method ?? init?.method ?? "GET").toUpperCase();
+    if (NO_BODY_METHODS.has(method)) {
+      return fetchImpl(input, init);
+    }
+    const headers = new Headers(request?.headers ?? init?.headers);
+    if (headers.get("content-encoding") !== null) {
+      return fetchImpl(input, init);
+    }
+    let compress;
+    let bufferedRequestBody;
+    if (request !== undefined && request.body !== null && isCompressibleMediaType(headers.get("content-type"))) {
+      bufferedRequestBody = await readRequestBodyWithinCap(request, maxBodyBytes);
+      if (bufferedRequestBody !== undefined && bufferedRequestBody.byteLength >= minBodyBytes) {
+        compress = "gzip";
+      }
+    } else if (init?.body !== null && init?.body !== undefined) {
+      const size = bufferedBodySize(init.body);
+      if (size !== undefined && size >= minBodyBytes && size <= maxBodyBytes) {
+        compress = "gzip";
+      }
+    }
+    if (compress === undefined) {
+      return fetchImpl(input, init);
+    }
+    if (request !== undefined && bufferedRequestBody !== undefined) {
+      return fetchImpl(request.url, {
+        ...init,
+        body: bufferedRequestBody,
+        cache: init?.cache ?? request.cache,
+        compress,
+        credentials: init?.credentials ?? request.credentials,
+        headers: request.headers,
+        integrity: init?.integrity ?? request.integrity,
+        keepalive: init?.keepalive ?? request.keepalive,
+        method: request.method,
+        mode: init?.mode ?? request.mode,
+        redirect: init?.redirect ?? request.redirect,
+        referrer: init?.referrer ?? request.referrer,
+        referrerPolicy: init?.referrerPolicy ?? request.referrerPolicy,
+        signal: init?.signal ?? request.signal
+      });
+    }
+    return fetchImpl(input, { ...init, compress });
+  };
+  return Object.assign(requestCompressionFetch, {
+    preconnect: fetchImpl.preconnect
+  });
+}
+
+// src/client/ssr-fetch.ts
+class DalpSsrSecurityError extends Error {
+  name = "DalpSsrSecurityError";
+}
+var originOf = (value) => {
+  const url = new URL(value);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new DalpSsrSecurityError(`DALP SDK: ${url.protocol} is not an approved SSR protocol.`);
+  }
+  return url.origin;
+};
+var REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "baggage",
+  "cookie",
+  "idempotency-key",
+  "origin",
+  "referer",
+  "traceparent",
+  "tracestate",
+  "x-api-key",
+  "x-chain-id",
+  "x-executor",
+  "x-organization-id",
+  "x-participant",
+  "x-selected-signers"
+];
+var withoutSensitiveHeaders = (source) => {
+  const headers = new Headers(source);
+  for (const name of SENSITIVE_HEADERS) {
+    headers.delete(name);
+  }
+  return headers;
+};
+function createSsrFetch(options) {
+  const incoming = new Headers(options.requestHeaders);
+  const approvedOrigins = new Set([originOf(options.baseUrl), ...(options.allowedOrigins ?? []).map(originOf)]);
+  const ssrFetch = async (input, init) => {
+    const request = input instanceof Request && init === undefined ? input : new Request(input, init);
+    if (!approvedOrigins.has(new URL(request.url).origin)) {
+      throw new DalpSsrSecurityError(`DALP SDK: ${request.url} is not an approved SSR destination.`);
+    }
+    const cookie = incoming.get("cookie");
+    if (cookie !== null && !["GET", "HEAD", "OPTIONS"].includes(request.method)) {
+      const incomingOrigin = incoming.get("origin");
+      let trustedOrigin = false;
+      try {
+        trustedOrigin = incomingOrigin !== null && approvedOrigins.has(originOf(incomingOrigin));
+      } catch {
+        trustedOrigin = false;
+      }
+      if (!trustedOrigin || incoming.get("sec-fetch-site") === "cross-site") {
+        throw new DalpSsrSecurityError("DALP SDK: a cookie-authenticated SSR mutation requires a trusted Origin.");
+      }
+    }
+    const headers = new Headers(request.headers);
+    if (cookie === null) {
+      headers.delete("cookie");
+    } else {
+      headers.set("cookie", cookie);
+    }
+    for (const name of ["origin", "traceparent", "tracestate", "baggage"]) {
+      const value = incoming.get(name);
+      if (value !== null && !headers.has(name)) {
+        headers.set(name, value);
+      }
+    }
+    let current = new Request(request, { headers, redirect: "manual" });
+    let sensitiveAllowed = true;
+    for (let redirectCount = 0;redirectCount <= 5; redirectCount += 1) {
+      const replay = current.clone();
+      const response = await options.fetch(current, { credentials: "omit", redirect: "manual" });
+      const location = response.headers.get("location");
+      if (!REDIRECT_STATUSES.has(response.status) || location === null) {
+        return response;
+      }
+      if (redirectCount === 5) {
+        throw new DalpSsrSecurityError("DALP SDK: SSR fetch exceeded the redirect limit.");
+      }
+      const nextUrl = new URL(location, current.url);
+      sensitiveAllowed = sensitiveAllowed && approvedOrigins.has(nextUrl.origin);
+      const redirectToGet = response.status === 303 || (response.status === 301 || response.status === 302) && replay.method === "POST";
+      const method = redirectToGet ? "GET" : replay.method;
+      if (!sensitiveAllowed && method !== "GET" && method !== "HEAD") {
+        throw new DalpSsrSecurityError("DALP SDK: refused to forward an SSR request body outside the trust boundary.");
+      }
+      const nextHeaders = sensitiveAllowed ? new Headers(replay.headers) : withoutSensitiveHeaders(replay.headers);
+      if (redirectToGet) {
+        nextHeaders.delete("content-length");
+        nextHeaders.delete("content-type");
+      }
+      current = new Request(nextUrl, {
+        body: method === "GET" || method === "HEAD" ? undefined : await replay.arrayBuffer(),
+        credentials: sensitiveAllowed ? replay.credentials : "omit",
+        headers: nextHeaders,
+        method,
+        redirect: "manual",
+        signal: replay.signal
+      });
+    }
+    throw new DalpSsrSecurityError("DALP SDK: unreachable redirect state.");
+  };
+  return Object.assign(ssrFetch, {
+    preconnect: options.fetch.preconnect ?? (() => {})
+  });
+}
+
+// src/client/conditional-request.ts
+var IF_NONE_MATCH = "If-None-Match";
+var CONDITIONAL_RESPONSE_STORE_CAPACITY = 64;
+var CONDITIONAL_RESPONSE_MAX_BODY_BYTES = 1048576;
+var IDENTITY_RESET_PATH_SUFFIXES = [
+  "/api/auth/sign-out",
+  "/api/auth/revoke-session",
+  "/api/auth/revoke-sessions",
+  "/api/auth/revoke-other-sessions",
+  "/api/auth/organization/set-active"
+];
+var headerOrDefault = (headers, name) => headers.get(name)?.trim() || "default";
+var tenantOf = (headers) => `${headerOrDefault(headers, "X-Organization-Id")}\x00${headerOrDefault(headers, "X-Participant")}`;
+var resourceKey = (request) => {
+  const url = new URL(request.url);
+  return `${url.origin}${url.pathname}${url.search}\x00${tenantOf(request.headers)}`;
+};
+var isIdentityResetPath = (url) => {
+  const path = new URL(url).pathname;
+  return IDENTITY_RESET_PATH_SUFFIXES.some((suffix) => path === suffix || path.endsWith(suffix));
+};
+var isEventStream = (response) => (response.headers.get("content-type") ?? "").includes("text/event-stream");
+var remember = (store, key, entry) => {
+  store.delete(key);
+  store.set(key, entry);
+  if (store.size > CONDITIONAL_RESPONSE_STORE_CAPACITY) {
+    const oldest = store.keys().next().value;
+    if (oldest !== undefined) {
+      store.delete(oldest);
+    }
+  }
+};
+var touch = (store, key) => {
+  const entry = store.get(key);
+  if (entry === undefined) {
+    return;
+  }
+  store.delete(key);
+  store.set(key, entry);
+  return entry;
+};
+var requestWithoutIfNoneMatch = (request) => {
+  const headers = new Headers;
+  for (const [name, value] of request.headers.entries()) {
+    if (name.toLowerCase() !== IF_NONE_MATCH.toLowerCase()) {
+      headers.append(name, value);
+    }
+  }
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    signal: request.signal,
+    credentials: request.credentials,
+    redirect: request.redirect
+  });
+};
+async function captureSuccessfulGet(store, key, response) {
+  if (!response.ok || isEventStream(response)) {
+    return response;
+  }
+  const etag = response.headers.get("etag")?.trim();
+  if (etag === undefined || etag.length === 0) {
+    store.delete(key);
+    return response;
+  }
+  const body = new Uint8Array(await response.arrayBuffer());
+  const headers = new Headers(response.headers);
+  headers.set("etag", etag);
+  if (body.byteLength <= CONDITIONAL_RESPONSE_MAX_BODY_BYTES) {
+    remember(store, key, { body, etag, headers });
+  }
+  return new Response(body, {
+    headers,
+    status: response.status,
+    statusText: response.statusText
+  });
+}
+function withConditionalRequests(base) {
+  const state = { store: new Map, lastIdentity: undefined };
+  const syncIdentity = (headers) => {
+    const identity = tenantOf(headers);
+    if (state.lastIdentity !== undefined && identity !== state.lastIdentity) {
+      state.store.clear();
+    }
+    state.lastIdentity = identity;
+  };
+  const decorated = async (input, init) => {
+    const request = new Request(input, init);
+    syncIdentity(request.headers);
+    if (request.method !== "GET") {
+      const response2 = await base(request);
+      if (isIdentityResetPath(request.url) && response2.ok) {
+        state.store.clear();
+        state.lastIdentity = undefined;
+      }
+      return response2;
+    }
+    const key = resourceKey(request);
+    let sent = request;
+    if (!request.headers.has(IF_NONE_MATCH)) {
+      const entry2 = touch(state.store, key);
+      if (entry2 !== undefined) {
+        const headers = new Headers(request.headers);
+        headers.set(IF_NONE_MATCH, entry2.etag);
+        sent = new Request(request, { headers });
+      }
+    }
+    const response = await base(sent);
+    if (response.status !== 304) {
+      return captureSuccessfulGet(state.store, key, response);
+    }
+    const entry = touch(state.store, key);
+    if (entry === undefined) {
+      const retried = await base(requestWithoutIfNoneMatch(sent));
+      return retried.status === 304 ? retried : captureSuccessfulGet(state.store, key, retried);
+    }
+    return new Response(new Uint8Array(entry.body), { status: 200, statusText: "OK", headers: entry.headers });
+  };
+  return {
+    fetch: decorated,
+    store: {
+      clear: () => {
+        state.store.clear();
+        state.lastIdentity = undefined;
+      }
+    }
+  };
+}
+
+// src/proxy/flat-args.ts
+function splitFlatArgs(route, input) {
+  const source = input === null || input === undefined || typeof input !== "object" ? {} : input;
+  const path = {};
+  const rest = {};
+  const pathParams = new Set(route.params);
+  for (const [key, value] of Object.entries(source)) {
+    if (pathParams.has(key)) {
+      path[key] = value;
+    } else {
+      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}`);
+  }
+  if (!route.hasPayload) {
+    return { path, query: rest, body: undefined };
+  }
+  if (input === null || input === undefined) {
+    return { path, query: {}, body: undefined };
+  }
+  for (const name of route.bodyParams) {
+    const value = path[name];
+    if (value !== undefined) {
+      rest[name] = value;
+    }
+  }
+  return { path, query: {}, body: rest };
+}
+function buildPath(route, path) {
+  return route.path.replaceAll(/:([A-Za-z0-9_]+)/gu, (_match, name) => {
+    const value = path[name];
+    return encodeURIComponent(typeof value === "string" ? value : String(value));
+  });
+}
+
+// src/proxy/transport.ts
+var CONTEXT_HEADERS = {
+  organizationId: "X-Organization-Id",
+  participant: "X-Participant",
+  executor: "X-Executor",
+  chainId: "X-Chain-Id",
+  selectedSigners: "X-Selected-Signers",
+  idempotencyKey: "Idempotency-Key"
+};
+function setNonEmptyHeader(headers, name, value) {
+  if (value !== undefined && String(value).trim().length > 0) {
+    headers.set(name, String(value));
+  }
+}
+function createDalpContextHeaders(context) {
+  const headers = new Headers;
+  setNonEmptyHeader(headers, CONTEXT_HEADERS.organizationId, context.organizationId);
+  setNonEmptyHeader(headers, CONTEXT_HEADERS.participant, context.participant);
+  setNonEmptyHeader(headers, CONTEXT_HEADERS.executor, context.executor);
+  setNonEmptyHeader(headers, CONTEXT_HEADERS.chainId, context.chainId);
+  setNonEmptyHeader(headers, CONTEXT_HEADERS.idempotencyKey, context.idempotencyKey);
+  if (context.selectedSigners !== undefined && context.selectedSigners.length > 0) {
+    headers.set(CONTEXT_HEADERS.selectedSigners, JSON.stringify(context.selectedSigners));
+  }
+  return headers;
+}
+var DEFAULT_PREFER_WAIT_SECONDS = 15;
+function createTransport(options) {
+  const baseUrl = normalizeDalpBaseUrl(String(options.baseUrl));
+  const runtime = options.runtime ?? (globalThis.window === undefined ? "server" : "browser");
+  const baseFetch = options.fetch ?? globalThis.fetch;
+  const transportFetch = runtime === "browser" ? baseFetch : withRequestBodyCompression(baseFetch);
+  const { apiKey: apiKeyOption } = options;
+  let apiKey;
+  if (apiKeyOption === undefined) {
+    apiKey = undefined;
+  } else if (apiKeyOption instanceof Secret) {
+    apiKey = apiKeyOption;
+  } else {
+    apiKey = secret(apiKeyOption.trim());
+  }
+  if (runtime === "browser" && apiKey !== undefined) {
+    throw createDalpSdkConfigurationError({
+      message: "DALP SDK: API keys are server/CLI-only credentials and cannot configure a browser client.",
+      why: "An API key placed in a browser client ships the credential to every visitor's bundle.",
+      fix: "Keep the API key on the server or CLI process; browser clients authenticate with the session cookie."
+    });
+  }
+  const sessionFetch = options.ssr === undefined ? transportFetch : createSsrFetch({
+    allowedOrigins: options.ssr.allowedOrigins,
+    baseUrl,
+    fetch: transportFetch,
+    requestHeaders: options.ssr.requestHeaders
+  });
+  const conditional = withConditionalRequests(sessionFetch);
+  return {
+    baseUrl,
+    fetch: conditional.fetch,
+    conditionalRequests: conditional.store,
+    credentials: runtime === "browser" ? "include" : "omit",
+    apiKey,
+    contextHeaders: createDalpContextHeaders(options.context ?? {}),
+    settlementTimeoutMs: options.settlementTimeoutMs
+  };
+}
+function callHeaders(transport, options) {
+  const headers = new Headers({ Accept: "application/json" });
+  if (transport.apiKey !== undefined) {
+    headers.set("X-Api-Key", unwrapSecret(transport.apiKey));
+  }
+  for (const [name, value] of transport.contextHeaders) {
+    if (!headers.has(name)) {
+      headers.set(name, value);
+    }
+  }
+  const extra = typeof options?.headers === "function" ? options.headers() : options?.headers ?? {};
+  for (const [name, value] of Object.entries(extra)) {
+    headers.set(name, value);
+  }
+  return headers;
+}
+function prepareRequest(transport, route, input, options) {
+  const split = splitFlatArgs(route, input);
+  const query = serializeDalpQuery(split.query);
+  const url = `${transport.baseUrl}/api/v2${buildPath(route, split.path)}${query === "" ? "" : `?${query}`}`;
+  const headers = callHeaders(transport, options);
+  if (split.body !== undefined) {
+    headers.set("Content-Type", "application/json");
+  }
+  if (route.queueBacked) {
+    headers.set("Prefer", `wait=${String(DEFAULT_PREFER_WAIT_SECONDS)}`);
+  }
+  return {
+    url,
+    method: route.method,
+    headers,
+    body: split.body === undefined ? undefined : JSON.stringify(split.body, wireValue)
+  };
+}
+function wireValue(_key, value) {
+  return typeof value === "bigint" ? value.toString() : value;
+}
+function readString(source, key) {
+  if (source === null || typeof source !== "object") {
+    return;
+  }
+  const value = Reflect.get(source, key);
+  return typeof value === "string" ? value : undefined;
+}
+function sdkErrorFromEnvelope(payload, response) {
+  const envelope = payload !== null && typeof payload === "object" ? payload : {};
+  const rawData = Reflect.get(envelope, "data");
+  const data = rawData !== null && typeof rawData === "object" ? rawData : {};
+  const retryable = Reflect.get(data, "retryable");
+  return new DalpSdkError({
+    code: readString(envelope, "code") ?? `sdk.transport.HTTP_${String(response.status)}`,
+    category: "dependency",
+    status: response.status,
+    retryable: typeof retryable === "boolean" ? retryable : response.status >= 500,
+    message: readString(envelope, "message") ?? `DALP API responded ${String(response.status)}`,
+    why: readString(data, "why") ?? `The platform answered ${String(response.status)}.`,
+    fix: readString(data, "fix") ?? "Inspect the response body and the request id before retrying.",
+    ...readString(data, "id") === undefined ? {} : { details: { id: readString(data, "id") } }
+  });
+}
+async function readResponse(response) {
+  const text = await response.text();
+  let payload;
+  try {
+    payload = text === "" ? undefined : JSON.parse(text);
+  } catch {
+    payload = text;
+  }
+  if (!response.ok) {
+    throw makeDalpApiError(sdkErrorFromEnvelope(payload, response));
+  }
+  return payload;
+}
+
+// src/proxy/settlement.ts
+var SUCCESS_STATE = "COMPLETED";
+var FAILURE_STATES = new Set(["FAILED", "DEAD_LETTER", "CANCELLED"]);
+var DEFAULT_SETTLEMENT_TIMEOUT_MS = 120000;
+var POLL_INTERVAL_MS = 1000;
+
+class SettlementTimeoutError extends DalpSdkError {
+  transactionId;
+  statusUrl;
+  constructor(transactionId, statusUrl, timeoutMs) {
+    super({
+      code: "sdk.settlement.TIMEOUT",
+      category: "dependency",
+      retryable: true,
+      message: `The mutation did not settle within ${String(Math.round(timeoutMs / 1000))}s and is still queued.`,
+      why: "The platform accepted the write and is still working on it. The wait ended before the work did.",
+      fix: `Follow ${statusUrl} or pass the transaction id to waitForTransaction. Do not resubmit the mutation.`,
+      details: { transactionId, statusUrl }
+    });
+    this.name = "SettlementTimeoutError";
+    this.transactionId = transactionId;
+    this.statusUrl = statusUrl;
+  }
+}
+
+class SettlementFailedError extends DalpSdkError {
+  transactionId;
+  constructor(transactionId, state, reason) {
+    super({
+      code: "sdk.settlement.FAILED",
+      category: "dependency",
+      retryable: false,
+      message: reason ?? `The mutation reached terminal state ${state}.`,
+      why: `The platform reported ${state} for transaction ${transactionId}.`,
+      fix: "Inspect the transaction request before submitting the mutation again.",
+      details: { transactionId, state }
+    });
+    this.name = "SettlementFailedError";
+    this.transactionId = transactionId;
+  }
+}
+function readString2(source, key) {
+  if (source === null || typeof source !== "object") {
+    return;
+  }
+  const value = Reflect.get(source, key);
+  return typeof value === "string" ? value : undefined;
+}
+function readHandle(payload) {
+  const body = payload !== null && typeof payload === "object" ? Reflect.get(payload, "data") ?? payload : payload;
+  const transactionId = readString2(body, "transactionId");
+  const statusUrl = readString2(body, "statusUrl");
+  if (transactionId === undefined || statusUrl === undefined) {
+    return;
+  }
+  return { transactionId, status: readString2(body, "status") ?? "QUEUED", statusUrl };
+}
+async function resolveSettlement(transport, payload, options, now = Date.now, sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+})) {
+  const handle = readHandle(payload);
+  if (handle === undefined) {
+    return payload;
+  }
+  const timeoutMs = options?.settlementTimeoutMs ?? transport.settlementTimeoutMs ?? DEFAULT_SETTLEMENT_TIMEOUT_MS;
+  let deadline = now() + timeoutMs;
+  let pollIntervalMs = POLL_INTERVAL_MS;
+  const statusUrl = handle.statusUrl.startsWith("http") ? handle.statusUrl : `${transport.baseUrl}${handle.statusUrl}`;
+  for (;; ) {
+    if (now() >= deadline) {
+      throw new SettlementTimeoutError(handle.transactionId, handle.statusUrl, timeoutMs);
+    }
+    await sleep(pollIntervalMs);
+    const response = await transport.fetch(statusUrl, {
+      method: "GET",
+      headers: callHeaders(transport, options),
+      credentials: transport.credentials,
+      ...options?.signal === undefined ? {} : { signal: options.signal }
+    });
+    const status = await readResponse(response);
+    const body = status !== null && typeof status === "object" ? Reflect.get(status, "data") ?? status : status;
+    const state = readString2(body, "status");
+    if (state === SUCCESS_STATE) {
+      return status;
+    }
+    if (state !== undefined && FAILURE_STATES.has(state)) {
+      throw new SettlementFailedError(handle.transactionId, state, readString2(body, "errorMessage"));
+    }
+    if (readsAsFundingPaused(body)) {
+      deadline = now() + timeoutMs;
+      pollIntervalMs = Math.min(pollIntervalMs * 2, PAUSED_POLL_INTERVAL_MAX_MS);
+    } else {
+      pollIntervalMs = POLL_INTERVAL_MS;
+    }
+  }
+}
+
+// src/proxy/sse.ts
+var RESERVED_STREAM_FAILURE_EVENT = "effect/httpapi/stream/failure";
+var STREAM_FAILED_ERROR_CODE = "sdk.stream.FAILED";
+function parseFrame(raw) {
+  try {
+    return JSON.parse(raw.data);
+  } catch {
+    return raw.data;
+  }
+}
+function dispatchFrame(raw) {
+  if (raw.event === RESERVED_STREAM_FAILURE_EVENT) {
+    throw makeDalpApiError(new DalpSdkError({
+      code: STREAM_FAILED_ERROR_CODE,
+      category: "dependency",
+      retryable: true,
+      message: "The DALP API stream failed before it completed.",
+      why: "The route ended the stream with its reserved failure event, so the remaining frames were never sent.",
+      fix: "Retry the stream. If it fails again, read the route's logs for the failure the server recorded.",
+      details: { cause: raw.data }
+    }));
+  }
+  return parseFrame(raw);
+}
+function readBlock(block) {
+  let event = "message";
+  const data = [];
+  for (const line of block.split(`
+`)) {
+    if (line === "" || line.startsWith(":")) {
+      continue;
+    }
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    const rest = separator === -1 ? "" : line.slice(separator + 1).replace(/^ /u, "");
+    if (field === "event") {
+      event = rest;
+    } else if (field === "data") {
+      data.push(rest);
+    }
+  }
+  return data.length === 0 ? undefined : { event, data: data.join(`
+`) };
+}
+async function* decodeEventStream(body) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    for (;; ) {
+      const chunk = await reader.read();
+      if (chunk.done) {
+        break;
+      }
+      buffer += decoder.decode(chunk.value, { stream: true });
+      buffer = buffer.replaceAll(`\r
+`, `
+`);
+      let boundary = buffer.indexOf(`
+
+`);
+      while (boundary !== -1) {
+        const raw = readBlock(buffer.slice(0, boundary));
+        buffer = buffer.slice(boundary + 2);
+        if (raw !== undefined) {
+          yield dispatchFrame(raw);
+        }
+        boundary = buffer.indexOf(`
+
+`);
+      }
+    }
+    const trailing = readBlock(buffer);
+    if (trailing !== undefined) {
+      yield dispatchFrame(trailing);
+    }
+  } finally {
+    await reader.cancel().catch(() => {});
+  }
+}
+async function* streamRequest(transport, route, input, options) {
+  const prepared = prepareRequest(transport, route, input, options);
+  prepared.headers.set("Accept", "text/event-stream");
+  const response = await transport.fetch(prepared.url, {
+    method: prepared.method,
+    headers: prepared.headers,
+    credentials: transport.credentials,
+    ...prepared.body === undefined ? {} : { body: prepared.body },
+    ...options?.signal === undefined ? {} : { signal: options.signal }
+  });
+  if (!response.ok) {
+    await readResponse(response);
+    return;
+  }
+  if (response.body === null) {
+    return;
+  }
+  yield* decodeEventStream(response.body);
+}
+
+// src/proxy/fetch-executor.ts
+async function sendRequest(transport, route, input, options) {
+  const prepared = prepareRequest(transport, route, input, options);
+  const response = await transport.fetch(prepared.url, {
+    method: prepared.method,
+    headers: prepared.headers,
+    credentials: transport.credentials,
+    ...prepared.body === undefined ? {} : { body: prepared.body },
+    ...options?.signal === undefined ? {} : { signal: options.signal }
+  });
+  const payload = await readResponse(response);
+  if (!route.queueBacked || response.status !== 202) {
+    return payload;
+  }
+  return resolveSettlement(transport, payload, options);
+}
+function createFetchExecutor(transport) {
+  return (route, _id, input, options) => route.serializer === "sse" ? streamRequest(transport, route, input, options) : sendRequest(transport, route, input, options);
+}
+
+// src/proxy/tanstack.ts
+function canonicalize(value) {
+  if (Array.isArray(value)) {
+    return value.map(canonicalize);
+  }
+  if (value === null || typeof value !== "object") {
+    return value;
+  }
+  const entries = [];
+  for (const key of Object.keys(value).sort((left, right) => left.localeCompare(right))) {
+    const entry = Reflect.get(value, key);
+    if (entry !== undefined) {
+      entries.push([key, canonicalize(entry)]);
+    }
+  }
+  return Object.fromEntries(entries);
+}
+function queryKeyFor(id, input) {
+  const canonical = canonicalize(input);
+  return canonical === undefined ? ["dalp", id] : ["dalp", id, canonical];
+}
+var UI_SETTLEMENT_TIMEOUT_MS = 30000;
+function createTanstackFactories(transport) {
+  return {
+    queryOptions: (route, id, input, options) => ({
+      queryKey: queryKeyFor(id, input),
+      queryFn: (context) => sendRequest(transport, route, 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_MS, ...options })
+    })
+  };
+}
+
+export { DalpApiError, isDalpApiError, findDalpSdkError, makeDalpApiError, createDalpContextHeaders, createTransport, DEFAULT_SETTLEMENT_TIMEOUT_MS, SettlementTimeoutError, SettlementFailedError, RESERVED_STREAM_FAILURE_EVENT, STREAM_FAILED_ERROR_CODE, decodeEventStream, streamRequest, sendRequest, createFetchExecutor, canonicalize, queryKeyFor, UI_SETTLEMENT_TIMEOUT_MS, createTanstackFactories };