@oscarpalmer/atoms 0.209.0 → 0.210.0

package/dist/index.d.mts

@@ -4591,37 +4591,42 @@ export declare function setValue<Data extends PlainObject>(data: Data, path: str
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
-type AsyncPlan<Value, Error = unknown> = {
+type AsyncPlan<Yielded, Returned> = {
   /**
    * Get the asynchronous generator for the plan
    *
    * @returns Asynchronous generator
    */
-  [Symbol.asyncIterator]: () => AsyncGenerator<unknown, Value, unknown>;
+  [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
   /**
    * Run the plan to completion
    *
+   * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Promise<Result<Value, Error>>;
+  run: () => Promise<PlanResult<Returned>>;
 };
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
-type Plan<Value, Error = unknown> = {
+type Plan<Yielded, Returned> = {
   /**
    * Get the generator for the plan
    *
    * @returns Generator
    */
-  [Symbol.iterator]: () => Generator<unknown, Value, unknown>;
+  [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
   /**
    * Run the plan to completion
    *
+   * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Result<Value, Error>;
+  run: () => PlanResult<Returned>;
 };
+type PlanErrorValues<Original> = Original extends Error ? Original : never;
+type PlanError<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned> | Error;
+type PlanResult<Returned> = Returned extends Error ? never : Returned;
 //#endregion
 //#region src/plan/index.d.ts
 /**
@@ -4630,28 +4635,51 @@ type Plan<Value, Error = unknown> = {
  * @param generator Generator to plan for
  * @returns Generator plan
  */
-export declare function asyncPlan<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): AsyncPlan<Value, Error>;
+export declare function plan<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned>;
+/**
+ * Create a plan for a generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function plan<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): Plan<Yielded, Returned>;
 /**
  * Run an asynchronous generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function asyncRun<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): Promise<Result<Value, Error>>;
+export declare function run<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function asyncRun<Value = unknown, Error = unknown>(plan: AsyncPlan<Value, Error>): Promise<Result<Value, Error>>;
+export declare function run<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
 /**
- * Is the value an asynchronous plan?
+ * Run a generator to completion
  *
- * @param value Value to check
- * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ * @param generator Generator to run
+ * @returns Result
  */
-export declare function isAsyncPlan<Value = unknown, Error = unknown>(value: unknown): value is AsyncPlan<Value, Error>;
+export declare function run<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
+/**
+ * Run a plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function run<Yielded, Returned>(plan: Plan<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
+//#endregion
+//#region src/internal/plan.d.ts
+/**
+ * Create an immediately failing generator
+ *
+ * @param reason Failure reason
+ * @returns Failing generator
+ */
+export declare function fail<Reason>(reason: Reason): Generator<never, never>;
 /**
  * Is the value an asynchronous generator function?
  *
@@ -4659,6 +4687,13 @@ export declare function isAsyncPlan<Value = unknown, Error = unknown>(value: unk
  * @returns `true` if the value is an asynchronous generator function, otherwise `false`
  */
 export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
+/**
+ * Is the value an asynchronous plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ */
+export declare function isAsyncPlan<Yielded = unknown, Returned = unknown>(value: unknown): value is AsyncPlan<Yielded, Returned>;
 /**
  * Is the value a generator function?
  *
@@ -4672,34 +4707,14 @@ export declare function isGenerator(value: unknown): value is () => Generator;
  * @param value Value to check
  * @returns `true` if the value is a plan, otherwise `false`
  */
-export declare function isPlan<Value = unknown, Error = unknown>(value: unknown): value is Plan<Value, Error>;
-/**
- * Create a plan for a generator function
- *
- * @param generator Generator to plan for
- * @returns Generator plan
- */
-export declare function plan<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, Error>): Plan<Value, Error>;
+export declare function isPlan<Yielded = unknown, Returned = unknown>(value: unknown): value is Plan<Yielded, Returned>;
 /**
- * Run a generator to completion
+ * Create an immediately succeeding generator
  *
- * @param generator Generator to run
- * @returns Result
+ * @param value Success value
+ * @returns Succeeding generator
  */
-export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Result<Value, Error>;
-/**
- * Run a plan to completion
- *
- * @param plan Plan to run
- * @returns Result
- */
-export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Result<Value, Error>;
-export declare namespace plan {
-  export var async: typeof asyncPlan;
-}
-export declare namespace run {
-  export var async: typeof asyncRun;
-}
+export declare function succeed<Value>(value: Value): Generator<never, Value>;
 //#endregion
 //#region src/internal/aborter.d.ts
 type Aborter = {
@@ -8431,4 +8446,4 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { type AsyncLimiter, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, type Limiter, Logger, type Plan, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };
+export { type AsyncLimiter, type AsyncPlan, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, type Limiter, Logger, type Plan, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };

package/dist/index.mjs

@@ -2756,93 +2756,35 @@ const PLAN_SYMBOL = Symbol("plan");
 const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
 const PLAN_TYPE_PLAN_SYNC = "plan";
 //#endregion
-//#region src/plan/index.ts
-function AsyncPlan(generator) {
-	this[PLAN_SYMBOL] = {
-		generator,
-		type: PLAN_TYPE_PLAN_ASYNC
-	};
-}
-AsyncPlan.prototype[Symbol.asyncIterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-AsyncPlan.prototype.run = runAsyncPlan;
-function Plan(generator) {
-	this[PLAN_SYMBOL] = {
-		generator,
-		type: PLAN_TYPE_PLAN_SYNC
-	};
-}
-Plan.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-Plan.prototype.run = runPlan;
-function asyncExecute(callback) {
-	return asyncAttempt(async () => {
-		const generator = callback();
-		let lastValue;
-		while (true) {
-			const next = await generator.next();
-			const { done } = next;
-			let value = next.value;
-			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.value;
-			lastValue = value;
-			if (done === true) break;
-		}
-		return lastValue;
-	});
-}
+//#region src/internal/plan.ts
 /**
-* Create a plan for an asynchronous generator function
+* Create an immediately failing generator
 *
-* @param generator Generator to plan for
-* @returns Generator plan
+* @param reason Failure reason
+* @returns Failing generator
 */
-function asyncPlan(generator) {
-	if (!isAsyncGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
-	return new AsyncPlan(generator);
-}
-async function asyncRun(input) {
-	if (isAsyncPlan(input)) return input.run();
-	if (!isAsyncGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
-	return asyncExecute(input);
-}
-function execute(callback) {
-	return attempt(() => {
-		const generator = callback();
-		let lastValue;
-		while (true) {
-			const next = generator.next();
-			const { done } = next;
-			let { value } = next;
-			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.value;
-			lastValue = value;
-			if (done === true) break;
-		}
-		return lastValue;
-	});
+function fail(reason) {
+	return (function* () {
+		throw reason;
+	})();
 }
 /**
-* Is the value an asynchronous plan?
+* Is the value an asynchronous generator function?
 *
 * @param value Value to check
-* @returns `true` if the value is an asynchronous plan, otherwise `false`
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
 */
-function isAsyncPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
 }
 /**
-* Is the value an asynchronous generator function?
+* Is the value an asynchronous plan?
 *
 * @param value Value to check
-* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
 */
-function isAsyncGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
 }
 /**
 * Is the value a generator function?
@@ -2869,19 +2811,92 @@ function isPlanInstance(type, value) {
 	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
 }
 /**
-* Create a plan for a generator function
+* Create an immediately succeeding generator
 *
-* @param generator Generator to plan for
-* @returns Generator plan
+* @param value Success value
+* @returns Succeeding generator
 */
+function succeed(value) {
+	return (function* () {
+		return value;
+	})();
+}
+//#endregion
+//#region src/plan/index.ts
+function AsyncPlan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_ASYNC
+	};
+}
+AsyncPlan.prototype[Symbol.asyncIterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+AsyncPlan.prototype.run = runAsyncPlan;
+function Plan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
+}
+Plan.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+Plan.prototype.run = runPlan;
+async function asyncExecute(callback) {
+	const generator = callback();
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = await generator.next(lastValue);
+			const { done } = next;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done === true) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator?.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+function execute(callback) {
+	const generator = callback();
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = generator.next(lastValue);
+			const done = next.done === true;
+			let { value } = next;
+			if (value instanceof Error) throw value;
+			lastValue = value;
+			if (done) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
 function plan(generator) {
-	if (!isGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
-	return new Plan(generator);
+	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
+	if (isGenerator(generator)) return new Plan(generator);
+	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 function run(input) {
-	if (isPlan(input)) return input.run();
-	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
-	return execute(input);
+	if (isAsyncPlan(input) || isPlan(input)) return input.run();
+	if (isAsyncGenerator(input)) return asyncExecute(input);
+	if (isGenerator(input)) return execute(input);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function runAsyncPlan() {
 	return asyncExecute(this[PLAN_SYMBOL].generator);
@@ -2889,8 +2904,6 @@ function runAsyncPlan() {
 function runPlan() {
 	return execute(this[PLAN_SYMBOL].generator);
 }
-plan.async = asyncPlan;
-run.async = asyncRun;
 //#endregion
 //#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
@@ -6992,4 +7005,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncPlan, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/models/plan.model.d.mts

@@ -1,21 +1,21 @@
-import { Result } from "./result.model.mjs";
 //#region src/internal/models/plan.model.d.ts
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
-export type AsyncPlan<Value, Error = unknown> = {
+export type AsyncPlan<Yielded, Returned> = {
   /**
    * Get the asynchronous generator for the plan
    *
    * @returns Asynchronous generator
    */
-  [Symbol.asyncIterator]: () => AsyncGenerator<unknown, Value, unknown>;
+  [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
   /**
    * Run the plan to completion
    *
+   * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Promise<Result<Value, Error>>;
+  run: () => Promise<PlanResult<Returned>>;
 };
 type AsyncPlanState = {
   generator: () => AsyncGenerator;
@@ -32,24 +32,28 @@ export type InternalPlan = {
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
-export type Plan<Value, Error = unknown> = {
+export type Plan<Yielded, Returned> = {
   /**
    * Get the generator for the plan
    *
    * @returns Generator
    */
-  [Symbol.iterator]: () => Generator<unknown, Value, unknown>;
+  [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
   /**
    * Run the plan to completion
    *
+   * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Result<Value, Error>;
+  run: () => PlanResult<Returned>;
 };
+type PlanErrorValues<Original> = Original extends Error ? Original : never;
+export type PlanError<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned> | Error;
+export type PlanResult<Returned> = Returned extends Error ? never : Returned;
 type PlanState = {
   generator: () => Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
-export type PlanType = "asyncPlan" | "plan";
+export type PlanType = "asyncPlan" | "plan" | "stop";
 export declare const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
 export declare const GENERATOR_NAME_SYNC = "GeneratorFunction";
 export declare const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";

package/dist/internal/plan.d.mts

@@ -0,0 +1,45 @@
+import { AsyncPlan, Plan } from "./models/plan.model.mjs";
+//#region src/internal/plan.d.ts
+/**
+ * Create an immediately failing generator
+ *
+ * @param reason Failure reason
+ * @returns Failing generator
+ */
+export declare function fail<Reason>(reason: Reason): Generator<never, never>;
+/**
+ * Is the value an asynchronous generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous generator function, otherwise `false`
+ */
+export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
+/**
+ * Is the value an asynchronous plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous plan, otherwise `false`
+ */
+export declare function isAsyncPlan<Yielded = unknown, Returned = unknown>(value: unknown): value is AsyncPlan<Yielded, Returned>;
+/**
+ * Is the value a generator function?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a generator function, otherwise `false`
+ */
+export declare function isGenerator(value: unknown): value is () => Generator;
+/**
+ * Is the value a plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a plan, otherwise `false`
+ */
+export declare function isPlan<Yielded = unknown, Returned = unknown>(value: unknown): value is Plan<Yielded, Returned>;
+/**
+ * Create an immediately succeeding generator
+ *
+ * @param value Success value
+ * @returns Succeeding generator
+ */
+export declare function succeed<Value>(value: Value): Generator<never, Value>;
+//#endregion

package/dist/internal/plan.mjs

@@ -0,0 +1,68 @@
+import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "./models/plan.model.mjs";
+//#region src/internal/plan.ts
+/**
+* Create an immediately failing generator
+*
+* @param reason Failure reason
+* @returns Failing generator
+*/
+function fail(reason) {
+	return (function* () {
+		throw reason;
+	})();
+}
+/**
+* Is the value an asynchronous generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
+}
+/**
+* Is the value an asynchronous plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
+*/
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGenerator(value) {
+	return isGeneratorInstance(GENERATOR_NAME_SYNC, value);
+}
+function isGeneratorInstance(name, value) {
+	return typeof value === "function" && value !== null && value.constructor.name === name && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+/**
+* Create an immediately succeeding generator
+*
+* @param value Success value
+* @returns Succeeding generator
+*/
+function succeed(value) {
+	return (function* () {
+		return value;
+	})();
+}
+//#endregion
+export { fail, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, succeed };

package/dist/plan/index.d.mts

@@ -1,5 +1,4 @@
-import { Result } from "../internal/models/result.model.mjs";
-import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
 //#region src/plan/index.d.ts
 /**
  * Create a plan for an asynchronous generator function
@@ -7,74 +6,40 @@ import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
  * @param generator Generator to plan for
  * @returns Generator plan
  */
-export declare function asyncPlan<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): AsyncPlan<Value, Error>;
+export declare function plan<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned>;
+/**
+ * Create a plan for a generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function plan<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): Plan<Yielded, Returned>;
 /**
  * Run an asynchronous generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function asyncRun<Value = unknown, Error = unknown>(generator: () => AsyncGenerator<unknown, Value, unknown>): Promise<Result<Value, Error>>;
+export declare function run<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function asyncRun<Value = unknown, Error = unknown>(plan: AsyncPlan<Value, Error>): Promise<Result<Value, Error>>;
-/**
- * Is the value an asynchronous plan?
- *
- * @param value Value to check
- * @returns `true` if the value is an asynchronous plan, otherwise `false`
- */
-export declare function isAsyncPlan<Value = unknown, Error = unknown>(value: unknown): value is AsyncPlan<Value, Error>;
-/**
- * Is the value an asynchronous generator function?
- *
- * @param value Value to check
- * @returns `true` if the value is an asynchronous generator function, otherwise `false`
- */
-export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
-/**
- * Is the value a generator function?
- *
- * @param value Value to check
- * @returns `true` if the value is a generator function, otherwise `false`
- */
-export declare function isGenerator(value: unknown): value is () => Generator;
-/**
- * Is the value a plan?
- *
- * @param value Value to check
- * @returns `true` if the value is a plan, otherwise `false`
- */
-export declare function isPlan<Value = unknown, Error = unknown>(value: unknown): value is Plan<Value, Error>;
-/**
- * Create a plan for a generator function
- *
- * @param generator Generator to plan for
- * @returns Generator plan
- */
-export declare function plan<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, Error>): Plan<Value, Error>;
+export declare function run<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Result<Value, Error>;
+export declare function run<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
 /**
  * Run a plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Result<Value, Error>;
-export declare namespace plan {
-  export var async: typeof asyncPlan;
-}
-export declare namespace run {
-  export var async: typeof asyncRun;
-}
+export declare function run<Yielded, Returned>(plan: Plan<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
 //#endregion

package/dist/plan/index.mjs

@@ -1,7 +1,5 @@
-import { isError, isOk } from "../internal/result/misc.mjs";
-import "../result/misc.mjs";
-import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -23,111 +21,60 @@ Plan.prototype[Symbol.iterator] = function() {
 	return this[PLAN_SYMBOL].generator();
 };
 Plan.prototype.run = runPlan;
-function asyncExecute(callback) {
-	return asyncAttempt(async () => {
-		const generator = callback();
-		let lastValue;
+async function asyncExecute(callback) {
+	const generator = callback();
+	let success = true;
+	let lastValue;
+	try {
 		while (true) {
-			const next = await generator.next();
+			const next = await generator.next(lastValue);
 			const { done } = next;
-			let value = next.value;
+			let { value } = next;
 			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.value;
 			lastValue = value;
 			if (done === true) break;
 		}
-		return lastValue;
-	});
-}
-/**
-* Create a plan for an asynchronous generator function
-*
-* @param generator Generator to plan for
-* @returns Generator plan
-*/
-function asyncPlan(generator) {
-	if (!isAsyncGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
-	return new AsyncPlan(generator);
-}
-async function asyncRun(input) {
-	if (isAsyncPlan(input)) return input.run();
-	if (!isAsyncGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
-	return asyncExecute(input);
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator?.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
 }
 function execute(callback) {
-	return attempt(() => {
-		const generator = callback();
-		let lastValue;
+	const generator = callback();
+	let success = true;
+	let lastValue;
+	try {
 		while (true) {
-			const next = generator.next();
-			const { done } = next;
+			const next = generator.next(lastValue);
+			const done = next.done === true;
 			let { value } = next;
 			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
-			if (isOk(value)) value = value.value;
 			lastValue = value;
-			if (done === true) break;
+			if (done) break;
 		}
-		return lastValue;
-	});
-}
-/**
-* Is the value an asynchronous plan?
-*
-* @param value Value to check
-* @returns `true` if the value is an asynchronous plan, otherwise `false`
-*/
-function isAsyncPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
-}
-/**
-* Is the value an asynchronous generator function?
-*
-* @param value Value to check
-* @returns `true` if the value is an asynchronous generator function, otherwise `false`
-*/
-function isAsyncGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
-}
-/**
-* Is the value a generator function?
-*
-* @param value Value to check
-* @returns `true` if the value is a generator function, otherwise `false`
-*/
-function isGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_SYNC, value);
-}
-function isGeneratorInstance(name, value) {
-	return typeof value === "function" && value !== null && value.constructor.name === name && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
-}
-/**
-* Is the value a plan?
-*
-* @param value Value to check
-* @returns `true` if the value is a plan, otherwise `false`
-*/
-function isPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
-}
-function isPlanInstance(type, value) {
-	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
 }
-/**
-* Create a plan for a generator function
-*
-* @param generator Generator to plan for
-* @returns Generator plan
-*/
 function plan(generator) {
-	if (!isGenerator(generator)) throw new Error(PLAN_MESSAGE_PLAN_INPUT);
-	return new Plan(generator);
+	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
+	if (isGenerator(generator)) return new Plan(generator);
+	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 function run(input) {
-	if (isPlan(input)) return input.run();
-	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
-	return execute(input);
+	if (isAsyncPlan(input) || isPlan(input)) return input.run();
+	if (isAsyncGenerator(input)) return asyncExecute(input);
+	if (isGenerator(input)) return execute(input);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function runAsyncPlan() {
 	return asyncExecute(this[PLAN_SYMBOL].generator);
@@ -135,7 +82,5 @@ function runAsyncPlan() {
 function runPlan() {
 	return execute(this[PLAN_SYMBOL].generator);
 }
-plan.async = asyncPlan;
-run.async = asyncRun;
 //#endregion
-export { asyncPlan, asyncRun, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, plan, run };
+export { plan, run };

package/dist/plan/is.d.mts

@@ -0,0 +1,2 @@
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };

package/dist/plan/is.mjs

@@ -0,0 +1,2 @@
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };

package/dist/plan/misc.d.mts

@@ -0,0 +1,2 @@
+import { fail, succeed } from "../internal/plan.mjs";
+export { fail, succeed };

package/dist/plan/misc.mjs

@@ -0,0 +1,2 @@
+import { fail, succeed } from "../internal/plan.mjs";
+export { fail, succeed };

package/dist/plan/models.d.mts

@@ -1,2 +1,2 @@
-import { Plan } from "../internal/models/plan.model.mjs";
-export type { Plan };
+import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+export type { AsyncPlan, Plan };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.209.0",
+	"version": "0.210.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -153,6 +153,14 @@
 			"types": "./dist/plan/index.d.mts",
 			"default": "./dist/plan/index.mjs"
 		},
+		"./plan/is": {
+			"types": "./dist/plan/is.d.mts",
+			"default": "./dist/plan/is.mjs"
+		},
+		"./plan/misc": {
+			"types": "./dist/plan/misc.d.mts",
+			"default": "./dist/plan/misc.mjs"
+		},
 		"./plan/models": {
 			"default": "./dist/plan/models.mjs"
 		},
@@ -297,7 +305,7 @@
 	"devDependencies": {
 		"@types/node": "^26.6",
 		"@vitest/coverage-istanbul": "5.0.1",
-		"eslint": "^10.11",
+		"eslint": "^10.12",
 		"jsdom": "^30.1",
 		"tsdown": "^0.23",
 		"typescript": "^7",