@oscarpalmer/atoms 0.216.0 → 0.218.0

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

@@ -1,5 +1,16 @@
 import { Err, Ok, Result } from "./result.model.mjs";
 //#region src/models/plan.model.d.ts
+/**
+ * An immediately failing asynchronous plan
+ */
+export type AsyncFailure<Value> = {
+  /**
+   * Get the generator for the failed plan
+   *
+   * @returns Generator
+   */
+  [Symbol.asyncIterator]: () => AsyncGenerator<Err<Value>, never>;
+};
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
@@ -26,21 +37,106 @@ export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    */
   run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
 };
+/**
+ * An immediately succeeding or failing asynchronous plan
+ */
+export type AsyncPlanned<Value, Error> = AsyncSuccess<Value> | AsyncFailure<Error>;
+export type AsyncPlannedState = {
+  generator: () => AsyncGenerator;
+  type: typeof PLAN_FAILURE_ASYNC | typeof PLAN_SUCCESS_ASYNC;
+};
 export type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
-} & BaseState<typeof PLAN_TYPE_PLAN_ASYNC>;
-type BaseState<Type extends PlanType> = {
-  type: Type;
+  type: typeof PLAN_TYPE_ASYNC;
+};
+/**
+ * A single asynchronous step within a plan of execution
+ */
+export type AsyncStep<Input> = {
+  /**
+   * Get the asynchronous generator for the step
+   *
+   * @returns Asynchronous generator
+   */
+  [Symbol.asyncIterator]: () => AsyncGenerator<AsyncStepYielded<Input>, AsyncStepReturned<Input>>;
+};
+type AsyncStepReturned<Input> = AsyncStepReturnedItem<Awaited<Input>>;
+type AsyncStepReturnedItem<Input> = Input extends {
+  [Symbol.asyncIterator](): AsyncGenerator<infer _, infer Returned>;
+} ? Returned : StepReturned<Input>;
+export type AsyncStepState = {
+  generator: () => AsyncGenerator;
+  type: typeof PLAN_STEP_ASYNC;
+};
+export type AsyncStepValue<Input> = [Extract<Awaited<Input>, InvalidAsyncStepValue<Awaited<Input>>>] extends [never] ? unknown : never;
+type AsyncStepYielded<Input> = AsyncStepYieldedItem<Awaited<Input>>;
+type AsyncStepYieldedItem<Input> = Input extends {
+  [Symbol.asyncIterator](): AsyncGenerator<infer Yielded>;
+} ? Yielded : StepYielded<Input>;
+/**
+ * An immediately successful asynchronous plan
+ */
+export type AsyncSuccess<Value> = {
+  /**
+   * Get the generator for the successful plan
+   *
+   * @returns Generator
+   */
+  [Symbol.asyncIterator]: () => AsyncGenerator<never, Value>;
+};
+/**
+ * An immediately failing plan
+ */
+export type Failure<Value> = {
+  /**
+   * Get the generator for the failed plan
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<Err<Value>, never>;
+};
+export type GenericPlanItem = {
+  [PLAN_SYMBOL]: GenericPlanItemState;
+  [Symbol.asyncIterator]: () => AsyncGenerator;
+  [Symbol.iterator]: () => Generator;
+};
+export type GenericPlanItemState = {
+  generator: () => AsyncGenerator | Generator;
+  type: PlanType | PlannedType | StepType;
 };
+export type InternalAsyncFailure = {
+  [PLAN_SYMBOL]: AsyncPlannedState;
+} & AsyncFailure<never>;
 export type InternalAsyncPlan = {
   [PLAN_SYMBOL]: AsyncPlanState;
 } & AsyncPlan<never, never, unknown[]>;
+export type InternalAsyncStep = {
+  [PLAN_SYMBOL]: AsyncStepState;
+} & AsyncStep<never>;
+export type InternalAsyncSuccess = {
+  [PLAN_SYMBOL]: AsyncPlannedState;
+} & AsyncSuccess<never>;
+export type InternalFailure = {
+  [PLAN_SYMBOL]: PlannedState;
+} & Failure<never>;
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
 } & Plan<never, never, unknown[]>;
-export type InternalPlanHelper = {
-  [PLAN_SYMBOL]: PlanHelperState;
-};
+export type InternalSuccess = {
+  [PLAN_SYMBOL]: PlannedState;
+} & Success<never>;
+export type InternalStep = {
+  [PLAN_SYMBOL]: StepState;
+} & Step<never>;
+type InvalidAsyncStepValue<Input> = ((...args: any[]) => unknown) | ParameterizedPlan<Input>;
+type InvalidStepValue<Input> = ((...args: any[]) => unknown) | {
+  [Symbol.asyncIterator]: unknown;
+} | ParameterizedPlan<Input> | Promise<unknown>;
+type ParameterizedPlan<Input> = Input extends {
+  [Symbol.iterator]: (...parameters: infer Parameters) => unknown;
+} ? [] extends Parameters ? never : Input : Input extends {
+  [Symbol.asyncIterator]: (...parameters: infer Parameters) => unknown;
+} ? [] extends Parameters ? never : Input : never;
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
  */
@@ -68,35 +164,60 @@ export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
   run(...parameters: Parameters): PlanReturned<Returned>;
 };
 /**
- * An immediately failing plan
+ * An OK result of a plan execution
  */
