@zerospin/error 2.0.1 → 2.1.0

package/.tsbuildinfo/build.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/zerospinerror.ts","../src/zerospinerrorjsonschema.ts","../src/index.ts","../src/types.ts"],"version":"5.9.0-dev.20250623"}
+{"root":["../src/zerospinerror.ts","../src/zerospinerrorjsonschema.ts","../src/index.ts","../src/types.ts"],"version":"5.9.3"}

package/.turbo/turbo-build.log

@@ -0,0 +1,13 @@
+
+> @zerospin/error@2.0.2 build /Users/morgs32/GitHub/zerospin/packages/error
+> tsup
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Using tsup config: /Users/morgs32/GitHub/zerospin/packages/error/tsup.config.ts
+CLI Target: es2022
+CLI Cleaning output folder
+ESM Build start
+ESM dist/index.js 1.30 KB
+ESM ⚡️ Build success in 7ms

package/.turbo/turbo-test.log

@@ -0,0 +1,14 @@
+
+> @zerospin/error@2.0.2 test /Users/morgs32/GitHub/zerospin/packages/error
+> vitest packages/profiler/src/toMatchProcedure
+
+
+ RUN  v3.2.4 /Users/morgs32/GitHub/zerospin/packages/error
+
+No test files found, exiting with code 1
+
+filter: packages/profiler/src/toMatchProcedure
+include: **/*.{test,spec}.?(c|m)[jt]s?(x)
+exclude:  **/node_modules/**, **/dist/**, **/cypress/**, **/.{idea,git,cache,output,temp}/**, **/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*
+
+ ELIFECYCLE  Test failed. See above for more details.

package/README.md

