@settlemint/dalp-sdk 3.1.19-main.35674213996 → 3.1.19-main.35680085175

package/dist/auth/client.d.ts

@@ -4,15 +4,6 @@ import { Secret } from "../secret.ts";
 import type { CookieStoreShape } from "../transport/cookie-store.ts";
 export interface DalpAuthClientConfig {
     readonly url: string;
-    /**
-     * API key sent as `x-api-key`. The `/api/auth` routes admit a key on 8 read
-     * routes only: `GET /get-session`, `GET /organization/list`,
-     * `GET /organization/get-full-organization`, `GET /organization/list-members`,
-     * `POST /organization/has-permission`, `GET /api-key/list`, `GET /api-key/get`,
-     * and `GET /passkey/list-user-passkeys`. Every other auth route answers a key
-     * with HTTP 403 and code `API_KEY_NOT_SUPPORTED_ON_ROUTE`; use a session
-     * cookie for those.
-     */
     readonly apiKey?: string;
     readonly cookie?: string;
     readonly cookieStore?: CookieStoreShape;
@@ -58,7 +49,6 @@ export interface DalpOrganizationMembersQuery {
     readonly organizationId?: string;
     readonly organizationSlug?: string;
 }
-/** Invitation row from Better Auth `listInvitations` / `listUserInvitations`. */
 export interface DalpOrganizationInvitation {
     readonly id: string;
     readonly organizationId: string;
@@ -70,13 +60,6 @@ export interface DalpOrganizationInvitation {
 export interface DalpOrganizationInvitationsQuery {
     readonly organizationId?: string;
 }
-/**
- * Stable Better Auth operation types composed into `DalpAuthClient`.
- *
- * This is not a separate runtime client — `createDalpAuthClient` returns
- * `DalpAuthClient`, which also includes wallet plugins. Keep this interface as
- * the typed non-wallet surface so inference stays explicit; do not construct it.
- */
 export interface DalpCliAuthClient {
     readonly getSession: DalpNoInputAuthOperation<GetSessionResponse>;
     readonly listSessions: DalpNoInputAuthOperation<ListUserSessionsResponse>;

package/dist/auth/live.d.ts

@@ -4,7 +4,6 @@ import { type AuthClient, type BetterAuthClientOptions } from "better-auth/clien
 import { adminClient, customSessionClient, deviceAuthorizationClient, inferAdditionalFields, organizationClient, twoFactorClient } from "better-auth/client/plugins";
 import { type DalpAuthClientConfig, type DalpCliAuthClient } from "./client.ts";
 import { type DalpWalletAuthClient, walletPincodeClient, walletSecretCodesClient, walletTwoFactorClient } from "./wallet-plugins.ts";
-/** The platform permission catalog and role set the admin plugin checks against. */
 declare const adminPluginOptions: {
     ac: import("better-auth/client").AccessControl;
     roles: {
@@ -13,7 +12,6 @@ declare const adminPluginOptions: {
         member: import("better-auth/client").Role;
     };
 };
-/** The same catalog, narrowed to the two roles an organization has. */
 declare const organizationPluginOptions: {
     ac: import("better-auth/client").AccessControl;
     roles: {
@@ -21,18 +19,6 @@ declare const organizationPluginOptions: {
         member: import("better-auth/client").Role;
     };
 };
-/**
- * The plugin tuple a DALP client is configured with, element by element.
- *
- * Every element names the factory's own return type rather than the anonymous
- * type the array literal infers. That anonymous type reaches `SchemaCheck` in
- * `@better-auth/core/db/internal`, which this browser-safe package cannot
- * import, so a named form is what keeps the published declaration portable
- * (TS2883). The two options objects are named for the same reason:
- * `adminClient` and `organizationClient` fold their arguments into their own
- * generics, and the client's endpoint inference reads those back, so the
- * arguments have to be nameable too.
- */
 type ConfiguredBetterAuthPluginTuple = [
     ReturnType<typeof customSessionClient>,
     ReturnType<typeof inferAdditionalFields>,
@@ -50,19 +36,11 @@ type ConfiguredBetterAuthClientOptions = Omit<BetterAuthClientOptions, "plugins"
     plugins: ConfiguredBetterAuthPluginTuple;
 };
 export type InferredBetterAuthClient = AuthClient<ConfiguredBetterAuthClientOptions>;
-/**
- * Better Auth members whose routes the mount does not serve, or that are a
- * browser page's step rather than an integrator call. Device approve and deny
- * belong to the verification page, so a CLI keeps only the code and token
- * exchange. Account deletion stays mounted for the signed-in user's
- * email-gated flow, which an SDK caller never starts.
- */
 type UnservedAuthClientMembers = "deleteUser" | "revokeSessions" | "sendVerificationEmail";
 interface DalpDeviceAuthClient {
     readonly device: Omit<InferredBetterAuthClient["device"], "approve" | "deny">;
     readonly passkey: Omit<InferredBetterAuthClient["passkey"], "updatePasskey">;
 }
-/** Better Auth client with the exact DALP plugin surface and stable operation types. */
 export type DalpAuthClient = Omit<InferredBetterAuthClient, keyof DalpCliAuthClient | keyof DalpWalletAuthClient | keyof DalpDeviceAuthClient | UnservedAuthClientMembers> & DalpDeviceAuthClient & DalpCliAuthClient & DalpWalletAuthClient;
 export declare function createDalpAuthClient(input: DalpAuthClientConfig): Promise<DalpAuthClient>;
 export declare const makeDalpAuthClient: typeof createDalpAuthClient;

package/dist/auth/permissions.d.ts

@@ -1,10 +1,3 @@
-/**
- * Client-side Better Auth access-control metadata for DALP auth clients.
- *
- * Related: packages/dapi/auth/src/utils/permissions.ts, kit/sdk/src/auth/live.ts
- *
- * @module
- */
 import { type AccessControl, type Role } from "better-auth/plugins/access";
 export declare const accessControl: AccessControl;
 export declare const adminRole: Role;

package/dist/auth/wallet-plugins.d.ts

@@ -1,6 +1,5 @@
 import type { DalpAuthResult } from "./client.ts";
 export type WalletAuthOperation<TInput, TData> = (input: TInput, options?: unknown) => Promise<DalpAuthResult<TData>>;
-/** Typed client actions supplied by the three DALP wallet-auth plugins. */
 export interface DalpWalletAuthClient {
     readonly wallet: {
         readonly pincode: {
@@ -146,5 +145,4 @@ export declare const walletSecretCodesClient: () => {
 };
 export type StripLeadingSlash<T extends string> = T extends `/${infer Rest}` ? Rest : never;
 export type WalletPluginPathMethodKeys = keyof ReturnType<typeof walletPincodeClient>["pathMethods"] | keyof ReturnType<typeof walletTwoFactorClient>["pathMethods"] | keyof ReturnType<typeof walletSecretCodesClient>["pathMethods"];
-/** CLI coverage keys for DALP wallet Better Auth plugin endpoints (no leading slash). */
 export type WalletAuthEndpointPath = StripLeadingSlash<WalletPluginPathMethodKeys>;

package/dist/auth.d.ts

@@ -1,22 +1,5 @@
-/**
- * The DALP Better Auth client, on its own subpath.
- *
- * The generated SDK already exposes every auth REST operation, so nothing here
- * exists to reach an endpoint. This surface exists for the parts a REST call
- * cannot express: the session and cookie state machine, the plugin actions that
- * run in the browser rather than over HTTP — `passkeyClient` drives the WebAuthn
- * ceremony through `navigator.credentials` — and the access-control model that
- * evaluates a permission locally instead of round-tripping `has-permission`.
- *
- * It is held off the package root because it costs roughly 70 KiB of Better
- * Auth that a consumer who only calls operations should never pay.
- *
- * @module
- */
 export { createDalpAuthClient, makeDalpAuthClient } from "./auth/live.ts";
 export type { DalpAuthClient } from "./auth/live.ts";
 export { decodeDalpAuthClientConfig } from "./auth/client.ts";
-export type { DalpAuthClientConfig, 
-/** @deprecated Prefer `DalpAuthClient` — this is the typed operation surface, not a separate client. */
-DalpCliAuthClient, DalpAuthError, DalpAuthOperation, DalpAuthResult, DalpOrganizationInvitation, DalpOrganizationInvitationsQuery, DalpOrganizationMember, DalpOrganizationMembersQuery, DecodedDalpAuthClientConfig, } from "./auth/client.ts";
+export type { DalpAuthClientConfig, DalpCliAuthClient, DalpAuthError, DalpAuthOperation, DalpAuthResult, DalpOrganizationInvitation, DalpOrganizationInvitationsQuery, DalpOrganizationMember, DalpOrganizationMembersQuery, DecodedDalpAuthClientConfig, } from "./auth/client.ts";
 export type { WalletAuthEndpointPath } from "./auth/wallet-plugins.ts";

package/dist/auth.js

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

package/dist/bundler.d.ts

@@ -4,15 +4,6 @@ import type { DalpFetch } from "./client/ssr-fetch.ts";
 import type { ReadonlyDeep } from "./readonly-deep.ts";
 export type DalpEstimateUserOperationGasReturnType = RpcEstimateUserOperationGasReturnType<"0.9">;
 export type DalpUserOperation = RpcUserOperation<"0.9">;
-/**
- * A user operation the bundler routes will act on.
- *
- * viem marks `sender`, `nonce` and `callData` optional on a request, because a
- * paymaster client fills a request in over several passes. The DAPI routes
- * require all three: an operation with no sender names no account, and one with
- * no call data asks for nothing. Re-requiring them here refuses the incomplete
- * operation at the call site rather than at the server.
- */
 export type DalpUserOperationRequest = RpcUserOperationRequest<"0.9"> & Pick<DalpUserOperation, "sender" | "nonce" | "callData">;
 export interface DalpBundlerClientConfig {
     readonly url: string;

package/dist/{chunk-k8n65b9r.js → chunk-x911g40a.js}

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

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

@@ -1,29 +1,7 @@
-/**
- * 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

@@ -1,13 +1,3 @@
-/**
- * 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";

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

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

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

@@ -1,47 +1,12 @@
 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
- * (`@wire/http/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

@@ -1,4 +1,3 @@
-/** 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;
 };
@@ -8,5 +7,4 @@ export interface CreateSsrFetchOptions {
     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

@@ -1,77 +1,33 @@
-/**
- * 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";

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

@@ -23,7 +23,6 @@ export declare class DalpApiError extends Error {
     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;

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

@@ -1,8 +1,2 @@
 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;

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

@@ -10,9 +10,7 @@ export interface DalpSdkErrorOptions {
     readonly retryAfterSeconds?: number;
     readonly cause?: unknown;
 }
-/** JSON-compatible value attached to a serialized SDK error. */
 export type DalpSdkJsonValue = null | boolean | number | string | ReadonlyArray<DalpSdkJsonValue> | DalpSdkJsonObject;
-/** JSON object attached to a serialized SDK error. */
 export interface DalpSdkJsonObject {
     readonly [key: string]: DalpSdkJsonValue;
 }
@@ -35,7 +33,6 @@ export interface DalpSdkErrorJson {
     readonly details?: DalpSdkErrorDetails;
     readonly retryAfterSeconds?: number;
 }
-/** SDK-owned configuration or auxiliary-adapter failure. API calls expose route errors directly. */
 export declare class DalpSdkError extends Error {
     readonly code: string;
     readonly category: string;
@@ -48,5 +45,4 @@ export declare class DalpSdkError extends Error {
     constructor(options: Readonly<DalpSdkErrorOptions>);
     toJSON(): DalpSdkErrorJson;
 }
-/** Build the one SDK-owned error used for invalid client construction. */
 export declare function createDalpSdkConfigurationError(input: Readonly<DalpSdkConfigurationErrorInput>): DalpSdkError;

package/dist/index.d.ts

@@ -1,17 +1,3 @@
-/**
- * Effect-free DALP SDK public entry.
- *
- * This entry carries only what every consumer needs: the client factory, its
- * config and errors, and the transport policy around it. Everything that costs
- * real weight sits on its own subpath, so the cost is something a consumer opts
- * into rather than something the root hands them — `./bundler` (viem, ~385 KiB),
- * `./auth` (the Better Auth client family, ~69 KiB), `./verify-webhook` and
- * `./sign-webhook-receipt` (`standardwebhooks`; the latter is Node-only), and
- * `./wait-for-transaction`, which calls a generated operation and therefore
- * inherits the generated validator module's full weight.
- *
- * @module
- */
 export { createDalpClient, createDalpContextHeaders } from "./client/factory.ts";
 export type { DalpClient } from "./client/factory.ts";
 export type { CompressionRequestInit } from "./client/request-compression.ts";

package/dist/index.js

@@ -25,7 +25,7 @@ import {
   createCookieStoreFetch2,
   SDK_VERSION2,
   SDK_USER_AGENT2
-} from "./chunk-k8n65b9r.js";
+} from "./chunk-x911g40a.js";
 import {
   readsAsIndexerRebuild2
 } from "./chunk-5qkmb0bq.js";

package/dist/proxy/builder.d.ts

@@ -1,47 +1,17 @@
-/**
- * Build the namespaced call surface from the route table.
- *
- * The tree is not emitted as 759 functions. It is a `Proxy` that resolves a
- * node on first access and caches it, so the runtime cost is one closure per
- * route a caller actually touches, and the module stays a few hundred lines
- * regardless of how many routes the platform grows.
- *
- * This module is executor-agnostic on purpose: it imports neither `fetch` nor
- * `effect`. The promise entry and the Effect entry pass their own executor and
- * get the same tree, which is what keeps route behavior from diverging between
- * the two surfaces.
- *
- * @module
- */
 import type { RouteRow, RouteTable } from "../routes/types.ts";
-/** Per-call overrides a caller may pass alongside the request. */
 export interface CallOptions {
     readonly signal?: AbortSignal;
-    /** How long the platform holds this write before it answers 202. Ignored on an immediate route. */
     readonly settlementTimeoutMs?: number;
-    /**
-     * Extra headers for this call. A function is evaluated per request, which is
-     * what a retryable write needs: `Idempotency-Key` must be fresh per attempt,
-     * and a TanStack mutation binds its options once but fires many times.
-     */
     readonly headers?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
 }
-/** What an interpreter supplies: how to turn a resolved route call into a result. */
 export type Executor = (route: RouteRow, id: string, input: unknown, options: CallOptions | undefined) => unknown;
-/**
- * Members attached to every leaf beside the call itself. A route segment may
- * never take one of these names; the emitter refuses such a declaration.
- */
 export interface LeafExtras {
     readonly queryOptions: (input?: unknown, options?: CallOptions) => unknown;
     readonly mutationOptions: (options?: CallOptions) => unknown;
 }
-/** How an interpreter builds the TanStack factories for one route. */
 export interface LeafFactories {
     readonly queryOptions: (route: RouteRow, id: string, input: unknown, options: CallOptions | undefined) => unknown;
     readonly mutationOptions: (route: RouteRow, id: string, options: CallOptions | undefined) => unknown;
 }
-/** Build the call surface for one executor. */
 export declare function buildProxy(table: RouteTable, executor: Executor, factories: LeafFactories): unknown;
-/** Look one route up by id, for a caller that builds its own command surface. */
 export declare function findRoute(table: RouteTable, id: string): RouteRow | undefined;

package/dist/proxy/client-core.d.ts

@@ -1,39 +1,16 @@
-/**
- * The table-agnostic client builder.
- *
- * Each entry pairs it with exactly one generated route table, so a consumer
- * loads and parses only the table it calls: the root entry loads the published
- * table, `./routes/console` loads the Console table.
- *
- * @module
- */
 import type { DalpApi, DalpRouteTypes } from "../generated/api-types.d.ts";
 import type { RouteTable } from "../routes/types.ts";
 import { type CallOptions } from "./builder.ts";
 import { type CreateDalpClientOptions } from "./transport.ts";
-/** Request and response types for one route, as a route-type registry carries them. */
 export interface DalpRouteTypeEntry {
     readonly request: unknown;
     readonly response: unknown;
 }
-/** Execute a route by its id, for a caller that builds its own command surface. */
 export interface DalpClient<Api = DalpApi, RouteTypes extends Record<keyof RouteTypes, DalpRouteTypeEntry> = DalpRouteTypes> {
     readonly api: Api;
-    /** Held conditional-GET bodies. Clear on sign-out and organization switch. */
     readonly conditionalRequests: {
         readonly clear: () => void;
     };
-    /**
-     * Dispatch by route id. Resolves the decoded body, or, for a
-     * `text/event-stream` route, the frame sequence the proxy leaf also returns.
-     *
-     * Typed against the id, so a command surface built from route ids keeps the
-     * request and response types the namespaced tree gives a call site.
-     */
     readonly execute: <Id extends keyof RouteTypes>(routeId: Id, input?: RouteTypes[Id]["request"], options?: CallOptions) => Promise<RouteTypes[Id]["response"]>;
 }
-/**
- * Build a client over one route table. The caller names the types that
- * describe that table; the generated table and its types are emitted together.
- */
 export declare function buildDalpClient<Api, RouteTypes extends Record<keyof RouteTypes, DalpRouteTypeEntry>>(options: CreateDalpClientOptions, table: RouteTable): DalpClient<Api, RouteTypes>;

package/dist/proxy/client.d.ts

@@ -1,18 +1,4 @@
-/**
- * The promise call surface.
- *
- * @module
- */
 import { type DalpClient } from "./client-core.ts";
 import type { CreateDalpClientOptions } from "./transport.ts";
 export type { DalpClient, DalpRouteTypeEntry } from "./client-core.ts";
-/**
- * Create the namespaced client over the published route table.
- *
- * `api` is the proxy tree. `execute` is the same dispatch reached by route id,
- * which is what `kit/cli` uses: its command tree is kubectl-shaped, derived
- * from URL segments, so it never wants the JavaScript namespace tree. The
- * Console builds its client with `createDalpConsoleClient` from
- * `@settlemint/dalp-sdk/routes/console` instead.
- */
 export declare function createDalpClient(options: CreateDalpClientOptions): DalpClient;

package/dist/proxy/fetch-executor.d.ts

@@ -1,30 +1,5 @@
-/**
- * The promise interpreter's executor.
- *
- * Sends the prepared request and resolves the decoded body. A 202 handle is
- * the declared response, so it is handed back rather than followed: its status
- * URL reports lifecycle state, not the route-specific 200 resource, and a
- * caller that swaps one for the other has lost the durable identifier its
- * write is addressed by. How long the platform holds the response before it
- * answers 202 is the caller's to set, through `settlementTimeoutMs`.
- *
- * No response validation. The emitted declarations describe the response and
- * the platform validated it on the way out, so re-checking it here would ship
- * a second copy of every schema to every consumer for no added guarantee.
- *
- * @module
- */
 import type { CallOptions, Executor } from "./builder.ts";
 import { type Transport } from "./transport.ts";
 import type { RouteRow } from "../routes/types.ts";
-/** Send one prepared request. */
 export declare function sendRequest(transport: Transport, route: RouteRow, input: unknown, options: CallOptions | undefined): Promise<unknown>;
-/**
- * Build the executor the proxy calls for every leaf.
- *
- * An SSE route returns its async iterable directly rather than a promise of
- * one, so `for await (const frame of dalp.transaction.statusStream(input))`
- * reads without an intervening await. Awaiting it first is also valid, because
- * awaiting a non-promise is a no-op.
- */
 export declare function createFetchExecutor(transport: Transport): Executor;

package/dist/proxy/flat-args.d.ts

@@ -1,52 +1,13 @@
-/**
- * Split one flat argument object into the parts an HTTP request needs.
- *
- * The call site names what it means and nothing else:
- *
- *     dalp.api.token.transfer({ tokenAddress, transfers })
- *
- * rather than restating the transport at every site as
- * `{ client, path: { tokenAddress }, body: { to, amount } }`. The route table
- * carries the path template's parameter names, so the split is a lookup, and
- * the build refuses any route whose path parameter would collide with a body or
- * query key, which is what makes merging them safe.
- *
- * @module
- */
 import type { RouteRow } from "../routes/types.ts";
-/**
- * One flat call argument, before the route table says which key goes where.
- * Named rather than `Record<string, unknown>` so the unstructured boundary is
- * explicit: this is caller input, not a decoded domain shape.
- */
-/** A JSON value a caller may pass in a flat call argument. */
 export type FlatCallValue = null | boolean | number | string | ReadonlyArray<FlatCallValue> | FlatCallObject;
-/** A nested object inside a flat call argument. */
 export interface FlatCallObject {
     readonly [key: string]: FlatCallValue;
 }
-/**
- * One flat call argument, before the route table says which key goes where.
- * Named rather than left as a bare record so the unstructured boundary is
- * explicit: this is caller input, not a decoded domain shape.
- */
 export type FlatCallInput = FlatCallObject;
-/** The request parts, ready for a URL and a body. */
 export interface SplitArgs {
     readonly path: FlatCallInput;
     readonly query: FlatCallInput;
     readonly body: FlatCallInput | undefined;
 }
-/**
- * Divide `input` into path, query and body according to `route`.
- *
- * A key named in the path template goes to the path. When the declaration
- * carries a payload, a key the route declares as a query parameter goes to the
- * query string and the remaining keys form the JSON body; without a payload
- * every remaining key is a query parameter. The method is not the signal: a
- * DELETE that declares a payload reads it from the body exactly as a POST does,
- * and a GET never declares one.
- */
 export declare function splitFlatArgs(route: RouteRow, input: unknown): SplitArgs;
-/** Substitute path parameters into the route's template. */
 export declare function buildPath(route: RouteRow, path: FlatCallInput): string;