@wowistudio/grit 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeroen Huisman
+
+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,304 @@
+# Grit
+
+> ⚠️ **Work in Progress**: This library is currently under active development. The API may change and some features may be incomplete.
+
+A powerful, fluent retry utility for TypeScript/JavaScript that makes handling transient failures elegant and configurable.
+
+## Features
+
+- **🔄 Configurable Retries**: Set the number of retry attempts with a simple API
+- **🎯 Error Filtering**: Retry only on specific errors or skip certain error types
+- **⏱️ Flexible Backoff Strategies**: Choose from fixed delays, exponential backoff, or random jitter
+- **🔗 Fluent API**: Chain methods for readable, declarative retry logic
+- **📊 Attempt Tracking**: Access attempt numbers in your retry logic
+- **🎣 Before Retry Hooks**: Execute custom logic before each retry attempt
+- **✅ TypeScript First**: Full type safety with TypeScript support
+
+## Installation
+
+```bash
+# Using npm
+npm install @wowistudio/grit
+# Using pnpm
+pnpm add @wowistudio/grit
+# Using yarn
+yarn add @wowistudio/grit
+```
+
+## Usage Examples
+
+### Basic
+
+```typescript
+import { Grit } from '@wowistudio/grit';
+
+// Simple retry with 3 attempts
+await Grit.retry(3)
+  .attempt(async (attempt) => {
+    console.log(`Attempt ${attempt}`);
+    // Your code that might fail
+    await fetchData();
+  });
+```
+
+### Error Filtering
+
+```typescript
+import { Grit } from '@wowistudio/grit';
+
+// Retry only on specific errors - only retry when NetworkError or TimeoutError occur
+class NetworkError extends Error {}
+class TimeoutError extends Error {}
+
+await Grit.retry(5)
+  .onlyErrors([NetworkError, TimeoutError])
+  .attempt(async () => {
+    await makeNetworkRequest();
+  });
+
+// Skip certain errors - retry on all errors except ValidationError
+class ValidationError extends Error {}
+
+await Grit.retry(3)
+  .skipErrors([ValidationError])
+  .attempt(async () => {
+    await processData();
+  });
+```
+
+### Delay
+
+```typescript
+import { Grit } from 'grit';
+
+// Fixed delay between retries - add a 1 second delay between attempts
+await Grit.retry(3)
+  .withDelay(1000)
+  .attempt(async () => {
+    await apiCall();
+  });
+
+// Exponential backoff - delays: 100ms, 200ms, 400ms, 800ms, 1600ms
+await Grit.retry(5)
+  .withDelay({ 
+    delay: 100,    // Initial delay: 100ms
+    factor: 2      // Multiply by 2 each time
+  })
+  .attempt(async () => {
+    await apiCall();
+  });
+
+// Random jitter with exponential backoff - prevents thundering herd problems
+await Grit.retry(4)
+  .withDelay({
+    minDelay: 100,   // Minimum delay: 100ms
+    maxDelay: 500,   // Maximum delay: 500ms
+    factor: 1.5      // Optional: multiply by factor each attempt
+  })
+  .attempt(async () => {
+    await distributedServiceCall();
+  });
+
+// Custom delay array - specify exact delays for each retry attempt (500ms, 1s, 2s)
+await Grit.retry(3)
+  .withDelay([500, 1000, 2000])
+  .attempt(async () => {
+    await apiCall();
+  });
+```
+
+#### Reusable Builder Instances
+
+You can define a builder instance once and reuse it. Each call to `.attempt()` creates a new execution context, so retry state and attempt counts are independent between calls:
+
+```typescript
+import { Grit } from '@wowistudio/grit';
+
+// Define a shared builder configuration
+const grit = Grit.retry(3)
+  .onlyErrors([NetworkError])
+  .beforeRetry((retryCount) => {
+    console.log(`Retrying (attempt ${retryCount})...`);
+  });
+
+// Use the same builder for multiple different operations
+const userData = await grit.attempt(() => fetchUserData(userId));
+const orderData = await grit.attempt(() => fetchOrderData(orderId));
+```
+
+### Complete Example
+
+```typescript
+import { Grit } from 'grit';
+
+// Combining multiple features for a real-world API call
+class RateLimitError extends Error {}
+class NetworkError extends Error {}
+
+async function fetchUserData(userId: string) {
+  return await Grit.retry(5)
+    .onlyErrors([RateLimitError, NetworkError])
+    .withDelay(500)
+    .beforeRetry(async (retryCount) => {
+      console.warn(`Retry ${retryCount} for user ${userId}`);
+    })
+    .attempt(async (attempt) => {
+      const response = await fetch(`/api/users/${userId}`);
+      
+      if (response.status === 429) {
+        throw new RateLimitError('Rate limited');
+      }
+      
+      if (!response.ok) {
+        throw new NetworkError('Network error');
+      }
+      
+      return response.json();
+    });
+}
+```
+
+## API Reference
+
+### `Grit.retry(retryCount: number)`
+
+Creates a new Grit instance with the specified number of retries.
+
+**Parameters:**
+- `retryCount` (number): Maximum number of retry attempts
+
+**Returns:** A new `Grit` instance
+
+### `.attempt(fn: FunctionToExecute)`
+
+Executes the provided function with retry logic immediately.
+
+**Parameters:**
+- `fn` (Function): An async function that receives the current attempt number as a parameter
+
+**Returns:** Promise that resolves with the function's return value or rejects if all retries are exhausted
+
+### `.onlyErrors(errors: ErrorConstructor[])`
+
+Configures retries to only occur for specific error types.
+
+**Parameters:**
+- `errors` (ErrorConstructor[]): Array of error constructors to retry on
+
+**Returns:** `Grit` instance for chaining
+
+### `.skipErrors(errors: ErrorConstructor[])`
+
+Configures retries to skip specific error types (retry on all others).
+
+**Parameters:**
+- `errors` (ErrorConstructor[]): Array of error constructors to skip
+
+**Returns:** `Grit` instance for chaining
+
+### `.withDelay(config: DelayConfig)`
+
+Configures the delay strategy between retries.
+
+**Parameters:**
+- `config` (DelayConfig): One of:
+  - `{ delay: number, factor?: number }`: Fixed delay with optional exponential factor
+  - `{ minDelay: number, maxDelay: number, factor?: number }`: Random delay between min/max with optional factor
+  - `number[]`: Array of specific delays for each retry (length must match retry count)
+
+**Returns:** `Grit` instance for chaining
+
+**Throws:** `GritError` if configuration is invalid
+
+### `.beforeRetry(fn: (retryCount: number) => void | Promise<void>)`
+
+Sets a callback to execute before each retry attempt.
+
+**Parameters:**
+- `fn` (Function): Async or sync function that receives the current retry count
+
+**Returns:** `Grit` instance for chaining
+
+## Delay Configuration
+
+### Fixed Delay
+
+```typescript
+.withDelay(1000) // 1 second between retries
+```
+
+### Exponential Backoff
+
+```typescript
+.withDelay({ 
+  delay: 100,   // Start with 100ms
+  factor: 2     // Double each time: 100ms, 200ms, 400ms, 800ms...
+})
+```
+
+### Random Jitter
+
+```typescript
+.withDelay({
+  minDelay: 100,  // Minimum 100ms
+  maxDelay: 500,  // Maximum 500ms
+  factor: 1.5     // Optional: scale by 1.5x each attempt
+})
+```
+
+### Custom Delay Array
+
+```typescript
+.withDelay([100, 200, 500, 1000]) // Exact delays for each retry
+// Array length must equal retry count
+```
+
+## Error Handling
+
+Grit provides two error classes:
+
+- **`GritError`**: Thrown for configuration errors
+- **`MaxRetriesError`**: Thrown when maximum retries are exceeded (if configured)
+
+```typescript
+import { Grit, GritError } from 'grit';
+
+try {
+  await Grit.retry(3).attempt(async () => {
+    // Your code
+  });
+} catch (error) {
+  if (error instanceof GritError) {
+    console.error('Configuration error:', error.message);
+  } else {
+    console.error('Operation failed after retries:', error);
+  }
+}
+```
+
+## Best Practices
+
+1. **Use `onlyErrors` for specific error types**: Don't retry on validation errors or other non-transient failures
+2. **Use exponential backoff for API calls**: Prevents overwhelming services
+3. **Use random jitter for distributed systems**: Prevents thundering herd problems
+4. **Log retry attempts**: Use `beforeRetry` to track retry behavior
+5. **Set reasonable retry counts**: Too many retries can cause long delays
+
+## TypeScript Support
+
+Grit is written in TypeScript and provides full type safety:
+
+```typescript
+import { Grit, DelayConfig, FunctionToExecute } from 'grit';
+
+// All types are exported for your use
+const delayConfig: DelayConfig = { delay: 1000 };
+const fn: FunctionToExecute = async (attempt) => {
+  // attempt is typed as number
+};
+```
+
+## License
+
+This project is licensed under the MIT License.
+

