mini-effect 0.0.0 → 0.0.1

package/README.md

@@ -1,190 +1,205 @@
-# 🎯 mini-effect
+# mini-effect
 
-> _Because sometimes you want Effect, but like... mini._
+Minimal Effect system for TypeScript. Lazy, composable, cancellable.
 
-A delightfully tiny Effect system for TypeScript that packs a punch! ✨
+## Installation
 
-## 🤔 What's This?
-
-Ever looked at [Effect-TS](https://effect.website/) and thought "wow, that's amazing but also... a lot"? Same.
-
-**mini-effect** gives you the good stuff:
+```bash
+npm install mini-effect
+```
 
-- 🦥 **Lazy evaluation** - Nothing runs until you say so
-- 🔗 **Pipes** - Compose like a functional programming wizard
-- 🎭 **Generators** - Write async code that doesn't look like callback spaghetti
-- 🎣 **Error handling** - Catch 'em all (or just some of 'em)
-- ⚡ **Concurrency** - `all`, `race`, `any`, `allSettled` - the gang's all here
-- 🛑 **AbortSignal support** - Cancel everything! EVERYTHING!
+## Modules
 
-All in a package so small it practically fits in a tweet. 🐦
+- `mini-effect` — core primitives
+- `mini-effect/concurrency` — parallel execution
+- `mini-effect/tag` — tagged error handling
+- `mini-effect/fetch` — HTTP requests
+- `mini-effect/schema` — validation (Valibot)
 
-## 📦 Installation
+## Core
 
-```bash
-npm install mini-effect
-# or
-pnpm add mini-effect
-# or
-yarn add mini-effect
+```typescript
+import { fn, succeed, fail, gen, pipe, run, catchSome } from "mini-effect";
 ```
 
-## 🚀 Quick Start
+### Create Effects
 
 ```typescript
-import { fn, run, succeed, fail, gen, pipe } from "mini-effect";
-import { all } from "mini-effect/concurrency";
-
-// Create an effect (it's lazy - nothing happens yet!)
-const fetchTodo = fn(async (signal) => {
-  const res = await fetch("https://jsonplaceholder.typicode.com/todos/1", {
-    signal,
-  });
-  return res.json();
-});
-
-// Run it! 🏃‍♂️
-const todo = await run(fetchTodo);
+const delay = fn(
+  (signal) =>
+    new Promise<void>((resolve, reject) => {
+      const id = setTimeout(resolve, 1000);
+      signal.addEventListener("abort", () => {
+        clearTimeout(id);
+        reject(signal.reason);
+      });
+    }),
+);
+const success = succeed(42);
+const failure = fail(new Error("failed"));
 ```
 
-## 🎮 The Fun Parts
-
-### Generators (a.k.a. "async/await but cooler")
+### Generators
 
 ```typescript
 const program = gen(function* (signal) {
   const a = yield* fn(() => Promise.resolve(1));
-  const b = yield* fn(() => Promise.resolve(2));
-  const c = yield* succeed(3);
-
-  return a + b + c; // 6!
+  const b = yield* succeed(2);
+  return a + b;
 });
-
-await run(program); // 6
 ```
 
-### Pipes (a.k.a. "look ma, no nesting!")
+### Pipe
 
 ```typescript
 const result = await run(
   pipe(
     succeed(5),
-    (n: number) => succeed(n * 2), // 10
-    (n: number) => succeed(n + 1), // 11
-    (n: number) => succeed(`Result: ${n}`), // "Result: 11"
+    (n: number) => succeed(n * 2),
+    (n: number) => succeed(n + 1),
   ),
 );
 ```
 
-### Error Handling (a.k.a. "try/catch grew up")
+### Error Recovery
 
 ```typescript
