@pixpilot/supabase-functions-client 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pixpilot
+
+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,363 @@
+# @pixpilot/supabase-functions-client
+
+A lightweight, type-safe wrapper around the Supabase Edge Functions client with structured error handling, automatic error message extraction, and chainable response helpers.
+
+---
+
+## Installation
+
+```sh
+pnpm add @pixpilot/supabase-functions-client @supabase/supabase-js
+```
+
+---
+
+## Quick Start
+
+```typescript
+import { FunctionsClient } from '@pixpilot/supabase-functions-client';
+import { createClient } from '@supabase/supabase-js';
+
+const supabase = createClient('https://your-project.supabase.co', 'your-anon-key');
+
+// Wrap the Supabase client once
+const functionsClient = new FunctionsClient(supabase);
+```
+
+---
+
+## API
+
+### `FunctionsClient`
+
+```typescript
+class FunctionsClient {
+  constructor(supabaseClient: SupabaseClient);
+
+  invoke<RequestBody = void, ResponseData = any>(
+    functionName: string,
+    options?: FunctionInvokeOptions<RequestBody>,
+  ): Promise<ResponseData>;
+
+  handleInvoke<T>(
+    invokeCall: () => Promise<T>,
+    onSuccess: (data: T) => Promise<void> | void,
+    onError: (error: EdgeFunctionError) => Promise<void> | void,
+    context?: string,
+  ): Promise<void>;
+
+  /** @deprecated Use handleInvoke instead. */
+  handleResponse<T>(
+    result: FunctionsResponse<T>,
+    onSuccess: (data: T) => Promise<void> | void,
+    onError: (error: string, code?: string, details?: unknown) => Promise<void> | void,
+    context?: string,
+  ): Promise<void>;
+}
+```
+
+---
+
+## Usage Patterns
+
+### 1. `invoke` – Direct Try/Catch (Recommended)
+
+`invoke` either returns data on success or **throws** an `EdgeFunctionError`
+(or `EdgeFunctionNoDataError`) on failure.
+
+```typescript
+import {
+  EdgeFunctionError,
+  EdgeFunctionNoDataError,
+  FunctionsClient,
+} from '@pixpilot/supabase-functions-client';
+
+interface ProcessJobRequest {
+  jobContent: string;
+  jobUrl: string;
+}
+
+interface ProcessJobResponse {
+  jobId: string;
+  status: string;
+}
+
+try {
+  /*
+   * RequestBody type is inferred, ResponseData is explicit.
+   * Because ProcessJobRequest has required properties, `body` is required
+   * in the second argument – TypeScript will enforce this.
+   */
+  const job = await functionsClient.invoke<ProcessJobRequest, ProcessJobResponse>(
+    'process-job',
+    { body: { jobContent: htmlContent, jobUrl: url } },
+  );
+
+  console.log('Job created:', job.jobId);
+} catch (error) {
+  if (error instanceof EdgeFunctionNoDataError) {
+    console.error('Function returned no data for:', error.functionName);
+  } else if (error instanceof EdgeFunctionError) {
+    console.error('Function failed:', error.message);
+    if (error.code) console.error('Error code:', error.code);
+    if (error.details) console.error('Details:', error.details);
+  } else {
+    throw error; // Re-throw unexpected errors
+  }
+}
+```
+
+#### Void body (no request body)
+
+When `RequestBody` is `void` or omitted, the options argument is optional and
+`body` is not allowed:
+
+```typescript
+interface HealthCheckResponse {
+  status: 'ok' | 'degraded';
+  timestamp: string;
+}
+
+// No second argument needed
+const health = await functionsClient.invoke<void, HealthCheckResponse>('health-check');
+console.log('Status:', health.status);
+```
+
+#### All-optional body
+
+When every property of `RequestBody` is optional, the options argument is also
+optional:
+
+```typescript
+interface SearchRequest {
+  query?: string;
+  limit?: number;
+}
+
+interface SearchResponse {
+  results: string[];
+}
+
+// Can omit options entirely
+const results = await functionsClient.invoke<SearchRequest, SearchResponse>('search');
+
+// Or pass a partial body
+const filtered = await functionsClient.invoke<SearchRequest, SearchResponse>('search', {
+  body: { query: 'typescript', limit: 10 },
+});
+```
+
+---
+
+### 2. `handleInvoke` – Callback Pattern
+
+Use `handleInvoke` when you want clean success/error callbacks without a
+try/catch block. Uncaught non-`EdgeFunctionError` exceptions are re-thrown.
+
+```typescript
+await functionsClient.handleInvoke(
+  // The function call
+  () =>
+    functionsClient.invoke<ProcessJobRequest, ProcessJobResponse>('process-job', {
+      body: { jobContent: htmlContent, jobUrl: url },
+    }),
+
+  // Success handler
+  (job) => {
+    console.log('Job created:', job.jobId);
+    showSuccessNotification(job);
+  },
+
+  // Error handler – receives an EdgeFunctionError
+  (error) => {
+    console.error('Function failed:', error.message);
+    if (error.code === 'QUOTA_EXCEEDED') {
+      showQuotaWarning();
+    } else {
+      showErrorNotification(error.message);
+    }
+  },
+
+  // Optional context label – included in log output
+  'Process Job',
+);
+```
+
+---
+
+### 3. `handleResponse` – Legacy Callback Pattern _(deprecated)_
+
+This method takes a `FunctionsResponse` object (the old `{data, error}` shape)
+and dispatches to one of two callbacks. Prefer `handleInvoke` for new code.
+
+```typescript
+const result: FunctionsResponse<ProcessJobResponse> = {
+  data: { jobId: '123', status: 'pending' },
+  error: null,
+};
+
+await functionsClient.handleResponse(
+  result,
+  // onSuccess
+  (job) => {
+    console.log('Job created:', job.jobId);
+  },
+  // onError
+  (errorMessage, errorCode, details) => {
+    console.error('Function failed:', errorMessage);
+    if (errorCode) console.error('Error code:', errorCode);
+  },
+);
+```
+
+---
+
+## Error Classes
+
+### `EdgeFunctionError`
+
+The base error class for all Edge Function failures.
+
+```typescript
+class EdgeFunctionError extends Error {
+  /** Name of the Edge Function that failed */
+  readonly functionName: string;
+
+  /** Optional machine-readable error code from the function response */
+  readonly code?: string;
+
+  /** Additional structured details from the function response */
+  readonly details?: unknown;
+}
+```
+
+### `EdgeFunctionNoDataError`
+
+Extends `EdgeFunctionError`. Thrown when the function call succeeds (HTTP 2xx)
+but returns no data.
+
+```typescript
+class EdgeFunctionNoDataError extends EdgeFunctionError {
+  // message: 'No data received from Edge Function.'
+}
+```
+
+### `instanceof` Checks
+
+```typescript
+import {
+  EdgeFunctionError,
+  EdgeFunctionNoDataError,
+} from '@pixpilot/supabase-functions-client';
+
+try {
+  const data = await functionsClient.invoke('my-function');
+} catch (error) {
+  if (error instanceof EdgeFunctionNoDataError) {
+    // Successful HTTP call but empty body
+    console.log('No data from:', error.functionName);
+  } else if (error instanceof EdgeFunctionError) {
+    // HTTP error OR network error
+    console.log(`${error.functionName} failed: ${error.message}`);
+    if (error.code) console.log('Code:', error.code);
+  }
+}
+```
+
+---
+
+## Automatic Error Message Extraction
+
+When an Edge Function returns a non-2xx response, the client automatically
+parses the JSON body and extracts the human-readable message. The resolution
+order is:
+
+1. `body.error` field
+2. `body.message` field
+3. HTTP error message (fallback)
+
+Edge Functions should return a structured error body:
+
+```typescript
+// From your Edge Function (Deno / Node):
+return new Response(
+  JSON.stringify({
+    error: 'User not found', // → EdgeFunctionError.message
+    code: 'USER_NOT_FOUND', // → EdgeFunctionError.code
+    details: { userId: 123 }, // → EdgeFunctionError.details
+  }),
+  { status: 404, headers: { 'Content-Type': 'application/json' } },
+);
+```
+
+---
+
+## Nested `ApiResponse` Unwrapping
+
+If your Edge Function wraps data in a `{ data, message }` envelope, the client
+automatically unwraps it:
+
+```typescript
+// Edge Function returns:
+// { data: { jobId: '123' }, message: 'Success' }
+
+// invoke() returns the inner data directly:
+const job = await functionsClient.invoke<void, ProcessJobResponse>('process-job');
+// job === { jobId: '123' }
+```
+
+---
+
+## Exported Types
+
+| Type                                 | Description                                                            |
+| ------------------------------------ | ---------------------------------------------------------------------- |
+| `EdgeFunctionErrorResponse`          | Shape of the error JSON returned by Edge Functions                     |
+| `FunctionsResponse<T>`               | Legacy `{ data, error, code, details }` response envelope              |
+| `FunctionInvokeOptions<RequestBody>` | Options passed to `invoke()`, body requirement adapts to `RequestBody` |
+| `InvokeOptions<RequestBody>`         | Determines whether options are required or optional                    |
+| `RequiredKeys<T>`                    | Utility: extracts required keys from a type                            |
+| `HasRequiredProperties<T>`           | Utility: `true` if `T` has at least one required key                   |
+
+---
+
+## Migration from Direct `supabase.functions.invoke`
+
+**Before:**
+
+```typescript
+const result = await supabase.functions.invoke<ProcessJobResponse>('process-job', {
+  body: { jobContent, jobUrl },
+});
+
+if (result.error) {
+  if (result.error instanceof FunctionsHttpError) {
+    // Manual JSON parsing, error code extraction...
+  }
+  return null;
+}
+
+return result.data ?? undefined;
+```
+
+**After:**
+
+```typescript
+try {
+  return await functionsClient.invoke<ProcessJobRequest, ProcessJobResponse>(
+    'process-job',
+    { body: { jobContent, jobUrl } },
+  );
+} catch (error) {
+  if (error instanceof EdgeFunctionError) {
+    console.error('Failed:', error.message, error.code);
+  }
+  return null;
+}
+```
+
+---
+
+## License
+
+MIT