package/dist/builder.d.ts

@@ -0,0 +1,20 @@
+import { GritError } from "./exceptions.ts";
+import type { DelayConfig, FunctionToExecute } from "./types.ts";
+declare class GritBuilder {
+    #private;
+    private retryCount?;
+    _onlyErrors: (typeof GritError)[];
+    _skipErrors: (typeof GritError)[];
+    fn: FunctionToExecute<any> | undefined;
+    $delay: DelayConfig | undefined;
+    beforeRetryFn?: (retryCount: number) => void;
+    logging: boolean;
+    constructor(retryCount: number);
+    onlyErrors(errors: (typeof GritError)[]): this;
+    skipErrors(errors: (typeof GritError)[]): this;
+    withLogging(enabled?: boolean): this;
+    withDelay(config: DelayConfig): this;
+    beforeRetry(fn: (retryCount: number) => void): this;
+    attempt<T>(fn: FunctionToExecute<T>): Promise<T> | T;
+}
+export { GritBuilder };

package/dist/builder.js

@@ -0,0 +1,54 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _GritBuilder_instances, _GritBuilder_build;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GritBuilder = void 0;
+const grit_ts_1 = require("./grit.ts");
+class GritBuilder {
+    constructor(retryCount) {
+        _GritBuilder_instances.add(this);
+        this._onlyErrors = [];
+        this._skipErrors = [];
+        this.fn = undefined;
+        this.logging = false;
+        this.retryCount = retryCount;
+    }
+    onlyErrors(errors) {
+        this._onlyErrors = errors;
+        return this;
+    }
+    skipErrors(errors) {
+        this._skipErrors = errors;
+        return this;
+    }
+    withLogging(enabled = true) {
+        this.logging = enabled;
+        return this;
+    }
+    withDelay(config) {
+        this.$delay = config;
+        return this;
+    }
+    beforeRetry(fn) {
+        this.beforeRetryFn = fn;
+        return this;
+    }
+    attempt(fn) {
+        return __classPrivateFieldGet(this, _GritBuilder_instances, "m", _GritBuilder_build).call(this).attempt(fn);
+    }
+}
+exports.GritBuilder = GritBuilder;
+_GritBuilder_instances = new WeakSet(), _GritBuilder_build = function _GritBuilder_build() {
+    return new grit_ts_1.Grit({
+        retryCount: this.retryCount,
+        onlyErrors: this._onlyErrors,
+        skipErrors: this._skipErrors,
+        delay: this.$delay,
+        beforeRetryFn: this.beforeRetryFn,
+        logging: this.logging,
+    });
+};

