@oscarpalmer/atoms 0.207.0 → 0.208.0

package/dist/index.d.mts

@@ -4589,18 +4589,64 @@ export declare function setValue<Data extends PlainObject>(data: Data, path: str
 //#endregion
 //#region src/internal/models/plan.model.d.ts
 /**
- * A plan of execution that can yield intermediate results and eventually return a value or an error.
+ * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
-type Plan<out Value, out Error = unknown> = {
+type AsyncPlan<Value, Error = unknown> = {
   /**
    * Run the plan to completion
    *
-   * @returns Final result, or an error
+   * @returns Result
    */
-  run: () => Error | Value;
+  run: () => Promise<Result<Value, Error>>;
+};
+/**
+ * A plan of execution that can yield intermediate results and eventually return a result
+ */
+type Plan<Value, Error = unknown> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Result
+   */
+  run: () => Result<Value, Error>;
 };
 //#endregion
 //#region src/plan/index.d.ts
+/**
+ * Create a plan for an asynchronous generator function
+ *
+ * @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>;
+/**
+ * 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>>;
+/**
+ * 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?
  *
@@ -4626,16 +4672,22 @@ export declare function plan<Value = unknown, Error = unknown>(generator: () =>
  * Run a generator to completion
  *
  * @param generator Generator to run
- * @returns Final result, or an error
+ * @returns Result
  */
-export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Error | Value;
+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 Final result, or an error
+ * @returns Result
  */