package/dist/functions-client.d.ts

@@ -0,0 +1,71 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { FunctionInvokeOptions, FunctionsResponse, RequiredKeys } from './types';
+/**
+ * Custom error class for Edge Function errors
+ * Allows for instanceof checks and provides structured error information
+ */
+export declare class EdgeFunctionError extends Error {
+    readonly code?: string | undefined;
+    readonly details?: unknown;
+    readonly functionName: string;
+    constructor(message: string, functionName: string, code?: string, details?: unknown);
+}
+/**
+ * Error thrown when Edge Function returns no data
+ */
+export declare class EdgeFunctionNoDataError extends EdgeFunctionError {
+    constructor(functionName: string);
+}
+/**
+ * Enhanced Supabase Functions client with better error handling
+ * Provides a wrapper around Supabase Edge Functions with:
+ * - Automatic custom error message extraction
+ * - Type-safe responses
+ * - Consistent error handling
+ * - Generic typing support
+ */
+export declare class FunctionsClient {
+    private supabase;
+    constructor(supabaseClient: SupabaseClient);
+    /**
+     * Invoke a Supabase Edge Function with enhanced error handling
+     * Throws EdgeFunctionError on failure, returns data on success
+     *
+     * @param functionName - The name of the Edge Function to invoke
+     * @param args - Function invocation options (optional if RequestBody has no required properties)
+     * @returns Promise<ResponseData> - The response data on success
+     * @throws {EdgeFunctionError} When the function fails or returns an error
+     * @throws {EdgeFunctionNoDataError} When the function succeeds but returns no data
+     */
+    invoke<RequestBody = void, ResponseData = any>(functionName: string, ...args: RequiredKeys<RequestBody> extends never ? [options?: FunctionInvokeOptions<RequestBody>] : [options: FunctionInvokeOptions<RequestBody>]): Promise<ResponseData>;
+    /**
+     * Helper method for handling function invocations with UI feedback
+     * Use this to wrap invoke calls and handle errors gracefully
+     *
+     * @param invokeCall - A function that calls invoke and returns the result
+     * @param onSuccess - Callback for successful responses
+     * @param onError - Callback for error responses
+     * @param context - Additional context for logging
+     *
+     * @example
+     * ```typescript
+     * await functionsClient.handleInvoke(
+     *   () => functionsClient.invoke<JobData>('process-job', options),
+     *   (data) => {
+     *     // Handle success
+     *     console.log('Job processed:', data);
+     *   },
+     *   (error) => {
+     *     // Handle error
+     *     showErrorMessage(error.message);
+     *   }
+     * );
+     * ```
+     */
+    handleInvoke<T>(invokeCall: () => Promise<T>, onSuccess: (data: T) => Promise<void> | void, onError: (error: EdgeFunctionError) => Promise<void> | void, context?: string): Promise<void>;
+    /**
+     * @deprecated Use handleInvoke instead. This method is kept for backward compatibility.
+     * Helper method for handling function responses with UI feedback
+     */
+    handleResponse<T>(result: FunctionsResponse<T>, onSuccess: (data: T) => Promise<void> | void, onError: (error: string, code?: string, details?: unknown) => Promise<void> | void, context?: string): Promise<void>;
+}

