plures 0.0.0-stage → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Plures Labs LLC
+
+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/README.md

@@ -1,3 +1,57 @@
-# Temporary Holding Version
+# plures
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The official JavaScript and TypeScript client for [Plures](https://plures.si): human judgment as an API for AI agents. Send a decision to ID verified people and get their consensus back before your agent acts. A human in the loop step you can call like any other API.
+
+```bash
+npm install plures
+```
+
+Works in Node 18+, Bun, Deno and edge runtimes. No dependencies.
+
+## Use it
+
+```ts
+import { Plures } from "plures";
+
+const plures = new Plures(); // reads PLURES_API_KEY, or pass the key: new Plures("pk_test_...")
+
+// Send it and wait for the answer (handy in scripts and agent tools)
+const task = await plures.verify({
+  question: "Does the invoice match the order?",
+  context: "Order: 48 chairs, $4,218. Invoice: 48 chairs plus $180 freight, $4,398.",
+  options: ["Matches", "Does not match"],
+  verifiers: 3,
+});
+console.log(task.result?.answer, task.result?.agreement);
+```
+
+Get a free test key at [plures.si](https://plures.si/?for=developers#join). Test keys complete at once with the first option (or `metadata.test_answer`) and never reach real people. Set `metadata.test_outcome` to `split`, `tie`, `expired` or `slow` to test the cases you route to your own team.
+
+## Production: webhooks
+
+```ts
+await plures.tasks.create(
+  { question, context, options: ["Approve", "Decline"], webhook_url: "https://your.app/plures", metadata: { orderId } },
+  { idempotencyKey: `refund-${orderId}` },
+);
+
+// In your webhook handler, pass the raw body exactly as received
+const event = await Plures.verifyWebhook(rawBody, req.headers.get("plures-signature"), process.env.PLURES_WEBHOOK_SECRET!);
+if (event.type === "task.completed" && event.data.result?.agreement === 1) {
+  // act on event.data.result.answer
+}
+```
+
+## API
+
+- `plures.tasks.create(params, { idempotencyKey? })`: send a task. Params: `question`, `options` (2 to 8, strings or `{ id, label }`), `context`, `image_url`, `instructions`, `verifiers` (1, 3, 5, 7 or 9), `max_verifiers`, `presence_check` (default true), `webhook_url`, `metadata`, `expires_in`.
+- `plures.tasks.retrieve(id)`, `plures.tasks.list({ status?, limit?, starting_after? })`, `plures.tasks.cancel(id)`
+- `plures.tasks.waitFor(id, { timeoutMs?, intervalMs? })`: poll until settled
+- `plures.verify(params, { timeoutMs?, idempotencyKey? })`: create and wait
+- `Plures.verifyWebhook(rawBody, signatureHeader, secret)`: check a webhook and return the event
+
+Errors throw `PluresError` with `status` and `type`. Server errors are retried twice.
+
+The result: `answer` (the option id most people chose, or null on a tie or expiry), `agreement` (0 to 1), `answers`, and `votes`. A good default is to act automatically at `agreement === 1` and send anything lower to your team.
+
+Full reference: [plures.si/docs](https://plures.si/docs). For agents that speak MCP, see [plures-mcp](https://www.npmjs.com/package/plures-mcp).

package/dist/index.cjs

@@ -0,0 +1,119 @@
+"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, {
+  Plures: () => Plures,
+  PluresError: () => PluresError,
+  VERSION: () => VERSION,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var VERSION = "1.1.0";
+var PluresError = class extends Error {
+  constructor(message, status, type) {
+    super(message);
+    this.status = status;
+    this.type = type;
+  }
+  status;
+  type;
+};
+var Plures = class {
+  base;
+  apiKey;
+  constructor(apiKey, opts = {}) {
+    const key = apiKey ?? (typeof process !== "undefined" ? process.env?.PLURES_API_KEY : void 0);
+    if (!key) throw new Error("Pass your Plures API key, or set PLURES_API_KEY. Get a free test key at https://plures.si/?for=developers#join");
+    this.apiKey = key;
+    this.base = (opts.baseUrl ?? (typeof process !== "undefined" ? process.env?.PLURES_BASE_URL : void 0) ?? "https://plures.si").replace(/\/$/, "");
+  }
+  async req(method, path, body, headers = {}) {
+    for (let attempt = 0; ; attempt++) {
+      const r = await fetch(this.base + path, {
+        method,
+        headers: { authorization: `Bearer ${this.apiKey}`, "user-agent": `plures-js/${VERSION}`, ...body ? { "content-type": "application/json" } : {}, ...headers },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (r.status >= 500 && attempt < 2) {
+        await sleep(500 * 2 ** attempt);
+        continue;
+      }
+      const data = await r.json().catch(() => ({}));
+      if (!r.ok) throw new PluresError(data?.error?.message ?? `HTTP ${r.status}`, r.status, data?.error?.type ?? "api_error");
+      return data;
+    }
+  }
+  tasks = {
+    /** Sends a question to verified people. Pass an idempotency key to make retries safe. */
+    create: (params, opts = {}) => this.req("POST", "/api/v1/tasks", params, opts.idempotencyKey ? { "idempotency-key": opts.idempotencyKey } : {}),
+    retrieve: (id) => this.req("GET", `/api/v1/tasks/${encodeURIComponent(id)}`),
+    list: (params = {}) => {
+      const q = new URLSearchParams(Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)]));
+      return this.req("GET", `/api/v1/tasks${q.size ? `?${q}` : ""}`);
+    },
+    cancel: (id) => this.req("POST", `/api/v1/tasks/${encodeURIComponent(id)}/cancel`),
+    /** Polls until the task is settled. Prefer webhooks in production. */
+    waitFor: async (id, opts = {}) => {
+      const end = Date.now() + (opts.timeoutMs ?? 10 * 6e4);
+      for (; ; ) {
+        const t = await this.tasks.retrieve(id);
+        if (t.status !== "pending") return t;
+        if (Date.now() > end) return t;
+        await sleep(opts.intervalMs ?? 3e3);
+      }
+    }
+  };
+  /** Creates a task and waits for people to answer it. */
+  async verify(params, opts = {}) {
+    const t = await this.tasks.create(params, { idempotencyKey: opts.idempotencyKey });
+    return t.status === "pending" ? this.tasks.waitFor(t.id, { timeoutMs: opts.timeoutMs }) : t;
+  }
+  /**
+   * Checks the Plures-Signature header on a webhook and returns the parsed event.
+   * Pass the raw request body exactly as received. Throws if the signature is wrong
+   * or older than toleranceSec.
+   */
+  static async verifyWebhook(rawBody, signatureHeader, secret, toleranceSec = 300) {
+    const parts = Object.fromEntries((signatureHeader ?? "").split(",").map((p) => p.split("=", 2)));
+    const t = Number(parts.t);
+    if (!t || !parts.v1) throw new Error("Missing Plures-Signature header");
+    if (Math.abs(Date.now() / 1e3 - t) > toleranceSec) throw new Error("Webhook timestamp is too old");
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${t}.${rawBody}`)));
+    const expected = Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
+    if (!timingSafeEqual(expected, parts.v1)) throw new Error("Webhook signature does not match");
+    return JSON.parse(rawBody);
+  }
+};
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var index_default = Plures;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Plures,
+  PluresError,
+  VERSION
+});

package/dist/index.d.cts

@@ -0,0 +1,118 @@
+type Option = {
+    id: string;
+    label: string;
+};
+type TaskStatus = "pending" | "completed" | "expired" | "canceled";
+type Result = {
+    answer: string | null;
+    label: string | null;
+    agreement: number;
+    answers: number;
+    votes: Record<string, number>;
+    tie?: boolean;
+    /** Who made the final call: verified people, or your team after verifiers didn't all agree. */
+    decided_by?: "verifiers" | "team";
+    /** The team member who decided, when decided_by is "team". */
+    reviewer?: string;
+    note?: string;
+};
+/** Set when verifiers didn't all agree and the decision went to your team. */
+type Escalation = {
+    reason: "split" | "tie" | "no_answer";
+    escalated_at: string;
+    verifiers: Result | null;
+    team_deadline?: string;
+};
+type Task = {
+    id: string;
+    object: "task";
+    mode: "live" | "test";
+    status: TaskStatus;
+    question: string;
+    context: string | null;
+    image_url: string | null;
+    instructions: string | null;
+    options: Option[];
+    verifiers: number;
+    presence_check?: boolean;
+    result: Result | null;
+    escalation?: Escalation | null;
+    metadata: Record<string, unknown>;
+    webhook_url: string | null;
+    created_at: string;
+    completed_at: string | null;
+    expires_at: string;
+};
+type CreateTask = {
+    question: string;
+    options: (string | Option)[];
+    context?: string;
+    image_url?: string;
+    instructions?: string;
+    verifiers?: 1 | 3 | 5 | 7 | 9;
+    max_verifiers?: number;
+    /** Confirm every answer with the verifier's Face ID, fingerprint or passkey. Default true. */
+    presence_check?: boolean;
+    webhook_url?: string;
+    metadata?: Record<string, unknown>;
+    expires_in?: number;
+    /** Send to your team when verifiers don't agree enough. Default: on when you've added a team. */
+    escalate?: boolean;
+    /** Agreement below which this task goes to your team, 0 to 1. Default from your dashboard. */
+    escalate_below?: number;
+};
+type WebhookEvent = {
+    id: string;
+    type: "task.completed" | "task.expired" | "task.canceled";
+    created_at: string;
+    data: Task;
+};
+declare const VERSION = "1.1.0";
+declare class PluresError extends Error {
+    readonly status: number;
+    readonly type: string;
+    constructor(message: string, status: number, type: string);
+}
+declare class Plures {
+    private base;
+    private apiKey;
+    constructor(apiKey?: string, opts?: {
+        baseUrl?: string;
+    });
+    private req;
+    tasks: {
+        /** Sends a question to verified people. Pass an idempotency key to make retries safe. */
+        create: (params: CreateTask, opts?: {
+            idempotencyKey?: string;
+        }) => Promise<Task>;
+        retrieve: (id: string) => Promise<Task>;
+        list: (params?: {
+            status?: TaskStatus;
+            limit?: number;
+            starting_after?: string;
+        }) => Promise<{
+            object: "list";
+            data: Task[];
+            has_more: boolean;
+        }>;
+        cancel: (id: string) => Promise<Task>;
+        /** Polls until the task is settled. Prefer webhooks in production. */
+        waitFor: (id: string, opts?: {
+            timeoutMs?: number;
+            intervalMs?: number;
+        }) => Promise<Task>;
+    };
+    /** Creates a task and waits for people to answer it. */
+    verify(params: CreateTask, opts?: {
+        timeoutMs?: number;
+        idempotencyKey?: string;
+    }): Promise<Task>;
+    /**
+     * Checks the Plures-Signature header on a webhook and returns the parsed event.
+     * Pass the raw request body exactly as received. Throws if the signature is wrong
+     * or older than toleranceSec.
+     */
+    static verifyWebhook(rawBody: string, signatureHeader: string | null, secret: string, toleranceSec?: number): Promise<WebhookEvent>;
+}
+
+export { type CreateTask, type Escalation, type Option, Plures, PluresError, type Result, type Task, type TaskStatus, VERSION, type WebhookEvent, Plures as default };

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+type Option = {
+    id: string;
+    label: string;
+};
+type TaskStatus = "pending" | "completed" | "expired" | "canceled";
+type Result = {
+    answer: string | null;
+    label: string | null;
+    agreement: number;
+    answers: number;
+    votes: Record<string, number>;
+    tie?: boolean;
+    /** Who made the final call: verified people, or your team after verifiers didn't all agree. */
+    decided_by?: "verifiers" | "team";
+    /** The team member who decided, when decided_by is "team". */
+    reviewer?: string;
+    note?: string;
+};
+/** Set when verifiers didn't all agree and the decision went to your team. */
+type Escalation = {
+    reason: "split" | "tie" | "no_answer";
+    escalated_at: string;
+    verifiers: Result | null;
+    team_deadline?: string;
+};
+type Task = {
+    id: string;
+    object: "task";
+    mode: "live" | "test";
+    status: TaskStatus;
+    question: string;
+    context: string | null;
+    image_url: string | null;
+    instructions: string | null;
+    options: Option[];
+    verifiers: number;
+    presence_check?: boolean;
+    result: Result | null;
+    escalation?: Escalation | null;
+    metadata: Record<string, unknown>;
+    webhook_url: string | null;
+    created_at: string;
+    completed_at: string | null;
+    expires_at: string;
+};
+type CreateTask = {
+    question: string;
+    options: (string | Option)[];
+    context?: string;
+    image_url?: string;
+    instructions?: string;
+    verifiers?: 1 | 3 | 5 | 7 | 9;
+    max_verifiers?: number;
+    /** Confirm every answer with the verifier's Face ID, fingerprint or passkey. Default true. */
+    presence_check?: boolean;
+    webhook_url?: string;
+    metadata?: Record<string, unknown>;
+    expires_in?: number;
+    /** Send to your team when verifiers don't agree enough. Default: on when you've added a team. */
+    escalate?: boolean;
+    /** Agreement below which this task goes to your team, 0 to 1. Default from your dashboard. */
+    escalate_below?: number;
+};
+type WebhookEvent = {
+    id: string;
+    type: "task.completed" | "task.expired" | "task.canceled";
+    created_at: string;
+    data: Task;
+};
+declare const VERSION = "1.1.0";
+declare class PluresError extends Error {
+    readonly status: number;
+    readonly type: string;
+    constructor(message: string, status: number, type: string);
+}
+declare class Plures {
+    private base;
+    private apiKey;
+    constructor(apiKey?: string, opts?: {
+        baseUrl?: string;
+    });
+    private req;
+    tasks: {
+        /** Sends a question to verified people. Pass an idempotency key to make retries safe. */
+        create: (params: CreateTask, opts?: {
+            idempotencyKey?: string;
+        }) => Promise<Task>;
+        retrieve: (id: string) => Promise<Task>;
+        list: (params?: {
+            status?: TaskStatus;
+            limit?: number;
+            starting_after?: string;
+        }) => Promise<{
+            object: "list";
+            data: Task[];
+            has_more: boolean;
+        }>;
+        cancel: (id: string) => Promise<Task>;
+        /** Polls until the task is settled. Prefer webhooks in production. */
+        waitFor: (id: string, opts?: {
+            timeoutMs?: number;
+            intervalMs?: number;
+        }) => Promise<Task>;
+    };
+    /** Creates a task and waits for people to answer it. */
+    verify(params: CreateTask, opts?: {
+        timeoutMs?: number;
+        idempotencyKey?: string;
+    }): Promise<Task>;
+    /**
+     * Checks the Plures-Signature header on a webhook and returns the parsed event.
+     * Pass the raw request body exactly as received. Throws if the signature is wrong
+     * or older than toleranceSec.
+     */
+    static verifyWebhook(rawBody: string, signatureHeader: string | null, secret: string, toleranceSec?: number): Promise<WebhookEvent>;
+}
+
+export { type CreateTask, type Escalation, type Option, Plures, PluresError, type Result, type Task, type TaskStatus, VERSION, type WebhookEvent, Plures as default };

package/dist/index.js

@@ -0,0 +1,92 @@
+// src/index.ts
+var VERSION = "1.1.0";
+var PluresError = class extends Error {
+  constructor(message, status, type) {
+    super(message);
+    this.status = status;
+    this.type = type;
+  }
+  status;
+  type;
+};
+var Plures = class {
+  base;
+  apiKey;
+  constructor(apiKey, opts = {}) {
+    const key = apiKey ?? (typeof process !== "undefined" ? process.env?.PLURES_API_KEY : void 0);
+    if (!key) throw new Error("Pass your Plures API key, or set PLURES_API_KEY. Get a free test key at https://plures.si/?for=developers#join");
+    this.apiKey = key;
+    this.base = (opts.baseUrl ?? (typeof process !== "undefined" ? process.env?.PLURES_BASE_URL : void 0) ?? "https://plures.si").replace(/\/$/, "");
+  }
+  async req(method, path, body, headers = {}) {
+    for (let attempt = 0; ; attempt++) {
+      const r = await fetch(this.base + path, {
+        method,
+        headers: { authorization: `Bearer ${this.apiKey}`, "user-agent": `plures-js/${VERSION}`, ...body ? { "content-type": "application/json" } : {}, ...headers },
+        body: body ? JSON.stringify(body) : void 0
+      });
+      if (r.status >= 500 && attempt < 2) {
+        await sleep(500 * 2 ** attempt);
+        continue;
+      }
+      const data = await r.json().catch(() => ({}));
+      if (!r.ok) throw new PluresError(data?.error?.message ?? `HTTP ${r.status}`, r.status, data?.error?.type ?? "api_error");
+      return data;
+    }
+  }
+  tasks = {
+    /** Sends a question to verified people. Pass an idempotency key to make retries safe. */
+    create: (params, opts = {}) => this.req("POST", "/api/v1/tasks", params, opts.idempotencyKey ? { "idempotency-key": opts.idempotencyKey } : {}),
+    retrieve: (id) => this.req("GET", `/api/v1/tasks/${encodeURIComponent(id)}`),
+    list: (params = {}) => {
+      const q = new URLSearchParams(Object.entries(params).filter(([, v]) => v != null).map(([k, v]) => [k, String(v)]));
+      return this.req("GET", `/api/v1/tasks${q.size ? `?${q}` : ""}`);
+    },
+    cancel: (id) => this.req("POST", `/api/v1/tasks/${encodeURIComponent(id)}/cancel`),
+    /** Polls until the task is settled. Prefer webhooks in production. */
+    waitFor: async (id, opts = {}) => {
+      const end = Date.now() + (opts.timeoutMs ?? 10 * 6e4);
+      for (; ; ) {
+        const t = await this.tasks.retrieve(id);
+        if (t.status !== "pending") return t;
+        if (Date.now() > end) return t;
+        await sleep(opts.intervalMs ?? 3e3);
+      }
+    }
+  };
+  /** Creates a task and waits for people to answer it. */
+  async verify(params, opts = {}) {
+    const t = await this.tasks.create(params, { idempotencyKey: opts.idempotencyKey });
+    return t.status === "pending" ? this.tasks.waitFor(t.id, { timeoutMs: opts.timeoutMs }) : t;
+  }
+  /**
+   * Checks the Plures-Signature header on a webhook and returns the parsed event.
+   * Pass the raw request body exactly as received. Throws if the signature is wrong
+   * or older than toleranceSec.
+   */
+  static async verifyWebhook(rawBody, signatureHeader, secret, toleranceSec = 300) {
+    const parts = Object.fromEntries((signatureHeader ?? "").split(",").map((p) => p.split("=", 2)));
+    const t = Number(parts.t);
+    if (!t || !parts.v1) throw new Error("Missing Plures-Signature header");
+    if (Math.abs(Date.now() / 1e3 - t) > toleranceSec) throw new Error("Webhook timestamp is too old");
+    const key = await crypto.subtle.importKey("raw", new TextEncoder().encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, new TextEncoder().encode(`${t}.${rawBody}`)));
+    const expected = Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
+    if (!timingSafeEqual(expected, parts.v1)) throw new Error("Webhook signature does not match");
+    return JSON.parse(rawBody);
+  }
+};
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var index_default = Plures;
+export {
+  Plures,
+  PluresError,
+  VERSION,
+  index_default as default
+};

package/package.json

@@ -1,6 +1,58 @@
 {
   "name": "plures",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.1.0",
+  "description": "Human judgment as an API for AI agents. Send a decision to ID verified people and get their consensus back.",
+  "keywords": [
+    "human-in-the-loop",
+    "hitl",
+    "ai-agents",
+    "human-review",
+    "human-approval",
+    "agents",
+    "llm",
+    "verification",
+    "plures"
+  ],
+  "homepage": "https://plures.si/docs",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/plureslabs/plures.git",
+    "directory": "js"
+  },
+  "bugs": "https://github.com/plureslabs/plures/issues",
+  "license": "MIT",
+  "author": "Plures Labs LLC <hello@plures.si>",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.6.3",
+    "@types/node": "^22.10.0"
+  }
+}