@webhooks-cc/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Mads Sauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,144 @@
+/**
+ * A webhook endpoint that captures incoming HTTP requests.
+ * Create endpoints via the dashboard or SDK to receive webhooks.
+ */
+interface Endpoint {
+    /** Unique identifier for this endpoint */
+    id: string;
+    /** URL-safe identifier used in webhook URLs (/w/{slug}) */
+    slug: string;
+    /** Display name for the endpoint */
+    name?: string;
+    /** Full URL where webhooks should be sent (undefined if server is misconfigured) */
+    url?: string;
+    /** Unix timestamp (ms) when the endpoint was created */
+    createdAt: number;
+}
+/**
+ * A captured webhook request with full HTTP details.
+ * Stored when a webhook arrives at an endpoint.
+ */
+interface Request {
+    /** Unique identifier for this request */
+    id: string;
+    /** Endpoint that received this request */
+    endpointId: string;
+    /** HTTP method (GET, POST, PUT, etc.) */
+    method: string;
+    /** Request path after the endpoint slug */
+    path: string;
+    /** HTTP headers from the original request */
+    headers: Record<string, string>;
+    /** Request body, if present */
+    body?: string;
+    /** URL query parameters */
+    queryParams: Record<string, string>;
+    /** Content-Type header value, if present */
+    contentType?: string;
+    /** Client IP address */
+    ip: string;
+    /** Request body size in bytes */
+    size: number;
+    /** Unix timestamp (ms) when the request arrived */
+    receivedAt: number;
+}
+/**
+ * Options for creating a new endpoint.
+ */
+interface CreateEndpointOptions {
+    /** Display name for the endpoint */
+    name?: string;
+}
+/**
+ * Options for listing captured requests.
+ */
+interface ListRequestsOptions {
+    /** Maximum number of requests to return */
+    limit?: number;
+    /** Only return requests received after this timestamp (ms) */
+    since?: number;
+}
+/**
+ * Options for waitFor() polling behavior.
+ */
+interface WaitForOptions {
+    /** Maximum time to wait in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Interval between polls in milliseconds (default: 500, min: 10, max: 60000) */
+    pollInterval?: number;
+    /** Filter function to match specific requests */
+    match?: (request: Request) => boolean;
+}
+/**
+ * Configuration options for the WebhooksCC client.
+ */
+interface ClientOptions {
+    /** API key for authentication (format: whcc_...) */
+    apiKey: string;
+    /** Base URL for the API (default: https://webhooks.cc) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+
+/**
+ * @fileoverview webhooks.cc SDK client for programmatic webhook management.
+ *
+ * @example
+ * ```typescript
+ * const client = new WebhooksCC({ apiKey: 'whcc_...' });
+ * const endpoint = await client.endpoints.create({ name: 'My Webhook' });
+ * const request = await client.requests.waitFor(endpoint.slug, {
+ *   timeout: 10000,
+ *   match: (r) => r.method === 'POST'
+ * });
+ * ```
+ */
+
+/**
+ * Error thrown when an API request fails with a specific HTTP status code.
+ * Allows callers to distinguish between different error types.
+ */
+declare class ApiError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+/**
+ * Client for the webhooks.cc API.
+ *
+ * Provides methods to create endpoints, list captured requests, and wait
+ * for incoming webhooks. Handles authentication, request signing, and
+ * response validation.
+ */
+declare class WebhooksCC {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(options: ClientOptions);
+    private request;
+    endpoints: {
+        create: (options?: CreateEndpointOptions) => Promise<Endpoint>;
+        list: () => Promise<Endpoint[]>;
+        get: (slug: string) => Promise<Endpoint>;
+        delete: (slug: string) => Promise<void>;
+    };
+    requests: {
+        list: (endpointSlug: string, options?: ListRequestsOptions) => Promise<Request[]>;
+        get: (requestId: string) => Promise<Request>;
+        /**
+         * Polls for incoming requests until one matches or timeout expires.
+         *
+         * Fetches requests that arrived since the last successful check. On API
+         * errors, continues polling without updating the timestamp to avoid
+         * missing requests during transient failures.
+         *
+         * @param endpointSlug - Endpoint to monitor
+         * @param options - Timeout, poll interval, and optional match filter
+         * @returns First matching request, or first request if no match filter
+         * @throws Error if timeout expires or max iterations (10000) reached
+         */
+        waitFor: (endpointSlug: string, options?: WaitForOptions) => Promise<Request>;
+    };
+}
+
+export { ApiError, type ClientOptions, type CreateEndpointOptions, type Endpoint, type ListRequestsOptions, type Request, type WaitForOptions, WebhooksCC };

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+/**
+ * A webhook endpoint that captures incoming HTTP requests.
+ * Create endpoints via the dashboard or SDK to receive webhooks.
+ */
+interface Endpoint {
+    /** Unique identifier for this endpoint */
+    id: string;
+    /** URL-safe identifier used in webhook URLs (/w/{slug}) */
+    slug: string;
+    /** Display name for the endpoint */
+    name?: string;
+    /** Full URL where webhooks should be sent (undefined if server is misconfigured) */
+    url?: string;
+    /** Unix timestamp (ms) when the endpoint was created */
+    createdAt: number;
+}
+/**
+ * A captured webhook request with full HTTP details.
+ * Stored when a webhook arrives at an endpoint.
+ */
+interface Request {
+    /** Unique identifier for this request */
+    id: string;
+    /** Endpoint that received this request */
+    endpointId: string;
+    /** HTTP method (GET, POST, PUT, etc.) */
+    method: string;
+    /** Request path after the endpoint slug */
+    path: string;
+    /** HTTP headers from the original request */
+    headers: Record<string, string>;
+    /** Request body, if present */
+    body?: string;
+    /** URL query parameters */
+    queryParams: Record<string, string>;
+    /** Content-Type header value, if present */
+    contentType?: string;
+    /** Client IP address */
+    ip: string;
+    /** Request body size in bytes */
+    size: number;
+    /** Unix timestamp (ms) when the request arrived */
+    receivedAt: number;
+}
+/**
+ * Options for creating a new endpoint.
+ */
+interface CreateEndpointOptions {
+    /** Display name for the endpoint */
+    name?: string;
+}
+/**
+ * Options for listing captured requests.
+ */
+interface ListRequestsOptions {
+    /** Maximum number of requests to return */
+    limit?: number;
+    /** Only return requests received after this timestamp (ms) */
+    since?: number;
+}
+/**
+ * Options for waitFor() polling behavior.
+ */
+interface WaitForOptions {
+    /** Maximum time to wait in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Interval between polls in milliseconds (default: 500, min: 10, max: 60000) */
+    pollInterval?: number;
+    /** Filter function to match specific requests */
+    match?: (request: Request) => boolean;
+}
+/**
+ * Configuration options for the WebhooksCC client.
+ */
+interface ClientOptions {
+    /** API key for authentication (format: whcc_...) */
+    apiKey: string;
+    /** Base URL for the API (default: https://webhooks.cc) */
+    baseUrl?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+
+/**
+ * @fileoverview webhooks.cc SDK client for programmatic webhook management.
+ *
+ * @example
+ * ```typescript
+ * const client = new WebhooksCC({ apiKey: 'whcc_...' });
+ * const endpoint = await client.endpoints.create({ name: 'My Webhook' });
+ * const request = await client.requests.waitFor(endpoint.slug, {
+ *   timeout: 10000,
+ *   match: (r) => r.method === 'POST'
+ * });
+ * ```
+ */
+
+/**
+ * Error thrown when an API request fails with a specific HTTP status code.
+ * Allows callers to distinguish between different error types.
+ */
+declare class ApiError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+/**
+ * Client for the webhooks.cc API.
+ *
+ * Provides methods to create endpoints, list captured requests, and wait
+ * for incoming webhooks. Handles authentication, request signing, and
+ * response validation.
+ */
+declare class WebhooksCC {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeout;
+    constructor(options: ClientOptions);
+    private request;
+    endpoints: {
+        create: (options?: CreateEndpointOptions) => Promise<Endpoint>;
+        list: () => Promise<Endpoint[]>;
+        get: (slug: string) => Promise<Endpoint>;
+        delete: (slug: string) => Promise<void>;
+    };
+    requests: {
+        list: (endpointSlug: string, options?: ListRequestsOptions) => Promise<Request[]>;
+        get: (requestId: string) => Promise<Request>;
+        /**
+         * Polls for incoming requests until one matches or timeout expires.
+         *
+         * Fetches requests that arrived since the last successful check. On API
+         * errors, continues polling without updating the timestamp to avoid
+         * missing requests during transient failures.
+         *
+         * @param endpointSlug - Endpoint to monitor
+         * @param options - Timeout, poll interval, and optional match filter
+         * @returns First matching request, or first request if no match filter
+         * @throws Error if timeout expires or max iterations (10000) reached
+         */
+        waitFor: (endpointSlug: string, options?: WaitForOptions) => Promise<Request>;
+    };
+}
+
+export { ApiError, type ClientOptions, type CreateEndpointOptions, type Endpoint, type ListRequestsOptions, type Request, type WaitForOptions, WebhooksCC };

package/dist/index.js

@@ -0,0 +1,189 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiError: () => ApiError,
+  WebhooksCC: () => WebhooksCC
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://webhooks.cc";
+var DEFAULT_TIMEOUT = 3e4;
+var MIN_POLL_INTERVAL = 10;
+var MAX_POLL_INTERVAL = 6e4;
+var ApiError = class extends Error {
+  constructor(statusCode, message) {
+    super(`API error (${statusCode}): ${message}`);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+var SAFE_PATH_SEGMENT_REGEX = /^[a-zA-Z0-9_-]+$/;
+function validatePathSegment(segment, name) {
+  if (!SAFE_PATH_SEGMENT_REGEX.test(segment)) {
+    throw new Error(
+      `Invalid ${name}: must contain only alphanumeric characters, hyphens, and underscores`
+    );
+  }
+}
+var WebhooksCC = class {
+  constructor(options) {
+    this.endpoints = {
+      create: async (options = {}) => {
+        return this.request("POST", "/endpoints", options);
+      },
+      list: async () => {
+        return this.request("GET", "/endpoints");
+      },
+      get: async (slug) => {
+        validatePathSegment(slug, "slug");
+        return this.request("GET", `/endpoints/${slug}`);
+      },
+      delete: async (slug) => {
+        validatePathSegment(slug, "slug");
+        await this.request("DELETE", `/endpoints/${slug}`);
+      }
+    };
+    this.requests = {
+      list: async (endpointSlug, options = {}) => {
+        validatePathSegment(endpointSlug, "endpointSlug");
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.since !== void 0) params.set("since", String(options.since));
+        const query = params.toString();
+        return this.request(
+          "GET",
+          `/endpoints/${endpointSlug}/requests${query ? `?${query}` : ""}`
+        );
+      },
+      get: async (requestId) => {
+        validatePathSegment(requestId, "requestId");
+        return this.request("GET", `/requests/${requestId}`);
+      },
+      /**
+       * Polls for incoming requests until one matches or timeout expires.
+       *
+       * Fetches requests that arrived since the last successful check. On API
+       * errors, continues polling without updating the timestamp to avoid
+       * missing requests during transient failures.
+       *
+       * @param endpointSlug - Endpoint to monitor
+       * @param options - Timeout, poll interval, and optional match filter
+       * @returns First matching request, or first request if no match filter
+       * @throws Error if timeout expires or max iterations (10000) reached
+       */
+      waitFor: async (endpointSlug, options = {}) => {
+        validatePathSegment(endpointSlug, "endpointSlug");
+        const { timeout = 3e4, pollInterval = 500, match } = options;
+        const safePollInterval = Math.max(
+          MIN_POLL_INTERVAL,
+          Math.min(MAX_POLL_INTERVAL, pollInterval)
+        );
+        const start = Date.now();
+        let lastChecked = 0;
+        const MAX_ITERATIONS = 1e4;
+        let iterations = 0;
+        while (Date.now() - start < timeout && iterations < MAX_ITERATIONS) {
+          iterations++;
+          const checkTime = Date.now();
+          try {
+            const requests = await this.requests.list(endpointSlug, {
+              since: lastChecked,
+              limit: 100
+            });
+            lastChecked = checkTime;
+            const matched = match ? requests.find(match) : requests[0];
+            if (matched) {
+              return matched;
+            }
+          } catch (error) {
+            if (error instanceof ApiError) {
+              if (error.statusCode === 401) {
+                throw new Error("Authentication failed: invalid or expired API key");
+              }
+              if (error.statusCode === 403) {
+                throw new Error("Access denied: insufficient permissions for this endpoint");
+              }
+              if (error.statusCode === 404) {
+                throw new Error(`Endpoint "${endpointSlug}" not found`);
+              }
+              if (error.statusCode < 500) {
+                throw error;
+              }
+            }
+          }
+          await sleep(safePollInterval);
+        }
+        if (iterations >= MAX_ITERATIONS) {
+          throw new Error(`Max iterations (${MAX_ITERATIONS}) reached while waiting for request`);
+        }
+        throw new Error(`Timeout waiting for request after ${timeout}ms`);
+      }
+    };
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/api${path}`, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        const sanitizedError = error.length > 200 ? error.slice(0, 200) + "..." : error;
+        throw new ApiError(response.status, sanitizedError);
+      }
+      if (response.status === 204 || response.headers.get("content-length") === "0") {
+        return void 0;
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType && !contentType.includes("application/json")) {
+        throw new Error(`Unexpected content type: ${contentType}`);
+      }
+      return response.json();
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timed out after ${this.timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiError,
+  WebhooksCC
+});

package/dist/index.mjs

@@ -0,0 +1,161 @@
+// src/client.ts
+var DEFAULT_BASE_URL = "https://webhooks.cc";
+var DEFAULT_TIMEOUT = 3e4;
+var MIN_POLL_INTERVAL = 10;
+var MAX_POLL_INTERVAL = 6e4;
+var ApiError = class extends Error {
+  constructor(statusCode, message) {
+    super(`API error (${statusCode}): ${message}`);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+var SAFE_PATH_SEGMENT_REGEX = /^[a-zA-Z0-9_-]+$/;
+function validatePathSegment(segment, name) {
+  if (!SAFE_PATH_SEGMENT_REGEX.test(segment)) {
+    throw new Error(
+      `Invalid ${name}: must contain only alphanumeric characters, hyphens, and underscores`
+    );
+  }
+}
+var WebhooksCC = class {
+  constructor(options) {
+    this.endpoints = {
+      create: async (options = {}) => {
+        return this.request("POST", "/endpoints", options);
+      },
+      list: async () => {
+        return this.request("GET", "/endpoints");
+      },
+      get: async (slug) => {
+        validatePathSegment(slug, "slug");
+        return this.request("GET", `/endpoints/${slug}`);
+      },
+      delete: async (slug) => {
+        validatePathSegment(slug, "slug");
+        await this.request("DELETE", `/endpoints/${slug}`);
+      }
+    };
+    this.requests = {
+      list: async (endpointSlug, options = {}) => {
+        validatePathSegment(endpointSlug, "endpointSlug");
+        const params = new URLSearchParams();
+        if (options.limit !== void 0) params.set("limit", String(options.limit));
+        if (options.since !== void 0) params.set("since", String(options.since));
+        const query = params.toString();
+        return this.request(
+          "GET",
+          `/endpoints/${endpointSlug}/requests${query ? `?${query}` : ""}`
+        );
+      },
+      get: async (requestId) => {
+        validatePathSegment(requestId, "requestId");
+        return this.request("GET", `/requests/${requestId}`);
+      },
+      /**
+       * Polls for incoming requests until one matches or timeout expires.
+       *
+       * Fetches requests that arrived since the last successful check. On API
+       * errors, continues polling without updating the timestamp to avoid
+       * missing requests during transient failures.
+       *
+       * @param endpointSlug - Endpoint to monitor
+       * @param options - Timeout, poll interval, and optional match filter
+       * @returns First matching request, or first request if no match filter
+       * @throws Error if timeout expires or max iterations (10000) reached
+       */
+      waitFor: async (endpointSlug, options = {}) => {
+        validatePathSegment(endpointSlug, "endpointSlug");
+        const { timeout = 3e4, pollInterval = 500, match } = options;
+        const safePollInterval = Math.max(
+          MIN_POLL_INTERVAL,
+          Math.min(MAX_POLL_INTERVAL, pollInterval)
+        );
+        const start = Date.now();
+        let lastChecked = 0;
+        const MAX_ITERATIONS = 1e4;
+        let iterations = 0;
+        while (Date.now() - start < timeout && iterations < MAX_ITERATIONS) {
+          iterations++;
+          const checkTime = Date.now();
+          try {
+            const requests = await this.requests.list(endpointSlug, {
+              since: lastChecked,
+              limit: 100
+            });
+            lastChecked = checkTime;
+            const matched = match ? requests.find(match) : requests[0];
+            if (matched) {
+              return matched;
+            }
+          } catch (error) {
+            if (error instanceof ApiError) {
+              if (error.statusCode === 401) {
+                throw new Error("Authentication failed: invalid or expired API key");
+              }
+              if (error.statusCode === 403) {
+                throw new Error("Access denied: insufficient permissions for this endpoint");
+              }
+              if (error.statusCode === 404) {
+                throw new Error(`Endpoint "${endpointSlug}" not found`);
+              }
+              if (error.statusCode < 500) {
+                throw error;
+              }
+            }
+          }
+          await sleep(safePollInterval);
+        }
+        if (iterations >= MAX_ITERATIONS) {
+          throw new Error(`Max iterations (${MAX_ITERATIONS}) reached while waiting for request`);
+        }
+        throw new Error(`Timeout waiting for request after ${timeout}ms`);
+      }
+    };
+    this.apiKey = options.apiKey;
+    this.baseUrl = options.baseUrl ?? DEFAULT_BASE_URL;
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/api${path}`, {
+        method,
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        const sanitizedError = error.length > 200 ? error.slice(0, 200) + "..." : error;
+        throw new ApiError(response.status, sanitizedError);
+      }
+      if (response.status === 204 || response.headers.get("content-length") === "0") {
+        return void 0;
+      }
+      const contentType = response.headers.get("content-type");
+      if (contentType && !contentType.includes("application/json")) {
+        throw new Error(`Unexpected content type: ${contentType}`);
+      }
+      return response.json();
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error(`Request timed out after ${this.timeout}ms`);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export {
+  ApiError,
+  WebhooksCC
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@webhooks-cc/sdk",
+  "version": "0.1.0",
+  "description": "Official SDK for webhooks.cc — programmatic webhook testing",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "webhook",
+    "testing",
+    "api",
+    "sdk",
+    "webhooks-cc"
+  ],
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webhooks-cc/webhooks-cc",
+    "directory": "packages/sdk"
+  },
+  "homepage": "https://webhooks.cc",
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}