@compose-market/sdk 0.1.0

package/index.d.ts

@@ -0,0 +1,244 @@
+type FetchLike = typeof fetch;
+export interface ComposeSDKOptions {
+    baseUrl?: string;
+    fetch?: FetchLike;
+    walletAddress?: string;
+    chainId?: number;
+    composeKey?: string;
+}
+export interface ComposeRequestOptions {
+    walletAddress?: string;
+    chainId?: number;
+    composeKey?: string | null;
+    paymentSignature?: string;
+    x402MaxAmountWei?: string;
+    headers?: HeadersInit;
+}
+export interface PaymentRequirement {
+    scheme: string;
+    network: string;
+    amount: string;
+    asset: string;
+    payTo: string;
+    maxTimeoutSeconds: number;
+    extra?: Record<string, unknown> | null;
+}
+export interface PaymentRequired {
+    x402Version: 2;
+    error?: string;
+    resource: {
+        url: string;
+        description?: string;
+        mimeType?: string;
+    };
+    accepts: PaymentRequirement[];
+    extensions?: Record<string, unknown> | null;
+}
+export interface ModelParamDefinition {
+    type: "string" | "integer" | "number" | "boolean" | "array";
+    required: boolean;
+    default?: string | number | boolean;
+    options?: Array<string | number>;
+    description?: string;
+}
+export interface ModelParamsResponse {
+    modelId: string;
+    type: "video" | "image" | null;
+    provider: string | null;
+    params: Record<string, ModelParamDefinition>;
+    defaults: Record<string, unknown>;
+}
+export interface FacilitatorSupportedResponse {
+    kinds: Array<{
+        x402Version: number;
+        scheme: string;
+        network: string;
+        extra?: Record<string, unknown>;
+    }>;
+    extensions: string[];
+    signers?: Record<string, string[]>;
+}
+export interface ComposeKeyResponse {
+    keyId: string;
+    token: string;
+    purpose: "session" | "api";
+    budgetLimit: string;
+    budgetUsed: string;
+    budgetRemaining: string;
+    createdAt: number;
+    expiresAt: number;
+    chainId: number;
+    name?: string;
+}
+export interface ActiveComposeKeyResponse {
+    hasSession: boolean;
+    reason?: string;
+    keyId?: string;
+    token?: string;
+    budgetLimit?: string;
+    budgetUsed?: string;
+    budgetLocked?: string;
+    budgetRemaining?: string;
+    expiresAt?: number;
+    chainId?: number;
+    name?: string;
+    status?: {
+        isActive: boolean;
+        isExpired: boolean;
+        expiresInSeconds: number;
+        budgetPercentRemaining: number;
+        warnings: {
+            budgetDepleted: boolean;
+            budgetLow: boolean;
+            expiringSoon: boolean;
+            expired: boolean;
+        };
+    };
+}
+export interface ComposeKeyListItem {
+    keyId: string;
+    purpose: "session" | "api";
+    budgetLimit: number;
+    budgetUsed: number;
+    budgetRemaining: number;
+    createdAt: number;
+    expiresAt: number;
+    revokedAt?: number;
+    name?: string;
+    lastUsedAt?: number;
+}
+export interface WalletAttachment {
+    address: string;
+    chainId: number;
+    activeKey: ActiveComposeKeyResponse;
+}
+export declare class ComposeApiError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    readonly headers: Record<string, string>;
+    constructor(input: {
+        message: string;
+        status: number;
+        body: unknown;
+        headers: Record<string, string>;
+    });
+}
+export declare class ComposePaymentRequiredError extends ComposeApiError {
+    readonly paymentRequired: PaymentRequired;
+    readonly paymentRequiredHeader: string | null;
+    constructor(input: {
+        message: string;
+        status: number;
+        body: unknown;
+        headers: Record<string, string>;
+        paymentRequired: PaymentRequired;
+        paymentRequiredHeader: string | null;
+    });
+}
+export declare class ComposeSDK {
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    private walletAddress;
+    private chainId;
+    private composeKey;
+    readonly wallets: {
+        attach: (input: {
+            address: string;
+            chainId: number;
+        }) => Promise<WalletAttachment>;
+        current: () => {
+            address: string | null;
+            chainId: number | null;
+        };
+        clear: () => void;
+    };
+    readonly keys: {
+        create: (input: {
+            purpose: "session" | "api";
+            budgetUsd?: number;
+            budgetWei?: number | string;
+            durationHours?: number;
+            expiresAt?: number;
+            chainId?: number;
+            name?: string;
+        }) => Promise<ComposeKeyResponse>;
+        getActive: (input?: {
+            chainId?: number;
+        }) => Promise<ActiveComposeKeyResponse>;
+        list: () => Promise<ComposeKeyListItem[]>;
+        revoke: (keyId: string) => Promise<{
+            success: boolean;
+            keyId: string;
+        }>;
+        use: (token: string) => void;
+        currentToken: () => string | null;
+        clearToken: () => void;
+    };
+    readonly models: {
+        list: () => Promise<{
+            object: "list";
+            data: Array<Record<string, unknown>>;
+        }>;
+        listAll: () => Promise<{
+            object: "list";
+            data: Array<Record<string, unknown>>;
+        }>;
+        get: (modelId: string) => Promise<Record<string, unknown>>;
+        getParams: (modelId: string) => Promise<ModelParamsResponse>;
+    };
+    readonly pricing: {
+        list: () => Promise<{
+            models: Array<Record<string, unknown>>;
+            [key: string]: unknown;
+        }>;
+    };
+    readonly inference: {
+        responses: {
+            create: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            get: (responseId: string, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            inputItems: (responseId: string, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            cancel: (responseId: string, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+        };
+        chat: {
+            completions: {
+                create: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            };
+        };
+        images: {
+            generate: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            edit: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+        };
+        audio: {
+            speech: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            transcriptions: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+        };
+        embeddings: {
+            create: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+        };
+        videos: {
+            generate: (body: Record<string, unknown>, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+            get: (videoId: string, options?: ComposeRequestOptions) => Promise<Record<string, unknown>>;
+        };
+    };
+    readonly x402: {
+        facilitator: {
+            getSupported: () => Promise<FacilitatorSupportedResponse>;
+            verify: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+            settle: (body: Record<string, unknown>) => Promise<Record<string, unknown>>;
+        };
+        decodePaymentRequired: (headerValue: string) => PaymentRequired;
+    };
+    constructor(options?: ComposeSDKOptions);
+    private resolveWalletContext;
+    private resolveComposeKeyToken;
+    private attachWallet;
+    private createKey;
+    private getActiveKey;
+    private listKeys;
+    private revokeKey;
+    private buildHeaders;
+    private requestJson;
+    private buildError;
+    private extractPaymentRequired;
+}
+export {};

package/index.js

@@ -0,0 +1,397 @@
+export class ComposeApiError extends Error {
+    status;
+    body;
+    headers;
+    constructor(input) {
+        super(input.message);
+        this.name = "ComposeApiError";
+        this.status = input.status;
+        this.body = input.body;
+        this.headers = input.headers;
+    }
+}
+export class ComposePaymentRequiredError extends ComposeApiError {
+    paymentRequired;
+    paymentRequiredHeader;
+    constructor(input) {
+        super(input);
+        this.name = "ComposePaymentRequiredError";
+        this.paymentRequired = input.paymentRequired;
+        this.paymentRequiredHeader = input.paymentRequiredHeader;
+    }
+}
+function normalizeBaseUrl(baseUrl) {
+    return (baseUrl || "https://api.compose.market").replace(/\/+$/, "");
+}
+function normalizeWalletAddress(address) {
+    const normalized = address.trim().toLowerCase();
+    if (!/^0x[a-f0-9]{40}$/u.test(normalized)) {
+        throw new Error("wallet address must be a valid 0x-prefixed EVM address");
+    }
+    return normalized;
+}
+function resolveChainId(chainId) {
+    if (!Number.isInteger(chainId) || Number(chainId) <= 0) {
+        throw new Error("chainId must be a positive integer");
+    }
+    return Number(chainId);
+}
+function toBudgetWei(input) {
+    const hasBudgetUsd = typeof input.budgetUsd === "number";
+    const hasBudgetWei = typeof input.budgetWei === "number" || typeof input.budgetWei === "string";
+    if (Number(hasBudgetUsd) + Number(hasBudgetWei) !== 1) {
+        throw new Error("provide exactly one of budgetUsd or budgetWei");
+    }
+    if (hasBudgetUsd) {
+        const usd = input.budgetUsd;
+        if (!Number.isFinite(usd) || usd <= 0) {
+            throw new Error("budgetUsd must be a positive number");
+        }
+        return String(Math.round(usd * 1_000_000));
+    }
+    if (typeof input.budgetWei === "number") {
+        if (!Number.isInteger(input.budgetWei) || input.budgetWei <= 0) {
+            throw new Error("budgetWei must be a positive integer");
+        }
+        return String(input.budgetWei);
+    }
+    const trimmed = input.budgetWei.trim();
+    if (!/^\d+$/u.test(trimmed) || BigInt(trimmed) <= 0n) {
+        throw new Error("budgetWei must be a positive integer string");
+    }
+    return trimmed;
+}
+function resolveExpiresAt(input) {
+    const hasDurationHours = typeof input.durationHours === "number";
+    const hasExpiresAt = typeof input.expiresAt === "number";
+    if (Number(hasDurationHours) + Number(hasExpiresAt) !== 1) {
+        throw new Error("provide exactly one of durationHours or expiresAt");
+    }
+    if (hasExpiresAt) {
+        if (!Number.isInteger(input.expiresAt) || input.expiresAt <= Date.now()) {
+            throw new Error("expiresAt must be a future unix timestamp in milliseconds");
+        }
+        return input.expiresAt;
+    }
+    const durationHours = input.durationHours;
+    if (!Number.isFinite(durationHours) || durationHours <= 0) {
+        throw new Error("durationHours must be a positive number");
+    }
+    return Date.now() + Math.round(durationHours * 60 * 60 * 1000);
+}
+function headersToRecord(headers) {
+    return Object.fromEntries(headers.entries());
+}
+function tryParseJson(value) {
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return value;
+    }
+}
+function parseErrorMessage(body, fallback) {
+    if (body && typeof body === "object") {
+        const record = body;
+        if (typeof record.error === "string" && record.error.trim().length > 0) {
+            return record.error;
+        }
+        if (record.error && typeof record.error === "object") {
+            const nested = record.error;
+            if (typeof nested.message === "string" && nested.message.trim().length > 0) {
+                return nested.message;
+            }
+        }
+        if (typeof record.message === "string" && record.message.trim().length > 0) {
+            return record.message;
+        }
+    }
+    return fallback;
+}
+function decodeBase64Json(value) {
+    const normalized = value.replace(/-/gu, "+").replace(/_/gu, "/");
+    const padding = normalized.length % 4 === 0 ? "" : "=".repeat(4 - (normalized.length % 4));
+    const base64 = `${normalized}${padding}`;
+    if (typeof globalThis.atob !== "function") {
+        throw new Error("Base64 decoding is unavailable in this runtime");
+    }
+    const binary = globalThis.atob(base64);
+    const bytes = Uint8Array.from(binary, (char) => char.charCodeAt(0));
+    const text = new TextDecoder().decode(bytes);
+    return JSON.parse(text);
+}
+function decodePaymentRequiredHeaderValue(value) {
+    return decodeBase64Json(value);
+}
+function stripUndefined(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+export class ComposeSDK {
+    baseUrl;
+    fetchImpl;
+    walletAddress;
+    chainId;
+    composeKey;
+    wallets;
+    keys;
+    models;
+    pricing;
+    inference;
+    x402;
+    constructor(options = {}) {
+        this.baseUrl = normalizeBaseUrl(options.baseUrl);
+        this.fetchImpl = options.fetch || fetch;
+        this.walletAddress = options.walletAddress ? normalizeWalletAddress(options.walletAddress) : null;
+        this.chainId = options.chainId !== undefined ? resolveChainId(options.chainId) : null;
+        this.composeKey = options.composeKey || null;
+        this.wallets = {
+            attach: async (input) => this.attachWallet(input),
+            current: () => ({
+                address: this.walletAddress,
+                chainId: this.chainId,
+            }),
+            clear: () => {
+                this.walletAddress = null;
+                this.chainId = null;
+            },
+        };
+        this.keys = {
+            create: async (input) => this.createKey(input),
+            getActive: async (input) => this.getActiveKey(input),
+            list: async () => this.listKeys(),
+            revoke: async (keyId) => this.revokeKey(keyId),
+            use: (token) => {
+                this.composeKey = token;
+            },
+            currentToken: () => this.composeKey,
+            clearToken: () => {
+                this.composeKey = null;
+            },
+        };
+        this.models = {
+            list: async () => this.requestJson("/v1/models", { method: "GET" }),
+            listAll: async () => this.requestJson("/v1/models/all", { method: "GET" }),
+            get: async (modelId) => this.requestJson(`/v1/models/${encodeURIComponent(modelId)}`, { method: "GET" }),
+            getParams: async (modelId) => this.requestJson(`/v1/models/${encodeURIComponent(modelId)}/params`, { method: "GET" }),
+        };
+        this.pricing = {
+            list: async () => this.requestJson("/api/pricing", { method: "GET" }),
+        };
+        this.inference = {
+            responses: {
+                create: async (body, options) => this.requestJson("/v1/responses", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+                get: async (responseId, options) => this.requestJson(`/v1/responses/${encodeURIComponent(responseId)}`, { method: "GET" }, options),
+                inputItems: async (responseId, options) => this.requestJson(`/v1/responses/${encodeURIComponent(responseId)}/input_items`, { method: "GET" }, options),
+                cancel: async (responseId, options) => this.requestJson(`/v1/responses/${encodeURIComponent(responseId)}/cancel`, { method: "POST" }, options),
+            },
+            chat: {
+                completions: {
+                    create: async (body, options) => this.requestJson("/v1/chat/completions", {
+                        method: "POST",
+                        body: JSON.stringify(body),
+                    }, options),
+                },
+            },
+            images: {
+                generate: async (body, options) => this.requestJson("/v1/images/generations", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+                edit: async (body, options) => this.requestJson("/v1/images/edits", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+            },
+            audio: {
+                speech: async (body, options) => this.requestJson("/v1/audio/speech", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+                transcriptions: async (body, options) => this.requestJson("/v1/audio/transcriptions", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+            },
+            embeddings: {
+                create: async (body, options) => this.requestJson("/v1/embeddings", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+            },
+            videos: {
+                generate: async (body, options) => this.requestJson("/v1/videos/generations", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }, options),
+                get: async (videoId, options) => this.requestJson(`/v1/videos/${encodeURIComponent(videoId)}`, { method: "GET" }, options),
+            },
+        };
+        this.x402 = {
+            facilitator: {
+                getSupported: async () => this.requestJson("/api/x402/facilitator/supported", { method: "GET" }),
+                verify: async (body) => this.requestJson("/api/x402/facilitator/verify", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }),
+                settle: async (body) => this.requestJson("/api/x402/facilitator/settle", {
+                    method: "POST",
+                    body: JSON.stringify(body),
+                }),
+            },
+            decodePaymentRequired: decodePaymentRequiredHeaderValue,
+        };
+    }
+    resolveWalletContext(input) {
+        const address = input?.walletAddress ?? this.walletAddress;
+        const chainId = input?.chainId ?? this.chainId;
+        if (!address) {
+            throw new Error("wallet context is required; call wallets.attach(...) first or pass walletAddress");
+        }
+        if (chainId === null || chainId === undefined) {
+            throw new Error("chainId is required; call wallets.attach(...) first or pass chainId");
+        }
+        return {
+            address: normalizeWalletAddress(address),
+            chainId: resolveChainId(chainId),
+        };
+    }
+    resolveComposeKeyToken(input) {
+        if (input && "composeKey" in input) {
+            return input.composeKey || null;
+        }
+        return this.composeKey;
+    }
+    async attachWallet(input) {
+        const address = normalizeWalletAddress(input.address);
+        const chainId = resolveChainId(input.chainId);
+        this.walletAddress = address;
+        this.chainId = chainId;
+        const activeKey = await this.getActiveKey({ chainId });
+        return {
+            address,
+            chainId,
+            activeKey,
+        };
+    }
+    async createKey(input) {
+        const wallet = this.resolveWalletContext({ chainId: input.chainId });
+        return this.requestJson("/api/keys", {
+            method: "POST",
+            body: JSON.stringify(stripUndefined({
+                budgetLimit: toBudgetWei(input),
+                expiresAt: resolveExpiresAt(input),
+                chainId: wallet.chainId,
+                purpose: input.purpose,
+                name: input.name,
+            })),
+        }, {
+            walletAddress: wallet.address,
+            chainId: wallet.chainId,
+        });
+    }
+    async getActiveKey(input) {
+        const wallet = this.resolveWalletContext({ chainId: input?.chainId });
+        return this.requestJson("/api/session", { method: "GET" }, {
+            walletAddress: wallet.address,
+            chainId: wallet.chainId,
+        });
+    }
+    async listKeys() {
+        const wallet = this.resolveWalletContext();
+        const result = await this.requestJson("/api/keys", { method: "GET" }, {
+            walletAddress: wallet.address,
+            chainId: wallet.chainId,
+        });
+        return result.keys;
+    }
+    async revokeKey(keyId) {
+        const wallet = this.resolveWalletContext();
+        return this.requestJson(`/api/keys/${encodeURIComponent(keyId)}`, { method: "DELETE" }, {
+            walletAddress: wallet.address,
+            chainId: wallet.chainId,
+        });
+    }
+    buildHeaders(options = {}, hasBody) {
+        const headers = new Headers(options.headers || {});
+        if (hasBody && !headers.has("Content-Type")) {
+            headers.set("Content-Type", "application/json");
+        }
+        const composeKey = this.resolveComposeKeyToken(options);
+        if (composeKey) {
+            headers.set("Authorization", `Bearer ${composeKey}`);
+        }
+        const walletAddress = options.walletAddress ?? this.walletAddress;
+        if (walletAddress) {
+            headers.set("x-session-user-address", normalizeWalletAddress(walletAddress));
+        }
+        const chainId = options.chainId ?? this.chainId;
+        if (chainId !== null && chainId !== undefined) {
+            headers.set("x-chain-id", String(resolveChainId(chainId)));
+        }
+        if (options.paymentSignature) {
+            headers.set("PAYMENT-SIGNATURE", options.paymentSignature);
+        }
+        if (options.x402MaxAmountWei) {
+            headers.set("x-x402-max-amount-wei", options.x402MaxAmountWei);
+        }
+        return headers;
+    }
+    async requestJson(path, init, options = {}) {
+        const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
+            ...init,
+            headers: this.buildHeaders(options, typeof init.body === "string"),
+        });
+        const text = await response.text();
+        const parsedBody = tryParseJson(text);
+        if (!response.ok) {
+            throw this.buildError(response, parsedBody);
+        }
+        return parsedBody;
+    }
+    buildError(response, body) {
+        const headers = headersToRecord(response.headers);
+        const paymentRequiredHeader = response.headers.get("payment-required");
+        const paymentRequired = this.extractPaymentRequired(body, paymentRequiredHeader);
+        const fallbackMessage = `${response.status} ${response.statusText}`.trim();
+        const message = parseErrorMessage(body, fallbackMessage);
+        if (response.status === 402 && paymentRequired) {
+            return new ComposePaymentRequiredError({
+                message,
+                status: response.status,
+                body,
+                headers,
+                paymentRequired,
+                paymentRequiredHeader,
+            });
+        }
+        return new ComposeApiError({
+            message,
+            status: response.status,
+            body,
+            headers,
+        });
+    }
+    extractPaymentRequired(body, headerValue) {
+        if (headerValue) {
+            try {
+                return decodePaymentRequiredHeaderValue(headerValue);
+            }
+            catch {
+                return null;
+            }
+        }
+        if (body && typeof body === "object") {
+            const record = body;
+            if (record.x402Version === 2 && Array.isArray(record.accepts) && record.resource) {
+                return record;
+            }
+        }
+        return null;
+    }
+}

package/package.json

@@ -0,0 +1,126 @@
+{
+  "name": "@compose-market/sdk",
+  "version": "0.1.0",
+  "description": "Official Compose.Market SDK for Compose keys, x402 facilitator access, model discovery, and inference APIs.",
+  "keywords": [
+    "x402",
+    "facilitator",
+    "a2a",
+    "agentic-economy",
+    "decentralized-inference"
+  ],
+  "homepage": "https://github.com/compose-market/sdk#readme",
+  "bugs": {
+    "url": "https://github.com/compose-market/sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/compose-market/sdk.git"
+  },
+  "license": "MIT",
+  "author": "jabyl",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    }
+  },
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "directories": {
+    "test": "tests"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "clean": "rm -f index.js index.d.ts",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "test": "npm run build && node --import tsx --test tests/**/*.test.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "accepts": "^2.0.0",
+    "body-parser": "^2.2.2",
+    "bytes": "^3.1.2",
+    "call-bind-apply-helpers": "^1.0.2",
+    "call-bound": "^1.0.4",
+    "content-disposition": "^1.1.0",
+    "content-type": "^1.0.5",
+    "cookie": "^0.7.2",
+    "cookie-signature": "^1.2.2",
+    "debug": "^4.4.3",
+    "depd": "^2.0.0",
+    "dunder-proto": "^1.0.1",
+    "ee-first": "^1.1.1",
+    "encodeurl": "^2.0.0",
+    "es-define-property": "^1.0.1",
+    "es-errors": "^1.3.0",
+    "es-object-atoms": "^1.1.1",
+    "esbuild": "^0.27.7",
+    "escape-html": "^1.0.3",
+    "etag": "^1.8.1",
+    "finalhandler": "^2.1.1",
+    "forwarded": "^0.2.0",
+    "fresh": "^2.0.0",
+    "function-bind": "^1.1.2",
+    "get-intrinsic": "^1.3.0",
+    "get-proto": "^1.0.1",
+    "get-tsconfig": "^4.14.0",
+    "gopd": "^1.2.0",
+    "has-symbols": "^1.1.0",
+    "hasown": "^2.0.3",
+    "http-errors": "^2.0.1",
+    "iconv-lite": "^0.7.2",
+    "inherits": "^2.0.4",
+    "ipaddr.js": "^1.9.1",
+    "is-promise": "^4.0.0",
+    "math-intrinsics": "^1.1.0",
+    "media-typer": "^1.1.0",
+    "merge-descriptors": "^2.0.0",
+    "mime-db": "^1.54.0",
+    "mime-types": "^3.0.2",
+    "ms": "^2.1.3",
+    "negotiator": "^1.0.0",
+    "object-inspect": "^1.13.4",
+    "on-finished": "^2.4.1",
+    "once": "^1.4.0",
+    "parseurl": "^1.3.3",
+    "path-to-regexp": "^8.4.2",
+    "proxy-addr": "^2.0.7",
+    "qs": "^6.15.1",
+    "range-parser": "^1.2.1",
+    "raw-body": "^3.0.2",
+    "resolve-pkg-maps": "^1.0.0",
+    "router": "^2.2.0",
+    "safer-buffer": "^2.1.2",
+    "send": "^1.2.1",
+    "serve-static": "^2.2.1",
+    "setprototypeof": "^1.2.0",
+    "side-channel": "^1.1.0",
+    "side-channel-list": "^1.0.1",
+    "side-channel-map": "^1.0.1",
+    "side-channel-weakmap": "^1.0.2",
+    "statuses": "^2.0.2",
+    "toidentifier": "^1.0.1",
+    "type-is": "^2.0.1",
+    "undici-types": "^7.19.2",
+    "unpipe": "^1.0.0",
+    "vary": "^1.1.2",
+    "wrappy": "^1.0.2"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.6.0",
+    "express": "^5.2.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "module": "./index.js"
+}