@rayrun/sdk 0.2.0

package/LICENSE

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2026 Rayrun
+
+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

@@ -0,0 +1,84 @@
+# @rayrun/sdk
+
+```sh
+npm install @rayrun/sdk
+```
+
+```js
+import { Rayrun } from '@rayrun/sdk';
+
+const rayrun = new Rayrun({ apiKey: process.env.RAYRUN_API_KEY });
+const { items: connections } = await rayrun.connections.list();
+```
+
+Create keys in **Dashboard → Settings → API keys**. The plaintext is shown once.
+
+The client covers catalog search, connection and credential setup, OAuth links, indexing, tool and
+client policies, activity, review queues, and webhooks. Safe reads retry rate limits, server errors,
+and transient network failures; writes do not retry automatically.
+
+## Stream code run-ahead
+
+A model harness that receives `execute_code` arguments incrementally can let Rayrun start eligible
+reads before generation finishes. Authenticate this companion channel with the same MCP OAuth access
+token used for the final tool call. Feed cumulative JSON argument snapshots, not individual token
+deltas.
+
+```js
+import { RayrunGateway } from '@rayrun/sdk';
+
+const gateway = new RayrunGateway({ accessToken: mcpAccessToken });
+const runAhead = await gateway.codeRunAhead.open();
+
+try {
+  for await (const argumentsSnapshot of streamedExecuteCodeArguments) {
+    void runAhead?.feedArguments(argumentsSnapshot);
+  }
+
+  await runAhead?.flush();
+
+  const result = await mcp.callTool({
+    name: 'execute_code',
+    arguments: JSON.parse(finalArguments),
+    ...(runAhead ? { _meta: runAhead.meta } : {}),
+  });
+} finally {
+  await runAhead?.close();
+}
+```
+
+`open()` returns `null` when this optional optimization is rate-limited or temporarily unavailable.
+`feedArguments()` coalesces snapshots while one request is in flight; call `flush()` once before the
+final MCP request. It throws synchronously when a snapshot is not a string, so TypeScript users get
+the mistake at the call site. If an active session becomes unavailable, `meta` becomes an empty object. In
+either case, send the final MCP call normally. Rayrun only runs ahead tools that are explicitly
+allowed, approved as Read by a workspace owner, and advertised by their server as read-only and
+idempotent. The final MCP call rechecks the token, complete program, policy, definition, arguments,
+and upstream identity before it can use an early result.
+
+## Verify webhooks
+
+Pass the exact request body and the `Rayrun-Signature` header before parsing the event. Verification
+also rejects timestamps outside a five-minute replay window by default.
+
+```js
+import { verifyWebhookSignature } from '@rayrun/sdk';
+
+const valid = verifyWebhookSignature({
+  body: rawBody,
+  secret: process.env.RAYRUN_WEBHOOK_SECRET,
+  signature: request.headers['rayrun-signature'],
+});
+```
+
+After verification, parse the body as `WebhookPayload`. Every event has a stable `id`, `type`, and
+`occurredAt`; its `data` shape is narrowed by `type`. Use `id` to deduplicate retries.
+
+```ts
+import type { WebhookPayload } from '@rayrun/sdk';
+
+const event: WebhookPayload = JSON.parse(rawBody);
+if (event.type === 'review.changed') {
+  console.log(event.data.reviewUid, event.data.status);
+}
+```

package/index.d.ts