-export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Error | Value;
+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;
+}
 //#endregion
 //#region src/internal/aborter.d.ts
 type Aborter = {

package/dist/index.mjs

@@ -2749,14 +2749,56 @@ const SET_EXPRESSION_INDEX = /^\d+$/;
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
 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.run = runAsyncPlan;
 function Plan(generator) {
-	this[PLAN_SYMBOL] = { generator };
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
 }
 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;
+			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);
+}
 function execute(callback) {
-	const result = attempt(() => {
+	return attempt(() => {
 		const generator = callback();
 		let lastValue;
 		while (true) {
@@ -2769,7 +2811,24 @@ function execute(callback) {
 		}
 		return lastValue;
 	});
-	return result.ok ? result.value : result.error;
+}
+/**
+* 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 typeof value === "function" && value.constructor.name === "AsyncGeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
 }
 /**
 * Is the value a generator function?
@@ -2787,7 +2846,10 @@ function isGenerator(value) {
 * @returns `true` if the value is a plan, otherwise `false`
 */
 function isPlan(value) {
-	return typeof value === "object" && value !== null && PLAN_SYMBOL in 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 a plan for a generator function
@@ -2804,9 +2866,14 @@ function run(input) {
 	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return execute(input);
 }
+function runAsyncPlan() {
+	return asyncExecute(this[PLAN_SYMBOL].generator);
+}
 function runPlan() {
 	return execute(this[PLAN_SYMBOL].generator);
 }
+plan.async = asyncPlan;
+run.async = asyncRun;
 //#endregion
 //#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
@@ -6908,4 +6975,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, 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, isAsyncOnce, 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, 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 };

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

@@ -1,23 +1,48 @@
+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> = {
+  /**
+   * Run the plan to completion
+   *
+   * @returns Result
+   */
+  run: () => Promise<Result<Value, Error>>;
+};
+type AsyncPlanState = {
+  generator: () => AsyncGenerator;
+} & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
+type BaseState<Type extends PlanType> = {
+  type: Type;
+};
+export type InternalAsyncPlan = {
+  [PLAN_SYMBOL]: AsyncPlanState;
+} & AsyncPlan<never, never>;
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
 } & Plan<never, never>;
 /**
- * A plan of execution that can yield intermediate results and eventually return a value or an error.
+ * A plan of execution that can yield intermediate results and eventually return a result
  */
-export type Plan<out Value, out Error = unknown> = {
+export type Plan<Value, Error = unknown> = {
   /**
    * Run the plan to completion
    *
-   * @returns Final result, or an error
+   * @returns Result
    */
-  run: () => Error | Value;
+  run: () => Result<Value, Error>;
 };
 type PlanState = {
   generator: () => Generator;
-};
-export declare const GENERATOR_NAME = "GeneratorFunction";
+} & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
+export type PlanType = "asyncPlan" | "plan";
+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";
 export declare const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
 export declare const PLAN_SYMBOL: symbol;
+export declare const PLAN_TYPE_PLAN_ASYNC: PlanType;
+export declare const PLAN_TYPE_PLAN_SYNC: PlanType;
 //#endregion

package/dist/internal/models/plan.model.mjs

@@ -1,7 +1,10 @@
 //#region src/internal/models/plan.model.ts
-const GENERATOR_NAME = "GeneratorFunction";
+const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
+const GENERATOR_NAME_SYNC = "GeneratorFunction";
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
 const PLAN_SYMBOL = Symbol("plan");
+const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
+const PLAN_TYPE_PLAN_SYNC = "plan";
 //#endregion
-export { GENERATOR_NAME, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL };
+export { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC };

package/dist/plan/index.d.mts

@@ -1,5 +1,41 @@
-import { Plan } from "../internal/models/plan.model.mjs";
+import { Result } from "../internal/models/result.model.mjs";
+import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
 //#region src/plan/index.d.ts
+/**
+ * Create a plan for an asynchronous generator function
+ *
+ * @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>;
+/**
+ * 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>>;
+/**
+ * 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?
  *
@@ -25,14 +61,20 @@ export declare function plan<Value = unknown, Error = unknown>(generator: () =>
  * Run a generator to completion
  *
  * @param generator Generator to run
- * @returns Final result, or an error
+ * @returns Result
  */
-export declare function run<Value = unknown, Error = unknown>(generator: () => Generator<unknown, Value, unknown>): Error | Value;
+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 Final result, or an error
+ * @returns Result
  */
-export declare function run<Value = unknown, Error = unknown>(plan: Plan<Value, Error>): Error | Value;
+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;
+}
 //#endregion

package/dist/plan/index.mjs

@@ -1,12 +1,52 @@
-import { attempt } from "../internal/result/attempt.mjs";
-import { PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
+import { asyncAttempt, attempt } from "../internal/result/attempt.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";
 //#region src/plan/index.ts
+function AsyncPlan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_ASYNC
+	};
+}
+AsyncPlan.prototype.run = runAsyncPlan;
 function Plan(generator) {
-	this[PLAN_SYMBOL] = { generator };
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
 }
 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;
+			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);
+}
 function execute(callback) {
-	const result = attempt(() => {
+	return attempt(() => {
 		const generator = callback();
 		let lastValue;
 		while (true) {
@@ -19,7 +59,24 @@ function execute(callback) {
 		}
 		return lastValue;
 	});
-	return result.ok ? result.value : result.error;
+}
+/**
+* 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 typeof value === "function" && value.constructor.name === "AsyncGeneratorFunction" && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
 }
 /**
 * Is the value a generator function?
@@ -37,7 +94,10 @@ function isGenerator(value) {
 * @returns `true` if the value is a plan, otherwise `false`
 */
 function isPlan(value) {
-	return typeof value === "object" && value !== null && PLAN_SYMBOL in 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 a plan for a generator function
@@ -54,8 +114,13 @@ function run(input) {
 	if (!isGenerator(input)) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return execute(input);
 }
+function runAsyncPlan() {
+	return asyncExecute(this[PLAN_SYMBOL].generator);
+}
 function runPlan() {
 	return execute(this[PLAN_SYMBOL].generator);
 }
+plan.async = asyncPlan;
+run.async = asyncRun;
 //#endregion
-export { isGenerator, isPlan, plan, run };
+export { asyncPlan, asyncRun, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, plan, run };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.207.0",
+	"version": "0.208.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",