-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>;
+/**
+ * An error result of a plan execution
+ */
 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;
-};
+type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer E> ? E : Original extends Failure<infer E> ? E : never;
+/**
+ * The returned result of a plan execution _(excluding errors, which are thrown)_
+ */
 export type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
 /**
- * An immediately successful or failing plan
+ * An immediately succeeding or failing plan
  */
-export type PlanResult<Success, Failure> = PlanSuccess<Success> | PlanFailure<Failure>;
+export type Planned<Value, Error> = Success<Value> | Failure<Error>;
+export type PlannedState = {
+  generator: () => Generator;
+  type: typeof PLAN_FAILURE_SYNC | typeof PLAN_SUCCESS_SYNC;
+};
+export type PlannedType = "asyncFailure" | "asyncSuccess" | "failure" | "success";
 export type PlanState = {
   generator(...parameters: unknown[]): Generator;
-} & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
+  type: typeof PLAN_TYPE_SYNC;
+};
+/**
+ * A single step within a plan of execution
+ */
+export type Step<Input> = {
+  /**
+   * Get the generator for the step
+   *
+   * @returns Generator
+   */
+  [Symbol.iterator]: () => Generator<StepYielded<Input>, StepReturned<Input>>;
+};
+type StepReturned<Input> = Input extends Error ? never : Input extends Err<infer _> ? never : Input extends Ok<infer Value> ? Value : Input extends {
+  [Symbol.iterator](): Generator<infer _, infer Returned>;
+} ? Returned : Input;
+export type StepState = {
+  generator: () => Generator;
+  type: typeof PLAN_STEP_SYNC;
+};
+export type StepType = "asyncStep" | "step";
+export type StepValue<Input> = [Extract<Input, InvalidStepValue<Input>>] extends [never] ? unknown : never;
+type StepYielded<Input> = Input extends Error ? Err<Input> : Input extends Err<infer _> ? Input : Input extends {
+  [Symbol.iterator](): Generator<infer Yielded>;
+} ? Yielded : never;
+export type PlanType = "asyncPlan" | "plan";
 /**
  * An immediately successful plan
  */