@@ -0,0 +1,265 @@
+/* oxlint-disable perfectionist/sort-classes, perfectionist/sort-modules, perfectionist/sort-object-types, perfectionist/sort-union-types -- Public types follow the documented API resource order. */
+export type CursorPage<T> = { items: T[]; page: { nextCursor: string | null } };
+export type PageQuery = { cursor?: string; limit?: number };
+export type ToolDecision = 'allow' | 'ask' | 'block';
+export type ToolAccessMode = 'read-only' | 'ask-before-changes' | 'allow-all' | 'custom';
+export type Risk = 'read' | 'change' | 'destructive' | 'unknown';
+export type Connection = {
+  authorizedAt: string | null;
+  authType: 'api-key' | 'basic' | 'none' | 'oauth2';
+  createdAt: string;
+  uid: string;
+  displayName: string;
+  enabled: boolean;
+  healthy: boolean | null;
+  kind: 'mcp' | 'openapi';
+  lastIndexedAt: string | null;
+  slug: string;
+  status: 'connected' | 'disabled' | 'error' | 'indexing' | 'needs-authorization' | 'new';
+  toolAccessMode: ToolAccessMode;
+};
+export type CatalogEntry = {
+  authType: Connection['authType'];
+  category: string | null;
+  description: string | null;
+  name: string;
+  namespace: string;
+  slug: string;
+  transport: string;
+  uid: string;
+};
+export type Tool = {
+  uid: string;
+  connectionUid: string;
+  name: string;
+  description: string | null;
+  risk: Risk;
+  riskReason: string;
+  approved: boolean;
+  rule: ToolDecision | null;
+  available: boolean;
+  callCount: number;
+  inputSchema: Record<string, unknown>;
+  title: string | null;
+};
+export type Client = {
+  clientName: string;
+  grantedAt: string;
+  lastUsedAt: string | null;
+  redirectHost: string;
+  revokedAt: string | null;
+  toolAccessMode: ToolAccessMode;
+  uid: string;
+  userName: string;
+};
+export type Activity = {
+  calledAt: string;
+  clientName: string | null;
+  connectionName: string | null;
+  durationMs: number | null;
+  errorCode: string | null;
+  id: string;
+  policyDecision: ToolDecision | null;
+  succeeded: boolean | null;
+  toolName: string;
+  userName: string | null;
+};
+export type Review = {
+  connectionName: string;
+  createdAt: string;
+  expiresAt: string;
+  status: 'approved' | 'cancelled' | 'consumed' | 'denied' | 'expired' | 'pending';
+  toolName: string;
+  uid: string;
+};
+export type Webhook = {
+  createdAt: string;
+  description: string | null;
+  enabled: boolean;
+  eventTypes: WebhookEvent[];
+  uid: string;
+  url: string;
+};
+export type Credential =
+  | {
+      authType: 'api-key';
+      apiKey: string;
+      apiKeyLocation: 'bearer-authentication' | 'header' | 'search-parameter';
+      apiKeyName?: string | null;
+      headers?: Record<string, string> | null;
+    }
+  | {
+      authType: 'basic';
+      basicPassword: string;
+      basicUsername: string;
+      headers?: Record<string, string> | null;
+    }
+  | { authType: 'none'; headers?: Record<string, string> | null };
+export type WebhookEvent =
+  | '*'
+  | 'activity.call'
+  | 'connection.changed'
+  | 'connection.indexed'
+  | 'review.changed'
+  | 'tool.definition-changed'
+  | 'tool.policy-changed';
+export type WebhookEnvelope<T extends Exclude<WebhookEvent, '*'>, D> = {
+  data: D;
+  id: string;
+  occurredAt: string;
+  type: T;
+};
+export type WebhookPayload =
+  | WebhookEnvelope<
+      'activity.call',
+      {
+        activityId: string;
+        calledAt: string;
+        connectionUid: string | null;
+        errorCode: string | null;
+        policyDecision: ToolDecision | null;
+        succeeded: boolean | null;
+        toolName: string;
+      }
+    >
+  | WebhookEnvelope<
+      'connection.changed',
+      {
+        authType: Connection['authType'];
+        connectionUid: string;
+        enabled: boolean;
+        kind: Connection['kind'];
+        name: string;
+      }
+    >
+  | WebhookEnvelope<
+      'connection.indexed',
+      {
+        connectionUid: string;
+        indexReferenceId: string;
+        status: string;
+        toolCount: number;
+      }
+    >
+  | WebhookEnvelope<
+      'review.changed',
+      {
+        connectionUid: string;
+        reviewUid: string;
+        status: Review['status'];
+        toolUid: string;
+      }
+    >
+  | WebhookEnvelope<
+      'tool.definition-changed',
+      { approved: boolean; connectionUid: string; kind: 'added' | 'changed'; toolUid: string }
+    >
+  | WebhookEnvelope<
+      'tool.policy-changed',
+      {
+        connectionUid: string | null;
+        decision: ToolDecision | null;
+        eventType: string;
+        toolUid: string | null;
+      }
+    >;
+
+export const CODE_RUN_AHEAD_META_KEY: 'io.rayrun/run-ahead-session';
+
+export class RayrunApiError extends Error {
+  code: string;
+  requestId: string | null;
+  status: number;
+}
+
+export function verifyWebhookSignature(options: {
+  body: string;
+  now?: number;
+  secret: string;
+  signature: string;
+  toleranceSeconds?: number;
+}): boolean;
+
+export class Rayrun {
+  constructor(options: { apiKey: string; baseUrl?: string; fetch?: typeof fetch });
+  catalog: {
+    list(query?: PageQuery & { query?: string }): Promise<CursorPage<CatalogEntry>>;
+  };
+  connections: {
+    create(
+      body:
+        | {
+            kind: 'mcp';
+            name: string;
+            url: string;
+            description?: string | null;
+            transport?: 'sse' | 'streamable-http';
+          }
+        | { kind: 'openapi'; specificationUrl: string; baseUrl?: string; name?: string },
+    ): Promise<{ connection: { uid: string } }>;
+    createOAuthLink(uid: string): Promise<{ authorizationUrl: string }>;
+    delete(uid: string): Promise<void>;
+    index(uid: string): Promise<{ enqueued: boolean }>;
+    list(query?: PageQuery): Promise<CursorPage<Connection>>;
+    setCredential(uid: string, body: Credential): Promise<{ enqueued: boolean }>;
+    setEnabled(
+      uid: string,
+      enabled: boolean,
+    ): Promise<{ connection: Pick<Connection, 'displayName' | 'enabled' | 'uid'> }>;
+    setPolicy(uid: string, mode: ToolAccessMode): Promise<void>;
+  };
+  tools: {
+    list(query?: PageQuery & { connectionUid?: string }): Promise<CursorPage<Tool>>;
+    setPolicy(
+      connectionUid: string,
+      toolUid: string,
+      body: { decision: ToolDecision | null; riskConfirmed?: boolean; riskOverride?: Risk | null },
+    ): Promise<void>;
+  };
+  clients: {
+    list(query?: PageQuery): Promise<CursorPage<Client>>;
+    setPolicy(uid: string, mode: Exclude<ToolAccessMode, 'custom'>): Promise<void>;
+    setToolPolicy(
+      uid: string,
+      toolUid: string,
+      body: { decision: ToolDecision | null; riskConfirmed?: boolean },
+    ): Promise<void>;
+  };
+  activity: { list(query?: PageQuery): Promise<CursorPage<Activity>> };
+  reviews: { list(query?: PageQuery): Promise<CursorPage<Review>> };
+  webhooks: {
+    create(body: {
+      url: string;
+      description?: string | null;
+      eventTypes: WebhookEvent[];
+    }): Promise<{ uid: string; secret: string }>;
+    delete(uid: string): Promise<void>;
+    list(): Promise<{ items: Webhook[] }>;
+    verify: typeof verifyWebhookSignature;
+  };
+  request(
+    method: string,
+    path: string,
+    options?: { body?: unknown; query?: Record<string, unknown>; signal?: AbortSignal },
+  ): Promise<unknown>;
+}
+
+export class RayrunCodeRunAheadSession {
+  private constructor();
+  readonly expiresAt: string;
+  readonly sessionId: string;
+  readonly meta: { readonly 'io.rayrun/run-ahead-session': string } | Record<string, never>;
+  feedArguments(rawArguments: string, options?: { signal?: AbortSignal }): Promise<void>;
+  flush(): Promise<void>;
+  close(options?: { signal?: AbortSignal }): Promise<void>;
+}
+
+export class RayrunGateway {
+  constructor(options: { accessToken: string; baseUrl?: string; fetch?: typeof fetch });
+  codeRunAhead: {
+    open(options?: {
+      services?: readonly string[];
+      signal?: AbortSignal;
+    }): Promise<RayrunCodeRunAheadSession | null>;
+  };
+}