@@ -0,0 +1,485 @@
+# @zerospin/error
+
+ZeroSpin Error provides a type-safe, structured error system for Effect-based applications. It extends Effect's `Data.TaggedError` to provide consistent error handling with serialization support, error codes, and optional metadata.
+
+## Installation
+
+```bash
+npm install @zerospin/error effect
+```
+
+## Basic Usage
+
+### Creating Errors
+
+`ZerospinError` can be created in two ways:
+
+**Simple form (code only):**
+```typescript
+import { ZerospinError } from '@zerospin/error'
+
+const error = new ZerospinError('my-error-code')
+// Creates an error with code: 'my-error-code', message: 'my-error-code'
+```
+
+**Full form (with metadata):**
+```typescript
+const error = new ZerospinError({
+  code: 'failed-to-fetch',
+  message: 'Failed to fetch data from server',
+  cause: originalError,
+  extra: { url: 'https://api.example.com' },
+  status: 500
+})
+```
+
+## Using ZerospinError in Effect Contexts
+
+### 1. Throwing Errors in Effect.gen
+
+In `Effect.gen` functions, use `yield*` to throw errors:
+
+```typescript
+import { Effect } from 'effect'
+import { ZerospinError } from '@zerospin/error'
+
+const fetchData = Effect.gen(function* () {
+  const res = yield* Effect.promise(() => fetch('/api/data'))
+  
+  if (res.status === 404) {
+    return yield* new ZerospinError({
+      code: 'resource-not-found',
+      message: 'Resource not found',
+    })
+  }
+  
+  return yield* res.json()
+})
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/client/src/ZerospinClientAdapter.ts
+export const ZerospinClientAdapter = Layer.effect(
+  ZerospinStorageAdapter,
+  Effect.fn('getClientAdapter')(function* () {
+    const isOPFSSupported = yield* OPFSAdapter.check().pipe(
+      Effect.either,
+      Effect.map((either) => Either.isRight(either))
+    )
+    if (isOPFSSupported) {
+      return OPFSAdapter
+    }
+    const isLocalStorageSupported = yield* LocalStorageAdapter.check().pipe(
+      Effect.either,
+      Effect.map((either) => Either.isRight(either))
+    )
+    if (isLocalStorageSupported) {
+      return LocalStorageAdapter
+    }
+    return yield* new ZerospinError({
+      code: 'no-adapter-available',
+      message: 'No adapter available',
+    })
+  })()
+)
+```
+
+### 2. Mapping Errors with Effect.mapError
+
+Transform errors from other Effect operations:
+
+```typescript
+import { Effect } from 'effect'
+import { ZerospinError } from '@zerospin/error'
+
+const parseJson = Effect.promise(() => res.json()).pipe(
+  Effect.mapError((error) => {
+    return new ZerospinError({
+      code: 'failed-to-parse-json',
+      message: 'Failed to parse JSON',
+      cause: error,
+    })
+  })
+)
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/client/src/makeZerospinFetchFrontendApi.ts
+const res = yield* Effect.promise(async () => {
+  return fetch(url, {
+    body: JSON.stringify(body),
+    headers: { 'Content-Type': 'application/json' },
+    method: 'POST',
+  }).catch((error: unknown) => {
+    throw new ZerospinError({
+      code: 'failed-to-fetch',
+      message: 'Failed to fetch',
+      cause: error,
+    })
+  })
+}).pipe(
+  Effect.mapError((error) => {
+    return new ZerospinError({
+      code: 'failed-to-fetch',
+      message: 'Failed to fetch',
+      cause: error,
+    })
+  })
+)
+```
+
+### 3. Catching All Errors with Effect.catchAll
+
+Handle any error and convert it to a ZerospinError:
+
+```typescript
+import { Effect } from 'effect'
+import { ZerospinError } from '@zerospin/error'
+
+const safeOperation = someEffect.pipe(
+  Effect.catchAll((error) => {
+    return new ZerospinError({
+      code: 'operation-failed',
+      message: error.message,
+      cause: error,
+    })
+  })
+)
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/zerospin/src/batch/makeSafe.ts
+const safe = yield* validateUnknown({
+  onExcessProperty: 'preserve',
+  schema,
+  value: command,
+}).pipe(
+  Effect.catchAll((error) => {
+    return new ZerospinError({
+      code: 'failed-to-validate-command',
+      message: error.message,
+      cause: error,
+    })
+  })
+)
+```
+
+### 4. Handling Promise Errors
+
+When working with promises, catch errors and throw ZerospinError:
+
+```typescript
+import { Effect } from 'effect'
+import { ZerospinError } from '@zerospin/error'
+
+const fetchData = Effect.promise(async () => {
+  try {
+    const response = await fetch('/api/data')
+    return await response.json()
+  } catch (error) {
+    throw new ZerospinError({
+      code: 'fetch-failed',
+      message: 'Failed to fetch data',
+      cause: error,
+    })
+  }
+})
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/client/src/makeZerospinFetchFrontendApi.ts
+const res = yield* Effect.promise(async () => {
+  return fetch(url, {
+    body: JSON.stringify(body),
+    headers: { 'Content-Type': 'application/json' },
+    method: 'POST',
+  }).catch((error: unknown) => {
+    throw new ZerospinError({
+      code: 'failed-to-fetch',
+      message: 'Failed to fetch',
+      cause: error,
+    })
+  })
+})
+```
+
+### 5. Schema Validation Errors
+
+Convert schema validation errors to ZerospinError:
+
+```typescript
+import { Effect, Schema } from 'effect'
+import { ZerospinError } from '@zerospin/error'
+
+const validateData = Schema.decode(Schema.String)(value).pipe(
+  Effect.mapError((error) => {
+    return new ZerospinError({
+      code: 'validation-failed',
+      message: error.message,
+      cause: error,
+    })
+  })
+)
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/zerospin/src/utils/encodeUnknown.ts
+export const encodeUnknown = Effect.fn('encodeUnknown')(<
+  DECODED,
+  ENCODED,
+>(props: {
+  schema: Schema.Schema<DECODED, ENCODED>
+  value: unknown
+  errorMessage?: string
+}): Effect.Effect<ENCODED, ZerospinError<'failed-to-encode-unknown'>> => {
+  const { errorMessage, schema, value } = props
+
+  return Schema.encodeUnknown(schema)(value).pipe(
+    Effect.mapError((error) => {
+      return new ZerospinError({
+        code: 'failed-to-encode-unknown',
+        message: errorMessage ?? error.message,
+        cause: error,
+      })
+    })
+  )
+})
+```
+
+**Another example:**
+```typescript
+// From packages/zerospin/src/contract/makeContract.ts
+return validateUnknown({
+  onExcessProperty: 'error',
+  schema: resultsSchema,
+  value: results,
+}).pipe(
+  Effect.mapError((error) => {
+    return new ZerospinError({
+      code: 'failed-to-validate-results',
+      message: error.message,
+      cause: error,
+    })
+  })
+)
+```
+
+### 6. Deserializing Errors from JSON
+
+When receiving errors from APIs or serialized sources:
+
+```typescript
+import { ZerospinError } from '@zerospin/error'
+
+// From packages/client/src/makeZerospinFetchFrontendApi.ts
+const payload = yield* Effect.promise(() => {
+  return res.json() as Promise<IAnyErrorJson | IJson>
+})
+
+if (res.status === 200) {
+  return payload as IJson
+}
+
+// Deserialize error from JSON
+return yield* new ZerospinError(payload as IAnyErrorJson)
+```
+
+### 7. Error Handling in Route Handlers
+
+Handle errors at the boundary and serialize for HTTP responses:
+
+```typescript
+import { Effect, Exit, Cause } from 'effect'
+import { ZerospinError } from '@zerospin/error'
+import { NextResponse } from 'next/server'
+
+const exit = await Effect.runPromiseExit(myEffect)
+
+return Exit.match(exit, {
+  onFailure: (cause) => {
+    console.error(Cause.pretty(cause))
+    if (Cause.isFailType(cause)) {
+      const error = cause.error as ZerospinError
+      return NextResponse.json(error.serialize(), {
+        status: error.status ?? 400,
+      })
+    }
+    return NextResponse.json(
+      new ZerospinError({
+        code: 'unexpected-error',
+        message: Cause.pretty(cause),
+      }).serialize(),
+      { status: 500 }
+    )
+  },
+  onSuccess: (value) => {
+    return NextResponse.json(value)
+  },
+})
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/zerospin/src/rpc/makeNextRoute.ts
+return Exit.match(exit, {
+  onFailure: (cause) => {
+    console.error(Cause.pretty(cause))
+    if (Cause.isFailType(cause)) {
+      const error = cause.error as ZerospinError
+      return NextResponse.json(error.serialize(), {
+        status: error.status ?? 400,
+      })
+    }
+    return NextResponse.json(
+      new ZerospinError({
+        code: 'unexpected-error',
+        message: Cause.pretty(cause),
+      }).serialize(),
+      { status: 500 }
+    )
+  },
+  onSuccess: (value) => {
+    return NextResponse.json(value)
+  },
+})
+```
+
+## Error Properties
+
+### Error Structure
+
+```typescript
+interface IError<T extends string = string, E = unknown> {
+  code: T                    // Error code identifier
+  status: null | number      // HTTP status code (optional)
+  cause?: unknown           // Original error that caused this
+  extra?: E                  // Additional typed metadata
+  message?: string           // Human-readable message
+}
+```
+
+### Type Safety with Error Codes
+
+You can create type-safe error codes:
+
+```typescript
+type MyErrorCodes = 
+  | 'failed-to-fetch'
+  | 'validation-failed'
+  | 'resource-not-found'
+
+const error: ZerospinError<MyErrorCodes> = new ZerospinError({
+  code: 'failed-to-fetch',  // TypeScript will validate this
+  message: 'Failed to fetch',
+})
+```
+
+## Utility Methods
+
+### Checking if Something is a ZerospinError
+
+```typescript
+import { ZerospinError } from '@zerospin/error'
+
+if (ZerospinError.isZerospinError(error)) {
+  console.log(error.code)
+  console.log(error.message)
+}
+```
+
+**Example from ZeroSpin:**
+```typescript
+// From packages/zerospin/src/ZerospinErrorLayer.ts
+Exit.mapError(exit, (error) => {
+  if (ZerospinError.isZerospinError(error)) {
+    if (error.cause) {
+      error.message += ` ${JSON.stringify(error.cause, null, 2)}`
+    }
+    if (error.extra) {
+      error.message += ` ${JSON.stringify(error.extra, null, 2)}`
+    }
+  }
+  return error
+})
+```
+
+### Serializing Errors
+
+Serialize errors for transmission over networks or storage:
+
+```typescript
+const error = new ZerospinError({
+  code: 'my-error',
+  message: 'Something went wrong',
+  extra: { actorId: '123' },
+  status: 400,
+})
+
+// Serialize full error
+const json = error.serialize()
+
+// Serialize without certain fields
+const jsonWithoutExtra = error.serialize(['extra'])
+```
+
+## Best Practices
+
+1. **Always provide meaningful error codes**: Use descriptive, kebab-case codes like `'failed-to-fetch'` instead of generic ones.
+
+2. **Preserve original errors**: Use the `cause` property to maintain error chains:
+   ```typescript
+   new ZerospinError({
+     code: 'operation-failed',
+     message: 'Operation failed',
+     cause: originalError,  // Preserve the original error
+   })
+   ```
+
+3. **Use typed extra data**: Leverage TypeScript generics for type-safe metadata:
+   ```typescript
+  new ZerospinError<ErrorCode, { actorId: string; action: string }>({
+     code: 'permission-denied',
+    extra: { actorId: '123', action: 'delete' },
+   })
+   ```
+
+4. **Handle at boundaries**: Convert to ZerospinError at Effect boundaries (promises, HTTP handlers, etc.) and let them propagate through your Effect pipeline.
+
+5. **Serialize for APIs**: Use `serialize()` when sending errors over HTTP or storing them.
+
+## API Reference
+
+### ZerospinError Class
+
+```typescript
+class ZerospinError<T extends string = never, E = unknown>
+  extends Data.TaggedError('ZerospinError')<IError<T, E>>
+```
+
+**Constructor:**
+- `new ZerospinError(code: string)` - Simple form
+- `new ZerospinError(props: IProps<T, E>)` - Full form
+
+**Static Methods:**
+- `ZerospinError.isZerospinError(data: unknown): data is ZerospinError` - Type guard
+- `ZerospinError.makeZerospinErrorJson(props): IAnyErrorJson` - Create JSON representation
+
+**Instance Methods:**
+- `serialize(omit?: string[]): IAnyErrorJson` - Serialize to JSON
+
+### Types
+
+```typescript
+type IAnyError = ZerospinError<string>
+type IAnyErrorJson = Brand.Brand<'ZerospinErrorJson'> & {
+  code: string
+  extra: unknown
+  message: string
+  status: null | number
+}
+```

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import * as effect_Cause from 'effect/Cause';
+import * as effect_Types from 'effect/Types';
+import { RequiredKeysOf } from 'type-fest';
+import { Brand, Schema } from 'effect';
+
+type IAnyErrorJson<ERROR extends IAnyError = IAnyError> = Brand.Brand<'ZerospinErrorJson'> & {
+    code: ERROR['code'];
+    extra: ERROR['extra'];
+    message: string;
+    status: null | number;
+};
+type IAnyError = ZerospinError<string>;
+interface IProps<T extends string = string, E = unknown> {
+    code: T;
+    cause?: unknown;
+    extra?: E;
+    message?: string;
+    status?: null | number;
+}
+interface IError<T extends string = string, E = unknown> {
+    code: T;
+    status: null | number;
+    cause?: unknown;
+    extra?: E;
+    message?: string;
+}
+declare const ZerospinError_base: new <A extends Record<string, any> = {}>(args: effect_Types.Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => effect_Cause.YieldableError & {
+    readonly _tag: "ZerospinError";
+} & Readonly<A>;
+declare class ZerospinError<T extends string = never, E = unknown> extends ZerospinError_base<IError<T, E>> {
+    message: string;
+    constructor(props: IProps<T, E> | T);
+    static isZerospinError(data: unknown): data is ZerospinError;
+    static makeZerospinErrorJson(props: {
+        cause: unknown;
+        code: string;
+        extra: unknown;
+        message: string;
+        status: null | number;
+    }): IAnyErrorJson;
+    serialize(omit?: Exclude<keyof IAnyErrorJson, RequiredKeysOf<IAnyErrorJson>>[]): IAnyErrorJson;
+}
+
+declare const ZerospinErrorJsonSchema: Schema.Schema<IAnyErrorJson, any>;
+
+export { type IAnyError, type IAnyErrorJson, type IError, ZerospinError, ZerospinErrorJsonSchema };

package/dist/index.js

@@ -1,2 +1,55 @@
-export * from './ZerospinError';
-export * from './ZerospinErrorJsonSchema';
+// src/ZerospinError.ts
+import { Brand, Data } from "effect";
+import { isObject } from "effect/Predicate";
+var ZerospinError = class _ZerospinError extends Data.TaggedError("ZerospinError") {
+  message;
+  constructor(props) {
+    if (typeof props === "string") {
+      super({
+        code: props,
+        extra: null,
+        message: props,
+        status: null
+      });
+      this.message = props;
+    } else {
+      super({
+        status: null,
+        ...props
+      });
+      this.message = props.message ?? props.code;
+    }
+  }
+  static isZerospinError(data) {
+    return isObject(data) && "_tag" in data && data._tag === "ZerospinError";
+  }
+  static makeZerospinErrorJson(props) {
+    return Brand.nominal()(props);
+  }
+  serialize(omit = []) {
+    const json = _ZerospinError.makeZerospinErrorJson({
+      cause: this.cause,
+      code: this.code,
+      extra: this.extra,
+      message: this.message,
+      status: this.status
+    });
+    for (const key of omit) {
+      delete json[key];
+    }
+    return json;
+  }
+};
+
+// src/ZerospinErrorJsonSchema.ts
+import { Schema } from "effect";
+var ZerospinErrorJsonSchema = Schema.Struct({
+  code: Schema.String,
+  extra: Schema.Unknown,
+  message: Schema.String,
+  status: Schema.Union(Schema.Null, Schema.Number)
+});
+export {
+  ZerospinError,
+  ZerospinErrorJsonSchema
+};

package/package.json

@@ -1,40 +1,44 @@
 {
   "name": "@zerospin/error",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "private": false,
   "type": "module",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./src/index.ts",
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.js"
     }
   },
   "dependencies": {
-    "type-fest": "^4.41.0"
+    "drizzle-orm": "^0.45.1",
+    "type-fest": "^5.4.1"
   },
   "devDependencies": {
-    "@effect/language-service": "^0.43.2",
-    "@effect/vitest": "^0.25.1",
-    "@vitest/coverage-v8": "^3.2.4",
-    "@vitest/pretty-format": "^3.1.4",
-    "effect": "^3.17.11",
-    "eslint": "^9.27.0",
-    "glob": "^11.0.3",
-    "jsdom": "^26.1.0",
-    "knip": "^4.2.4",
-    "tsafe": "^1.8.5",
-    "tsx": "^4.20.3",
-    "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.2.4",
+    "@effect/language-service": "^0.68.0",
+    "@effect/vitest": "^0.27.0",
+    "@types/node": "^22.13.2",
+    "@vitest/coverage-v8": "^4.0.17",
+    "@vitest/pretty-format": "^4.0.17",
+    "effect": "^3.19.14",
+    "eslint": "^9.39.2",
+    "glob": "^13.0.0",
+    "jsdom": "^27.4.0",
+    "knip": "^5.81.0",
+    "tsafe": "^1.8.12",
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "vite-tsconfig-paths": "^6.0.4",
+    "vitest": "^4.0.17",
     "@zerospin/utils": "2.0.1"
   },
   "peerDependencies": {
-    "effect": "^3.15.2"
+    "effect": "^3.17.11"
   },
   "scripts": {
-    "build": "tsc -b tsconfig.build.json",
-    "watch": "tsc -b tsconfig.build.json --watch",
+    "build": "tsup",
+    "watch": "tsup --watch",
     "typecheck": "tsc --noEmit",
     "test": "vitest",
     "lint": "eslint .",

package/src/ZerospinError.ts

@@ -1,31 +1,39 @@
-import type { RequiredKeysOf } from 'type-fest'
+import type { RequiredKeysOf } from 'type-fest';
 
-import { Brand, Data } from 'effect'
-import { isObject } from 'effect/Predicate'
+import { Brand, Data } from 'effect';
+import { isObject } from 'effect/Predicate';
 
-import type { IAnyErrorJson } from './types'
+export type IAnyErrorJson<ERROR extends IAnyError = IAnyError> =
+  Brand.Brand<'ZerospinErrorJson'> & {
+    code: ERROR['code'];
+    extra: ERROR['extra'];
+    message: string;
+    status: null | number;
+  };
+
+export type IAnyError = ZerospinError<string>;
 
 interface IProps<T extends string = string, E = unknown> {
-  code: T
-  cause?: unknown
-  extra?: E
-  message?: string
-  status?: null | number
+  code: T;
+  cause?: unknown;
+  extra?: E;
+  message?: string;
+  status?: null | number;
 }
 
 export interface IError<T extends string = string, E = unknown> {
-  code: T
-  status: null | number
-  cause?: unknown
-  extra?: E
-  message?: string
+  code: T;
+  status: null | number;
+  cause?: unknown;
+  extra?: E;
+  message?: string;
 }
 
 export class ZerospinError<
   T extends string = never,
   E = unknown,
 > extends Data.TaggedError('ZerospinError')<IError<T, E>> {
-  public override message!: string
+  public override message!: string;
 
   constructor(props: IProps<T, E> | T) {
     if (typeof props === 'string') {
@@ -34,37 +42,34 @@ export class ZerospinError<
         extra: null as E,
         message: props,
         status: null,
-      })
-      this.message = props
+      });
+      this.message = props;
     } else {
       super({
         status: null,
         ...props,
-      })
-      this.message = props.message ?? props.code
+      });
+      this.message = props.message ?? props.code;
     }
   }
 
   static isZerospinError(data: unknown): data is ZerospinError {
-    return isObject(data) && '_tag' in data && data._tag === 'ZerospinError'
+    return isObject(data) && '_tag' in data && data._tag === 'ZerospinError';
   }
 
   static makeZerospinErrorJson(props: {
-    cause: unknown
-    code: string
-    extra: unknown
-    message: string
-    status: null | number
+    cause: unknown;
+    code: string;
+    extra: unknown;
+    message: string;
+    status: null | number;
   }): IAnyErrorJson {
-    return Brand.nominal<IAnyErrorJson>()(props)
+    return Brand.nominal<IAnyErrorJson>()(props);
   }
 
   serialize(
     // You can omit anything BUT id, code
-    omit: Exclude<
-      keyof IAnyErrorJson,
-      RequiredKeysOf<IAnyErrorJson>
-    >[] = []
+    omit: Exclude<keyof IAnyErrorJson, RequiredKeysOf<IAnyErrorJson>>[] = []
   ): IAnyErrorJson {
     const json = ZerospinError.makeZerospinErrorJson({
       cause: this.cause,
@@ -72,12 +77,12 @@ export class ZerospinError<
       extra: this.extra,
       message: this.message,
       status: this.status,
-    })
+    });
 
     for (const key of omit) {
-      delete json[key]
+      delete json[key];
     }
 
