@settlemint/dalp-sdk 3.1.18 → 3.1.19-main.34482536277

package/dist/chunk-sk9nc2q3.js

@@ -0,0 +1,10 @@
+// src/reads-as-indexer-rebuild.ts
+function readsAsIndexerRebuild2(status) {
+  if (status === null || typeof status !== "object") {
+    return false;
+  }
+  const rebuild = Reflect.get(status, "indexerRebuild");
+  return rebuild !== undefined && rebuild !== null;
+}
+
+export { readsAsIndexerRebuild2 };

package/dist/chunk-xp3fx2yt.js

@@ -0,0 +1,63 @@
+import {
+  createDalpSdkConfigurationError2
+} from "./chunk-j4sxrfzz.js";
+
+// src/secret.ts
+var SECRET_REDACTION_MARKER2 = "[REDACTED]";
+var inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+var secretValue = new WeakMap;
+
+class Secret2 {
+  constructor(value) {
+    secretValue.set(this, value);
+    Object.freeze(this);
+  }
+  static from(value) {
+    if (value.trim().length === 0) {
+      throw new TypeError("DALP SDK: a secret value must not be empty.");
+    }
+    return new Secret2(value);
+  }
+  toString() {
+    return SECRET_REDACTION_MARKER2;
+  }
+  toJSON() {
+    return SECRET_REDACTION_MARKER2;
+  }
+  [inspectSymbol]() {
+    return SECRET_REDACTION_MARKER2;
+  }
+}
+var secret2 = (value) => Secret2.from(value);
+var unwrapSecret = (value) => {
+  const raw = secretValue.get(value);
+  if (raw === undefined) {
+    throw new TypeError("DALP SDK: cannot unwrap an invalid secret value.");
+  }
+  return raw;
+};
+
+// src/url.ts
+function normalizeDalpBaseUrl(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch (error) {
+    throw createDalpSdkConfigurationError2({
+      message: `DALP SDK: invalid url "${url}". Provide a full URL including the protocol (e.g., "https://dalp.example.com").`,
+      why: "The SDK could not parse the configured DALP API URL.",
+      fix: 'Provide a full http:// or https:// URL, for example "https://dalp.example.com".',
+      cause: error
+    });
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw createDalpSdkConfigurationError2({
+      message: `DALP SDK: url must use https:// or http:// protocol, got "${parsed.protocol}".`,
+      why: `The SDK received a URL with the unsupported "${parsed.protocol}" protocol.`,
+      fix: 'Use a DALP API base URL that starts with "https://" or "http://".'
+    });
+  }
+  return `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+
+export { SECRET_REDACTION_MARKER2, Secret2, secret2, unwrapSecret, normalizeDalpBaseUrl };

package/dist/chunk-ybqqdgrd.js

@@ -0,0 +1,260 @@
+// src/transport/cookie-store.ts
+var parseCookieHeader = (header) => {
+  const cookies = new Map;
+  for (const part of header.split(";")) {
+    const pair = part.trim();
+    const separator = pair.indexOf("=");
+    if (separator > 0) {
+      cookies.set(pair.slice(0, separator), pair);
+    }
+  }
+  return cookies;
+};
+var isCookieDeletion = (setCookie, now = Date.now()) => {
+  if (/\bmax-age\s*=\s*-?0+\b/iu.test(setCookie) || /\bmax-age\s*=\s*-\d+\b/iu.test(setCookie)) {
+    return true;
+  }
+  const expires = /\bexpires\s*=\s*([^;]+)/iu.exec(setCookie)?.[1];
+  if (expires === undefined) {
+    return false;
+  }
+  const parsed = Date.parse(expires.trim());
+  return !Number.isNaN(parsed) && parsed <= now;
+};
+function makeCookieStore2(initialHeader = "") {
+  const cookies = parseCookieHeader(initialHeader);
+  return {
+    header: () => [...cookies.values()].join("; "),
+    isEmpty: () => cookies.size === 0,
+    setCookieHeader: (header) => {
+      cookies.clear();
+      for (const [name, pair] of parseCookieHeader(header)) {
+        cookies.set(name, pair);
+      }
+    },
+    storeSetCookieHeaders: (headers) => {
+      for (const setCookie of headers) {
+        const pair = setCookie.split(";", 1)[0]?.trim() ?? "";
+        const separator = pair.indexOf("=");
+        if (separator <= 0) {
+          continue;
+        }
+        const name = pair.slice(0, separator);
+        if (isCookieDeletion(setCookie)) {
+          cookies.delete(name);
+        } else {
+          cookies.set(name, pair);
+        }
+      }
+    }
+  };
+}
+var getSetCookieHeaders = (headers) => {
+  const { getSetCookie } = headers;
+  if (getSetCookie !== undefined) {
+    return getSetCookie.call(headers);
+  }
+  const value = headers.get("set-cookie");
+  return value === null ? [] : splitCombinedSetCookie(value);
+};
+var splitCombinedSetCookie = (value) => {
+  const cookies = [];
+  const lowered = value.toLowerCase();
+  let start = 0;
+  let inExpires = false;
+  for (let index = 0;index < value.length; index += 1) {
+    if (lowered.startsWith("expires=", index)) {
+      inExpires = true;
+    }
+    const character = value[index];
+    if (character === ";") {
+      inExpires = false;
+    }
+    if (character !== "," || inExpires) {
+      continue;
+    }
+    const next = value.slice(index + 1);
+    if (!/^\s*[\w!#$%&'*+\-.^`|~]+=/u.test(next)) {
+      continue;
+    }
+    cookies.push(value.slice(start, index).trim());
+    start = index + 1;
+  }
+  const finalCookie = value.slice(start).trim();
+  if (finalCookie.length > 0) {
+    cookies.push(finalCookie);
+  }
+  return cookies;
+};
+function createCookieStoreFetch2(cookieStore, fetchImpl = globalThis.fetch) {
+  return async (input, init) => {
+    const headers = new Headers(init?.headers ?? (input instanceof Request ? input.headers : undefined));
+    if (!cookieStore.isEmpty() && !headers.has("cookie")) {
+      headers.set("cookie", cookieStore.header());
+    }
+    const response = await fetchImpl(input, { ...init, headers });
+    if (response.status < 500) {
+      cookieStore.storeSetCookieHeaders(getSetCookieHeaders(response.headers));
+    }
+    return response;
+  };
+}
+// package.json
+var package_default = {
+  name: "@settlemint/dalp-sdk",
+  version: "3.1.19-main.34482536277",
+  private: false,
+  description: "Fully typed SDK for the DALP tokenization platform API",
+  homepage: "https://settlemint.com",
+  bugs: {
+    email: "support@settlemint.com"
+  },
+  license: "SEE LICENSE IN LICENSE",
+  author: {
+    name: "SettleMint",
+    email: "support@settlemint.com",
+    url: "https://settlemint.com"
+  },
+  files: [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  type: "module",
+  sideEffects: [
+    "./src/**"
+  ],
+  exports: {
+    "./package.json": "./package.json",
+    "./runtime-exports": {
+      types: "./dist/runtime-exports.d.ts",
+      import: "./dist/runtime-exports.js",
+      default: "./dist/runtime-exports.js"
+    },
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.js",
+      default: "./dist/index.js"
+    },
+    "./types": {
+      types: "./dist/types.d.ts",
+      import: "./dist/types.js",
+      default: "./dist/types.js"
+    },
+    "./scalars": {
+      types: "./dist/scalars/index.d.ts",
+      import: "./dist/scalars/index.js",
+      default: "./dist/scalars/index.js"
+    },
+    "./react-query": {
+      types: "./dist/react-query.d.ts",
+      import: "./dist/react-query.js",
+      default: "./dist/react-query.js"
+    },
+    "./auth": {
+      types: "./dist/auth.d.ts",
+      import: "./dist/auth.js",
+      default: "./dist/auth.js"
+    },
+    "./bundler": {
+      types: "./dist/bundler.d.ts",
+      import: "./dist/bundler.js",
+      default: "./dist/bundler.js"
+    },
+    "./verify-webhook": {
+      types: "./dist/verify-webhook.d.ts",
+      import: "./dist/verify-webhook.js",
+      default: "./dist/verify-webhook.js"
+    },
+    "./wait-for-transaction": {
+      types: "./dist/wait-for-transaction.d.ts",
+      import: "./dist/wait-for-transaction.js",
+      default: "./dist/wait-for-transaction.js"
+    },
+    "./sdk-error": {
+      types: "./dist/errors/sdk-error.d.ts",
+      import: "./dist/errors/sdk-error.js",
+      default: "./dist/errors/sdk-error.js"
+    },
+    "./sign-webhook-receipt": {
+      types: "./dist/sign-webhook-receipt.d.ts",
+      import: "./dist/sign-webhook-receipt.js",
+      default: "./dist/sign-webhook-receipt.js"
+    },
+    "./effect": {
+      types: "./dist/effect.d.ts",
+      import: "./dist/effect.js",
+      default: "./dist/effect.js"
+    },
+    "./routes": {
+      types: "./dist/routes/index.d.ts",
+      import: "./dist/routes/index.js",
+      default: "./dist/routes/index.js"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    build: "bun scripts/build.ts && bun scripts/check-dts-portability.ts",
+    codegen: "bun scripts/codegen.ts",
+    publint: "publint run --strict --pack bun",
+    attw: 'archive=$(bun pm pack --destination "$PWD" --quiet | tail -n 1) && attw "$archive" --profile esm-only; code=$?; rm -f "$archive"; exit $code',
+    publish: 'cp ../../LICENSE . && bun run --cwd ../.. publish-if-absent "$PWD"',
+    prepack: "cp ../../LICENSE .",
+    test: "bun --bun vitest run --config node_modules/@tools/vitest-config/vitest.config.mjs --configLoader native --project unit --project browser --testTimeout 30000 tests/unit",
+    "test:coverage": "bun --bun vitest run --config node_modules/@tools/vitest-config/vitest.config.mjs --configLoader native --project unit --project browser --testTimeout 30000 tests/unit --coverage",
+    lint: "oxlint --deny-warnings .",
+    typecheck: "tsc -p . && tsc --noEmit -p scripts/tsconfig.json",
+    "check:dts-portability": "bun scripts/check-dts-portability.ts",
+    "check:auth-coverage": "bun scripts/check-auth-coverage.ts",
+    "codegen:webhook-events-sdk": "bun scripts/generate-webhook-events-sdk.ts"
+  },
+  dependencies: {
+    "@better-auth/api-key": "1.7.2",
+    "@better-auth/passkey": "1.7.2",
+    "better-auth": "1.7.2",
+    "better-call": "1.4.0",
+    dnum: "2.17.0",
+    standardwebhooks: "1.1.1",
+    viem: "2.56.3"
+  },
+  devDependencies: {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@core/schema": "workspace:*",
+    "@tanstack/react-query": "5.102.8",
+    "@tools/typescript-config": "workspace:*",
+    "@tools/vitest-config": "workspace:*",
+    "@types/bun": "catalog:toolchain",
+    effect: "catalog:effect",
+    publint: "0.3.24",
+    typescript: "7.0.2",
+    vitest: "catalog:toolchain",
+    zod: "4.5.4"
+  },
+  peerDependencies: {
+    "@tanstack/react-query": "^5.101.4",
+    effect: "^4.0.0-rc.112",
+    zod: "^4.5.4"
+  },
+  peerDependenciesMeta: {
+    "@tanstack/react-query": {
+      optional: true
+    },
+    effect: {
+      optional: true
+    },
+    zod: {
+      optional: true
+    }
+  },
+  engines: {
+    node: ">=20"
+  }
+};
+
+// src/version.ts
+var SDK_VERSION2 = package_default.version;
+var SDK_USER_AGENT2 = `DALP SDK v${SDK_VERSION2}`;
+
+export { makeCookieStore2, createCookieStoreFetch2, SDK_VERSION2, SDK_USER_AGENT2 };

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

@@ -0,0 +1,30 @@
+/**
+ * Conditional GET, as a fetch decorator.
+ *
+ * The policy is unchanged from the interceptor pair this replaces: hold the
+ * ETag and body of a successful GET, send `If-None-Match` on the next one, and
+ * serve the held body on a 304. Only the attachment point moved, from a
+ * generated client's interceptor list to the fetch the transport already wraps
+ * for compression and SSR.
+ */
+import type { DalpFetch } from "./ssr-fetch.ts";
+/** Handle a caller holds so it can clear the store on sign-out or org switch. */
+export interface ConditionalRequestStore {
+    readonly clear: () => void;
+}
+/**
+ * Wrap `fetch` with the If-None-Match / 304 rewrite pair for conditional GET.
+ *
+ * Server ETags must be strong content digests computed after authorization
+ * inside the requester's partition. The dapi response cache guarantees this:
+ * `encodeResponseCacheEntry` sets `etag` to the SHA-256 of the serialized
+ * body after the request-context middleware has authenticated the session.
+ * Version-stamp ETags (generation counters, watermarks, table versions) are
+ * forbidden for conditional-request adopters: a stamp can collide across
+ * tenants or lag a body change and would let this store serve another
+ * partition's bytes as a 200.
+ */
+export declare function withConditionalRequests(base: DalpFetch): {
+    fetch: DalpFetch;
+    store: ConditionalRequestStore;
+};

package/dist/client/factory.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The client factory.
+ *
+ * The transport policy this used to assemble around the generated client now
+ * lives in `../proxy/transport.ts`, which both interpreters share. This module
+ * stays as the published entry point's seam so a consumer's import path did not
+ * move with the internals.
+ *
+ * @module
+ */
+export { createDalpClient, type DalpClient } from "../proxy/client.ts";
+export { createDalpContextHeaders } from "../proxy/transport.ts";
+export type { CreateDalpClientOptions, DalpClientContext, DalpSsrOptions, Transport } from "../proxy/transport.ts";
+export type { DalpFetch } from "./ssr-fetch.ts";

package/dist/client/query-serializer.d.ts

@@ -0,0 +1,2 @@
+/** Serialize generated SDK query objects with recursive OpenAPI deepObject keys. */
+export declare function serializeDalpQuery(query: unknown): string;

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 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/client/ssr-fetch.d.ts

@@ -0,0 +1,12 @@
+/** Minimal fetch shape — Bun's `typeof fetch` also requires `preconnect`. */
+export type DalpFetch = ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & {
+    readonly preconnect?: typeof fetch.preconnect;
+};
+export interface CreateSsrFetchOptions {
+    readonly allowedOrigins?: ReadonlyArray<string | URL>;
+    readonly baseUrl: string | URL;
+    readonly fetch: DalpFetch;
+    readonly requestHeaders: HeadersInit;
+}
+/** Direct destinations must be approved; unapproved redirects lose all caller credentials and context. */
+export declare function createSsrFetch(options: CreateSsrFetchOptions): DalpFetch;

package/dist/effect.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The Effect call surface.
+ *
+ * The same namespaced tree as the root entry, returning `Effect` values instead
+ * of promises. It exists because the CLI and other code under our control want
+ * Effect, and hiding it behind promises there would mean unwrapping and
+ * rewrapping at every boundary.
+ *
+ * This is the only SDK export that exposes Effect values. The root export
+ * remains Promise-based.
+ *
+ * Errors are tagged from the wire envelope rather than decoded from per-route
+ * schemas. The envelope is identical across every route (`code`, `status`,
+ * `message`, and a `data` carrying the stable DALP id), so one reader covers
+ * 759 routes, and no runtime schema ships.
+ *
+ * @module
+ */
+import * as Effect from "effect/Effect";
+import type { DalpApi, DalpRouteId, DalpRouteTypes } from "./generated/api-types.d.ts";
+import { type CallOptions } from "./proxy/builder.ts";
+import { type CreateDalpClientOptions } from "./proxy/transport.ts";
+import { DalpApiError } from "./errors/api-error.ts";
+/** The failure channel every route call carries. */
+export declare class DalpRequestError extends Error {
+    readonly _tag = "DalpRequestError";
+    /** Stable DALP error id when the platform supplied one, else the SDK code. */
+    readonly id: string;
+    /** The DALP error code, mirroring `DalpApiError.code`. */
+    readonly code: string;
+    readonly status: number | undefined;
+    readonly retryable: boolean;
+    /**
+     * The server's requested delay before a retry, when it sent `Retry-After`.
+     *
+     * A retryable failure without this is a caller guessing at a backoff the
+     * server already named, so it travels with `retryable` rather than staying
+     * behind on the promise client's `DalpApiError`.
+     */
+    readonly retryAfterSeconds: number | undefined;
+    readonly routeId: string;
+    /** The wire envelope's route-specific `data`, e.g. `requiredRoles` on a role-gated 403. */
+    readonly data: DalpApiError["data"];
+    constructor(routeId: string, cause: unknown);
+}
+/** The Effect-shaped mirror of `DalpApi`. */
+export type DalpEffectApi = DalpEffectApiNode<DalpApi>;
+/**
+ * A stream leaf answers with its frame sequence rather than one body, so it is
+ * matched before the promise leaf: its call signature returns an `AsyncIterable`
+ * and would otherwise fall through to the recursive branch, which maps a call
+ * signature to an object with no keys and leaves the route uncallable.
+ */
+type DalpEffectApiNode<T> = {
+    readonly [K in keyof T]: T[K] extends (...args: infer Args) => AsyncIterable<infer Frame> ? (...args: Args) => Effect.Effect<AsyncIterable<Frame>, DalpRequestError> : T[K] extends (...args: infer Args) => Promise<infer A> ? (...args: Args) => Effect.Effect<A, DalpRequestError> : DalpEffectApiNode<T[K]>;
+};
+/** The routes that answer with `text/event-stream`, named by the route table. */
+export type DalpStreamingRouteId = {
+    [Id in DalpRouteId]: DalpRouteTypes[Id]["streaming"] extends true ? Id : never;
+}[DalpRouteId];
+export interface DalpEffectClient {
+    readonly api: DalpEffectApi;
+    /**
+     * Two signatures rather than one conditional return type. A caller generic over
+     * the streaming routes has to resolve the frame sequence from its own
+     * constraint, and a conditional keyed on `Id` stays unresolved until `Id` is a
+     * single route, which is what pushed every such caller into an assertion.
+     */
+    readonly execute: {
+        <Id extends DalpStreamingRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions): Effect.Effect<AsyncIterable<DalpRouteTypes[Id]["response"]>, DalpRequestError>;
+        <Id extends DalpRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions): Effect.Effect<DalpRouteTypes[Id]["response"], DalpRequestError>;
+    };
+}
+/** Create the Effect client. Same routes, same transport, different channel. */
+export declare function createDalpEffectClient(options: CreateDalpClientOptions): DalpEffectClient;
+export type { CallOptions } from "./proxy/builder.ts";
+export type { CreateDalpClientOptions } from "./proxy/transport.ts";
+export type { DalpRouteId, DalpRouteTypes } from "./generated/api-types.d.ts";

