ai-sdk-guardrails 1.0.0

package/dist/index-CWIb12lh.d.cts

@@ -0,0 +1,121 @@
+import * as ai from 'ai';
+import { generateText, generateObject, streamText, streamObject, embed } from 'ai';
+
+interface GuardrailResult {
+    /** Whether the guardrail was triggered (blocked the request) */
+    tripwireTriggered: boolean;
+    /** Human-readable message describing why the guardrail was triggered */
+    message?: string;
+    /** Detailed metadata about the guardrail execution */
+    metadata?: Record<string, unknown>;
+    /** Severity level of the guardrail violation */
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+    /** Suggested action to resolve the issue */
+    suggestion?: string;
+    /** Performance metrics for the guardrail execution */
+    performance?: {
+        executionTimeMs: number;
+        memoryUsage?: number;
+    };
+    /** Additional context information */
+    context?: {
+        guardrailName: string;
+        guardrailVersion?: string;
+        executedAt: Date;
+        environment?: string;
+    };
+}
+type GuardrailsParams = {
+    inputGuardrails?: InputGuardrail[];
+    outputGuardrails?: OutputGuardrail[];
+    onInputBlocked?: (error: GuardrailError) => void;
+    onOutputBlocked?: (error: GuardrailError) => void;
+    throwOnBlocked?: boolean;
+    enablePerformanceMonitoring?: boolean;
+};
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type GenerateObjectParams = Parameters<typeof generateObject>[0];
+type StreamTextParams = Parameters<typeof streamText>[0];
+type StreamObjectParams = Parameters<typeof streamObject>[0];
+type EmbedParams = Parameters<typeof embed>[0];
+type GenerateTextResult = Awaited<ReturnType<typeof generateText>>;
+type GenerateObjectResult = Awaited<ReturnType<typeof generateObject>>;
+type StreamTextResult = ReturnType<typeof streamText>;
+type StreamObjectResult = ReturnType<typeof streamObject>;
+type EmbedResult = ReturnType<typeof embed>;
+type InputGuardrailContext = GenerateTextParams | GenerateObjectParams | StreamTextParams | StreamObjectParams | EmbedParams;
+type AIResult = GenerateTextResult | GenerateObjectResult | StreamTextResult | StreamObjectResult | EmbedResult;
+type OutputGuardrailContext = {
+    input: InputGuardrailContext;
+    result: AIResult;
+};
+interface InputGuardrail {
+    /** Unique identifier for the guardrail */
+    name: string;
+    /** Human-readable description of what this guardrail does */
+    description?: string;
+    /** Version of the guardrail for tracking changes */
+    version?: string;
+    /** Tags for categorizing guardrails */
+    tags?: string[];
+    /** Whether this guardrail is enabled */
+    enabled?: boolean;
+    /** Priority level for execution order */
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    /** Configuration options for the guardrail */
+    config?: Record<string, string | number | boolean>;
+    /** The main execution function */
+    execute: (context: InputGuardrailContext) => Promise<GuardrailResult> | GuardrailResult;
+    /** Optional setup function called once when guardrail is initialized */
+    setup?: () => Promise<void> | void;
+    /** Optional cleanup function called when guardrail is destroyed */
+    cleanup?: () => Promise<void> | void;
+}
+interface OutputGuardrail {
+    /** Unique identifier for the guardrail */
+    name: string;
+    /** Human-readable description of what this guardrail does */
+    description?: string;
+    /** Version of the guardrail for tracking changes */
+    version?: string;
+    /** Tags for categorizing guardrails */
+    tags?: string[];
+    /** Whether this guardrail is enabled */
+    enabled?: boolean;
+    /** Priority level for execution order */
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    /** Configuration options for the guardrail */
+    config?: Record<string, string | number | boolean>;
+    /** The main execution function */
+    execute: (context: OutputGuardrailContext, accumulatedText?: string) => Promise<GuardrailResult> | GuardrailResult;
+    /** Optional setup function called once when guardrail is initialized */
+    setup?: () => Promise<void> | void;
+    /** Optional cleanup function called when guardrail is destroyed */
+    cleanup?: () => Promise<void> | void;
+}
+
+declare class GuardrailError extends Error {
+    guardrailName: string;
+    reason: string;
+    type: 'input' | 'output';
+    issues: Array<{
+        guardrail: string;
+        message: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    constructor(guardrailName: string, reason: string, type: 'input' | 'output');
+    getSummary(): {
+        totalIssues: number;
+        guardrailsTriggered: string[];
+        type: "input" | "output";
+    };
+}
+declare function generateTextWithGuardrails(params: Parameters<typeof generateText>[0], guardrailParams: GuardrailsParams): Promise<ai.GenerateTextResult<ai.ToolSet, unknown>>;
+declare function generateObjectWithGuardrails(params: Parameters<typeof generateObject>[0], guardrailParams: GuardrailsParams): Promise<ReturnType<typeof generateObject>>;
+declare function streamTextWithGuardrails(params: StreamTextParams, guardrailParams: GuardrailsParams): Promise<ReturnType<typeof streamText>>;
+declare function streamObjectWithGuardrails(params: StreamObjectParams, guardrailParams: GuardrailsParams): Promise<ReturnType<typeof streamObject>>;
+declare function embedWithGuardrails(params: EmbedParams, guardrailParams: GuardrailsParams): Promise<ai.EmbedResult<unknown>>;
+declare function createInputGuardrail(name: string, description: string, execute: InputGuardrail['execute']): InputGuardrail;
+declare function createOutputGuardrail(name: string, execute: OutputGuardrail['execute']): OutputGuardrail;
+
+export { type AIResult as A, GuardrailError as G, type InputGuardrailContext as I, type OutputGuardrail as O, type InputGuardrail as a, generateObjectWithGuardrails as b, streamObjectWithGuardrails as c, createInputGuardrail as d, embedWithGuardrails as e, createOutputGuardrail as f, generateTextWithGuardrails as g, type GuardrailResult as h, type GuardrailsParams as i, streamTextWithGuardrails as s };

package/dist/index-CWIb12lh.d.ts

@@ -0,0 +1,121 @@
+import * as ai from 'ai';
+import { generateText, generateObject, streamText, streamObject, embed } from 'ai';
+
+interface GuardrailResult {
+    /** Whether the guardrail was triggered (blocked the request) */
+    tripwireTriggered: boolean;
+    /** Human-readable message describing why the guardrail was triggered */
+    message?: string;
+    /** Detailed metadata about the guardrail execution */
+    metadata?: Record<string, unknown>;
+    /** Severity level of the guardrail violation */
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+    /** Suggested action to resolve the issue */
+    suggestion?: string;
+    /** Performance metrics for the guardrail execution */
+    performance?: {
+        executionTimeMs: number;
+        memoryUsage?: number;
+    };
+    /** Additional context information */
+    context?: {
+        guardrailName: string;
+        guardrailVersion?: string;
+        executedAt: Date;
+        environment?: string;
+    };
+}
+type GuardrailsParams = {
+    inputGuardrails?: InputGuardrail[];
+    outputGuardrails?: OutputGuardrail[];
+    onInputBlocked?: (error: GuardrailError) => void;
+    onOutputBlocked?: (error: GuardrailError) => void;
+    throwOnBlocked?: boolean;
+    enablePerformanceMonitoring?: boolean;
+};
+type GenerateTextParams = Parameters<typeof generateText>[0];
+type GenerateObjectParams = Parameters<typeof generateObject>[0];
+type StreamTextParams = Parameters<typeof streamText>[0];
+type StreamObjectParams = Parameters<typeof streamObject>[0];
+type EmbedParams = Parameters<typeof embed>[0];
+type GenerateTextResult = Awaited<ReturnType<typeof generateText>>;
+type GenerateObjectResult = Awaited<ReturnType<typeof generateObject>>;
+type StreamTextResult = ReturnType<typeof streamText>;
+type StreamObjectResult = ReturnType<typeof streamObject>;
+type EmbedResult = ReturnType<typeof embed>;
+type InputGuardrailContext = GenerateTextParams | GenerateObjectParams | StreamTextParams | StreamObjectParams | EmbedParams;
+type AIResult = GenerateTextResult | GenerateObjectResult | StreamTextResult | StreamObjectResult | EmbedResult;
+type OutputGuardrailContext = {
+    input: InputGuardrailContext;
+    result: AIResult;
+};
+interface InputGuardrail {
+    /** Unique identifier for the guardrail */
+    name: string;
+    /** Human-readable description of what this guardrail does */
+    description?: string;
+    /** Version of the guardrail for tracking changes */
+    version?: string;
+    /** Tags for categorizing guardrails */
+    tags?: string[];
+    /** Whether this guardrail is enabled */
+    enabled?: boolean;
+    /** Priority level for execution order */
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    /** Configuration options for the guardrail */
+    config?: Record<string, string | number | boolean>;
+    /** The main execution function */
+    execute: (context: InputGuardrailContext) => Promise<GuardrailResult> | GuardrailResult;
+    /** Optional setup function called once when guardrail is initialized */
+    setup?: () => Promise<void> | void;
+    /** Optional cleanup function called when guardrail is destroyed */
+    cleanup?: () => Promise<void> | void;
+}
+interface OutputGuardrail {
+    /** Unique identifier for the guardrail */
+    name: string;
+    /** Human-readable description of what this guardrail does */
+    description?: string;
+    /** Version of the guardrail for tracking changes */
+    version?: string;
+    /** Tags for categorizing guardrails */
+    tags?: string[];
+    /** Whether this guardrail is enabled */
+    enabled?: boolean;
+    /** Priority level for execution order */
+    priority?: 'low' | 'medium' | 'high' | 'critical';
+    /** Configuration options for the guardrail */
+    config?: Record<string, string | number | boolean>;
+    /** The main execution function */
+    execute: (context: OutputGuardrailContext, accumulatedText?: string) => Promise<GuardrailResult> | GuardrailResult;
+    /** Optional setup function called once when guardrail is initialized */
+    setup?: () => Promise<void> | void;
+    /** Optional cleanup function called when guardrail is destroyed */
+    cleanup?: () => Promise<void> | void;
+}
+
+declare class GuardrailError extends Error {
+    guardrailName: string;
+    reason: string;
+    type: 'input' | 'output';
+    issues: Array<{
+        guardrail: string;
+        message: string;
+        metadata?: Record<string, unknown>;
+    }>;
+    constructor(guardrailName: string, reason: string, type: 'input' | 'output');
+    getSummary(): {
+        totalIssues: number;
+        guardrailsTriggered: string[];
+        type: "input" | "output";
+    };
+}
+declare function generateTextWithGuardrails(params: Parameters<typeof generateText>[0], guardrailParams: GuardrailsParams): Promise<ai.GenerateTextResult<ai.ToolSet, unknown>>;
+declare function generateObjectWithGuardrails(params: Parameters<typeof generateObject>[0], guardrailParams: GuardrailsParams): Promise<ReturnType<typeof generateObject>>;
+declare function streamTextWithGuardrails(params: StreamTextParams, guardrailParams: GuardrailsParams): Promise<ReturnType<typeof streamText>>;
+declare function streamObjectWithGuardrails(params: StreamObjectParams, guardrailParams: GuardrailsParams): Promise<ReturnType<typeof streamObject>>;
+declare function embedWithGuardrails(params: EmbedParams, guardrailParams: GuardrailsParams): Promise<ai.EmbedResult<unknown>>;
+declare function createInputGuardrail(name: string, description: string, execute: InputGuardrail['execute']): InputGuardrail;
+declare function createOutputGuardrail(name: string, execute: OutputGuardrail['execute']): OutputGuardrail;
+
+export { type AIResult as A, GuardrailError as G, type InputGuardrailContext as I, type OutputGuardrail as O, type InputGuardrail as a, generateObjectWithGuardrails as b, streamObjectWithGuardrails as c, createInputGuardrail as d, embedWithGuardrails as e, createOutputGuardrail as f, generateTextWithGuardrails as g, type GuardrailResult as h, type GuardrailsParams as i, streamTextWithGuardrails as s };

package/dist/index.cjs

@@ -0,0 +1,245 @@
+"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, {
+  GuardrailError: () => GuardrailError,
+  createInputGuardrail: () => createInputGuardrail,
+  createOutputGuardrail: () => createOutputGuardrail,
+  embedWithGuardrails: () => embedWithGuardrails,
+  generateObjectWithGuardrails: () => generateObjectWithGuardrails,
+  generateTextWithGuardrails: () => generateTextWithGuardrails,
+  streamObjectWithGuardrails: () => streamObjectWithGuardrails,
+  streamTextWithGuardrails: () => streamTextWithGuardrails
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core.ts
+var import_ai = require("ai");
+var GuardrailError = class extends Error {
+  constructor(guardrailName, reason, type) {
+    super(`${type} guardrail '${guardrailName}' blocked: ${reason}`);
+    this.guardrailName = guardrailName;
+    this.reason = reason;
+    this.type = type;
+    this.name = "GuardrailError";
+    this.issues = [{ guardrail: guardrailName, message: reason }];
+  }
+  issues;
+  getSummary() {
+    return {
+      totalIssues: this.issues.length,
+      guardrailsTriggered: this.issues.map((i) => i.guardrail),
+      type: this.type
+    };
+  }
+};
+async function runInputGuardrails(guardrails = [], context) {
+  for (const guardrail of guardrails) {
+    const result = await guardrail.execute(context);
+    if (result.tripwireTriggered) {
+      throw new GuardrailError(
+        guardrail.name,
+        result.message || "Input blocked",
+        "input"
+      );
+    }
+  }
+}
+async function runOutputGuardrails(guardrails = [], context, accumulatedText) {
+  for (const guardrail of guardrails) {
+    const result = await guardrail.execute(context, accumulatedText);
+    if (result.tripwireTriggered) {
+      throw new GuardrailError(
+        guardrail.name,
+        result.message || "Output blocked",
+        "output"
+      );
+    }
+  }
+}
+async function generateTextWithGuardrails(params, guardrailParams) {
+  const { inputGuardrails, outputGuardrails } = guardrailParams;
+  const startTime = Date.now();
+  const finalInputGuardrails = inputGuardrails;
+  const finalOutputGuardrails = outputGuardrails;
+  try {
+    await runInputGuardrails(finalInputGuardrails, params);
+  } catch (error) {
+    if (error instanceof GuardrailError && guardrailParams.onInputBlocked) {
+      guardrailParams.onInputBlocked(error);
+      if (guardrailParams.throwOnBlocked !== false) {
+        throw error;
+      }
+      return (0, import_ai.generateText)(params);
+    }
+    throw error;
+  }
+  const result = await (0, import_ai.generateText)(params);
+  const generationTimeMs = Date.now() - startTime;
+  try {
+    await runOutputGuardrails(finalOutputGuardrails, {
+      input: params,
+      result
+    });
+  } catch (error) {
+    if (error instanceof GuardrailError && guardrailParams.onOutputBlocked) {
+      guardrailParams.onOutputBlocked(error);
+      if (guardrailParams.throwOnBlocked !== false) {
+        throw error;
+      }
+      return { ...result, text: "" };
+    }
+    throw error;
+  }
+  return result;
+}
+async function generateObjectWithGuardrails(params, guardrailParams) {
+  const { inputGuardrails, outputGuardrails } = guardrailParams;
+  const startTime = Date.now();
+  const finalInputGuardrails = inputGuardrails;
+  const finalOutputGuardrails = outputGuardrails;
+  try {
+    await runInputGuardrails(finalInputGuardrails, params);
+  } catch (error) {
+    if (error instanceof GuardrailError && guardrailParams.onInputBlocked) {
+      guardrailParams.onInputBlocked(error);
+      if (guardrailParams.throwOnBlocked !== false) {
+        throw error;
+      }
+      return (0, import_ai.generateObject)(params);
+    }
+    throw error;
+  }
+  const result = await (0, import_ai.generateObject)(params);
+  try {
+    await runOutputGuardrails(finalOutputGuardrails, {
+      input: params,
+      result
+    });
+  } catch (error) {
+    if (error instanceof GuardrailError && guardrailParams.onOutputBlocked) {
+      guardrailParams.onOutputBlocked(error);
+      if (guardrailParams.throwOnBlocked !== false) {
+        throw error;
+      }
+      return { ...result, object: null };
+    }
+    throw error;
+  }
+  return result;
+}
+async function streamTextWithGuardrails(params, guardrailParams) {
+  const { inputGuardrails, outputGuardrails } = guardrailParams;
+  const finalInputGuardrails = inputGuardrails;
+  const finalOutputGuardrails = outputGuardrails;
+  try {
+    await runInputGuardrails(finalInputGuardrails, params);
+  } catch (error) {
+    if (error instanceof GuardrailError && guardrailParams.onInputBlocked) {
+      guardrailParams.onInputBlocked(error);
+      if (guardrailParams.throwOnBlocked !== false) {
+        throw error;
+      }
+    }
+    throw error;
+  }
+  const result = await (0, import_ai.streamText)(params);
+  if (!finalOutputGuardrails) {
+    return result;
+  }
+  let accumulatedText = "";
+  const transformedStream = new ReadableStream({
+    start(controller) {
+      const reader = result.textStream.getReader();
+      const processChunk = async () => {
+        try {
+          const { done, value } = await reader.read();
+          if (done) {
+            controller.close();
+            return;
+          }
+          accumulatedText += value;
+          try {
+            await runOutputGuardrails(
+              finalOutputGuardrails,
+              {
+                input: params,
+                result
+              },
+              accumulatedText
+            );
+            controller.enqueue(value);
+            processChunk();
+          } catch (error) {
+            if (error instanceof GuardrailError) {
+              if (guardrailParams.onOutputBlocked) {
+                guardrailParams.onOutputBlocked(error);
+              }
+              if (guardrailParams.throwOnBlocked !== false) {
+                controller.error(error);
+                return;
+              }
+            } else {
+              controller.error(error);
+              return;
+            }
+          }
+        } catch (error) {
+          controller.error(error);
+        }
+      };
+      processChunk();
+    }
+  });
+  return {
+    ...result,
+    textStream: transformedStream
+  };
+}
+async function streamObjectWithGuardrails(params, guardrailParams) {
+  const { inputGuardrails } = guardrailParams;
+  await runInputGuardrails(inputGuardrails, params);
+  const result = await (0, import_ai.streamObject)(params);
+  return result;
+}
+async function embedWithGuardrails(params, guardrailParams) {
+  const { inputGuardrails } = guardrailParams;
+  await runInputGuardrails(inputGuardrails, params);
+  const result = await (0, import_ai.embed)(params);
+  return result;
+}
+function createInputGuardrail(name, description, execute) {
+  return { name, description, execute };
+}
+function createOutputGuardrail(name, execute) {
+  return { name, execute };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GuardrailError,
+  createInputGuardrail,
+  createOutputGuardrail,
+  embedWithGuardrails,
+  generateObjectWithGuardrails,
+  generateTextWithGuardrails,
+  streamObjectWithGuardrails,
+  streamTextWithGuardrails
+});

