mini-effect 0.0.5 → 0.0.7

package/README.md

@@ -19,7 +19,17 @@ npm install mini-effect
 ## Core
 
 ```typescript
-import { fn, succeed, fail, gen, pipe, run, catchSome } from "mini-effect";
+import {
+  fn,
+  succeed,
+  fail,
+  gen,
+  pipe,
+  run,
+  catchSome,
+  dependency,
+  retry,
+} from "mini-effect";
 ```
 
 ### Create Effects
@@ -74,6 +84,24 @@ pipe(
 );
 ```
 
+### Retry
+
+```typescript
+// Retry up to 3 times before failing
+const resilient = retry(
+  3,
+  fn(() => fetchUnreliableData()),
+);
+
+// Retry forever until success
+const persistent = retry(
+  "forever",
+  fn(() => pollUntilReady()),
+);
+```
+
+When `times` is a number, the effect is retried up to that many times; if it still fails, the last error propagates. When `times` is `"forever"`, retries are unlimited and the error type narrows to `never`.
+
 ### Execution
 
 ```typescript
@@ -81,6 +109,60 @@ const result = await run(effect);
 const result = await run(effect, abortController.signal);
 ```
 
+## Dependencies
+
+```typescript
+import { dependency, gen, run } from "mini-effect";
+```
+
+`dependency` creates a typed tag that represents a value your effects need at runtime. Use `yield*` to read a dependency and `.provide()` to supply it.
+
+### Define a Dependency
+
+```typescript
+const UserName = dependency("UserName")<string>();
+const Logger = dependency("Logger")<{ log: (msg: string) => void }>();
+```
+
+### Read Dependencies in Effects
+
+```typescript
+const sayHello = gen(function* () {
+  const name = yield* UserName;
+  return `Hello, ${name}`;
+});
+```
+
+### Provide Dependencies via Pipe
+
+```typescript
+const result = await run(sayHello.pipe(UserName.provide("Alice")));
+// => "Hello, Alice"
+```
+
+### Compose Across Effects
+
+Dependencies propagate through `yield*` — provide them at any level:
+
+```typescript
+const program = gen(function* () {
+  const message = yield* sayHello;
+  return message;
+}).pipe(UserName.provide("GPT"));
+
+await run(program);
+// => "Hello, GPT"
+```
+
+### Missing Dependencies
+
+If a dependency is not provided, the effect fails with an `Error`:
+
+```typescript
+await run(sayHello);
+// throws Error("Missing dependency: UserName")
+```
+
 ## Concurrency
 
 ```typescript