package/dist/effect.js

@@ -0,0 +1,87 @@
+import {
+  data
+} from "./chunk-09prmw53.js";
+import"./chunk-j4sxrfzz.js";
+import {
+  DalpApiError2,
+  createTransport,
+  streamRequest,
+  sendRequest,
+  queryKeyFor2
+} from "./chunk-shp8v4ws.js";
+import"./chunk-xp3fx2yt.js";
+import {
+  buildProxy,
+  findRoute
+} from "./chunk-rb8k4w3q.js";
+
+// src/effect.ts
+import * as Effect from "effect/Effect";
+class DalpRequestError extends Error {
+  _tag = "DalpRequestError";
+  id;
+  code;
+  status;
+  retryable;
+  retryAfterSeconds;
+  routeId;
+  data;
+  constructor(routeId, cause) {
+    const api = cause instanceof DalpApiError2 ? cause : undefined;
+    super(api?.message ?? `DALP request failed for ${routeId}`, { cause });
+    this.name = "DalpRequestError";
+    this._tag = "DalpRequestError";
+    this.routeId = routeId;
+    this.code = api?.code ?? "sdk.transport.REQUEST_FAILED";
+    this.id = api?.id ?? this.code;
+    this.status = api?.status;
+    this.retryable = api?.retryable ?? true;
+    this.retryAfterSeconds = api?.retryAfterSeconds;
+    this.data = api?.data;
+  }
+}
+function runRoute(transport, route, id, input, options) {
+  return Effect.callback((resume) => {
+    const controller = new AbortController;
+    const signal = options?.signal ?? controller.signal;
+    const run = async () => {
+      try {
+        resume(Effect.succeed(route.serializer === "sse" ? streamRequest(transport, route, input, { ...options, signal }) : await sendRequest(transport, route, input, { ...options, signal })));
+      } catch (error) {
+        resume(Effect.fail(new DalpRequestError(id, error)));
+      }
+    };
+    run();
+    return Effect.sync(() => {
+      controller.abort();
+    });
+  });
+}
+function createDalpEffectClient(options) {
+  const transport = createTransport(options);
+  const executor = (route, id, input, callOptions) => runRoute(transport, route, id, input, callOptions);
+  const factories = {
+    queryOptions: (route, id, input, callOptions) => ({
+      queryKey: queryKeyFor2(id, input),
+      queryFn: () => runRoute(transport, route, id, input, callOptions)
+    }),
+    mutationOptions: (route, id, callOptions) => ({
+      mutationKey: ["dalp", id],
+      mutationFn: (input) => runRoute(transport, route, id, input, callOptions)
+    })
+  };
+  return {
+    api: buildProxy(data, executor, factories),
+    execute: (routeId, input, callOptions) => {
+      const route = findRoute(data, routeId);
+      if (route === undefined) {
+        return Effect.fail(new DalpRequestError(routeId, new TypeError(`Unknown DALP route \`${routeId}\``)));
+      }
+      return runRoute(transport, route, routeId, input, callOptions);
+    }
+  };
+}
+export {
+  DalpRequestError,
+  createDalpEffectClient
+};