package/dist/index.d.cts

@@ -0,0 +1,2 @@
+export { G as GuardrailError, h as GuardrailResult, i as GuardrailsParams, a as InputGuardrail, O as OutputGuardrail, d as createInputGuardrail, f as createOutputGuardrail, e as embedWithGuardrails, b as generateObjectWithGuardrails, g as generateTextWithGuardrails, c as streamObjectWithGuardrails, s as streamTextWithGuardrails } from './index-CWIb12lh.cjs';
+import 'ai';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { G as GuardrailError, h as GuardrailResult, i as GuardrailsParams, a as InputGuardrail, O as OutputGuardrail, d as createInputGuardrail, f as createOutputGuardrail, e as embedWithGuardrails, b as generateObjectWithGuardrails, g as generateTextWithGuardrails, c as streamObjectWithGuardrails, s as streamTextWithGuardrails } from './index-CWIb12lh.js';
+import 'ai';

package/dist/index.js

@@ -0,0 +1,20 @@
+import {
+  GuardrailError,
+  createInputGuardrail,
+  createOutputGuardrail,
+  embedWithGuardrails,
+  generateObjectWithGuardrails,
+  generateTextWithGuardrails,
+  streamObjectWithGuardrails,
+  streamTextWithGuardrails
+} from "./chunk-BNGJDZMX.js";
+export {
+  GuardrailError,
+  createInputGuardrail,
+  createOutputGuardrail,
+  embedWithGuardrails,
+  generateObjectWithGuardrails,
+  generateTextWithGuardrails,
+  streamObjectWithGuardrails,
+  streamTextWithGuardrails
+};

