@oscarpalmer/atoms 0.210.0 → 0.211.0

package/dist/array/sort.d.mts

@@ -53,7 +53,7 @@ export type ArrayValueSorter<Item> = {
   /**
    * Value to sort by
    */
-  value: (item: Item) => unknown;
+  value(item: Item): unknown;
 };
 /**
  * Comparator to use when comparing items and values

package/dist/color/models.d.mts

@@ -187,16 +187,16 @@ export type Color = {
   unsubscribe(): void;
 };
 export type ColorChanges = {
-  "*": (value: Color) => void;
-  alpha: (value: number) => void;
-  hex: (value: string) => void;
-  hexa: (value: string) => void;
-  hsl: (value: HSLColor) => void;
-  hsla: (value: HSLAColor) => void;
-  hwb: (value: HWBColor) => void;
-  hwba: (value: HWBAColor) => void;
-  rgb: (value: RGBColor) => void;
-  rgba: (value: RGBAColor) => void;
+  "*"(value: Color): void;
+  alpha(value: number): void;
+  hex(value: string): void;
+  hexa(value: string): void;
+  hsl(value: HSLColor): void;
+  hsla(value: HSLAColor): void;
+  hwb(value: HWBColor): void;
+  hwba(value: HWBAColor): void;
+  rgb(value: RGBColor): void;
+  rgba(value: RGBAColor): void;
 };
 export type ColorDefaults = {
   alpha: Alpha;

package/dist/index.d.mts

@@ -90,7 +90,7 @@ export type OnceAsync<Callback extends GenericAsyncCallback> = {
    * @param parameters Callback parameters
    * @returns Call result
    */
-  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 } & OnceProperties;
 /**
  * A callback function that can only be called once, returning the same value on subsequent calls
@@ -102,7 +102,7 @@ export type Once<Callback extends GenericCallback> = {
    * @param parameters Callback parameters
    * @returns Call result
    */
-  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 } & OnceProperties;
 type OnceProperties = {
   /**
@@ -116,7 +116,7 @@ type OnceProperties = {
   /**
    * Clear the callback's cached value
    */
-  clear: () => void;
+  clear(): void;
 };
 /**
  * A generic object
@@ -2615,7 +2615,7 @@ export type ArrayValueSorter<Item> = {
   /**
    * Value to sort by
    */
-  value: (item: Item) => unknown;
+  value(item: Item): unknown;
 };
 /**
  * Comparator to use when comparing items and values
@@ -3711,14 +3711,14 @@ export type ResultMatch<Value, Returned, E = Error> = {
    * @param original Original error, if available
    * @returns Value to return
    */
-  error: (error: E, original?: Error) => Returned;
+  error(error: E, original?: Error): Returned;
   /**
    * Callback for ok result
    *
    * @param value Ok value
    * @returns Value to return
    */
