@oscarpalmer/atoms 0.214.0 → 0.216.0

package/dist/index.d.mts

@@ -4677,14 +4677,14 @@ type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): Promise<PlanReturned<Returned>>;
+  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
 };
 type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
@@ -4724,16 +4724,42 @@ type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    */
   run(...parameters: Parameters): PlanReturned<Returned>;
 };
+/**
+ * An immediately failing plan
+ */
+type PlanFailure<E> = {
+  /**
+   * Get the generator for the failed plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<Err<E>, never>;
+};
 type PlanOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
 type PlanErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
-type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrors<Yielded, Returned>;
-type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : never;
+type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer E> ? E : Original extends PlanFailure<infer E> ? E : never;
 type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
+/**
+ * An immediately successful or failing plan
+ */
+type PlanResult<Success, Failure> = PlanSuccess<Success> | PlanFailure<Failure>;
 type PlanState = {
   generator(...parameters: unknown[]): Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
+/**
+ * An immediately successful plan
+ */
+type PlanSuccess<Value> = {
+  /**
+   * Get the generator for the successful plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<never, Value>;
+};
 type PlanType = "asyncPlan" | "plan";
-declare const PLAN_SYMBOL: symbol;
+declare const PLAN_SYMBOL: unique symbol;
 declare const PLAN_TYPE_PLAN_ASYNC: PlanType;
 declare const PLAN_TYPE_PLAN_SYNC: PlanType;
 //#endregion
@@ -4745,7 +4771,15 @@ declare const PLAN_TYPE_PLAN_SYNC: PlanType;
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * 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>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -4753,7 +4787,15 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<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>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -4770,7 +4812,7 @@ export declare function attemptRun<Yielded, Returned, Parameters extends unknown
  * @returns Result
  */
 export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
-export declare function attemptRunAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function attemptRunAsyncPlan(this: never, first: never, second: never): Promise<unknown>;
 export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;
@@ -4781,20 +4823,41 @@ export declare namespace attemptRun {
  * Run an asynchronous generator to completion
  *
  * @param generator Generator to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @param generator Generator to run
+ * @param signal Optional abort signal
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+/**
+ * Run an asynchronous plan to completion
+ *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
+ * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
@@ -4802,10 +4865,11 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * Run a plan to completion
  *
  * @param plan Plan to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
-export declare function runAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
 export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
@@ -4865,21 +4929,17 @@ export declare function isPlan<Yielded = unknown, Returned = unknown, Parameters
 /**
  * Create an immediately failing plan
  *
- * @param reason Failure reason
+ * @param value Failure value
  * @returns Plan failure
  */
-export declare function fail<Reason>(reason: Reason): Generator<Reason, void>;
+export declare function fail<Value>(value: Value): PlanFailure<Value>;
 /**
  * Create an immediately succeeding plan
  *
  * @param value Success value
  * @returns Plan success
  */
-export declare function succeed<Value>(value: Value): Generator<never, Value>;
-export declare function succeedResult<Returned>(value: Returned): Generator<never, Ok<Returned>>;
-export declare namespace succeed {
-  export var result: typeof succeedResult;
-}
+export declare function succeed<Value>(value: Value): PlanSuccess<Value>;
 //#endregion
 //#region src/models/aborter.model.d.ts
 type Aborter = {
@@ -8625,4 +8685,4 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { type ArrayComparisonSorter, type ArrayKeySorter, type ArrayKeySorters, type ArraySorter, type ArraySorters, type ArrayValueSorter, type Asserter, type AssignOptions, type Assigner, type AsyncFlow, type AsyncLimiter, type AsyncOnce, type AsyncPlan, type Beacon, type BeaconOptions, type CloneOptions, type Cloner, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type CompareCallback, type ComparisonSorter, type DiffOptions, type DiffResult, type EqualOptions, type Equalizer, type Flow, type FulfilledPromise, type Fuzzy, type FuzzyItem, type FuzzyOptions, type FuzzyResult, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, type Herald, type HeraldEvents, type HeraldOptions, Key$1 as Key, type KeyedQueue, type Limiter, Logger, type Memoized, type MemoizedOptions, type MergeOptions, type Merger, type NormalizeOptions, type Normalizer, type Observable, type Observer, type Once, type Plan, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type Queue, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, type Renderer, type Shaken, type Smushed, type SortDirection, type Sorter, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TemplateOptions, type Templater, type TemplaterOptions, type TemplaterRenderer, type TimeLogger, type TransformCallback, type TransformCallbacks, type Transformer, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };
+export { type ArrayComparisonSorter, type ArrayKeySorter, type ArrayKeySorters, type ArraySorter, type ArraySorters, type ArrayValueSorter, type Asserter, type AssignOptions, type Assigner, type AsyncFlow, type AsyncLimiter, type AsyncOnce, type AsyncPlan, type Beacon, type BeaconOptions, type CloneOptions, type Cloner, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type CompareCallback, type ComparisonSorter, type DiffOptions, type DiffResult, type EqualOptions, type Equalizer, type Flow, type FulfilledPromise, type Fuzzy, type FuzzyItem, type FuzzyOptions, type FuzzyResult, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, type Herald, type HeraldEvents, type HeraldOptions, Key$1 as Key, type KeyedQueue, type Limiter, Logger, type Memoized, type MemoizedOptions, type MergeOptions, type Merger, type NormalizeOptions, type Normalizer, type Observable, type Observer, type Once, type Plan, type PlanFailure, type PlanResult, type PlanSuccess, type PromiseOptions, type PromiseStrategy, type PromisesOptions, type Queue, type QueueOptions, type Queued, type RGBAColor, type RGBColor, type RejectedPromise, type Renderer, type Shaken, type Smushed, type SortDirection, type Sorter, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TemplateOptions, type Templater, type TemplaterOptions, type TemplaterRenderer, type TimeLogger, type TransformCallback, type TransformCallbacks, type Transformer, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };

package/dist/index.mjs

@@ -2820,8 +2820,26 @@ function isPlanInstance(type, value) {
 	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
 }
 //#endregion
+//#region src/models/aborter.model.ts
+const ABORTER_EVENT = "abort";
+const ABORTER_OPTIONS = { once: true };
+//#endregion
+//#region src/internal/aborter.ts
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORTER_EVENT, onAbort, ABORTER_OPTIONS);
+	return {
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORTER_EVENT, onAbort)
+	};
+}
+//#endregion
 //#region src/plan/generate.ts
-async function asyncGenerate(input, parameters, unwrap) {
+async function asyncGenerate(input, unwrap, first, second) {
+	const aborter = createAborter(second ?? first, noop);
+	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
+	const parameters = Array.isArray(first) ? first : [];
 	let generator;
 	if (typeof input === "function") generator = input(...parameters);
 	else generator = input.generator(...parameters);
@@ -2829,11 +2847,12 @@ async function asyncGenerate(input, parameters, unwrap) {
 	let lastValue;
 	try {
 		while (true) {
+			if (aborter != null && aborter.signal.aborted) await generator.throw(aborter.signal.reason);
 			const next = await generator.next(lastValue);
 			const done = next.done === true;
 			const { value } = next;
-			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
+			if (value instanceof Error) await generator.throw(value);
+			if (isError(value)) await generator.throw(value.error);
 			lastValue = value;
 			if (done === true) break;
 		}
@@ -2841,8 +2860,10 @@ async function asyncGenerate(input, parameters, unwrap) {
 		lastValue = error;
 		success = false;
 	} finally {
+		aborter?.cancel();
 		await generator.return(lastValue);
 	}
+	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
@@ -2857,8 +2878,8 @@ function generate(input, parameters, unwrap) {
 			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;
+			if (value instanceof Error) generator.throw(value);
+			if (isError(value)) generator.throw(value.error);
 			lastValue = value;
 			if (done) break;
 		}
@@ -2873,18 +2894,22 @@ function generate(input, parameters, unwrap) {
 }
 //#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, true));
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+function asyncAttemptRun(input, first, second) {
+	let generator;
+	if (isAsyncPlan(input)) generator = input[PLAN_SYMBOL];
+	else if (isAsyncGenerator(input)) generator = input;
+	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return asyncAttempt(() => asyncGenerate(generator, true, first, second));
 }
 function attemptRun(input, ...parameters) {
-	if (isPlan(input)) return input.attempt(...parameters);
-	if (isGenerator(input)) return attempt(() => generate(input, parameters, true));
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	let generator;
+	if (isPlan(input)) generator = input[PLAN_SYMBOL];
+	else if (isGenerator(input)) generator = input;
+	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return attempt(() => generate(generator, parameters, true));
 }
-function attemptRunAsyncPlan(...parameters) {
-	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL], parameters, true));
+function attemptRunAsyncPlan(first, second) {
+	return asyncAttemptRun(this, first, second);
 }
 function attemptRunPlan(...parameters) {
 	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
@@ -2892,9 +2917,9 @@ function attemptRunPlan(...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, false);
+function asyncRun(input, first, second) {
+	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, false, first, second);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function run(input, ...parameters) {
@@ -2902,8 +2927,8 @@ function run(input, ...parameters) {
 	if (isGenerator(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan(...parameters) {
-	return asyncGenerate(this[PLAN_SYMBOL], parameters, false);
+function runAsyncPlan(first, second) {
+	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
 }
 function runPlan(...parameters) {
 	return generate(this[PLAN_SYMBOL], parameters, false);
@@ -2942,16 +2967,28 @@ function plan(generator) {
 }
 //#endregion
 //#region src/plan/misc.ts
+function PlanFailure(generator) {
+	this[PLAN_SYMBOL] = { generator };
+}
+PlanFailure.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+function PlanSuccess(generator) {
+	this[PLAN_SYMBOL] = { generator };
+}
+PlanSuccess.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
 /**
 * Create an immediately failing plan
 *
-* @param reason Failure reason
+* @param value Failure value
 * @returns Plan failure
 */
-function fail(reason) {
-	return (function* () {
-		throw reason;
-	})();
+function fail(value) {
+	return new PlanFailure(function* () {
+		yield error(value);
+	});
 }
 /**
 * Create an immediately succeeding plan
@@ -2960,30 +2997,9 @@ function fail(reason) {
 * @returns Plan success
 */
 function succeed(value) {
-	return (function* () {
+	return new PlanSuccess(function* () {
 		return value;
-	})();
-}
-function succeedResult(value) {
-	return (function* () {
-		return ok(value);
-	})();
-}
-succeed.result = succeedResult;
-//#endregion
-//#region src/models/aborter.model.ts
-const ABORTER_EVENT = "abort";
-const ABORTER_OPTIONS = { once: true };
-//#endregion
-//#region src/internal/aborter.ts
-function createAborter(value, onAbort) {
-	if (!(value instanceof AbortSignal)) return;
-	value.addEventListener(ABORTER_EVENT, onAbort, ABORTER_OPTIONS);
-	return {
-		callback: onAbort,
-		signal: value,
-		cancel: () => value.removeEventListener(ABORTER_EVENT, onAbort)
-	};
+	});
 }
 //#endregion
 //#region src/models/promise.model.ts
@@ -7095,4 +7111,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, 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, attemptRunAsyncPlan, attemptRunPlan, 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, runAsyncPlan, runPlan, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, succeedResult, 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, 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, attemptRunAsyncPlan, attemptRunPlan, 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, runAsyncPlan, runPlan, 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/models/plan.model.d.mts

@@ -17,14 +17,14 @@ export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): Promise<PlanReturned<Returned>>;
+  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
 };
 export type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
@@ -38,6 +38,9 @@ export type InternalAsyncPlan = {
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
 } & Plan<never, never, unknown[]>;
+export type InternalPlanHelper = {
+  [PLAN_SYMBOL]: PlanHelperState;
+};
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
@@ -64,20 +67,49 @@ export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    */
   run(...parameters: Parameters): PlanReturned<Returned>;
 };
+/**
+ * An immediately failing plan
+ */
+export type PlanFailure<E> = {
+  /**
+   * Get the generator for the failed plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<Err<E>, never>;
+};
 export type PlanOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
 type PlanErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
-export type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrors<Yielded, Returned>;
-type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : never;
+export type PlanError<Yielded, Returned> = [PlanErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer E> ? E : Original extends PlanFailure<infer E> ? E : never;
+type PlanHelperState = {
+  generator: () => Generator;
+};
 export type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
+/**
+ * An immediately successful or failing plan
+ */
+export type PlanResult<Success, Failure> = PlanSuccess<Success> | PlanFailure<Failure>;
 export type PlanState = {
   generator(...parameters: unknown[]): Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
+/**
+ * An immediately successful plan
+ */
+export type PlanSuccess<Value> = {
+  /**
+   * Get the generator for the successful plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<never, Value>;
+};
 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_SYMBOL: unique symbol;
 export declare const PLAN_TYPE_PLAN_ASYNC: PlanType;
 export declare const PLAN_TYPE_PLAN_SYNC: PlanType;
 //#endregion

package/dist/plan/generate.d.mts

@@ -1,5 +1,5 @@
 import { AsyncPlanState, PlanState } from "../models/plan.model.mjs";
 //#region src/plan/generate.d.ts
-export declare function asyncGenerate(input: AsyncPlanState | ((...parameters: unknown[]) => AsyncGenerator), parameters: unknown[], unwrap: boolean): Promise<unknown>;
+export declare function asyncGenerate(input: AsyncPlanState | ((...args: unknown[]) => AsyncGenerator), unwrap: boolean, first?: unknown, second?: unknown): Promise<unknown>;
 export declare function generate(input: PlanState | ((...parameters: unknown[]) => Generator), parameters: unknown[], unwrap: boolean): unknown;
 //#endregion

package/dist/plan/generate.mjs

@@ -1,6 +1,11 @@
+import { noop } from "../internal/function/misc.mjs";
+import { createAborter } from "../internal/aborter.mjs";
 import { isError, isOk } from "../internal/result/misc.mjs";
 //#region src/plan/generate.ts
-async function asyncGenerate(input, parameters, unwrap) {
+async function asyncGenerate(input, unwrap, first, second) {
+	const aborter = createAborter(second ?? first, noop);
+	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
+	const parameters = Array.isArray(first) ? first : [];
 	let generator;
 	if (typeof input === "function") generator = input(...parameters);
 	else generator = input.generator(...parameters);
@@ -8,11 +13,12 @@ async function asyncGenerate(input, parameters, unwrap) {
 	let lastValue;
 	try {
 		while (true) {
+			if (aborter != null && aborter.signal.aborted) await generator.throw(aborter.signal.reason);
 			const next = await generator.next(lastValue);
 			const done = next.done === true;
 			const { value } = next;
-			if (value instanceof Error) throw value;
-			if (isError(value)) throw value.error;
+			if (value instanceof Error) await generator.throw(value);
+			if (isError(value)) await generator.throw(value.error);
 			lastValue = value;
 			if (done === true) break;
 		}
@@ -20,8 +26,10 @@ async function asyncGenerate(input, parameters, unwrap) {
 		lastValue = error;
 		success = false;
 	} finally {
+		aborter?.cancel();
 		await generator.return(lastValue);
 	}
+	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
@@ -36,8 +44,8 @@ function generate(input, parameters, unwrap) {
 			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;
+			if (value instanceof Error) generator.throw(value);
+			if (isError(value)) generator.throw(value.error);
 			lastValue = value;
 			if (done) break;
 		}

package/dist/plan/misc.d.mts

@@ -1,21 +1,17 @@
-import { Ok } from "../models/result.model.mjs";
+import { PlanFailure, PlanSuccess } from "../models/plan.model.mjs";
 //#region src/plan/misc.d.ts
 /**
  * Create an immediately failing plan
  *
- * @param reason Failure reason
+ * @param value Failure value
  * @returns Plan failure
  */
-export declare function fail<Reason>(reason: Reason): Generator<Reason, void>;
+export declare function fail<Value>(value: Value): PlanFailure<Value>;
 /**
  * Create an immediately succeeding plan
  *
  * @param value Success value
  * @returns Plan success
  */
-export declare function succeed<Value>(value: Value): Generator<never, Value>;
-export declare function succeedResult<Returned>(value: Returned): Generator<never, Ok<Returned>>;
-export declare namespace succeed {
-  export var result: typeof succeedResult;
-}
+export declare function succeed<Value>(value: Value): PlanSuccess<Value>;
 //#endregion

package/dist/plan/misc.mjs

@@ -1,15 +1,28 @@
-import { ok } from "../internal/result/misc.mjs";
+import { error } from "../internal/result/misc.mjs";
+import { PLAN_SYMBOL } from "../models/plan.model.mjs";
 //#region src/plan/misc.ts
+function PlanFailure(generator) {
+	this[PLAN_SYMBOL] = { generator };
+}
+PlanFailure.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+function PlanSuccess(generator) {
+	this[PLAN_SYMBOL] = { generator };
+}
+PlanSuccess.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
 /**
 * Create an immediately failing plan
 *
-* @param reason Failure reason
+* @param value Failure value
 * @returns Plan failure
 */
-function fail(reason) {
-	return (function* () {
-		throw reason;
-	})();
+function fail(value) {
+	return new PlanFailure(function* () {
+		yield error(value);
+	});
 }
 /**
 * Create an immediately succeeding plan
@@ -18,15 +31,9 @@ function fail(reason) {
 * @returns Plan success
 */
 function succeed(value) {
-	return (function* () {
+	return new PlanSuccess(function* () {
 		return value;
-	})();
-}
-function succeedResult(value) {
-	return (function* () {
-		return ok(value);
-	})();
+	});
 }
-succeed.result = succeedResult;
 //#endregion
-export { fail, succeed, succeedResult };
+export { fail, succeed };

package/dist/plan/models.d.mts

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

package/dist/plan/result.d.mts

@@ -1,5 +1,5 @@
 import { Result } from "../models/result.model.mjs";
-import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
+import { AsyncPlan, InternalPlan, Plan, PlanError, PlanOk } from "../models/plan.model.mjs";
 //#region src/plan/result.d.ts
 /**
  * Attempt to run the generator to completion
@@ -8,7 +8,23 @@ import { AsyncPlan, InternalAsyncPlan, InternalPlan, Plan, PlanError, PlanOk } f
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+/**
+ * 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>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<Result<PlanOk<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, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -16,7 +32,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -33,7 +49,7 @@ export declare function attemptRun<Yielded, Returned, Parameters extends unknown
  * @returns Result
  */
 export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
-export declare function attemptRunAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function attemptRunAsyncPlan(this: never, first: never, second: never): Promise<unknown>;
 export declare function attemptRunPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;

package/dist/plan/result.mjs

@@ -3,18 +3,22 @@ import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../models/plan.model.mjs";
 import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.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, true));
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+function asyncAttemptRun(input, first, second) {
+	let generator;
+	if (isAsyncPlan(input)) generator = input[PLAN_SYMBOL];
+	else if (isAsyncGenerator(input)) generator = input;
+	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return asyncAttempt(() => asyncGenerate(generator, true, first, second));
 }
 function attemptRun(input, ...parameters) {
-	if (isPlan(input)) return input.attempt(...parameters);
-	if (isGenerator(input)) return attempt(() => generate(input, parameters, true));
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	let generator;
+	if (isPlan(input)) generator = input[PLAN_SYMBOL];
+	else if (isGenerator(input)) generator = input;
+	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
+	return attempt(() => generate(generator, parameters, true));
 }
-function attemptRunAsyncPlan(...parameters) {
-	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL], parameters, true));
+function attemptRunAsyncPlan(first, second) {
+	return asyncAttemptRun(this, first, second);
 }
 function attemptRunPlan(...parameters) {
 	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));

package/dist/plan/run.d.mts

@@ -5,20 +5,41 @@ import { asyncAttemptRun, attemptRun } from "./result.mjs";
  * Run an asynchronous generator to completion
  *
  * @param generator Generator to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+/**
+ * Run an asynchronous generator to completion
+ *
+ * @param generator Generator to run
+ * @param signal Optional abort signal
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned>(generator: () => AsyncGenerator<Yielded, Returned>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
+/**
+ * Run an asynchronous plan to completion
+ *
+ * @param plan Plan to run
+ * @param parameters Parameters for starting the run
+ * @param signal Optional abort signal
+ * @returns Result
+ */
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, parameters: Parameters, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
+ * @param signal Optional abort signal
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
+export declare function asyncRun<Yielded, Returned>(plan: AsyncPlan<Yielded, Returned, []>, signal?: AbortSignal): Promise<PlanReturned<Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
@@ -26,10 +47,11 @@ export declare function run<Yielded, Returned, Parameters extends unknown[]>(gen
  * Run a plan to completion
  *
  * @param plan Plan to run
+ * @param parameters Parameters for starting the run
  * @returns Result
  */
 export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
-export declare function runAsyncPlan(this: InternalAsyncPlan, ...parameters: unknown[]): Promise<unknown>;
+export declare function runAsyncPlan(this: InternalAsyncPlan, first: never, second: never): Promise<unknown>;
 export declare function runPlan(this: InternalPlan, ...parameters: unknown[]): unknown;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;

package/dist/plan/run.mjs

@@ -3,9 +3,9 @@ import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "./is.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, false);
+function asyncRun(input, first, second) {
+	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, false, first, second);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function run(input, ...parameters) {
@@ -13,8 +13,8 @@ function run(input, ...parameters) {
 	if (isGenerator(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan(...parameters) {
-	return asyncGenerate(this[PLAN_SYMBOL], parameters, false);
+function runAsyncPlan(first, second) {
+	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
 }
 function runPlan(...parameters) {
 	return generate(this[PLAN_SYMBOL], parameters, false);

package/package.json

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