@@ -155,15 +237,23 @@ Re-exports all of [Valibot](https://valibot.dev/).
 
 ### `mini-effect`
 
-| 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`        |
+| 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`        |
+| `dependency` | `(tag: string) => <T>() => Dependency<tag, T>`                   |
+| `retry`      | `(times: number \| "forever", effect) => Effect`                 |
+
+#### `Dependency<D, T>`
+
+| Member    | Signature                 |
+| --------- | ------------------------- |
+| `provide` | `(instance: T) => Effect` |
 
 ### `mini-effect/concurrency`
 

package/dist/concurrency.d.mts

@@ -1,10 +1,10 @@
-import { Effect, inferError, inferReturn } from "./mini-effect.mjs";
+import { Effect, inferDependency, inferError, inferProvides, 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 fork: <const E extends Effect>(effect: E) => Effect<() => void, never, never, never>;
+declare const all: <const E extends Effect<any, any>[]>(values: E) => Effect<{ [K in keyof E]: inferReturn<E[K]> }, inferError<E[number]>, inferDependency<E[number]>, inferProvides<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 any: <const E extends Effect[]>(values: E) => Effect<inferReturn<E[number]>, inferError<E[number]>, inferDependency<E[number]>, inferProvides<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, fork, race };

package/dist/concurrency.mjs

@@ -1,4 +1,4 @@
-import { _run as run, fn } from "./mini-effect.mjs";
+import { fn, run } from "./mini-effect.mjs";
 
 //#region src/concurrency.ts
 const localController = (signal) => {
@@ -6,16 +6,27 @@ const localController = (signal) => {
 	signal.addEventListener("abort", () => controller.abort(signal.reason));
 	return controller;
 };
-const fork = (effect) => fn((signal) => {
+const fork = (effect) => fn((signal, ctx) => {
 	const controller = localController(signal);
-	run(effect, controller.signal).catch();
+	run(effect, controller.signal, ctx).catch();
 	return () => controller.abort();
 });
-const promiseMethod = (method, values) => fn(async (signal) => {
+const promiseMethod = (method, values) => fn(async (signal, ctx) => {
 	let controller = localController(signal);
 	let localSignal = controller.signal;
+	let result;
+	let done;
+	let raceController = new AbortController();
 	try {
-		return await Promise[method](values.map((effect) => run(effect, localSignal)));
+		let promise = Promise[method](values.map((effect) => run(effect, localSignal, ctx)));
+		result = await Promise.race([promise, new Promise((resolve, reject) => {
+			done = resolve;
+			signal.addEventListener("abort", () => reject(signal.reason), { signal: raceController.signal });
+		})]);
+		raceController.abort();
+		done?.();
+		done = void 0;
+		return result;
 	} finally {
 		if (!controller.signal.aborted) controller.abort();
 	}

package/dist/fetch.d.mts

@@ -5,10 +5,10 @@ import { Failure, FailureConstructor } from "./tag.mjs";
 declare const FailedToFetchError: FailureConstructor<"FailedToFetch">;
 declare const FailedToReadError: FailureConstructor<"FailedToRead">;
 declare const request: (input: string | URL, init?: RequestInit) => Effect<Response, InstanceType<typeof FailedToFetchError>>;
-declare const blob: (response: Response) => Effect<Blob, Failure<"FailedToRead">>;
-declare const bytes: (response: Response) => Effect<Uint8Array<ArrayBuffer>, Failure<"FailedToRead">>;
-declare const formData: (response: Response) => Effect<FormData, Failure<"FailedToRead">>;
-declare const json: (response: Response) => Effect<unknown, InstanceType<typeof FailedToReadError>>;
-declare const text: (response: Response) => Effect<string, Failure<"FailedToRead">>;
+declare const blob: (response: Response) => Effect<Blob, Failure<"FailedToRead">, never, never>;
+declare const bytes: (response: Response) => Effect<Uint8Array<ArrayBuffer>, Failure<"FailedToRead">, never, never>;
+declare const formData: (response: Response) => Effect<FormData, Failure<"FailedToRead">, never, never>;
+declare const json: (response: Response) => Effect<unknown, InstanceType<typeof FailedToReadError>, never, never>;
+declare const text: (response: Response) => Effect<string, Failure<"FailedToRead">, never, never>;
 //#endregion
 export { blob, bytes, formData, json, request, text };

package/dist/mini-effect.d.mts

@@ -1,42 +1,57 @@
 //#region src/mini-effect.d.ts
 declare const SYMBOL: SymbolConstructor;
-declare const REMOVE: unique symbol;
+declare const DEPENDENCY_TYPE: unique symbol;
+declare const DEPENDENCY: unique symbol;
+declare const PROVIDES_TYPE: unique symbol;
+declare const PROVIDER: unique symbol;
+declare const HANDLES_ERROR: 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: <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 run: <T, E$1>(effect: Effect<T, E$1>, signal?: AbortSignal, ctx?: Record<string, unknown>) => Promise<T>;
+declare const fn: <R$1, C = never>(thunk: Thunk<R$1>) => Effect<R$1, C, never, never>;
+declare const fail: <C>(cause: C) => Effect<never, C, never, never>;
+declare const succeed: <R$1>(result: R$1) => Effect<R$1, never, never, never>;
+declare const catchSome: <T = any, C = any, CE = any, D$1 = any, P$1 = any>(thunk: (cause: unknown) => Effect<T, C, D$1, P$1> | undefined) => WrapEffect<T, C, CE, D$1, P$1>;
+declare const dependency: <D$1 extends string>(tag: D$1) => <T>() => Dependency<D$1, T>;
+declare const gen: <T extends Effect, TReturn, TNext>(thunk: (signal: AbortSignal, ctx: Record<string, unknown>) => Generator<T, TReturn, TNext>, localContext?: boolean) => Effect<TReturn, inferError<T>, Exclude<inferDependency<T>, inferProvides<T>>, inferProvides<T>>;
 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 const retry: <R$1 extends number | "forever", T, C>(times: R$1, effect: Effect<T, C>) => Effect<T, R$1 extends "forever" ? never : C>;
-declare class Effect<T = any, C = any> {
-  [RUN]?: (signal: AbortSignal) => T | PromiseLike<T>;
+declare const retry: <R$1 extends number | "forever", T, C, D$1, P$1>(times: R$1, effect: Effect<T, C, D$1, P$1>) => Effect<T, R$1 extends "forever" ? never : C, D$1, P$1>;
+declare class Effect<T = any, C = any, D$1 = any, P$1 = any> {
+  [RUN]?: Thunk<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]>;
+  [DEPENDENCY_TYPE]: D$1;
+  [PROVIDES_TYPE]: P$1;
+  constructor(run?: Thunk<T>, catchSome?: (cause: unknown) => Effect | undefined);
+  [SYMBOL.iterator](): Generator<Effect<T, C, D$1, P$1>, T, any>;
+  readonly pipe: <E$1 extends [Pipeable, ...Pipeable[]]>(...pipeable: E$1) => PipeReturn<[Effect<T, C, D$1, P$1>, ...E$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>;
+declare class WrapEffect<T = any, C = any, CE = any, D$1 = any, P$1 = any> extends Effect<T, C, D$1, P$1> {
+  readonly [HANDLES_ERROR]: CE;
 }
-type Thunk<out R$1> = (signal: AbortSignal) => R$1 | PromiseLike<R$1>;
-type PipeableThunk<T = any, C = any, I = any> = (next: I) => Effect<T, C>;
+declare class Dependency<D$1 extends string = any, T = any> extends WrapEffect<T, never, Dependency<D$1, T>, Dependency<D$1, T>, never> {
+  readonly [DEPENDENCY]: true;
+  readonly __tag: D$1;
+  constructor(tag: D$1);
+  readonly provide: (instance: T) => Provide<D$1, T>;
+}
+declare class Provide<D$1 extends string = any, T = any> extends Effect<void, never, never, Dependency<D$1, T>> {
+  readonly [PROVIDER] = true;
+  constructor(tag: D$1, instance: T);
+}
+type Thunk<out R$1> = (signal: AbortSignal, ctx: Record<string, unknown>) => R$1 | PromiseLike<R$1>;
+type PipeableThunk<out T = any, out C = any, in I = any, out D$1 = never, out P$1 = never> = (next: I) => Effect<T, C, D$1, P$1>;
 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 inferInput<T> = T extends PipeableThunk<any, any, infer I> ? I : T extends Effect ? any : never;
+type inferReturn<T> = T extends PipeableThunk<infer R> ? R : T extends WrapEffect<infer R> ? R : T extends Effect<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> : never;
-type PipeReturn<F extends Pipeable[]> = IsNever<CheckPipe<F>> extends true ? never : Simplify<Effect<inferReturn<CheckPipe<F>> | inferReturn<Extract<F[number], WrapEffect>>, Exclude<inferError<F[number]>, inferExclude<Extract<F[number], WrapEffect>>>>>;
-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 inferDependency<T> = T extends Dependency<infer A, infer B> ? Dependency<A, B> : T extends Effect<any, any, infer D> ? D : never;
+type inferProvides<T> = T extends Provide<infer D, infer T> ? Dependency<D, T> : T extends Effect<any, any, any, infer D> ? D : never;
+type Simplify<T> = T extends Effect<infer R, infer E, infer D, infer P> ? Effect<R, E, D, P> : never;
+type PipeReturn<F extends Pipeable[]> = IsNever<CheckPipe<F>> extends true ? never : Simplify<Effect<inferReturn<CheckPipe<F>> | inferReturn<Extract<F[number], WrapEffect>>, Exclude<inferError<F[number]>, inferExclude<Extract<F[number], WrapEffect>>>, Exclude<inferDependency<F[number]>, inferProvides<F[number]>>, Exclude<inferProvides<F[number]>, inferDependency<F[number]>>>>;
+type CheckPipe<F extends Pipeable[]> = F extends [Effect, Provide, ...infer R] ? R extends [Pipeable, ...Pipeable[]] ? CheckPipe<R> : F[0] : 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, Pipeable, PipeableThunk, Thunk, WrapEffect, run as _run, run, catchSome, fail, fn, gen, inferError, inferExclude, inferInput, inferReturn, pipe, retry, succeed };
+export { Dependency, Effect, Pipeable, PipeableThunk, Thunk, WrapEffect, catchSome, dependency, fail, fn, gen, inferDependency, inferError, inferExclude, inferInput, inferProvides, inferReturn, pipe, retry, run, succeed };

package/dist/mini-effect.mjs

@@ -1,24 +1,33 @@
 //#region src/mini-effect.ts
 const SYMBOL = Symbol;
-const REMOVE = /* @__PURE__ */ SYMBOL();
+const DEPENDENCY_TYPE = /* @__PURE__ */ SYMBOL();
+const DEPENDENCY = /* @__PURE__ */ SYMBOL();
+const PROVIDES_TYPE = /* @__PURE__ */ SYMBOL();
+const PROVIDER = /* @__PURE__ */ SYMBOL();
+const HANDLES_ERROR = /* @__PURE__ */ SYMBOL();
 const RUN = SYMBOL();
 const ERROR = SYMBOL();
 const DEFAULT_SIGNAL = new AbortController().signal;
 const isFunction = (value) => typeof value === "function";
-const quickYieldResult = (iterator, signal, ret) => {
+const quickYieldResult = (iterator, signal, ctx, ret) => {
 	ret = iterator.next(ret);
-	return ret.done ? ret.value : run(ret.value, signal).then((r) => quickYieldResult(iterator, signal, r));
+	return ret.done ? ret.value : run(ret.value, signal, ctx).then((r) => quickYieldResult(iterator, signal, ctx, r));
 };
-const run = (effect, signal) => new Promise((resolve) => resolve(effect[RUN](signal ?? DEFAULT_SIGNAL)));
+const run = (effect, signal, ctx) => new Promise((resolve) => resolve(effect[RUN](signal ?? DEFAULT_SIGNAL, ctx ?? {})));
 const fn = (thunk) => new Effect(thunk);
 const fail = (cause) => fn(() => {
 	throw cause;
 });
 const succeed = (result) => fn(() => result);
 const catchSome = (thunk) => new WrapEffect(void 0, thunk);
-const gen = (thunk) => fn((signal) => quickYieldResult(thunk(signal), signal));
+const dependency = (tag) => () => new Dependency(tag);
+const gen = (thunk, localContext) => fn((signal, ctx) => {
+	let ctxOverride = localContext ? { ...ctx } : ctx;
+	return quickYieldResult(thunk(signal, ctxOverride), signal, ctxOverride);
+});
 const wrapEffect = (pipe$1, onErr) => new WrapEffect(pipe$1[RUN], (cause) => pipe$1[ERROR]?.(cause) ?? onErr(cause));
 const pipe = (first, ...pipeable) => {
+	let deps = [];
 	let run$1 = [];
 	let wrap = [];
 	let pipe$1;
@@ -31,19 +40,21 @@ const pipe = (first, ...pipeable) => {
 		}
 	};
 	let handler, wrappedFirst = wrapEffect(first, handlePipeError);
-	for (pipe$1 of pipeable) {
+	for (pipe$1 of pipeable) if (pipe$1[PROVIDER]) deps.push(pipe$1);
+	else {
 		handler = pipe$1[ERROR];
 		if (isFunction(handler)) wrap.push(handler);
 		if (isFunction(pipe$1) || isFunction(pipe$1[RUN])) run$1.push(pipe$1);
 	}
-	return gen(function* () {
+	return gen(function* (_, ctx) {
+		for (pipe$1 of deps) yield* pipe$1;
 		next = yield* wrappedFirst;
 		for (pipe$1 of run$1) {
 			if (isFunction(pipe$1)) pipe$1 = pipe$1(next);
 			if (isFunction(pipe$1[RUN])) next = yield* wrapEffect(pipe$1, handlePipeError);
 		}
 		return next;
-	});
+	}, true);
 };
 const retry = (times, effect) => {
 	let step = 0;
@@ -52,16 +63,18 @@ const retry = (times, effect) => {
 var Effect = class {
 	[RUN];
 	[ERROR];
+	[DEPENDENCY_TYPE];
+	[PROVIDES_TYPE];
 	constructor(run$1, catchSome$1) {
-		this[RUN] = catchSome$1 && run$1 ? (signal) => {
+		this[RUN] = catchSome$1 && run$1 ? (signal, ctx) => {
 			let res;
 			let handleError = (cause) => {
 				const recovery = catchSome$1(cause);
-				if (recovery) return recovery[RUN]?.(signal);
+				if (recovery) return recovery[RUN]?.(signal, ctx);
 				throw cause;
 			};
 			try {
-				res = run$1(signal);
+				res = run$1(signal, ctx);
 				return isFunction(res?.then) ? res.then(void 0, handleError) : res;
 			} catch (cause) {
 				return handleError(cause);
@@ -74,31 +87,29 @@ var Effect = class {
 	}
 	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;
+var WrapEffect = class extends Effect {
+	[HANDLES_ERROR];
+};
+var Dependency = class extends WrapEffect {
+	[DEPENDENCY];
+	__tag;
+	constructor(tag) {
+		super((_, ctx) => {
+			if (tag in ctx) return ctx[tag];
+			throw new Error(`Missing dependency: ${tag}`);
+		});
+		this.__tag = tag;
 	}
-	*[SYMBOL.iterator]() {
-		return yield this;
+	provide = (instance) => new Provide(this.__tag, instance);
+};
+var Provide = class extends Effect {
+	[PROVIDER] = true;
+	constructor(tag, instance) {
+		super((_, ctx) => {
+			ctx[tag] = instance;
+		});
 	}
 };
 
 //#endregion
-export { Effect, WrapEffect, run as _run, run, catchSome, fail, fn, gen, pipe, retry, succeed };
+export { Dependency, Effect, WrapEffect, catchSome, dependency, fail, fn, gen, pipe, retry, run, succeed };

package/dist/schema.d.mts

@@ -6,6 +6,6 @@ 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 FaildToValidateError: FailureConstructor<"FailedToValidate">;
-declare const validate: <const S extends Schema>(schema: S) => (value: unknown) => Effect<v.InferOutput<S>, InstanceType<typeof FaildToValidateError>>;
+declare const validate: <const S extends Schema>(schema: S) => (value: unknown) => Effect<v.InferOutput<S>, InstanceType<typeof FaildToValidateError>, never, never>;
 //#endregion
 export { Schema, validate };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mini-effect",
   "type": "module",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "A mini-effect library for TypeScript.",
   "author": "Jacob Ebey <jacob.ebey@live.com>",
   "license": "MIT",