-import { catchClass, catchSome } from "mini-effect";
-
-class NotFoundError extends Error {
-  constructor(public id: number) {
-    super(`Not found: ${id}`);
-  }
-}
-
-const safeProgram = pipe(
+pipe(
   fn(() => {
-    throw new NotFoundError(42);
+    throw new Error("x");
   }),
-  catchClass(NotFoundError, (err) => succeed(`Handled: ${err.id}`)),
+  catchSome((cause) =>
+    cause instanceof Error ? succeed("recovered") : undefined,
+  ),
 );
+```
+
+### Execution
 
-await run(safeProgram); // "Handled: 42"
+```typescript
+const result = await run(effect);
+const result = await run(effect, abortController.signal);
 ```
 
-### Concurrency (a.k.a. "Promise.all's cooler cousin")
+## Concurrency
 
 ```typescript
-import { all, race, any, allSettled } from "mini-effect/concurrency";
-
-// Run 'em all at once!
-const results = await run(
-  all([
-    fn(() => fetch("/api/users")),
-    fn(() => fetch("/api/posts")),
-    fn(() => fetch("/api/comments")),
-  ]),
-);
+import { all, allSettled, any, race, fork } from "mini-effect/concurrency";
+```
 
-// First one wins! 🏆
-const fastest = await run(
-  race([fn(() => fetchFromServer1()), fn(() => fetchFromServer2())]),
-);
+| Function     | Behavior                               |
+| ------------ | -------------------------------------- |
+| `all`        | Parallel execution, fail-fast          |
+| `allSettled` | Parallel execution, collect all        |
+| `any`        | First success wins                     |
+| `race`       | First completion wins                  |
+| `fork`       | Background execution, returns abort fn |
+
+```typescript
+await run(all([effectA, effectB, effectC]));
+const abort = await run(fork(backgroundEffect));
+```
 
-// First SUCCESS wins (failures don't count)
-const firstSuccess = await run(any([fn(() => tryThis()), fn(() => tryThat())]));
+## Tagged Errors
 
-// Get all results, even the failures 🤷
-const allResults = await run(
-  allSettled([succeed(1), fail(new Error("oops")), succeed(3)]),
+```typescript
+import { failure, catchTags } from "mini-effect/tag";
+
+const NotFound = failure("NotFound");
+const Unauthorized = failure("Unauthorized");
+
+pipe(
+  fn(() => {
+    throw new NotFound();
+  }),
+  catchTags({
+    NotFound: () => succeed("fallback"),
+    Unauthorized: () => succeed("login"),
+  }),
 );
 ```
 
-### Cancellation (a.k.a. "STOP THE PRESSES!")
+## Fetch
 
 ```typescript
-const controller = new AbortController();
+import { request, json, text, blob, bytes, formData } from "mini-effect/fetch";
+```
 
-const longRunning = fn(async (signal) => {
-  // Check if we should bail
-  if (signal.aborted) {
-    throw new DOMException("Aborted!", "AbortError");
-  }
+| Function   | Returns      | Error Tag       |
+| ---------- | ------------ | --------------- |
+| `request`  | `Response`   | `FailedToFetch` |
+| `json`     | `unknown`    | `FailedToRead`  |
+| `text`     | `string`     | `FailedToRead`  |
+| `blob`     | `Blob`       | `FailedToRead`  |
+| `bytes`    | `Uint8Array` | `FailedToRead`  |
+| `formData` | `FormData`   | `FailedToRead`  |
 
-  // Or pass it to fetch
-  const res = await fetch("/api/slow", { signal });
-  return res.json();
-});
+```typescript
+pipe(request("https://api.example.com/data"), (res) => json(res));
+```
 
-// Start it
-const promise = run(longRunning, controller.signal);
+## Schema
 
-// Actually, never mind! 🙅
-controller.abort();
+```typescript
+import { validate, object, string, number } from "mini-effect/schema";
+
+const User = object({ name: string(), age: number() });
+const validated = validate(User)({ name: "Alice", age: 30 });
 ```
 
-## 🗺️ API at a Glance
+Error tag: `FailedToValidate`
+
+Re-exports all of [Valibot](https://valibot.dev/).
+
+## API Reference
+
+### `mini-effect`
 
-| Function                     | What it does                        |
-| ---------------------------- | ----------------------------------- |
-| `fn(thunk)`                  | Create an effect from a function    |
-| `succeed(value)`             | Create a successful effect          |
-| `fail(error)`                | Create a failed effect              |
-| `gen(generator)`             | Create an effect from a generator   |
-| `pipe(effect, ...steps)`     | Compose effects left-to-right       |
-| `run(effect, signal?)`       | Execute an effect (returns Promise) |
-| `catchSome(handler)`         | Catch errors selectively            |
-| `catchClass(Class, handler)` | Catch errors by type                |
+| Export      | Signature                                                        |
+| ----------- | ---------------------------------------------------------------- |
+| `fn`        | `(thunk: (signal: AbortSignal) => T \| Promise<T>) => Effect<T>` |
+| `succeed`   | `(value: T) => Effect<T, never>`                                 |
+| `fail`      | `(error: E) => Effect<never, E>`                                 |
+| `gen`       | `(generator: (signal) => Generator<Effect>) => Effect`           |
+| `pipe`      | `(effect, ...fns) => Effect`                                     |
+| `run`       | `(effect, signal?) => Promise<T>`                                |
+| `catchSome` | `(handler: (cause) => Effect \| undefined) => WrapEffect`        |
 
-### Concurrency
+### `mini-effect/concurrency`
 
-| Function              | What it does                 |
-| --------------------- | ---------------------------- |
-| `all(effects)`        | Run all, fail if any fails   |
-| `allSettled(effects)` | Run all, collect all results |
-| `any(effects)`        | First success wins           |
-| `race(effects)`       | First to finish wins         |
+| Export       | Signature                                        |
+| ------------ | ------------------------------------------------ |
+| `all`        | `(effects: Effect[]) => Effect<T[]>`             |
+| `allSettled` | `(effects: Effect[]) => Effect<SettledResult[]>` |
+| `any`        | `(effects: Effect[]) => Effect<T>`               |
+| `race`       | `(effects: Effect[]) => Effect<T>`               |
+| `fork`       | `(effect: Effect) => Effect<() => void>`         |
 
-## 🧠 Why Effects?
+### `mini-effect/tag`
 
-Effects are like promises, but:
+| Export      | Signature                                        |
+| ----------- | ------------------------------------------------ |
+| `failure`   | `(tag: string) => FailureConstructor`            |
+| `catchTags` | `(handlers: Record<Tag, Handler>) => WrapEffect` |
 
-1. **Lazy** - They don't run until you explicitly `run()` them
-2. **Composable** - Pipe and combine them without execution
-3. **Typed errors** - Your errors are part of the type signature
-4. **Cancellable** - AbortSignal support baked right in
+### `mini-effect/fetch`
 
-Think of an Effect as a _description_ of a computation, not the computation itself. You're building a recipe, not cooking the meal. When you're ready to eat, call `run()`! 🍳
+| Export     | Type     |
+| ---------- | -------- |
+| `request`  | Function |
+| `json`     | Function |
+| `text`     | Function |
+| `blob`     | Function |
+| `bytes`    | Function |
+| `formData` | Function |
 
-## 📄 License
+### `mini-effect/schema`
 
-MIT © [Jacob Ebey](https://github.com/jacob-ebey)
+| Export     | Description                     |
+| ---------- | ------------------------------- |
+| `validate` | `(schema) => (value) => Effect` |
+| `*`        | All Valibot exports             |
 
----
+## License
 
-_Built with ☕ and a healthy disregard for bundle size anxiety._
+MIT

package/dist/concurrency.d.mts

@@ -1,9 +1,10 @@
 import { Effect, inferError, inferReturn } from "./mini-effect.mjs";
 
 //#region src/concurrency.d.ts
+declare const fork: <const E extends Effect<any, any>>(effect: E) => Effect<() => void, never>;
 declare const all: <const E extends Effect<any, any>[]>(values: E) => Effect<{ [K in keyof E]: inferReturn<E[K]> }, inferError<E[number]>>;
 declare const allSettled: <const E extends Effect<any, any>[]>(values: E) => Effect<{ [K in keyof E]: PromiseSettledResult<inferReturn<E[K]>> }, inferError<E[number]>>;
 declare const any: <const E extends Effect<any, any>[]>(values: E) => Effect<inferReturn<E[number]>, inferError<E[number]>>;
 declare const race: <const E extends Effect<any, any>[]>(values: E) => Effect<inferReturn<E[number]>, inferError<E[number]>>;
 //#endregion
-export { all, allSettled, any, race };
+export { all, allSettled, any, fork, race };

package/dist/concurrency.mjs

@@ -6,6 +6,11 @@ const localController = (signal) => {
 	signal.addEventListener("abort", () => controller.abort(signal.reason));
 	return controller;
 };
+const fork = (effect) => fn((signal) => {
+	const controller = localController(signal);
+	run(effect, controller.signal).catch();
+	return () => controller.abort();
+});
 const promiseMethod = (method, values) => fn(async (signal) => {
 	let controller = localController(signal);
 	let localSignal = controller.signal;
@@ -21,4 +26,4 @@ const any = (values) => promiseMethod("any", values);
 const race = (values) => promiseMethod("race", values);
 
 //#endregion
-export { all, allSettled, any, race };
+export { all, allSettled, any, fork, race };

package/dist/fetch.d.mts

@@ -0,0 +1,13 @@
+import { Effect } from "./mini-effect.mjs";
+import { FailureConstructor } from "./tag.mjs";
+
+//#region src/fetch.d.ts
+declare const FailedToReadError: FailureConstructor<"FailedToRead">;
+declare const request: (input: string | URL, init?: RequestInit) => Effect<Response, never>;
+declare const blob: (response: Response) => Effect<any, never>;
+declare const bytes: (response: Response) => Effect<any, never>;
+declare const formData: (response: Response) => Effect<any, never>;
+declare const json: (response: Response) => Effect<unknown, typeof FailedToReadError>;
+declare const text: (response: Response) => Effect<any, never>;
+//#endregion
+export { blob, bytes, formData, json, request, text };

package/dist/fetch.mjs

@@ -0,0 +1,22 @@
+import { catchSome, fail, fn } from "./mini-effect.mjs";
+import { failure } from "./tag.mjs";
+
+//#region src/fetch.ts
+const FailedToFetchError = failure("FailedToFetch");
+const FailedToReadError = failure("FailedToRead");
+const request = (input, init) => {
+	return fn((signal) => fetch(input, {
+		signal,
+		...init
+	})).pipe(catchSome((cause) => fail(new FailedToFetchError({ cause }))));
+};
+const read = (method, response) => fn(() => response[method]()).pipe(catchSome((cause) => fail(new FailedToReadError({ cause }))));
+new Response().blob;
+const blob = (response) => read("blob", response);
+const bytes = (response) => read("bytes", response);
+const formData = (response) => read("formData", response);
+const json = (response) => read("json", response);
+const text = (response) => read("text", response);
+
+//#endregion
+export { blob, bytes, formData, json, request, text };

package/dist/mini-effect.d.mts

@@ -1,37 +1,41 @@
 //#region src/mini-effect.d.ts
-declare const EXCLUDE: unique symbol;
+declare const SYMBOL: SymbolConstructor;
+declare const REMOVE: unique symbol;
+declare const RUN: unique symbol;
+declare const ERROR: unique symbol;
 declare const run: <T, E$1>(effect: Effect<T, E$1>, signal?: AbortSignal) => Promise<T>;
 declare const fn: <R$1, C = never>(thunk: Thunk<R$1>) => Effect<R$1, C>;
 declare const fail: <C>(cause: C) => Effect<never, C>;
 declare const succeed: <R$1>(result: R$1) => Effect<R$1, never>;
-declare const catchSome: <R$1 = any, E$1 = any, EE = never>(thunk: (cause: unknown) => Effect<R$1, E$1> | undefined) => WrapEffect<R$1, E$1, EE>;
-declare const catchClass: <T extends {
-  new (...args: any[]): any;
-}, E$1 extends Effect<any, any>>(type: T, thunk: (cause: T) => E$1) => Pipeable<any, inferReturn<E$1>, inferError<E$1>, T>;
+declare const catchSome: <T = any, C = any, CE = any>(thunk: (cause: unknown) => Effect<T, C> | undefined) => WrapEffect<T, C, CE>;
 declare const gen: <T extends Effect<any, any>, TReturn, TNext>(thunk: (signal: AbortSignal) => Generator<T, TReturn, TNext>) => Effect<TReturn, inferError<T>>;
-declare const pipe: <F extends Effect<any, any>, P$1 extends [Pipeable<any, any, any>, ...Pipeable<any, any, any>[]]>(first: F, ...pipeable: PipeReturn<[F, ...P$1]> extends never ? never : P$1) => PipeReturn<[F, ...P$1]>;
+declare const pipe: <F extends Effect, P$1 extends [Pipeable, ...Pipeable[]]>(first: F, ...pipeable: PipeReturn<[F, ...P$1]> extends never ? never : P$1) => PipeReturn<[F, ...P$1]>;
+declare class Effect<T = any, C = any> {
+  [RUN]?: (signal: AbortSignal) => T | PromiseLike<T>;
+  [ERROR]?: (cause: unknown) => Effect | undefined;
+  constructor(run?: (signal: AbortSignal) => PromiseLike<T> | T, catchSome?: (cause: unknown) => Effect | undefined);
+  [SYMBOL.iterator](): Generator<Effect<T, C>, T, any>;
+  readonly pipe: <P$1 extends [Pipeable, ...Pipeable[]]>(...pipeable: P$1) => PipeReturn<[Effect<T, C>, ...P$1]>;
+}
+declare class WrapEffect<T = any, C = any, CE = any> {
+  readonly [RUN]?: (signal: AbortSignal) => PromiseLike<T> | T;
+  readonly [ERROR]?: (cause: unknown) => Effect<any, any> | undefined;
+  readonly [REMOVE]: CE;
+  constructor(run?: (signal: AbortSignal) => PromiseLike<T> | T, catchSome?: (cause: unknown) => Effect | undefined);
+  [SYMBOL.iterator](): Generator<Effect<T, C>, T, any>;
+}
 type Thunk<out R$1> = (signal: AbortSignal) => R$1 | PromiseLike<R$1>;
-type PipeableThunk<in I = any, out T = any, out E$1 = any> = (next: I) => Effect<T, E$1> | WrapEffect<T, E$1, any>;
-type Pipeable<I = any, T = any, E$1 = any, EE = any> = PipeableThunk<I, T, E$1> | Effect<T, E$1> | WrapEffect<T, E$1, EE>;
-type Effect<out T, out C> = {
-  [RUN]?(signal: AbortSignal): PromiseLike<T> | T;
-  [WRAP]?(cause: unknown): Effect<T, C> | undefined;
-  [Symbol.iterator](): Generator<Effect<T, C>, T, any>;
-  pipe<P$1 extends [Pipeable<any, any, any>, ...Pipeable<any, any, any>[]]>(...pipeable: P$1): PipeReturn<[Effect<T, C>, ...P$1]>;
-};
-type WrapEffect<T, C, EE> = {
-  [WRAP]?(cause: unknown): Effect<T, C> | undefined;
-  [EXCLUDE]?: EE;
-};
-type inferInput<T> = T extends PipeableThunk<infer I, any, any> ? I : never;
-type inferReturn<T> = T extends Pipeable<any, infer R, any> ? R : T extends Effect<infer R, any> ? R : never;
-type inferError<T> = T extends Pipeable<any, any, infer E> ? E : T extends Effect<any, infer E> ? E : never;
-type mergePipeable<A extends Pipeable, B extends Pipeable> = A extends Pipeable<any, infer A2, infer A3> ? B extends Pipeable<any, infer B2, infer B3, infer B4> ? Pipeable<any, A2 | B2, Exclude<A3 | B3, B4>, never> : A : B;
-type asEffect<P$1> = P$1 extends Pipeable<any, infer R, infer E> ? Effect<R, E> : never;
-type PipeReturn<F extends Pipeable[]> = asEffect<mergePipeable<CheckPipe<F, F[0]>, Effect<never, inferError<F[number]>>>>;
-type CheckPipe<F extends Pipeable[], L extends Pipeable> = F extends [Pipeable, WrapEffect<any, any, any>, ...infer R] ? R extends Pipeable[] ? CheckPipe<[mergePipeable<L, mergePipeable<F[0], F[1]>>, ...R], mergePipeable<L, mergePipeable<F[0], F[1]>>> : never : F extends [Pipeable, Pipeable, ...infer P] ? ExtendsStrict<inferReturn<F[0]>, inferInput<F[1]>> extends true ? P extends Pipeable[] ? CheckPipe<[F[1], ...P], F[1]> : never : never : F extends [WrapEffect<any, any, any>] ? mergePipeable<F[0], L> : F extends [Pipeable<any, infer R, infer E>] ? Effect<R, E> : never;
+type PipeableThunk<T = any, C = any, I = any> = (next: I) => Effect<T, C>;
+type Pipeable = PipeableThunk | Effect | WrapEffect;
+type inferInput<T> = T extends PipeableThunk<any, any, infer I> ? I : never;
+type inferReturn<T> = T extends WrapEffect<infer R> ? R : T extends Effect<infer R> ? R : T extends PipeableThunk<infer R> ? R : never;
+type inferError<T> = T extends PipeableThunk<any, infer E> ? E : T extends WrapEffect<any, infer E> ? E : T extends Effect<any, infer E> ? E : never;
+type inferExclude<T> = T extends WrapEffect<any, any, infer CE> ? CE : never;
+type Simplify<T> = T extends Effect<infer R, infer E> ? Effect<R, E> : T;
+type PipeReturn<F extends Pipeable[]> = IsNever<CheckPipe<F>> extends true ? never : Simplify<Effect<inferReturn<CheckPipe<F>> | inferReturn<Extract<F[number], WrapEffect<any, any, any>>>, Exclude<inferError<CheckPipe<F>>, inferExclude<F[number]>>>>;
+type CheckPipe<F extends Pipeable[]> = F extends [Effect, WrapEffect, ...infer R] ? R extends [Pipeable, ...Pipeable[]] ? CheckPipe<R> : F[0] : F extends [Pipeable, Pipeable, ...infer P] ? ExtendsStrict<inferReturn<F[0]>, inferInput<F[1]>> extends true ? P extends Pipeable[] ? CheckPipe<[F[1], ...P]> : never : never : F extends [WrapEffect] ? Effect<inferReturn<F[0]>> : F extends [Pipeable] ? F[0] : never;
 type IsNever<T> = [T] extends [never] ? true : false;
 type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
 type ExtendsStrict<Left, Right> = IsAny<Left | Right> extends true ? true : IsNever<Left> extends true ? IsNever<Right> : [Left] extends [Right] ? true : false;
 //#endregion
-export { Effect, IsAny, Pipeable, PipeableThunk, Thunk, WrapEffect, run as _run, run, catchClass, catchSome, fail, fn, gen, inferError, inferInput, inferReturn, pipe, succeed };
+export { Effect, Pipeable, PipeableThunk, Thunk, WrapEffect, run as _run, run, catchSome, fail, fn, gen, inferError, inferExclude, inferInput, inferReturn, pipe, succeed };

package/dist/mini-effect.mjs

@@ -1,7 +1,8 @@
 //#region src/mini-effect.ts
 const SYMBOL = Symbol;
+const REMOVE = /* @__PURE__ */ SYMBOL();
 const RUN = SYMBOL();
-const WRAP = SYMBOL();
+const ERROR = SYMBOL();
 const DEFAULT_SIGNAL = new AbortController().signal;
 const isFunction = (value) => typeof value === "function";
 const quickYieldResult = (iterator, signal, ret) => {
@@ -9,15 +10,14 @@ const quickYieldResult = (iterator, signal, ret) => {
 	return ret.done ? ret.value : run(ret.value, signal).then((r) => quickYieldResult(iterator, signal, r));
 };
 const run = (effect, signal) => new Promise((resolve) => resolve(effect[RUN](signal ?? DEFAULT_SIGNAL)));
-const fn = (thunk) => new EffectImpl(thunk);
+const fn = (thunk) => new Effect(thunk);
 const fail = (cause) => fn(() => {
 	throw cause;
 });
 const succeed = (result) => fn(() => result);
-const catchSome = (thunk) => new EffectImpl(void 0, thunk);
-const catchClass = (type, thunk) => catchSome((cause) => cause instanceof type ? thunk(cause) : void 0);
+const catchSome = (thunk) => new WrapEffect(void 0, thunk);
 const gen = (thunk) => fn((signal) => quickYieldResult(thunk(signal), signal));
-const wrapEffect = (pipe$1, onErr) => new EffectImpl(pipe$1[RUN], (cause) => pipe$1[WRAP]?.(cause) ?? onErr(cause));
+const wrapEffect = (pipe$1, onErr) => new WrapEffect(pipe$1[RUN], (cause) => pipe$1[ERROR]?.(cause) ?? onErr(cause));
 const pipe = (first, ...pipeable) => {
 	let run$1 = [];
 	let wrap = [];
@@ -32,7 +32,7 @@ const pipe = (first, ...pipeable) => {
 	};
 	let handler, wrappedFirst = wrapEffect(first, handlePipeError);
 	for (pipe$1 of pipeable) {
-		handler = pipe$1[WRAP];
+		handler = pipe$1[ERROR];
 		if (isFunction(handler)) wrap.push(handler);
 		if (isFunction(pipe$1) || isFunction(pipe$1[RUN])) run$1.push(pipe$1);
 	}
@@ -45,9 +45,9 @@ const pipe = (first, ...pipeable) => {
 		return next;
 	});
 };
-var EffectImpl = class {
+var Effect = class {
 	[RUN];
-	[WRAP];
+	[ERROR];
 	constructor(run$1, catchSome$1) {
 		this[RUN] = catchSome$1 && run$1 ? (signal) => {
 			let res;
@@ -63,13 +63,38 @@ var EffectImpl = class {
 				return handleError(cause);
 			}
 		} : run$1;
-		this[WRAP] = catchSome$1;
+		this[ERROR] = catchSome$1;
 	}
 	*[SYMBOL.iterator]() {
 		return yield this;
 	}
 	pipe = (...pipeable) => pipe(this, ...pipeable);
 };
+var WrapEffect = class {
+	[RUN];
+	[ERROR];
+	[REMOVE];
+	constructor(run$1, catchSome$1) {
+		this[RUN] = catchSome$1 && run$1 ? (signal) => {
+			let res;
+			let handleError = (cause) => {
+				const recovery = catchSome$1(cause);
+				if (recovery) return recovery[RUN]?.(signal);
+				throw cause;
+			};
+			try {
+				res = run$1(signal);
+				return isFunction(res?.then) ? res.then(void 0, handleError) : res;
+			} catch (cause) {
+				return handleError(cause);
+			}
+		} : run$1;
+		this[ERROR] = catchSome$1;
+	}
+	*[SYMBOL.iterator]() {
+		return yield this;
+	}
+};
 
 //#endregion
-export { run as _run, run, catchClass, catchSome, fail, fn, gen, pipe, succeed };
+export { Effect, WrapEffect, run as _run, run, catchSome, fail, fn, gen, pipe, succeed };

package/dist/schema.d.mts

@@ -0,0 +1,9 @@
+import { Effect } from "./mini-effect.mjs";
+import * as v from "valibot";
+export * from "valibot";
+
+//#region src/schema.d.ts
+type Schema = v.BaseSchema<unknown, unknown, v.BaseIssue<unknown>> | v.BaseSchemaAsync<unknown, unknown, v.BaseIssue<unknown>>;
+declare const validate: <const S extends Schema>(schema: S) => (value: unknown) => Effect<v.InferOutput<S>, never>;
+//#endregion
+export { Schema, validate };

package/dist/schema.mjs

@@ -0,0 +1,12 @@
+import { catchSome, fail, fn } from "./mini-effect.mjs";
+import { failure } from "./tag.mjs";
+import * as v from "valibot";
+
+export * from "valibot"
+
+//#region src/schema.ts
+const FaildToValidateError = failure("FailedToValidate");
+const validate = (schema) => (value) => fn(() => v.parseAsync(schema, value)).pipe(catchSome((cause) => fail(new FaildToValidateError({ cause }))));
+
+//#endregion
+export { validate };

package/dist/tag.d.mts

@@ -0,0 +1,14 @@
+import { Effect, WrapEffect, inferError, inferReturn } from "./mini-effect.mjs";
+
+//#region src/tag.d.ts
+type Failure<T extends string> = {
+  __tag: T;
+  cause?: unknown;
+};
+type FailureConstructor<T extends string> = {
+  new (options?: ErrorOptions): Failure<T>;
+};
+declare const failure: <T extends string>(tag: T) => FailureConstructor<T>;
+declare const catchTags: <CE extends string, E extends Effect>(handlers: Record<CE, (cause: unknown) => E | undefined>) => WrapEffect<inferReturn<E>, inferError<E>, Failure<CE>>;
+//#endregion
+export { Failure, FailureConstructor, catchTags, failure };

package/dist/tag.mjs

@@ -0,0 +1,16 @@
+import { catchSome } from "./mini-effect.mjs";
+
+//#region src/tag.ts
+const failure = (tag) => class Failure extends Error {
+	__tag = tag;
+	constructor(options) {
+		super(tag, options);
+	}
+};
+const catchTags = (handlers) => catchSome((cause) => {
+	let tag = cause?.__tag;
+	return typeof tag === "string" ? Object.entries(handlers).find(([t, h]) => t === tag)?.[1]?.(cause) : void 0;
+});
+
+//#endregion
+export { catchTags, failure };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mini-effect",
   "type": "module",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "description": "A mini-effect library for TypeScript.",
   "author": "Jacob Ebey <jacob.ebey@live.com>",
   "license": "MIT",
@@ -15,7 +15,10 @@
   },
   "exports": {
     "./concurrency": "./dist/concurrency.mjs",
+    "./fetch": "./dist/fetch.mjs",
     "./mini-effect": "./dist/mini-effect.mjs",
+    "./schema": "./dist/schema.mjs",
+    "./tag": "./dist/tag.mjs",
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",
@@ -33,7 +36,10 @@
   },
   "devDependencies": {
     "@types/node": "^25.2.3",
-    "tsdown": "^0.18.4",
+    "tsdown": "~0.18.4",
     "typescript": "^5.9.3"
+  },
+  "dependencies": {
+    "valibot": "^1.2.0"
   }
 }