package/dist/errors/api-error.d.ts

@@ -0,0 +1,33 @@
+import { findCurrentError } from "./find-current-error.ts";
+import type { DalpSdkErrorDetails } from "./sdk-error.ts";
+export type DalpApiErrorCategory = "client" | "auth" | "permission" | "domain" | "contract" | "dependency" | "operational" | "config" | "unknown";
+export interface DalpApiErrorOptions {
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly id?: string;
+    readonly code: string;
+    readonly category: DalpApiErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly retryAfterSeconds?: number;
+    readonly data?: DalpSdkErrorDetails;
+}
+export declare class DalpApiError extends Error {
+    readonly id?: string;
+    readonly code: string;
+    readonly category: DalpApiErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly retryAfterSeconds?: number;
+    /** The wire envelope's route-specific `data`, e.g. `requiredRoles` on a role-gated 403. */
+    readonly data?: DalpSdkErrorDetails;
+    constructor(options: DalpApiErrorOptions);
+    static make(options: DalpApiErrorOptions): DalpApiError;
+}
+export declare const isDalpApiError: (error: unknown) => error is DalpApiError;
+export declare const findDalpSdkError: typeof findCurrentError;
+export declare const makeDalpApiError: (error: unknown) => DalpApiError;

package/dist/errors/find-current-error.d.ts

@@ -0,0 +1,8 @@
+import { DalpSdkError } from "./sdk-error.ts";
+/**
+ * Walk a nested SDK error graph and return the first DalpSdkError.
+ *
+ * Follows `cause` and `reasons[].error` / `reasons[].defect`. Stops after
+ * `maxNodes` so a cyclic wrapper cannot loop forever.
+ */
+export declare const findCurrentError: (error: unknown, maxNodes?: number) => DalpSdkError | undefined;