package/dist/exceptions.d.ts

@@ -0,0 +1,7 @@
+declare class GritError extends Error {
+    constructor(message: string);
+}
+declare class MaxRetriesError extends Error {
+    constructor(message: string);
+}
+export { GritError, MaxRetriesError };

package/dist/exceptions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MaxRetriesError = exports.GritError = void 0;
+class GritError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "GritError";
+    }
+}
+exports.GritError = GritError;
+class MaxRetriesError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MaxRetriesError";
+    }
+}
+exports.MaxRetriesError = MaxRetriesError;

package/dist/grit.d.ts

@@ -0,0 +1,18 @@
+import { GritBuilder } from "./builder.ts";
+import type { GritProps } from "./types.ts";
+declare class Grit {
+    #private;
+    private retryCount?;
+    private attempts;
+    private retries;
+    private onlyErrors;
+    private skipErrors;
+    private delay;
+    private beforeRetryFn?;
+    private logging;
+    constructor(props: GritProps);
+    attemptSync<T>(fn: (attempts: number) => T): T;
+    attempt<T>(fn: (attempts: number) => Promise<T>): Promise<T>;
+    static retry(retryCount: number): GritBuilder;
+}
+export { Grit };

package/dist/grit.js

@@ -0,0 +1,99 @@
+"use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Grit_instances, _Grit_currentDelay_get, _Grit_handleBeforeRetry, _Grit_backoff, _Grit_backoffSync, _Grit_processError, _Grit_execute, _Grit_executeSync;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grit = void 0;
+const builder_ts_1 = require("./builder.ts");
+const exceptions_ts_1 = require("./exceptions.ts");
+const utils_ts_1 = require("./utils.ts");
+class Grit {
+    constructor(props) {
+        _Grit_instances.add(this);
+        this.attempts = 1;
+        this.retries = 0;
+        this.logging = false;
+        const { retryCount, fn, onlyErrors, skipErrors, delay, beforeRetryFn, logging } = props;
+        this.retryCount = retryCount;
+        this.onlyErrors = onlyErrors || [];
+        this.skipErrors = skipErrors || [];
+        this.delay = delay;
+        this.beforeRetryFn = beforeRetryFn;
+        this.logging = logging || false;
+        (0, utils_ts_1.validateGritConfig)(delay, retryCount);
+    }
+    attemptSync(fn) {
+        return __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_executeSync).call(this, fn);
+    }
+    async attempt(fn) {
+        return __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_execute).call(this, fn);
+    }
+    static retry(retryCount) {
+        return new builder_ts_1.GritBuilder(retryCount);
+    }
+}
+exports.Grit = Grit;
+_Grit_instances = new WeakSet(), _Grit_currentDelay_get = function _Grit_currentDelay_get() {
+    let delay = undefined;
+    if (typeof this.delay === "number") {
+        delay = this.delay;
+    }
+    else if (Array.isArray(this.delay)) {
+        delay = this.delay.shift();
+    }
+    else if ((0, utils_ts_1.isObject)(this.delay) && "delay" in this.delay) {
+        const { factor, delay: initialDelay } = this.delay;
+        delay = initialDelay * Math.pow(factor || 1, this.attempts - 2);
+    }
+    else if ((0, utils_ts_1.isObject)(this.delay) && "minDelay" in this.delay) {
+        const { minDelay, maxDelay, factor } = this.delay;
+        const randomDelay = Math.random() * (maxDelay - minDelay) + minDelay;
+        delay = factor ? randomDelay * Math.pow(factor, this.attempts - 2) : randomDelay;
+    }
+    if (!delay)
+        throw new exceptions_ts_1.GritError("No delay. Should never happen.");
+    if (this.logging)
+        console.debug("Delaying for", delay, "ms");
+    return delay;
+}, _Grit_handleBeforeRetry = function _Grit_handleBeforeRetry() {
+    if (this.retries > 0 && this.beforeRetryFn)
+        this.beforeRetryFn(this.retries);
+}, _Grit_backoff = async function _Grit_backoff() {
+    return new Promise((resolve) => setTimeout(resolve, __classPrivateFieldGet(this, _Grit_instances, "a", _Grit_currentDelay_get)));
+}, _Grit_backoffSync = function _Grit_backoffSync() {
+    setTimeout(() => { }, __classPrivateFieldGet(this, _Grit_instances, "a", _Grit_currentDelay_get));
+}, _Grit_processError = function _Grit_processError(error) {
+    if (error && typeof error === 'object' && 'constructor' in error) {
+        if (this.skipErrors.length > 0 && this.skipErrors.includes(error.constructor))
+            throw error;
+        if (this.onlyErrors.length > 0 && !this.onlyErrors.includes(error.constructor))
+            throw error;
+    }
+    this.attempts++;
+    this.retries++;
+}, _Grit_execute = async function _Grit_execute(fn) {
+    try {
+        __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_handleBeforeRetry).call(this);
+        return await fn(this.attempts);
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_processError).call(this, error);
+        if (this.delay)
+            return __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_backoff).call(this).then(() => __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_execute).call(this, fn));
+        return await __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_execute).call(this, fn);
+    }
+}, _Grit_executeSync = function _Grit_executeSync(fn) {
+    try {
+        __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_handleBeforeRetry).call(this);
+        return fn(this.attempts);
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_processError).call(this, error);
+        if (this.delay)
+            __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_backoffSync).call(this);
+        return __classPrivateFieldGet(this, _Grit_instances, "m", _Grit_executeSync).call(this, fn);
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { GritBuilder } from "./builder.ts";
+export { Grit } from "./grit.ts";
+export type { DelayConfig, FunctionToExecute } from "./types.ts";