package/dist/functions-client.js

@@ -0,0 +1,177 @@
+import { FunctionsHttpError } from '@supabase/supabase-js';
+/**
+ * Custom error class for Edge Function errors
+ * Allows for instanceof checks and provides structured error information
+ */
+export class EdgeFunctionError extends Error {
+    code;
+    details;
+    functionName;
+    constructor(message, functionName, code, details) {
+        super(message);
+        this.name = 'EdgeFunctionError';
+        this.functionName = functionName;
+        this.code = code;
+        this.details = details;
+    }
+}
+/**
+ * Error thrown when Edge Function returns no data
+ */
+export class EdgeFunctionNoDataError extends EdgeFunctionError {
+    constructor(functionName) {
+        super('No data received from Edge Function.', functionName);
+        this.name = 'EdgeFunctionNoDataError';
+    }
+}
+/**
+ * Enhanced Supabase Functions client with better error handling
+ * Provides a wrapper around Supabase Edge Functions with:
+ * - Automatic custom error message extraction
+ * - Type-safe responses
+ * - Consistent error handling
+ * - Generic typing support
+ */
+export class FunctionsClient {
+    supabase;
+    constructor(supabaseClient) {
+        this.supabase = supabaseClient;
+    }
+    /**
+     * Invoke a Supabase Edge Function with enhanced error handling
+     * Throws EdgeFunctionError on failure, returns data on success
+     *
+     * @param functionName - The name of the Edge Function to invoke
+     * @param args - Function invocation options (optional if RequestBody has no required properties)
+     * @returns Promise<ResponseData> - The response data on success
+     * @throws {EdgeFunctionError} When the function fails or returns an error
+     * @throws {EdgeFunctionNoDataError} When the function succeeds but returns no data
+     */
+    async invoke(functionName, ...args) {
+        const options = args[0];
+        try {
+            const result = await this.supabase.functions.invoke(functionName, 
+            // eslint-disable-next-line ts/no-unsafe-argument
+            options);
+            // Handle error cases
+            if (result.error != null) {
+                console.error(`Edge Function '${functionName}' error:`, result.error);
+                // Handle FunctionsHttpError to extract custom error message
+                if (result.error instanceof FunctionsHttpError) {
+                    try {
+                        // The context property contains the Response object
+                        const response = result.error.context;
+                        const errorResponse = (await response.json());
+                        const customErrorMessage = errorResponse.error ?? errorResponse.message ?? result.error.message;
+                        throw new EdgeFunctionError(customErrorMessage, functionName, errorResponse.code, errorResponse.details);
+                    }
+                    catch (parseError) {
+                        if (parseError instanceof EdgeFunctionError) {
+                            throw parseError;
+                        }
+                        console.error(`Failed to parse error response from '${functionName}':`, parseError);
+                        throw new EdgeFunctionError(result.error.message, functionName);
+                    }
+                }
+                else {
+                    // Handle other error types
+                    const errorMessage = 'message' in result.error
+                        ? result.error.message
+                        : 'An unknown error occurred.';
+                    throw new EdgeFunctionError(errorMessage, functionName);
+                }
+            }
+            // Handle success case
+            if (result.data == null) {
+                throw new EdgeFunctionNoDataError(functionName);
+            }
+            // Check if the response follows the ApiResponse structure with nested data
+            if (typeof result.data === 'object' &&
+                result.data !== null &&
+                'data' in result.data &&
+                'message' in result.data) {
+                // Extract the actual data from the nested structure
+                const apiResponse = result.data;
+                return apiResponse.data;
+            }
+            // If it's not nested, return as is
+            return result.data;
+        }
+        catch (error) {
+            // Re-throw EdgeFunctionError instances
+            if (error instanceof EdgeFunctionError) {
+                throw error;
+            }
+            console.error(`Unexpected error invoking Edge Function '${functionName}':`, error);
+            const errorMessage = error instanceof Error
+                ? error.message
+                : `An unexpected error occurred while invoking '${functionName}'.`;
+            throw new EdgeFunctionError(errorMessage, functionName);
+        }
+    }
+    /**
+     * Helper method for handling function invocations with UI feedback
+     * Use this to wrap invoke calls and handle errors gracefully
+     *
+     * @param invokeCall - A function that calls invoke and returns the result
+     * @param onSuccess - Callback for successful responses
+     * @param onError - Callback for error responses
+     * @param context - Additional context for logging
+     *
+     * @example
+     * ```typescript
+     * await functionsClient.handleInvoke(
+     *   () => functionsClient.invoke<JobData>('process-job', options),
+     *   (data) => {
+     *     // Handle success
+     *     console.log('Job processed:', data);
+     *   },
+     *   (error) => {
+     *     // Handle error
+     *     showErrorMessage(error.message);
+     *   }
+     * );
+     * ```
+     */
+    async handleInvoke(invokeCall, onSuccess, onError, context) {
+        try {
+            const data = await invokeCall();
+            await onSuccess(data);
+        }
+        catch (error) {
+            if (error instanceof EdgeFunctionError) {
+                const contextStr = context != null && context.length > 0 ? ` (${context})` : '';
+                console.error(`Function error${contextStr}:`, error.message);
+                if (error.code != null && error.code.length > 0) {
+                    console.error(`Error code${contextStr}:`, error.code);
+                }
+                await onError(error);
+            }
+            else {
+                // Re-throw unexpected errors
+                throw error;
+            }
+        }
+    }
+    /**
+     * @deprecated Use handleInvoke instead. This method is kept for backward compatibility.
+     * Helper method for handling function responses with UI feedback
+     */
+    async handleResponse(result, onSuccess, onError, context) {
+        if (result.error != null) {
+            const contextStr = context != null && context.length > 0 ? ` (${context})` : '';
+            console.error(`Function error${contextStr}:`, result.error);
+            if (result.code != null && result.code.length > 0) {
+                console.error(`Error code${contextStr}:`, result.code);
+            }
+            await onError(result.error, result.code, result.details);
+        }
+        else if (result.data != null) {
+            await onSuccess(result.data);
+        }
+        else {
+            // This shouldn't happen with our implementation, but just in case
+            await onError('Unexpected response: no data or error received.');
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './functions-client';
+export * from './types';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './functions-client';
+export * from './types';

package/dist/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Custom error response interface from Edge Functions
+ */
+export interface EdgeFunctionErrorResponse {
+    error?: string;
+    message?: string;
+    code?: string;
+    details?: any;
+}
+/**
+ * Enhanced function response with better error handling
+ */
+export interface FunctionsResponse<T> {
+    data: T | null;
+    error: string | null;
+    code?: string;
+    details?: any;
+    message?: string;
+}
+/**
+ * Utility to extract required keys from a type
+ */
+export type RequiredKeys<T> = {
+    [K in keyof T]-?: Record<string, never> extends {
+        [P in K]: T[K];
+    } ? never : K;
+}[keyof T];
+/**
+ * Check if type has required keys
+ */
+export type HasRequiredProperties<T> = RequiredKeys<T> extends never ? false : true;
+/**
+ * Function invocation options with conditional body requirement.
+ *
+ * - When `RequestBody` is `void | undefined`, the body option is not present.
+ * - When `RequestBody` has all-optional properties, `body` is optional.
+ * - When `RequestBody` has at least one required property, `body` is required.
+ */
+export type FunctionInvokeOptions<RequestBody> = RequestBody extends void | undefined ? {
+    headers?: Record<string, string>;
+    method?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+    signal?: AbortSignal;
+} : HasRequiredProperties<RequestBody> extends true ? {
+    headers?: Record<string, string>;
+    method?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+    body: RequestBody;
+    signal?: AbortSignal;
+} : {
+    headers?: Record<string, string>;
+    method?: 'POST' | 'GET' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: RequestBody;
+    signal?: AbortSignal;
+};
+/**
+ * Determines whether the `options` parameter to `invoke()` is required or
+ * optional based on the shape of `RequestBody`.
+ *
+ * - If `RequestBody` is `void | undefined`, options are optional.
+ * - If `RequestBody` has no required properties, options are optional.
+ * - If `RequestBody` has required properties, options are required.
+ */
+export type InvokeOptions<RequestBody> = RequestBody extends void | undefined ? FunctionInvokeOptions<RequestBody> | undefined : RequiredKeys<RequestBody> extends never ? FunctionInvokeOptions<RequestBody> | undefined : FunctionInvokeOptions<RequestBody>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@pixpilot/supabase-functions-client",
+  "type": "module",
+  "version": "0.2.0",
+  "description": "A client library for Supabase Functions, providing a simple and efficient way to interact with serverless functions deployed on the Supabase platform.",
+  "author": "m.doaie <m.doaie@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/pixpilot/supabase-toolkit",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pixpilot/supabase-toolkit.git",
+    "directory": "packages/supabase-functions-client"
+  },
+  "bugs": {
+    "url": "https://github.com/pixpilot/supabase-toolkit/issues"
+  },
+  "keywords": [],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@supabase/supabase-js": "^2.75.0"
+  },
+  "devDependencies": {
+    "@supabase/supabase-js": "^2.75.0",
+    "@types/node": "^22.18.10",
+    "eslint": "^9.37.0",
+    "typescript": "^5.9.3",
+    "@internal/eslint-config": "0.3.0",
+    "@internal/prettier-config": "0.0.1",
+    "@internal/tsdown-config": "0.1.0",
+    "@internal/vitest-config": "0.1.0",
+    "@internal/tsconfig": "0.1.0"
+  },
+  "prettier": "@internal/prettier-config",
+  "scripts": {
+    "clean": "git clean -xdf .cache .turbo dist",
+    "clean:all": "pnpm clean && git clean -xdf node_modules",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
+    "build:watch": "pnpm run clean && tsc -p tsconfig.build.json --watch",
+    "test": "vitest --run --passWithNoTests",
+    "test:watch": "vitest --watch",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint",
+    "format": "prettier --check . --ignore-path ../../.gitignore --ignore-path ../../.prettierignore"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}