package/package.json

@@ -0,0 +1,91 @@
+{
+  "name": "ai-sdk-guardrails",
+  "version": "1.0.0",
+  "description": "The safest way to build production AI applications with the Vercel AI SDK. Comprehensive TypeScript library for intelligent input/output validation, streaming safety, and enterprise-grade reliability.",
+  "keywords": [
+    "ai",
+    "guardrails",
+    "vercel-ai-sdk",
+    "typescript",
+    "validation",
+    "safety",
+    "streaming",
+    "security",
+    "content-filtering",
+    "prompt-injection",
+    "ai-safety"
+  ],
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./guardrails/input": {
+      "types": "./dist/guardrails/input.d.ts",
+      "import": "./dist/guardrails/input.js",
+      "require": "./dist/guardrails/input.cjs"
+    },
+    "./guardrails/output": {
+      "types": "./dist/guardrails/output.d.ts",
+      "import": "./dist/guardrails/output.js",
+      "require": "./dist/guardrails/output.cjs"
+    }
+  },
+  "homepage": "https://github.com/jagreehal/ai-sdk-guardrails",
+  "bugs": {
+    "url": "https://github.com/jagreehal/ai-sdk-guardrails/issues"
+  },
+  "author": "Jag Reehal<jag@jagreehal.com> (https://jagreehal.com)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jagreehal/ai-sdk-guardrails.git"
+  },
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "dependencies": {
+    "ai": "^4.3.19",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@ai-sdk/openai": "^1.3.23",
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@changesets/cli": "^2.29.5",
+    "@total-typescript/ts-reset": "^0.6.1",
+    "@total-typescript/tsconfig": "^1.0.4",
+    "@types/eslint-config-prettier": "^6.11.3",
+    "@types/node": "^24.0.14",
+    "@typescript-eslint/eslint-plugin": "^8.37.0",
+    "@typescript-eslint/parser": "^8.37.0",
+    "autoevals": "^0.0.130",
+    "dotenv": "^17.2.0",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-unicorn": "^59.0.1",
+    "mathjs": "^14.5.3",
+    "ollama": "^0.5.16",
+    "ollama-ai-provider": "^1.2.0",
+    "openai": "^5.9.2",
+    "prettier": "^3.6.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.37.0",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "ci": "npm run build && npm run check-format && npm run check-exports && npm run lint && npm run test",
+    "lint": "eslint src/**/*.ts",
+    "lint:fix": "eslint src/**/*.ts --fix",
+    "format": "prettier --write src/**/*.ts",
+    "format:check": "prettier --check src/**/*.ts",
+    "type-check": "tsc --noEmit",
+    "test": "vitest run",
+    "check-format": "prettier --check .",
+    "check-exports": "attw --pack . --ignore-rules false-esm no-resolution",
+    "local-release": "npm run ci && changeset version && changeset publish"
+  }
+}