package/dist/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Grit = exports.GritBuilder = void 0;
+var builder_ts_1 = require("./builder.ts");
+Object.defineProperty(exports, "GritBuilder", { enumerable: true, get: function () { return builder_ts_1.GritBuilder; } });
+var grit_ts_1 = require("./grit.ts");
+Object.defineProperty(exports, "Grit", { enumerable: true, get: function () { return grit_ts_1.Grit; } });

package/dist/types.d.ts

@@ -0,0 +1,19 @@
+export type GritProps = {
+    retryCount?: number;
+    fn?: FunctionToExecute<any>;
+    onlyErrors?: (typeof Error)[];
+    skipErrors?: (typeof Error)[];
+    delay?: DelayConfig;
+    isConstructor?: boolean;
+    beforeRetryFn?: (retryCount: number) => void;
+    logging?: boolean;
+};
+export type DelayConfig = number | number[] | {
+    factor?: number;
+    delay: number;
+} | {
+    factor?: number;
+    minDelay: number;
+    maxDelay: number;
+};
+export type FunctionToExecute<T> = (attempts: number) => (T | Promise<T>);

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import type { DelayConfig } from "./types.ts";
+export declare const isObject: (o: any) => o is Record<string, any>;
+export declare const isPromise: <T>(value: any) => value is Promise<T>;
+export declare const validateGritConfig: (config: DelayConfig | undefined, retryCount: number | undefined) => void;