-  ok: (value: Value) => Returned;
+  ok(value: Value): Returned;
 };
 /**
  * Unwrap a result value
@@ -4257,9 +4257,9 @@ type BaseHandler = {
   handlers: WeakMap<WeakKey, string | GenericCallback>;
   options: BaseHandlerOptions;
   owner: GenericCallback;
-  deregister: (constructor: Constructor) => void;
-  get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
-  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+  deregister(constructor: Constructor): void;
+  get(first: unknown, second: unknown): string | GenericCallback | undefined;
+  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 type BaseHandlerOptions = {
   callback: GenericCallback;
@@ -4591,86 +4591,148 @@ 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<Yielded, Returned> = {
+type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
   /**
    * Get the asynchronous generator for the plan
    *
    * @returns Asynchronous generator
    */
   [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
+  /**
+   * Attempt to run the plan to completion
+   *
+   * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+   *
+   * @returns Promised result
+   */
+  attempt(...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Promise<PlanResult<Returned>>;
+  run(...parameters: Parameters): Promise<PlanResult<Returned>>;
 };
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
-type Plan<Yielded, Returned> = {
+type Plan<Yielded, Returned, Parameters extends unknown[]> = {
   /**
    * Get the generator for the plan
    *
    * @returns Generator
    */
   [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
+  /**
+   * Attempt to run the plan to completion
+   *
+   * _Returns a {@link Result} instead of a raw value or throwing an error_
+   *
+   * @returns Result
+   */
+  attempt(...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => PlanResult<Returned>;
+  run(...parameters: Parameters): PlanResult<Returned>;
 };
-type PlanErrorValues<Original> = Original extends Error ? Original : never;
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : Original extends Result<infer _, infer Error> ? Error : never;
 type PlanError<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned> | Error;
-type PlanResult<Returned> = Returned extends Error ? never : Returned;
+type PlanResult<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned extends Result<infer Value, infer _> ? Value : Returned;
 //#endregion
-//#region src/plan/index.d.ts
+//#region src/plan/result.d.ts
 /**
- * Create a plan for an asynchronous generator function
+ * Attempt to run the generator to completion
  *
- * @param generator Generator to plan for
- * @returns Generator plan
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Promised result
  */
-export declare function plan<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
 /**
- * Create a plan for a generator function
+ * Attempt to run the plan to completion
  *
- * @param generator Generator to plan for
- * @returns Generator plan
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Promised result
  */
-export declare function plan<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): Plan<Yielded, Returned>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * Attempt to run the generator to completion
+ *
+ * _Returns a {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Result
+ */
+export declare function attemptRun<Yielded, Returned>(generator: () => Generator<Yielded, Returned, unknown>, ...parameters: Parameters<typeof generator>): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+/**
+ * Attempt to run the plan to completion
+ *
+ * _Returns a {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Result
+ */
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+export declare namespace attemptRun {
+  export var async: typeof asyncAttemptRun;
+}
+//#endregion
+//#region src/plan/run.d.ts
 /**
  * Run an asynchronous generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function run<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function run<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned>): Promise<PlanResult<Returned> | PlanError<Yielded, Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function run<Yielded, Returned>(generator: () => Generator<Yielded, Returned>): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned, unknown>, ...parameters: Parameters): 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>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare namespace asyncRun {
+  export var attempt: typeof asyncAttemptRun;
+}
+export declare namespace run {
+  export var async: typeof asyncRun;
+  export var attempt: typeof attemptRun;
+}
+//#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 plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned, Parameters>;
+/**
+ * Create a plan for a generator function
+ *
+ * @param generator Generator to plan for
+ * @returns Generator plan
+ */
+export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>): Plan<Yielded, Returned, Parameters>;
 //#endregion
 //#region src/internal/plan.d.ts
 /**
@@ -4679,7 +4741,7 @@ export declare function run<Yielded, Returned>(plan: Plan<Yielded, Returned>): P
  * @param reason Failure reason
  * @returns Failing generator
  */
-export declare function fail<Reason>(reason: Reason): Generator<never, never>;
+export declare function fail<Reason>(reason: Reason): Generator<unknown, never>;
 /**
  * Is the value an asynchronous generator function?
  *
@@ -4693,7 +4755,7 @@ export declare function isAsyncGenerator(value: unknown): value is () => AsyncGe
  * @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>;
+export declare function isAsyncPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is AsyncPlan<Yielded, Returned, Parameters>;
 /**
  * Is the value a generator function?
  *
@@ -4707,20 +4769,20 @@ 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<Yielded = unknown, Returned = unknown>(value: unknown): value is Plan<Yielded, Returned>;
+export declare function isPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is Plan<Yielded, Returned, Parameters>;
 /**
  * Create an immediately succeeding generator
  *
  * @param value Success value
  * @returns Succeeding generator
  */
-export declare function succeed<Value>(value: Value): Generator<never, Value>;
+export declare function succeed<Value>(value: Value): Generator<unknown, Value>;
 //#endregion
 //#region src/internal/aborter.d.ts
 type Aborter = {
   callback: GenericCallback;
+  cancel(): void;
   signal: AbortSignal;
-  cancel: () => void;
 };
 //#endregion
 //#region src/promise/constants.d.ts
@@ -4759,8 +4821,8 @@ export type PromiseData = {
   result: ArrayOrPlainObject;
 };
 export type PromiseHandlers = {
-  resolve: (value: unknown[]) => void;
-  reject: (reason: unknown) => void;
+  resolve(value: unknown[]): void;
+  reject(reason: unknown): void;
 };
 /**
  * Options for a _Promise_-handling function
@@ -6556,14 +6618,14 @@ type Subscriptions<Value = unknown> = {
   /**
    * Clear all subscriptions
    */
-  clear: () => void;
+  clear(): void;
   /**
    * Create _(or retrieve)_ a subscription
    *
    * @param parameters Subscription parameters
    * @returns Tuple holding subsccription and existing boolean
    */
-  create: (parameters: SubscriptionParameters) => [Subscription, boolean];
+  create(parameters: SubscriptionParameters): [Subscription, boolean];
 };
 /**
  * Parameters for creating a subscription store
@@ -6983,16 +7045,16 @@ type Color = {
   unsubscribe(): void;
 };
 type ColorChanges = {
-  "*": (value: Color) => void;
-  alpha: (value: number) => void;
-  hex: (value: string) => void;
-  hexa: (value: string) => void;
-  hsl: (value: HSLColor) => void;
-  hsla: (value: HSLAColor) => void;
-  hwb: (value: HWBColor) => void;
-  hwba: (value: HWBAColor) => void;
-  rgb: (value: RGBColor) => void;
-  rgba: (value: RGBAColor) => void;
+  "*"(value: Color): void;
+  alpha(value: number): void;
+  hex(value: string): void;
+  hexa(value: string): void;
+  hsl(value: HSLColor): void;
+  hsla(value: HSLAColor): void;
+  hwb(value: HWBColor): void;
+  hwba(value: HWBAColor): void;
+  rgb(value: RGBColor): void;
+  rgba(value: RGBAColor): void;
 };
 type ColorWithAlpha = {
   /**

package/dist/index.mjs

@@ -2737,7 +2737,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -2765,6 +2765,7 @@ const PLAN_TYPE_PLAN_SYNC = "plan";
 */
 function fail(reason) {
 	return (function* () {
+		yield;
 		throw reason;
 	})();
 }
@@ -2818,33 +2819,14 @@ function isPlanInstance(type, value) {
 */
 function succeed(value) {
 	return (function* () {
+		yield;
 		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();
+//#region src/plan/generate.ts
+async function asyncGenerate(callback, parameters) {
+	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
 	try {
@@ -2853,6 +2835,7 @@ async function asyncExecute(callback) {
 			const { done } = next;
 			let { value } = next;
 			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
 			lastValue = value;
 			if (done === true) break;
 		}
@@ -2860,21 +2843,22 @@ async function asyncExecute(callback) {
 		lastValue = error;
 		success = false;
 	} finally {
-		generator?.return(lastValue);
+		await generator?.return(lastValue);
 	}
 	if (success) return lastValue;
 	throw lastValue;
 }
-function execute(callback) {
-	const generator = callback();
+function generate(callback, parameters) {
+	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
 	try {
 		while (true) {
 			const next = generator.next(lastValue);
 			const done = next.done === true;
-			let { value } = next;
+			const { value } = next;
 			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
 			lastValue = value;
 			if (done) break;
 		}
@@ -2887,22 +2871,74 @@ function execute(callback) {
 	if (success) return lastValue;
 	throw lastValue;
 }
-function plan(generator) {
-	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
-	if (isGenerator(generator)) return new Plan(generator);
-	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+//#endregion
+//#region src/plan/result.ts
+function asyncAttemptRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.attempt(...parameters);
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function attemptRun(input, ...parameters) {
+	if (isPlan(input)) return input.attempt(...parameters);
+	if (isGenerator(input)) return attempt(() => generate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function run(input) {
-	if (isAsyncPlan(input) || isPlan(input)) return input.run();
-	if (isAsyncGenerator(input)) return asyncExecute(input);
-	if (isGenerator(input)) return execute(input);
+function attemptRunAsyncPlan(...parameters) {
+	return asyncAttempt(() => this.run(...parameters));
+}
+function attemptRunPlan(...parameters) {
+	return attempt(() => this.run(...parameters));
+}
+attemptRun.async = asyncAttemptRun;
+//#endregion
+//#region src/plan/run.ts
+function asyncRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.run(...parameters);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function run(input, ...parameters) {
+	if (isPlan(input)) return input.run(...parameters);
+	if (isGenerator(input)) return generate(input, parameters);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan() {
-	return asyncExecute(this[PLAN_SYMBOL].generator);
+function runAsyncPlan(...parameters) {
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL].generator, parameters);
+}
+asyncRun.attempt = asyncAttemptRun;
+run.async = asyncRun;
+run.attempt = attemptRun;
+//#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.attempt = attemptRunAsyncPlan;
+AsyncPlan.prototype.run = runAsyncPlan;
+function Plan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
 }
-function runPlan() {
-	return execute(this[PLAN_SYMBOL].generator);
+Plan.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+Plan.prototype.attempt = attemptRunPlan;
+Plan.prototype.run = runPlan;
+function plan(generator) {
+	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
+	if (isGenerator(generator)) return new Plan(generator);
+	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
 //#region src/internal/aborter.ts
@@ -7005,4 +7041,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, 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 };
+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, asyncAttemptRun, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, 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/aborter.d.mts

@@ -2,8 +2,8 @@ import { GenericCallback } from "../models.mjs";
 //#region src/internal/aborter.d.ts
 export type Aborter = {
   callback: GenericCallback;
+  cancel(): void;
   signal: AbortSignal;
-  cancel: () => void;
 };
 export declare function createAborter(value: unknown, onAbort: () => void): Aborter | undefined;
 //#endregion

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

@@ -1,57 +1,74 @@
+import { Err, Ok, 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<Yielded, Returned> = {
+export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
   /**
    * Get the asynchronous generator for the plan
    *
    * @returns Asynchronous generator
    */
   [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
+  /**
+   * Attempt to run the plan to completion
+   *
+   * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+   *
+   * @returns Promised result
+   */
+  attempt(...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => Promise<PlanResult<Returned>>;
+  run(...parameters: Parameters): Promise<PlanResult<Returned>>;
 };
 type AsyncPlanState = {
-  generator: () => AsyncGenerator;
+  generator(...parameters: unknown[]): AsyncGenerator;
 } & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
 type BaseState<Type extends PlanType> = {
   type: Type;
 };
 export type InternalAsyncPlan = {
   [PLAN_SYMBOL]: AsyncPlanState;
-} & AsyncPlan<never, never>;
+} & AsyncPlan<never, never, unknown[]>;
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
-} & Plan<never, never>;
+} & Plan<never, never, unknown[]>;
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
-export type Plan<Yielded, Returned> = {
+export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
   /**
    * Get the generator for the plan
    *
    * @returns Generator
    */
   [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
+  /**
+   * Attempt to run the plan to completion
+   *
+   * _Returns a {@link Result} instead of a raw value or throwing an error_
+   *
+   * @returns Result
+   */
+  attempt(...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run: () => PlanResult<Returned>;
+  run(...parameters: Parameters): PlanResult<Returned>;
 };
-type PlanErrorValues<Original> = Original extends Error ? Original : never;
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : Original extends Result<infer _, infer Error> ? Error : never;
 export type PlanError<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned> | Error;
-export type PlanResult<Returned> = Returned extends Error ? never : Returned;
+export type PlanResult<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned extends Result<infer Value, infer _> ? Value : Returned;
 type PlanState = {
-  generator: () => Generator;
+  generator(...parameters: unknown[]): Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
 export type PlanType = "asyncPlan" | "plan" | "stop";
 export declare const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";

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

@@ -43,14 +43,14 @@ export type ResultMatch<Value, Returned, E = Error> = {
    * @param original Original error, if available
    * @returns Value to return
    */
-  error: (error: E, original?: Error) => Returned;
+  error(error: E, original?: Error): Returned;
   /**
    * Callback for ok result
    *
    * @param value Ok value
    * @returns Value to return
    */
-  ok: (value: Value) => Returned;
+  ok(value: Value): Returned;
 };
 /**
  * Unwrap a result value

package/dist/internal/plan.d.mts

@@ -6,7 +6,7 @@ import { AsyncPlan, Plan } from "./models/plan.model.mjs";
  * @param reason Failure reason
  * @returns Failing generator
  */
-export declare function fail<Reason>(reason: Reason): Generator<never, never>;
+export declare function fail<Reason>(reason: Reason): Generator<unknown, never>;
 /**
  * Is the value an asynchronous generator function?
  *
@@ -20,7 +20,7 @@ export declare function isAsyncGenerator(value: unknown): value is () => AsyncGe
  * @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>;
+export declare function isAsyncPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is AsyncPlan<Yielded, Returned, Parameters>;
 /**
  * Is the value a generator function?
  *
@@ -34,12 +34,12 @@ 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<Yielded = unknown, Returned = unknown>(value: unknown): value is Plan<Yielded, Returned>;
+export declare function isPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is Plan<Yielded, Returned, Parameters>;
 /**
  * Create an immediately succeeding generator
  *
  * @param value Success value
  * @returns Succeeding generator
  */
-export declare function succeed<Value>(value: Value): Generator<never, Value>;
+export declare function succeed<Value>(value: Value): Generator<unknown, Value>;
 //#endregion

package/dist/internal/plan.mjs

@@ -8,6 +8,7 @@ import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_
 */
 function fail(reason) {
 	return (function* () {
+		yield;
 		throw reason;
 	})();
 }
@@ -61,6 +62,7 @@ function isPlanInstance(type, value) {
 */
 function succeed(value) {
 	return (function* () {
+		yield;
 		return value;
 	})();
 }

package/dist/internal/subscription.d.mts

@@ -65,14 +65,14 @@ export type Subscriptions<Value = unknown> = {
   /**
    * Clear all subscriptions
    */
-  clear: () => void;
+  clear(): void;
   /**
    * Create _(or retrieve)_ a subscription
    *
    * @param parameters Subscription parameters
    * @returns Tuple holding subsccription and existing boolean
    */
-  create: (parameters: SubscriptionParameters) => [Subscription, boolean];
+  create(parameters: SubscriptionParameters): [Subscription, boolean];
 };
 /**
  * Parameters for creating a subscription store

package/dist/internal/value/handlers.d.mts

@@ -4,9 +4,9 @@ type BaseHandler = {
   handlers: WeakMap<WeakKey, string | GenericCallback>;
   options: BaseHandlerOptions;
   owner: GenericCallback;
-  deregister: (constructor: Constructor) => void;
-  get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
-  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+  deregister(constructor: Constructor): void;
+  get(first: unknown, second: unknown): string | GenericCallback | undefined;
+  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 type BaseHandlerOptions = {
   callback: GenericCallback;

package/dist/internal/value/set.mjs

@@ -21,7 +21,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}

package/dist/models.d.mts

@@ -90,7 +90,7 @@ export type OnceAsync<Callback extends GenericAsyncCallback> = {
    * @param parameters Callback parameters
    * @returns Call result
    */
-  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 } & OnceProperties;
 /**
  * A callback function that can only be called once, returning the same value on subsequent calls
@@ -102,7 +102,7 @@ export type Once<Callback extends GenericCallback> = {
    * @param parameters Callback parameters
    * @returns Call result
    */
-  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
 } & OnceProperties;
 type OnceProperties = {
   /**
@@ -116,7 +116,7 @@ type OnceProperties = {
   /**
    * Clear the callback's cached value
    */
-  clear: () => void;
+  clear(): void;
 };
 /**
  * A generic object

package/dist/plan/generate.d.mts

@@ -0,0 +1,4 @@
+//#region src/plan/generate.d.ts
+export declare function asyncGenerate(callback: (...parameters: unknown[]) => AsyncGenerator, parameters: unknown[]): Promise<unknown>;
+export declare function generate(callback: (...parameters: unknown[]) => Generator, parameters: unknown[]): unknown;
+//#endregion

package/dist/plan/generate.mjs

@@ -0,0 +1,50 @@
+import { isError } from "../internal/result/misc.mjs";
+//#region src/plan/generate.ts
+async function asyncGenerate(callback, parameters) {
+	const generator = callback(...parameters);
+	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;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done === true) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		await generator?.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+function generate(callback, parameters) {
+	const generator = callback(...parameters);
+	let success = true;
+	let lastValue;
+	try {
+		while (true) {
+			const next = generator.next(lastValue);
+			const done = next.done === true;
+			const { value } = next;
+			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
+			lastValue = value;
+			if (done) break;
+		}
+	} catch (error) {
+		lastValue = error;
+		success = false;
+	} finally {
+		generator.return(lastValue);
+	}
+	if (success) return lastValue;
+	throw lastValue;
+}
+//#endregion
+export { asyncGenerate, generate };

package/dist/plan/index.d.mts

@@ -1,4 +1,6 @@
-import { AsyncPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+import { asyncAttemptRun, attemptRun } from "./result.mjs";
+import { asyncRun, run } from "./run.mjs";
 //#region src/plan/index.d.ts
 /**
  * Create a plan for an asynchronous generator function
@@ -6,40 +8,13 @@ import { AsyncPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.
  * @param generator Generator to plan for
  * @returns Generator plan
  */
-export declare function plan<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned>;
+export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>): AsyncPlan<Yielded, Returned, Parameters>;
 /**
  * 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 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 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<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
+export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>): Plan<Yielded, Returned, Parameters>;
+//#endregion
+export { asyncAttemptRun, asyncRun, attemptRun, run };

package/dist/plan/index.mjs

@@ -1,5 +1,7 @@
-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";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+import { isAsyncGenerator, isGenerator } from "../internal/plan.mjs";
+import { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan } from "./result.mjs";
+import { asyncRun, run, runAsyncPlan, runPlan } from "./run.mjs";
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -10,6 +12,7 @@ function AsyncPlan(generator) {
 AsyncPlan.prototype[Symbol.asyncIterator] = function() {
 	return this[PLAN_SYMBOL].generator();
 };
+AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
 AsyncPlan.prototype.run = runAsyncPlan;
 function Plan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -20,67 +23,12 @@ function Plan(generator) {
 Plan.prototype[Symbol.iterator] = function() {
 	return this[PLAN_SYMBOL].generator();
 };
+Plan.prototype.attempt = attemptRunPlan;
 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 (isAsyncGenerator(generator)) return new AsyncPlan(generator);
 	if (isGenerator(generator)) return new Plan(generator);
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
-function run(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);
-}
-function runPlan() {
-	return execute(this[PLAN_SYMBOL].generator);
-}
 //#endregion
-export { plan, run };
+export { asyncAttemptRun, asyncRun, attemptRun, plan, run };

package/dist/plan/result.d.mts

@@ -0,0 +1,41 @@
+import { Result } from "../internal/models/result.model.mjs";
+import { AsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+//#region src/plan/result.d.ts
+/**
+ * Attempt to run the generator to completion
+ *
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Promised result
+ */
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * Attempt to run the plan to completion
+ *
+ * _Returns a promised {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Promised result
+ */
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * Attempt to run the generator to completion
+ *
+ * _Returns a {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Result
+ */
+export declare function attemptRun<Yielded, Returned>(generator: () => Generator<Yielded, Returned, unknown>, ...parameters: Parameters<typeof generator>): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+/**
+ * Attempt to run the plan to completion
+ *
+ * _Returns a {@link Result} instead of a raw value or throwing an error_
+ *
+ * @returns Result
+ */
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRunAsyncPlan(this: InternalPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+export declare namespace attemptRun {
+  export var async: typeof asyncAttemptRun;
+}
+//#endregion

package/dist/plan/result.mjs

@@ -0,0 +1,24 @@
+import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
+import { PLAN_MESSAGE_RUN_INPUT } from "../internal/models/plan.model.mjs";
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { asyncGenerate, generate } from "./generate.mjs";
+//#region src/plan/result.ts
+function asyncAttemptRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.attempt(...parameters);
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function attemptRun(input, ...parameters) {
+	if (isPlan(input)) return input.attempt(...parameters);
+	if (isGenerator(input)) return attempt(() => generate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function attemptRunAsyncPlan(...parameters) {
+	return asyncAttempt(() => this.run(...parameters));
+}
+function attemptRunPlan(...parameters) {
+	return attempt(() => this.run(...parameters));
+}
+attemptRun.async = asyncAttemptRun;
+//#endregion
+export { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan };

package/dist/plan/run.d.mts

@@ -0,0 +1,41 @@
+import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanResult } from "../internal/models/plan.model.mjs";
+import { asyncAttemptRun, attemptRun } from "./result.mjs";
+//#region src/plan/run.d.ts
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
+/**
+ * Run an asynchronous plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
+/**
+ * Run a generator to completion
+ *
+ * @param generator Generator to run
+ * @returns Result
+ */
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned, unknown>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+/**
+ * Run a plan to completion
+ *
+ * @param plan Plan to run
+ * @returns Result
+ */
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare function runAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
+export declare namespace asyncRun {
+  export var attempt: typeof asyncAttemptRun;
+}
+export declare namespace run {
+  export var async: typeof asyncRun;
+  export var attempt: typeof attemptRun;
+}
+//#endregion

package/dist/plan/run.mjs

@@ -0,0 +1,26 @@
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
+import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { asyncGenerate, generate } from "./generate.mjs";
+import { asyncAttemptRun, attemptRun } from "./result.mjs";
+//#region src/plan/run.ts
+function asyncRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.run(...parameters);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function run(input, ...parameters) {
+	if (isPlan(input)) return input.run(...parameters);
+	if (isGenerator(input)) return generate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function runAsyncPlan(...parameters) {
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL].generator, parameters);
+}
+asyncRun.attempt = asyncAttemptRun;
+run.async = asyncRun;
+run.attempt = attemptRun;
+//#endregion
+export { asyncRun, run, runAsyncPlan, runPlan };

package/dist/promise/models.d.mts

@@ -34,8 +34,8 @@ export type PromiseData = {
   result: ArrayOrPlainObject;
 };
 export type PromiseHandlers = {
-  resolve: (value: unknown[]) => void;
-  reject: (reason: unknown) => void;
+  resolve(value: unknown[]): void;
+  reject(reason: unknown): void;
 };
 /**
  * Options for a _Promise_-handling function

package/package.json

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