package/index.js

@@ -0,0 +1,325 @@
+import { createHmac, timingSafeEqual } from 'node:crypto';
+
+export class RayrunApiError extends Error {
+  constructor(message, { code, requestId, status }) {
+    super(message);
+    this.name = 'RayrunApiError';
+    this.code = code;
+    this.requestId = requestId;
+    this.status = status;
+  }
+}
+
+export const CODE_RUN_AHEAD_META_KEY = 'io.rayrun/run-ahead-session';
+
+const isRunAheadAvailabilityError = (error) => {
+  return (
+    error instanceof TypeError ||
+    (error instanceof RayrunApiError &&
+      (error.status === 404 || error.status === 409 || error.status === 429 || error.status >= 500))
+  );
+};
+
+const withoutUndefined = (value) => {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+};
+
+const retryDelayMilliseconds = (retryAfter, attempt) => {
+  if (retryAfter) {
+    const seconds = Number(retryAfter);
+    if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1_000;
+
+    const date = Date.parse(retryAfter);
+    if (Number.isFinite(date)) return Math.max(0, date - Date.now());
+  }
+
+  const base = 250 * 2 ** attempt;
+  return base + Math.floor(Math.random() * Math.max(1, base / 4));
+};
+
+const wait = async (milliseconds, signal) => {
+  await new Promise((resolve, reject) => {
+    const finish = () => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve();
+    };
+    const onAbort = () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener('abort', onAbort);
+      reject(signal.reason);
+    };
+    const timeout = setTimeout(finish, milliseconds);
+
+    if (signal?.aborted) return onAbort();
+    signal?.addEventListener('abort', onAbort, { once: true });
+  });
+};
+
+export const verifyWebhookSignature = ({
+  body,
+  now = Date.now(),
+  secret,
+  signature,
+  toleranceSeconds = 300,
+}) => {
+  const fields = new Map(signature.split(',').map((field) => field.split('=', 2)));
+  const timestamp = fields.get('t');
+  const suppliedDigest = fields.get('v1');
+  if (
+    !timestamp ||
+    !suppliedDigest ||
+    !/^\d+$/u.test(timestamp) ||
+    !/^[0-9a-f]{64}$/u.test(suppliedDigest)
+  ) {
+    return false;
+  }
+  if (Math.abs(Math.floor(now / 1_000) - Number(timestamp)) > toleranceSeconds) return false;
+
+  const expectedDigest = createHmac('sha256', secret).update(`${timestamp}.${body}`).digest('hex');
+  return timingSafeEqual(Buffer.from(suppliedDigest, 'hex'), Buffer.from(expectedDigest, 'hex'));
+};
+
+export class Rayrun {
+  constructor({
+    apiKey,
+    baseUrl = 'https://ray.run',
+    fetch: fetchImplementation = globalThis.fetch,
+  }) {
+    if (!apiKey) throw new TypeError('Rayrun requires an apiKey.');
+    if (!fetchImplementation) throw new TypeError('Rayrun requires a fetch implementation.');
+
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/u, '');
+    this.fetch = fetchImplementation;
+
+    this.catalog = { list: (query) => this.request('GET', '/catalog', { query }) };
+    this.connections = {
+      create: (body) => this.request('POST', '/connections', { body }),
+      createOAuthLink: (uid) => this.request('POST', `/connections/${uid}/oauth-link`),
+      delete: (uid) => this.request('DELETE', `/connections/${uid}`),
+      index: (uid) => this.request('POST', `/connections/${uid}/index`),
+      list: (query) => this.request('GET', '/connections', { query }),
+      setCredential: (uid, body) => this.request('PUT', `/connections/${uid}/credential`, { body }),
+      setEnabled: (uid, enabled) =>
+        this.request('PATCH', `/connections/${uid}`, { body: { enabled } }),
+      setPolicy: (uid, mode) =>
+        this.request('PATCH', `/connections/${uid}/policy`, { body: { mode } }),
+    };
+    this.tools = {
+      list: (query) => this.request('GET', '/tools', { query }),
+      setPolicy: (connectionUid, toolUid, body) =>
+        this.request('PATCH', `/connections/${connectionUid}/tools/${toolUid}/policy`, { body }),
+    };
+    this.clients = {
+      list: (query) => this.request('GET', '/clients', { query }),
+      setPolicy: (uid, mode) => this.request('PATCH', `/clients/${uid}/policy`, { body: { mode } }),
+      setToolPolicy: (uid, toolUid, body) =>
+        this.request('PATCH', `/clients/${uid}/tools/${toolUid}/policy`, { body }),
+    };
+    this.activity = { list: (query) => this.request('GET', '/activity', { query }) };
+    this.reviews = { list: (query) => this.request('GET', '/reviews', { query }) };
+    this.webhooks = {
+      create: (body) => this.request('POST', '/webhooks', { body }),
+      delete: (uid) => this.request('DELETE', `/webhooks/${uid}`),
+      list: () => this.request('GET', '/webhooks'),
+      verify: verifyWebhookSignature,
+    };
+  }
+
+  async request(method, path, { body, query, signal } = {}) {
+    const url = new URL(`${this.baseUrl}/v1${path}`);
+    for (const [name, value] of Object.entries(withoutUndefined(query ?? {}))) {
+      url.searchParams.set(name, String(value));
+    }
+
+    const retries = method === 'GET' ? 2 : 0;
+    for (let attempt = 0; ; attempt += 1) {
+      let response;
+
+      try {
+        response = await this.fetch(url, {
+          body: body === undefined ? undefined : JSON.stringify(body),
+          headers: withoutUndefined({
+            authorization: `Bearer ${this.apiKey}`,
+            'content-type': body === undefined ? undefined : 'application/json',
+            'user-agent': '@rayrun/sdk',
+          }),
+          method,
+          signal,
+        });
+      } catch (error) {
+        if (attempt >= retries || signal?.aborted || error?.name === 'AbortError') throw error;
+        await wait(retryDelayMilliseconds(null, attempt), signal);
+        continue;
+      }
+
+      if ((response.status === 429 || response.status >= 500) && attempt < retries) {
+        const retryAfter = response.headers.get('retry-after');
+        await Promise.resolve(response.body?.cancel()).catch(() => {});
+        await wait(retryDelayMilliseconds(retryAfter, attempt), signal);
+        continue;
+      }
+
+      if (!response.ok) {
+        const problem = await response.json().catch(() => null);
+        throw new RayrunApiError(
+          problem?.error?.message ?? `Rayrun API request failed with HTTP ${response.status}.`,
+          {
+            code: problem?.error?.code ?? 'request_failed',
+            requestId: problem?.error?.requestId ?? response.headers.get('rayrun-request-id'),
+            status: response.status,
+          },
+        );
+      }
+
+      return response.status === 204 ? undefined : response.json();
+    }
+  }
+}
+
+export class RayrunCodeRunAheadSession {
+  constructor({ gateway, sessionId, expiresAt }) {
+    this.gateway = gateway;
+    this.sessionId = sessionId;
+    this.expiresAt = expiresAt;
+    this.active = true;
+    this.latestArguments = '';
+    this.sentArguments = '';
+    this.pending = Promise.resolve();
+    this.draining = false;
+  }
+
+  get meta() {
+    return this.active ? { [CODE_RUN_AHEAD_META_KEY]: this.sessionId } : {};
+  }
+
+  feedArguments(rawArguments, { signal } = {}) {
+    if (typeof rawArguments !== 'string') {
+      throw new TypeError('Run-ahead arguments must be a JSON string snapshot.');
+    }
+
+    if (rawArguments.length <= this.latestArguments.length) return this.pending;
+
+    this.latestArguments = rawArguments;
+    if (this.draining) return this.pending;
+
+    this.draining = true;
+    this.pending = this.pending
+      .then(async () => {
+        while (this.active && this.sentArguments.length < this.latestArguments.length) {
+          const snapshot = this.latestArguments;
+
+          this.sentArguments = snapshot;
+
+          try {
+            await this.gateway.request({
+              body: { arguments: snapshot, operation: 'feed', sessionId: this.sessionId },
+              signal,
+            });
+          } catch (error) {
+            if (!isRunAheadAvailabilityError(error)) throw error;
+
+            this.active = false;
+          }
+        }
+      })
+      .finally(() => {
+        this.draining = false;
+      });
+    // Harnesses commonly enqueue snapshots without awaiting each one, then call flush() once.
+    // Attach a handler now so a contract/authentication error cannot become an unhandled rejection
+    // before flush() observes and rethrows the original rejected promise.
+    void this.pending.catch(() => {});
+
+    return this.pending;
+  }
+
+  async flush() {
+    try {
+      await this.pending;
+    } catch (error) {
+      if (isRunAheadAvailabilityError(error)) {
+        this.active = false;
+        return;
+      }
+
+      throw error;
+    }
+  }
+
+  async close({ signal } = {}) {
+    await this.pending.catch(() => {});
+    if (!this.active) return;
+
+    try {
+      await this.gateway.request({
+        body: { operation: 'close', sessionId: this.sessionId },
+        signal,
+      });
+    } catch {
+      // Closing is best-effort. The server expires abandoned sessions after two minutes, and an
+      // optional latency optimization must never replace or mask the authoritative MCP result.
+    } finally {
+      this.active = false;
+    }
+  }
+}
+
+export class RayrunGateway {
+  constructor({
+    accessToken,
+    baseUrl = 'https://ray.run',
+    fetch: fetchImplementation = globalThis.fetch,
+  }) {
+    if (!accessToken) throw new TypeError('RayrunGateway requires an accessToken.');
+    if (!fetchImplementation) throw new TypeError('RayrunGateway requires a fetch implementation.');
+
+    this.accessToken = accessToken;
+    this.baseUrl = baseUrl.replace(/\/$/u, '');
+    this.fetch = fetchImplementation;
+    this.codeRunAhead = {
+      open: async ({ services, signal } = {}) => {
+        try {
+          const created = await this.request({
+            body: withoutUndefined({ operation: 'start', services }),
+            signal,
+          });
+
+          return new RayrunCodeRunAheadSession({ gateway: this, ...created });
+        } catch (error) {
+          if (isRunAheadAvailabilityError(error)) return null;
+          throw error;
+        }
+      },
+    };
+  }
+
+  async request({ body, signal }) {
+    const response = await this.fetch(`${this.baseUrl}/mcp/run-ahead`, {
+      body: JSON.stringify(body),
+      headers: {
+        authorization: `Bearer ${this.accessToken}`,
+        'content-type': 'application/json',
+        'user-agent': '@rayrun/sdk',
+      },
+      method: 'POST',
+      signal,
+    });
+
+    if (!response.ok) {
+      const problem = await response.json().catch(() => null);
+      throw new RayrunApiError(
+        problem?.error_description ??
+          problem?.error?.message ??
+          `Rayrun gateway request failed with HTTP ${response.status}.`,
+        {
+          code: problem?.error?.code ?? problem?.error ?? 'request_failed',
+          requestId: problem?.error?.requestId ?? response.headers.get('rayrun-request-id'),
+          status: response.status,
+        },
+      );
+    }
+
+    return response.status === 204 ? undefined : response.json();
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@rayrun/sdk",
+  "version": "0.2.0",
+  "description": "Type-safe client for the Rayrun public API",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/rayrundev/rayrun.git",
+    "directory": "packages/sdk"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=20"
+  }
+}