package/dist/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateGritConfig = exports.isPromise = exports.isObject = void 0;
+const exceptions_ts_1 = require("./exceptions.ts");
+const isObject = (o) => {
+    return typeof o === 'object' && !Array.isArray(o) && o !== null;
+};
+exports.isObject = isObject;
+const isPromise = (value) => {
+    return value !== null && typeof value === "object" && typeof value.then === "function";
+};
+exports.isPromise = isPromise;
+const validateGritConfig = (config, retryCount) => {
+    if (!config)
+        return;
+    if (!retryCount)
+        throw new exceptions_ts_1.GritError("Missing retry config (Grit.retry(<count>))");
+    // validate array config
+    if (Array.isArray(config)) {
+        if (config.length !== retryCount)
+            throw new exceptions_ts_1.GritError("Delay array length must be equal to retry count");
+        for (const delay of config) {
+            if (delay <= 0)
+                throw new exceptions_ts_1.GritError("delay must be greater than 0");
+        }
+        return;
+    }
+    if (typeof config === "number") {
+        if (config <= 0)
+            throw new exceptions_ts_1.GritError("delay must be greater than 0");
+        return;
+    }
+    if (!(0, exports.isObject)(config))
+        throw new exceptions_ts_1.GritError("Invalid backoff config");
+    // validate delay config
+    if ("delay" in config) {
+        if (typeof config.delay !== "number")
+            throw new exceptions_ts_1.GritError("delay must be a number");
+        if (config.delay <= 0)
+            throw new exceptions_ts_1.GritError("delay must be greater than 0");
+        return;
+    }
+    // validate random delay config
+    const { minDelay, maxDelay } = config;
+    if (!minDelay || typeof minDelay !== "number")
+        throw new exceptions_ts_1.GritError("minDelay must be a number");
+    if (!maxDelay || typeof maxDelay !== "number")
+        throw new exceptions_ts_1.GritError("maxDelay must be a number");
+    if (minDelay >= maxDelay)
+        throw new exceptions_ts_1.GritError("minDelay must be less than maxDelay");
+    if (minDelay <= 0)
+        throw new exceptions_ts_1.GritError("minDelay must be greater than 0");
+    if (maxDelay <= 0)
+        throw new exceptions_ts_1.GritError("maxDelay must be greater than 0");
+};
+exports.validateGritConfig = validateGritConfig;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@wowistudio/grit",
+  "description": "A library for retry.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "/dist"
+  ],
+  "version": "1.0.0",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "default": "./src/index.ts"
+    }
+  },
+  "type": "module",
+  "scripts": {
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "vitest": "^2.1.8",
+    "@types/node": "^20.9.0"
+  }
+}