-    return json
+    return json;
   }
 }

package/src/ZerospinErrorJsonSchema.ts

@@ -1,6 +1,6 @@
 import { Schema } from 'effect'
 
-import type { IAnyErrorJson } from './types'
+import type { IAnyErrorJson } from './ZerospinError'
 
 export const ZerospinErrorJsonSchema = Schema.Struct({
   code: Schema.String,

package/src/index.ts

@@ -1,3 +1,2 @@
-export type * from './types';
 export * from './ZerospinError';
 export * from './ZerospinErrorJsonSchema';

package/tsconfig.json

@@ -7,6 +7,7 @@
   "compilerOptions": {
     "incremental": false,
     "types": [
+      "node",
       "vitest/globals"
     ],
     "outDir": "./dist",

package/tsup.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'tsup';
+
+export default defineConfig({
+  clean: true,
+  dts: true, // Declarations via tsup; typecheck script still separate
+  entry: ['src/index.ts'],
+  format: ['esm'],
+  minify: process.env.NODE_ENV === 'production',
+  outDir: 'dist',
+  sourcemap: false,
+  splitting: false,
+});
+

package/dist/ZerospinError.js

@@ -1,44 +0,0 @@
-import { Brand, Data } from 'effect';
-import { isObject } from 'effect/Predicate';
-export class ZerospinError extends Data.TaggedError('ZerospinError') {
-    message;
-    constructor(props) {
-        if (typeof props === 'string') {
-            super({
-                code: props,
-                extra: null,
-                message: props,
-                status: null,
-            });
-            this.message = props;
-        }
-        else {
-            super({
-                status: null,
-                ...props,
-            });
-            this.message = props.message ?? props.code;
-        }
-    }
-    static isZerospinError(data) {
-        return isObject(data) && '_tag' in data && data._tag === 'ZerospinError';
-    }
-    static makeZerospinErrorJson(props) {
-        return Brand.nominal()(props);
-    }
-    serialize(
-    // You can omit anything BUT id, code
-    omit = []) {
-        const json = ZerospinError.makeZerospinErrorJson({
-            cause: this.cause,
-            code: this.code,
-            extra: this.extra,
-            message: this.message,
-            status: this.status,
-        });
-        for (const key of omit) {
-            delete json[key];
-        }
-        return json;
-    }
-}

package/dist/ZerospinErrorJsonSchema.js

@@ -1,7 +0,0 @@
-import { Schema } from 'effect';
-export const ZerospinErrorJsonSchema = Schema.Struct({
-    code: Schema.String,
-    extra: Schema.Unknown,
-    message: Schema.String,
-    status: Schema.Union(Schema.Null, Schema.Number),
-});

package/dist/types.js

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

package/src/types.ts

@@ -1,13 +0,0 @@
-import type { Brand } from 'effect';
-
-import type { ZerospinError } from './ZerospinError';
-
-export type IAnyErrorJson<ERROR extends IAnyError = IAnyError> =
-  Brand.Brand<'ZerospinErrorJson'> & {
-    code: ERROR['code'];
-    extra: ERROR['extra'];
-    message: string;
-    status: null | number;
-  };
-
-export type IAnyError = ZerospinError<string>;