-export type PlanSuccess<Value> = {
+export type Success<Value> = {
   /**
    * Get the generator for the successful plan
    *
@@ -104,12 +225,22 @@ export type PlanSuccess<Value> = {
    */
   [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 GENERATOR_FUNCTION_TYPE_ASYNC = "[object AsyncGeneratorFunction]";
+export declare const GENERATOR_FUNCTION_TYPE_SYNC = "[object GeneratorFunction]";
+export declare const GENERATOR_TYPE_ASYNC = "[object AsyncGenerator]";
+export declare const GENERATOR_TYPE_SYNC = "[object Generator]";
+export declare const PLAN_FAILURE_ASYNC: "asyncFailure";
+export declare const PLAN_FAILURE_SYNC: "failure";
 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_MESSAGE_USE_NESTED_FN = "Cannot use nested functions with 'use'";
+export declare const PLAN_MESSAGE_USE_SYNC_ASYNC = "Cannot use asynchronous values with 'use'";
+export declare const PLAN_STEP_ASYNC: "asyncStep";
+export declare const PLAN_STEP_SYNC: "step";
+export declare const PLAN_SUCCESS_ASYNC: "asyncSuccess";
+export declare const PLAN_SUCCESS_SYNC: "success";
 export declare const PLAN_SYMBOL: unique symbol;
-export declare const PLAN_TYPE_PLAN_ASYNC: PlanType;
-export declare const PLAN_TYPE_PLAN_SYNC: PlanType;
-//#endregion
+export declare const PLAN_TYPE_ASYNC: "asyncPlan";
+export declare const PLAN_TYPE_SYNC: "plan";
+//#endregion
+export {};

package/dist/models/plan.model.mjs

@@ -1,10 +1,20 @@
 //#region src/models/plan.model.ts
-const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
-const GENERATOR_NAME_SYNC = "GeneratorFunction";
+const GENERATOR_FUNCTION_TYPE_ASYNC = "[object AsyncGeneratorFunction]";
+const GENERATOR_FUNCTION_TYPE_SYNC = "[object GeneratorFunction]";
+const GENERATOR_TYPE_ASYNC = "[object AsyncGenerator]";
+const GENERATOR_TYPE_SYNC = "[object Generator]";
+const PLAN_FAILURE_ASYNC = "asyncFailure";
+const PLAN_FAILURE_SYNC = "failure";
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+const PLAN_MESSAGE_USE_NESTED_FN = "Cannot use nested functions with 'use'";
+const PLAN_MESSAGE_USE_SYNC_ASYNC = "Cannot use asynchronous values with 'use'";
+const PLAN_STEP_ASYNC = "asyncStep";
+const PLAN_STEP_SYNC = "step";
+const PLAN_SUCCESS_ASYNC = "asyncSuccess";
+const PLAN_SUCCESS_SYNC = "success";
 const PLAN_SYMBOL = Symbol("plan");
-const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
-const PLAN_TYPE_PLAN_SYNC = "plan";
+const PLAN_TYPE_ASYNC = "asyncPlan";
+const PLAN_TYPE_SYNC = "plan";
 //#endregion
-export { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC };
+export { GENERATOR_FUNCTION_TYPE_ASYNC, GENERATOR_FUNCTION_TYPE_SYNC, GENERATOR_TYPE_ASYNC, GENERATOR_TYPE_SYNC, PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_MESSAGE_USE_NESTED_FN, PLAN_MESSAGE_USE_SYNC_ASYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC };

package/dist/models/queue.model.d.mts

@@ -248,4 +248,5 @@ export declare const QUEUE_STATUS_EMPTY: QueueStatusKey;
 export declare const QUEUE_STATUS_FULL: QueueStatusKey;
 export declare const QUEUE_STATUS_PAUSED: QueueStatusKey;
 export declare const QUEUE_SYMBOL: unique symbol;
-//#endregion
+//#endregion
+export {};

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

@@ -68,4 +68,5 @@ type UnwrapResult<Original extends Result<unknown, unknown>> = Original extends
  * Unwrap any value
  */
 export type UnwrapValue<Original> = Original extends GenericCallback ? ReturnType<Original> extends Result<unknown, unknown> ? UnwrapResult<ReturnType<Original>> : ReturnType<Original> : Original extends Result<unknown, unknown> ? UnwrapResult<Original> : Original extends Promise<infer Value> ? Awaited<Value> : Original;
-//#endregion
+//#endregion
+export {};

package/dist/models/string/string.fuzzy.model.d.mts

@@ -88,7 +88,7 @@ export type FuzzyResult<Item> = {
 /**
  * Options for fuzzy searching
  */
-export type FuzzySearchOptions = FuzzyOptions;
+export type FuzzySearchOptions = { [Key in keyof FuzzyOptions]: FuzzyOptions[Key]; };
 export type FuzzyState<Item> = {
   handler(item: Item): string;
   items: Item[];

package/dist/models/string/string.misc.model.mjs

@@ -2,7 +2,7 @@
 const STRING_DELIMITER_UUID_DEFAULT = "-";
 const STRING_DELIMITER_UUID_HTML = "_";
 const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_WORDS = /([^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+)/g;
 const STRING_EXPRESSION_WHITESPACE_PREFIX = /^(\s+)/;
 const STRING_MATCH_ENDS_WITH = "endsWith";
 const STRING_MATCH_INCLUDES = "includes";

package/dist/models/value/value.equal.model.d.mts

@@ -73,4 +73,5 @@ export declare const EQUAL_ERROR_PROPERTIES: string[];
 export declare const EQUAL_EXPRESSION_PROPERTIES: string[];
 export declare const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
 export declare const EQUAL_SYMBOL: unique symbol;
-//#endregion
+//#endregion
+export {};

package/dist/models/value/value.merge.model.d.mts

@@ -3,7 +3,7 @@ import { ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection } f
 /**
  * Options for assigning values
  */
-export type AssignOptions = BaseOptions;
+export type AssignOptions = { [Key in keyof BaseOptions]: BaseOptions[Key]; };
 type BaseOptions = {
   /**
    * Key _(or key epxressions)_ for values that should be replaced
@@ -79,4 +79,5 @@ export type MergingOptions = {
 };
 export declare const MERGE_SYMBOL_ASSIGN: unique symbol;
 export declare const MERGE_SYMBOL_MERGE: unique symbol;
-//#endregion
+//#endregion
+export {};

package/dist/models/value/value.misc.model.d.mts

@@ -30,4 +30,5 @@ export declare const VALUE_MISC_NESTED_MESSAGE_MISSING = "Expected property to e
 export declare const VALUE_MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
 export declare const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 export declare const SMUSH_MAX_DEPTH = 100;
-//#endregion
+//#endregion
+export {};

package/dist/number.mjs

@@ -1,2 +1 @@
-import { between, clamp, getNumber } from "./internal/number.mjs";
-export { between, clamp, getNumber };
+export { between, clamp, getNumber } from "./internal/number.mjs";

package/dist/plan/index.d.mts

@@ -1,6 +1,4 @@
 import { AsyncPlan, Plan } from "../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
@@ -16,5 +14,4 @@ export declare function plan<Yielded, Returned, Parameters extends unknown[]>(ge
  * @returns Generator plan
  */
 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 };
+//#endregion

package/dist/plan/index.mjs

@@ -1,34 +1,33 @@
-import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../models/plan.model.mjs";
-import { isAsyncGenerator, isGenerator } from "./is.mjs";
-import { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan } from "./result.mjs";
-import { asyncRun, run, runAsyncPlan, runPlan } from "./run.mjs";
+import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC } from "../models/plan.model.mjs";
+import { attemptRunPlan, getGenerator, runAsyncPlan, runPlan } from "../internal/plan/index.mjs";
+import { isAsyncGeneratorFunction, isGeneratorFunction } from "./is.mjs";
+import { asyncAttemptRun } from "./result.mjs";
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
-		type: PLAN_TYPE_PLAN_ASYNC
+		type: PLAN_TYPE_ASYNC
 	};
 }
-AsyncPlan.prototype[Symbol.asyncIterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
+AsyncPlan.prototype[Symbol.asyncIterator] = getGenerator;
 AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
 AsyncPlan.prototype.run = runAsyncPlan;
 function Plan(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
-		type: PLAN_TYPE_PLAN_SYNC
+		type: PLAN_TYPE_SYNC
 	};
 }
-Plan.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
+Plan.prototype[Symbol.iterator] = getGenerator;
 Plan.prototype.attempt = attemptRunPlan;
 Plan.prototype.run = runPlan;
+function attemptRunAsyncPlan(first, second) {
+	return asyncAttemptRun(this, first, second);
+}
 function plan(generator) {
-	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
-	if (isGenerator(generator)) return new Plan(generator);
+	if (isAsyncGeneratorFunction(generator)) return new AsyncPlan(generator);
+	if (isGeneratorFunction(generator)) return new Plan(generator);
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
-export { asyncAttemptRun, asyncRun, attemptRun, plan, run };
+export { plan };

package/dist/plan/is.d.mts

@@ -1,12 +1,26 @@
-import { AsyncPlan, Plan } from "../models/plan.model.mjs";
+import { AsyncFailure, AsyncPlan, AsyncStep, AsyncSuccess, Failure, Plan, Step, Success } from "../models/plan.model.mjs";
 //#region src/plan/is.d.ts
+/**
+ * Is the value an asynchronous, immediately failing plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous, immediately failing plan, otherwise `false`
+ */
+export declare function isAsyncFailure<Value = unknown>(value: unknown): value is AsyncFailure<Value>;
+/**
+ * Is the value an asynchronous generator?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous generator, otherwise `false`
+ */
+export declare function isAsyncGenerator<Y = unknown, R = unknown, N = unknown>(value: unknown): value is AsyncGenerator<Y, R, N>;
 /**
  * Is the value an asynchronous generator function?
  *
  * @param value Value to check
  * @returns `true` if the value is an asynchronous generator function, otherwise `false`
  */
-export declare function isAsyncGenerator(value: unknown): value is () => AsyncGenerator;
+export declare function isAsyncGeneratorFunction<Y = unknown, R = unknown, N = unknown>(value: unknown): value is () => AsyncGenerator<Y, R, N>;
 /**
  * Is the value an asynchronous plan?
  *
@@ -14,13 +28,41 @@ export declare function isAsyncGenerator(value: unknown): value is () => AsyncGe
  * @returns `true` if the value is an asynchronous plan, otherwise `false`
  */
 export declare function isAsyncPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is AsyncPlan<Yielded, Returned, Parameters>;
+/**
+ * Is the value an asynchronous step?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous step, otherwise `false`
+ */
+export declare function isAsyncStep<Value = unknown>(value: unknown): value is AsyncStep<Value>;
+/**
+ * Is the value an asynchronous, immediately successful plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous, immediately successful plan, otherwise `false`
+ */
+export declare function isAsyncSuccess<Value = unknown>(value: unknown): value is AsyncSuccess<Value>;
+/**
+ * Is the value an immediately failing plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an immediately failing plan, otherwise `false`
+ */
+export declare function isFailure<Value = unknown>(value: unknown): value is Failure<Value>;
+/**
+ * Is the value a generator?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a generator, otherwise `false`
+ */
+export declare function isGenerator<Y = unknown, R = unknown, N = unknown>(value: unknown): value is Generator<Y, R, N>;
 /**
  * Is the value a generator function?
  *
  * @param value Value to check
  * @returns `true` if the value is a generator function, otherwise `false`
  */
-export declare function isGenerator(value: unknown): value is () => Generator;
+export declare function isGeneratorFunction<Y = unknown, R = unknown, N = unknown>(value: unknown): value is () => Generator<Y, R, N>;
 /**
  * Is the value a plan?
  *
@@ -28,4 +70,18 @@ export declare function isGenerator(value: unknown): value is () => Generator;
  * @returns `true` if the value is a plan, otherwise `false`
  */
 export declare function isPlan<Yielded = unknown, Returned = unknown, Parameters extends unknown[] = unknown[]>(value: unknown): value is Plan<Yielded, Returned, Parameters>;
+/**
+ * Is the value a step?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a step, otherwise `false`
+ */
+export declare function isStep<Value = unknown>(value: unknown): value is Step<Value>;
+/**
+ * Is the value an immediately successful plan?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an immediately successful plan, otherwise `false`
+ */
+export declare function isSuccess<Value = unknown>(value: unknown): value is Success<Value>;
 //#endregion

package/dist/plan/is.mjs

@@ -1,13 +1,31 @@
-import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../models/plan.model.mjs";
+import { GENERATOR_FUNCTION_TYPE_ASYNC, GENERATOR_FUNCTION_TYPE_SYNC, GENERATOR_TYPE_ASYNC, GENERATOR_TYPE_SYNC, PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC } from "../models/plan.model.mjs";
 //#region src/plan/is.ts
 /**
+* Is the value an asynchronous, immediately failing plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous, immediately failing plan, otherwise `false`
+*/
+function isAsyncFailure(value) {
+	return isPlanInstance(PLAN_FAILURE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous generator?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_TYPE_ASYNC, value);
+}
+/**
 * Is the value an asynchronous generator function?
 *
 * @param value Value to check
 * @returns `true` if the value is an asynchronous generator function, otherwise `false`
 */
-function isAsyncGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
+function isAsyncGeneratorFunction(value) {
+	return isGeneratorInstance(GENERATOR_FUNCTION_TYPE_ASYNC, value);
 }
 /**
 * Is the value an asynchronous plan?
@@ -16,7 +34,43 @@ function isAsyncGenerator(value) {
 * @returns `true` if the value is an asynchronous plan, otherwise `false`
 */
 function isAsyncPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+	return isPlanInstance(PLAN_TYPE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous step?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous step, otherwise `false`
+*/
+function isAsyncStep(value) {
+	return isPlanInstance(PLAN_STEP_ASYNC, value);
+}
+/**
+* Is the value an asynchronous, immediately successful plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous, immediately successful plan, otherwise `false`
+*/
+function isAsyncSuccess(value) {
+	return isPlanInstance(PLAN_SUCCESS_ASYNC, value);
+}
+/**
+* Is the value an immediately failing plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an immediately failing plan, otherwise `false`
+*/
+function isFailure(value) {
+	return isPlanInstance(PLAN_FAILURE_SYNC, value);
+}
+/**
+* Is the value a generator?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator, otherwise `false`
+*/
+function isGenerator(value) {
+	return isGeneratorInstance(GENERATOR_TYPE_SYNC, value);
 }
 /**
 * Is the value a generator function?
@@ -24,11 +78,11 @@ function isAsyncPlan(value) {
 * @param value Value to check
 * @returns `true` if the value is a generator function, otherwise `false`
 */
-function isGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_SYNC, value);
+function isGeneratorFunction(value) {
+	return isGeneratorInstance(GENERATOR_FUNCTION_TYPE_SYNC, value);
 }
-function isGeneratorInstance(name, value) {
-	return typeof value === "function" && value !== null && value.constructor.name === name && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
+function isGeneratorInstance(type, value) {
+	return Object.prototype.toString.call(value) === type;
 }
 /**
 * Is the value a plan?
@@ -37,10 +91,28 @@ function isGeneratorInstance(name, value) {
 * @returns `true` if the value is a plan, otherwise `false`
 */
 function isPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
+	return isPlanInstance(PLAN_TYPE_SYNC, value);
 }
 function isPlanInstance(type, value) {
 	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
 }
+/**
+* Is the value a step?
+*
+* @param value Value to check
+* @returns `true` if the value is a step, otherwise `false`
+*/
+function isStep(value) {
+	return isPlanInstance(PLAN_STEP_SYNC, value);
+}
+/**
+* Is the value an immediately successful plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an immediately successful plan, otherwise `false`
+*/
+function isSuccess(value) {
+	return isPlanInstance(PLAN_SUCCESS_SYNC, value);
+}
 //#endregion
-export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };
+export { isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncPlan, isAsyncStep, isAsyncSuccess, isFailure, isGenerator, isGeneratorFunction, isPlan, isStep, isSuccess };