@settlemint/dalp-sdk 3.1.4-main.32581911907 → 3.1.4-main.32583419224

package/dist/auth.js

@@ -2,7 +2,7 @@ import {
   SDK_USER_AGENT,
   createCookieStoreFetch,
   makeCookieStore
-} from "./chunk-vsahxaj9.js";
+} from "./chunk-w22a1b41.js";
 import {
   normalizeDalpBaseUrl,
   secret,

package/dist/bundler.js

@@ -1,6 +1,6 @@
 import {
   createDalpClient
-} from "./chunk-d8fp1mkr.js";
+} from "./chunk-cy9b59s6.js";
 import {
   v2TransactionsBundlerEstimateUserOperationGas,
   v2TransactionsBundlerGetChainId,

package/dist/{chunk-d8fp1mkr.js → chunk-cy9b59s6.js}

@@ -195,6 +195,127 @@ function serializeDalpQuery(query) {
   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";
@@ -331,8 +452,9 @@ function createDalpContextHeaders(context) {
 }
 function createDalpClient(options) {
   const baseUrl = normalizeDalpBaseUrl(String(options.baseUrl));
-  const fetchImpl = options.fetch ?? globalThis.fetch;
   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) {
@@ -349,10 +471,10 @@ function createDalpClient(options) {
       fix: "Keep the API key on the server or CLI process; browser clients authenticate with the session cookie."
     });
   }
-  const resolvedFetch = options.ssr === undefined ? fetchImpl : createSsrFetch({
+  const resolvedFetch = options.ssr === undefined ? transportFetch : createSsrFetch({
     allowedOrigins: options.ssr.allowedOrigins,
     baseUrl,
-    fetch: fetchImpl,
+    fetch: transportFetch,
     requestHeaders: options.ssr.requestHeaders
   });
   const client = createClient({

package/dist/{chunk-vsahxaj9.js → chunk-w22a1b41.js}

@@ -102,7 +102,7 @@ function createCookieStoreFetch(cookieStore, fetchImpl = globalThis.fetch) {
 // package.json
 var package_default = {
   name: "@settlemint/dalp-sdk",
-  version: "3.1.4-main.32581911907",
+  version: "3.1.4-main.32583419224",
   private: false,
   description: "Fully typed SDK for the DALP tokenization platform API",
   homepage: "https://settlemint.com",

package/dist/client/request-compression.d.ts

@@ -0,0 +1,47 @@
+import type { DalpFetch } from "./ssr-fetch.ts";
+/**
+ * Request-body compression for DALP server/CLI clients.
+ *
+ * Bun 1.4 added a `compress` fetch option: it compresses a buffered body
+ * before sending and sets `Content-Encoding` on the wire. This wrapper opts
+ * eligible outgoing bodies into gzip so big JSON payloads shrink in transit;
+ * the receiving DAPI host decodes them at its boundary
+ * (`@dapi/server/request-body-decoding`), so callers need no per-route work.
+ *
+ * Eligibility mirrors what the transport can actually do:
+ *
+ * - Only body-bearing methods (`GET`/`HEAD` never).
+ * - Bodies already carrying `Content-Encoding`, or an explicit caller
+ *   `compress`, pass through untouched.
+ * - With `(url, init)` the body must be one of Bun's buffered types
+ *   (string, ArrayBuffer, TypedArray/DataView, Blob) and fall inside the
+ *   size window — gzip framing dominates tiny payloads, and huge explicitly
+ *   sized bodies stay uncompressed (the DAPI decode cap mirrors this bound).
+ * - Streams, `FormData`, and `URLSearchParams` pass through: the transport
+ *   forwards streaming bodies unchanged.
+ * - A `Request` instance is measured through a bounded clone before compression.
+ */
+/** Bodies smaller than this stay uncompressed; gzip framing dominates tiny JSON. */
+export declare const DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES = 1024;
+/** Explicitly-sized bodies larger than this are sent uncompressed. */
+export declare const DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES = 16777216;
+/**
+ * Bun's `compress` fetch option. bun-types 1.4.0 still types `RequestInit`
+ * from lib.dom without it, so the field is declared here and set through one
+ * narrow cast at the transport seam.
+ */
+export type FetchRequestCompression = true | "gzip" | "deflate" | "br" | "zstd";
+export interface CompressionRequestInit extends RequestInit {
+    readonly compress?: FetchRequestCompression;
+}
+export interface RequestBodyCompressionOptions {
+    /** Test seam overriding DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES. */
+    readonly minBodyBytes?: number;
+    /** Test seam overriding DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES. */
+    readonly maxBodyBytes?: number;
+}
+/**
+ * Wrap a fetch seam so eligible request bodies travel gzip-compressed.
+ * Ineligible calls forward the original arguments untouched.
+ */
+export declare function withRequestBodyCompression(fetchImpl: DalpFetch, options?: RequestBodyCompressionOptions): DalpFetch;

package/dist/index.d.ts

@@ -13,6 +13,7 @@
  * @module
  */
 export { createDalpClient, createDalpContextHeaders } from "./client/factory.ts";
+export type { CompressionRequestInit } from "./client/request-compression.ts";
 export type { CreateDalpClientOptions, DalpClientContext, DalpSsrOptions } from "./client/factory.ts";
 export { clearConditionalRequestStore } from "./client/conditional-request.ts";
 export { createCookieStoreFetch, makeCookieStore } from "./transport/cookie-store.ts";

package/dist/index.js

@@ -3,12 +3,12 @@ import {
   SDK_VERSION,
   createCookieStoreFetch,
   makeCookieStore
-} from "./chunk-vsahxaj9.js";
+} from "./chunk-w22a1b41.js";
 import {
   clearConditionalRequestStore,
   createDalpClient,
   createDalpContextHeaders
-} from "./chunk-d8fp1mkr.js";
+} from "./chunk-cy9b59s6.js";
 import"./chunk-w21k7p99.js";
 import {
   SECRET_REDACTION_MARKER,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@settlemint/dalp-sdk",
-  "version": "3.1.4-main.32581911907",
+  "version": "3.1.4-main.32583419224",
   "private": false,
   "description": "Fully typed SDK for the DALP tokenization platform API",
   "homepage": "https://settlemint.com",