@oscarpalmer/atoms 0.221.0 → 0.223.0

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

@@ -1,5 +1,4 @@
-import { Subscription, SubscriptionProperty, Subscriptions } from "./subscription.model.mjs";
-//#region src/models/beacon.model.d.ts
+import { Subscription, Subscriptions } from "./subscription.model.mjs";
 /**
  * A beacon is a lighthouse, holding an observable value that can be subscribed to and emitted from
  */
@@ -55,6 +54,7 @@ export type BeaconState<Value> = {
   observable?: Observable<Value>;
   options: Required<BeaconOptions<Value>>;
   subscriptions?: Subscriptions<Observer<unknown>>;
+  name: typeof BEACON_NAME;
   value: Value;
 };
 export type InternalBeacon = {
@@ -92,6 +92,7 @@ export type Observable<Value> = {
 export type ObservableState<Value> = {
   active: boolean;
   beacon: BeaconState<Value>;
+  name: typeof BEACON_OBSERVABLE;
 };
 export type Observer<Value> = {
   /**
@@ -109,11 +110,8 @@ export type Observer<Value> = {
 };
 export declare const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 export declare const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-export declare const BEACON_PROPERTY = "$beacon";
 export declare const BEACON_NAME = "beacon";
 export declare const BEACON_OBSERVABLE = "observable";
 export declare const BEACON_SYMBOL: unique symbol;
 export declare const BEACON_TYPE_ERROR = "error";
-export declare const BEACON_TYPE_NEXT = "next";
-export declare const beaconSubscription: SubscriptionProperty;
-//#endregion
+export declare const BEACON_TYPE_NEXT = "next";

package/dist/models/beacon.model.mjs

@@ -1,16 +1,9 @@
-import { SUBSCRIPTION_NAME } from "./subscription.model.mjs";
-//#region src/models/beacon.model.ts
+// src/models/beacon.model.ts
 const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-const BEACON_PROPERTY = "$beacon";
 const BEACON_NAME = "beacon";
 const BEACON_OBSERVABLE = "observable";
-const BEACON_SYMBOL = Symbol(BEACON_PROPERTY);
+const BEACON_SYMBOL = Symbol("beacon");
 const BEACON_TYPE_ERROR = "error";
 const BEACON_TYPE_NEXT = "next";
-const beaconSubscription = {
-	key: BEACON_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
-//#endregion
-export { BEACON_MESSAGE_RETRIEVE, BEACON_MESSAGE_SUBSCRIBE, BEACON_NAME, BEACON_OBSERVABLE, BEACON_PROPERTY, BEACON_SYMBOL, BEACON_TYPE_ERROR, BEACON_TYPE_NEXT, beaconSubscription };
+export { BEACON_MESSAGE_RETRIEVE, BEACON_MESSAGE_SUBSCRIBE, BEACON_NAME, BEACON_OBSERVABLE, BEACON_SYMBOL, BEACON_TYPE_ERROR, BEACON_TYPE_NEXT };

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

@@ -1,7 +1,6 @@
-import { Subscription } from "./subscription.model.mjs";
-import { Herald, HeraldEvents } from "./herald.model.mjs";
 import { COLOR_SYMBOL } from "../color/constants.mjs";
-//#region src/models/color.model.d.ts
+import { Herald, HeraldEvents } from "./herald.model.mjs";
+import { Subscription } from "./subscription.model.mjs";
 export type Alpha = {
   hex: string;
   value: number;
@@ -307,5 +306,4 @@ export type ColorValue = string | HSLColor | HWBColor | RGBColor;
  * Extended color values
  */
 export type ColorValueExtended = ColorValue | HSLAColor | HWBAColor | RGBAColor;
-//#endregion
 export {};

package/dist/models/function/assert.model.d.mts

@@ -1,5 +1,4 @@
 import { NestedKeys, PlainObject } from "../index.mjs";
-//#region src/models/function/assert.model.d.ts
 export type AssertNestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: AssertNestedPick<Value[Key], Rest>; } : never : Path extends keyof Value ? { [Key in Path]: Value[Key]; } : never : never;
 /**
  * Asserter for a property of a value
@@ -9,5 +8,4 @@ export type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Va
  * A function that asserts a value is of a specific type, throwing an error if it is not
  */
 export type Asserter<Value> = (value: unknown) => asserts value is Value;
-export declare const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
-//#endregion
+export declare const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";

package/dist/models/function/assert.model.mjs

@@ -1,4 +1,3 @@
-//#region src/models/function/assert.model.ts
+// src/models/function/assert.model.ts
 const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
-//#endregion
 export { ASSERT_MESSAGE_VALUE_DEFINED };

package/dist/models/function/limiter.model.d.mts

@@ -1,5 +1,4 @@
 import { GenericAsyncCallback, GenericCallback } from "../index.mjs";
-//#region src/models/function/limiter.model.d.ts
 export type AsyncLimiterItem = {
   parameters: unknown[];
   promise: Promise<unknown>;
@@ -51,6 +50,7 @@ export type Limiter<Callback extends GenericCallback> = {
 export type LimiterState<Callback = GenericCallback> = {
   callback: Callback;
   interval: number;
+  name: string;
   parameters: unknown[];
   start?: number;
   throttle: boolean;
@@ -61,11 +61,9 @@ export type LimiterType = "debounce" | "throttle" | "wait";
 export declare const LIMITER_DEBOUNCE: LimiterType;
 export declare const LIMITER_NAME_ASYNC = "asyncLimiter";
 export declare const LIMITER_NAME_SYNC = "limiter";
-export declare const LIMITER_PROPERTY = "$limiter";
 export declare const LIMITER_OFFSET = 5;
 export declare const LIMITER_SYMBOL: unique symbol;
 export declare const LIMITER_THROTTLE: LimiterType;
 export declare const LIMITER_WAIT: LimiterType;
 export declare const clearTimer: (handle: number) => void;
-export declare const startTimer: (callback: FrameRequestCallback) => number;
-//#endregion
+export declare const startTimer: (callback: FrameRequestCallback) => number;

package/dist/models/function/limiter.model.mjs

@@ -1,8 +1,7 @@
-//#region src/models/function/limiter.model.ts
+// src/models/function/limiter.model.ts
 const LIMITER_DEBOUNCE = "debounce";
 const LIMITER_NAME_ASYNC = "asyncLimiter";
 const LIMITER_NAME_SYNC = "limiter";
-const LIMITER_PROPERTY = "$limiter";
 const LIMITER_OFFSET = 5;
 const LIMITER_SYMBOL = Symbol("limiter");
 const LIMITER_THROTTLE = "throttle";
@@ -11,5 +10,4 @@ const LIMITER_WAIT = "wait";
 const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
 // istanbul ignore next
 const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
-//#endregion
-export { LIMITER_DEBOUNCE, LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_OFFSET, LIMITER_PROPERTY, LIMITER_SYMBOL, LIMITER_THROTTLE, LIMITER_WAIT, clearTimer, startTimer };
+export { LIMITER_DEBOUNCE, LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_OFFSET, LIMITER_SYMBOL, LIMITER_THROTTLE, LIMITER_WAIT, clearTimer, startTimer };

package/dist/models/function/memoize.model.d.mts

@@ -1,6 +1,5 @@
-import { GenericCallback } from "../index.mjs";
 import { SizedMap } from "../../internal/sized/map.mjs";
-//#region src/models/function/memoize.model.d.ts
+import { GenericCallback } from "../index.mjs";
 export type InternalMemoized = {
   [MEMOIZED_SYMBOL]: MemoizedState;
 } & Memoized<GenericCallback>;
@@ -84,5 +83,4 @@ export type MemoizedStateOptions = {
 export declare const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
 export declare const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 export declare const MEMOIZED_KEY_SEPARATOR = "_";
-export declare const MEMOIZED_SYMBOL: unique symbol;
-//#endregion
+export declare const MEMOIZED_SYMBOL: unique symbol;

package/dist/models/function/memoize.model.mjs

@@ -1,7 +1,6 @@
-//#region src/models/function/memoize.model.ts
+// src/models/function/memoize.model.ts
 const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
 const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 const MEMOIZED_KEY_SEPARATOR = "_";
 const MEMOIZED_SYMBOL = Symbol("memoized");
-//#endregion
 export { MEMOIZED_CACHE_SIZE_DEFAULT, MEMOIZED_CALLBACK, MEMOIZED_KEY_SEPARATOR, MEMOIZED_SYMBOL };

package/dist/models/function/once.model.d.mts

@@ -1,5 +1,4 @@
 import { GenericAsyncCallback, GenericCallback } from "../index.mjs";
-//#region src/models/function/once.model.d.ts
 /**
  * An asynchronous function that can only be called once, returning the same value on subsequent calls
  */
@@ -69,9 +68,7 @@ export type OnceState<Value, Callback = GenericCallback> = {
 };
 export declare const ONCE_NAME_ASYNC = "asyncOnce";
 export declare const ONCE_NAME_SYNC = "once";
-export declare const ONCE_PROPERTY = "$once";
 export declare const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 export declare const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
 export declare const ONCE_SYMBOL: unique symbol;
-//#endregion
 export {};

package/dist/models/function/once.model.mjs

@@ -1,9 +1,7 @@
-//#region src/models/function/once.model.ts
+// src/models/function/once.model.ts
 const ONCE_NAME_ASYNC = "asyncOnce";
 const ONCE_NAME_SYNC = "once";
-const ONCE_PROPERTY = "$once";
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
-const ONCE_SYMBOL = Symbol(ONCE_PROPERTY);
-//#endregion
-export { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_PROPERTY, ONCE_SYMBOL };
+const ONCE_SYMBOL = Symbol("once");
+export { ONCE_MESSAGE_CLEARED, ONCE_MESSAGE_EXPECTATION, ONCE_NAME_ASYNC, ONCE_NAME_SYNC, ONCE_SYMBOL };

package/dist/models/function/retry.model.d.mts

@@ -1,4 +1,3 @@
-//#region src/models/function/retry.model.d.ts
 /**
  * An error thrown when a retry fails
  */
@@ -13,5 +12,4 @@ export type RetryOptions = {
 };
 export declare const RETRY_ERROR_NAME = "RetryError";
 export declare const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
-export declare const RETRY_MESSAGE_FAILED = "Retry failed";
-//#endregion
+export declare const RETRY_MESSAGE_FAILED = "Retry failed";

package/dist/models/function/retry.model.mjs

@@ -1,4 +1,4 @@
-//#region src/models/function/retry.model.ts
+// src/models/function/retry.model.ts
 /**
 * An error thrown when a retry fails
 */
@@ -13,5 +13,4 @@ var RetryError = class extends Error {
 const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
-//#endregion
 export { RETRY_ERROR_NAME, RETRY_MESSAGE_EXPECTATION, RETRY_MESSAGE_FAILED, RetryError };

package/dist/models/function/work.model.d.mts

@@ -1,7 +1,6 @@
 import { GenericCallback } from "../index.mjs";
-import { Asserter } from "./assert.model.mjs";
 import { UnwrapValue } from "../result.model.mjs";
-//#region src/models/function/work.model.d.ts
+import { Asserter } from "./assert.model.mjs";
 /**
  * An asynchronous _Flow_, a function that pipes a value through a series of functions
  */
@@ -16,5 +15,4 @@ export declare const WORK_MESSAGE_NESTING = "Return values are too deeply nested
 export declare const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
 export declare const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
 export declare const assertFlowFunctions: Asserter<Function[]>;
-export declare const assertPipeFunctions: Asserter<Function[]>;
-//#endregion
+export declare const assertPipeFunctions: Asserter<Function[]>;

package/dist/models/function/work.model.mjs

@@ -1,5 +1,5 @@
 import { assert } from "../../internal/function/assert.mjs";
-//#region src/models/function/work.model.ts
+// src/models/function/work.model.ts
 const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
 const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
 const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
@@ -7,5 +7,4 @@ const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions"
 const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
 const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_FLOW_ARRAY, TypeError);
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
-//#endregion
 export { WORK_MESSAGE_FLOW_ARRAY, WORK_MESSAGE_FLOW_PROMISE, WORK_MESSAGE_NESTING, WORK_MESSAGE_PIPE_ARRAY, WORK_MESSAGE_PIPE_PROMISE, assertFlowFunctions, assertPipeFunctions };

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

@@ -1,6 +1,5 @@
 import { GenericCallback } from "./index.mjs";
-import { Subscription, SubscriptionProperty, Subscriptions } from "./subscription.model.mjs";
-//#region src/models/herald.model.d.ts
+import { Subscription, Subscriptions } from "./subscription.model.mjs";
 export type Herald<Events extends Record<string, GenericCallback>> = {
   readonly events: HeraldEvents<Events>;
   /**
@@ -35,7 +34,6 @@ export type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Ke
 export type HeraldOnCreate<Events extends Record<string, GenericCallback>> = <Event extends keyof Events>(event: Event, callback: Events[Event], subscription: Subscription) => void;
 export type HeraldOptions<Events extends Record<string, GenericCallback>> = {
   names: Array<keyof Events>;
-  property?: SubscriptionProperty;
   onCreate?: HeraldOnCreate<Events>;
 };
 export type HeraldState = {
@@ -46,15 +44,18 @@ export type HeraldState = {
 export type InternalHerald = {
   [HERALD_SYMBOL]: {
     events: HeraldEvents<Record<string, GenericCallback>>;
+    name: typeof HERALD_NAME_HERALD;
     state: HeraldState;
   };
 } & Herald<Record<string, GenericCallback>>;
+export type InternalHeraldEvents = {
+  [HERALD_SYMBOL]: {
+    name: typeof HERALD_NAME_EVENTS;
+  };
+} & HeraldEvents<Record<string, GenericCallback>>;
 export declare const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
 export declare const HERALD_MESSAGE_ONCREATE = "Herald requires a valid onCreate callback for subscription creation";
 export declare const HERALD_MESSAGE_PROPERTY = "Herald requires valid property information for subscription identification";
 export declare const HERALD_NAME_EVENTS = "events";
 export declare const HERALD_NAME_HERALD = "herald";
-export declare const HERALD_PROPERTY = "$herald";
-export declare const HERALD_SYMBOL: unique symbol;
-export declare const heraldSubscription: SubscriptionProperty;
-//#endregion
+export declare const HERALD_SYMBOL: unique symbol;

package/dist/models/herald.model.mjs

@@ -1,15 +1,8 @@
-import { SUBSCRIPTION_NAME } from "./subscription.model.mjs";
-//#region src/models/herald.model.ts
+// src/models/herald.model.ts
 const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
 const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for subscription creation`;
 const HERALD_MESSAGE_PROPERTY = `Herald requires valid property information for subscription identification`;
 const HERALD_NAME_EVENTS = "events";
 const HERALD_NAME_HERALD = "herald";
-const HERALD_PROPERTY = "$herald";
-const HERALD_SYMBOL = Symbol(HERALD_PROPERTY);
-const heraldSubscription = {
-	key: HERALD_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
-//#endregion
-export { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_MESSAGE_PROPERTY, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_PROPERTY, HERALD_SYMBOL, heraldSubscription };
+const HERALD_SYMBOL = Symbol("herald");
+export { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_MESSAGE_PROPERTY, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_SYMBOL };

package/dist/models/index.d.mts

@@ -1,4 +1,3 @@
-//#region src/models/index.d.ts
 /**
  * A generic array or object
  */
@@ -124,5 +123,4 @@ export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUn
  * A function that unsubscribes from a subscription
  */
 export type Unsubscriber = () => void;
-//#endregion
 export {};

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

@@ -1,4 +1,3 @@
-//#region src/models/logger.model.d.ts
 export type InternalTimeLogger = {
   [LOGGER_SYMBOL]: TimeLoggerState;
 } & TimeLogger;
@@ -78,6 +77,4 @@ export type TimeLoggerState = {
 };
 export declare const LOGGER_NAME = "Logger";
 export declare const LOGGER_NAME_TIMED = "TimedLogger";
-export declare const LOGGER_PROPERTY = "$logger";
-export declare const LOGGER_SYMBOL: unique symbol;
-//#endregion
+export declare const LOGGER_SYMBOL: unique symbol;

package/dist/models/logger.model.mjs

@@ -1,7 +1,5 @@
-//#region src/models/logger.model.ts
+// src/models/logger.model.ts
 const LOGGER_NAME = "Logger";
 const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
-const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
-//#endregion
-export { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_PROPERTY, LOGGER_SYMBOL };
+const LOGGER_SYMBOL = Symbol("logger");
+export { LOGGER_NAME, LOGGER_NAME_TIMED, LOGGER_SYMBOL };

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

@@ -1,4 +1,3 @@
-//#region src/models/math.model.d.ts
 export type Aggregation = {
   array: boolean;
   count: number;
@@ -12,5 +11,4 @@ export type NonAverageAggregationType = "max" | "min" | "sum";
 export declare const AGGREGATION_AVERAGE = "average";
 export declare const AGGREGATION_MAX = "max";
 export declare const AGGREGATION_MIN = "min";
-export declare const AGGREGATION_SUM = "sum";
-//#endregion
+export declare const AGGREGATION_SUM = "sum";

package/dist/models/math.model.mjs

@@ -1,7 +1,6 @@
-//#region src/models/math.model.ts
+// src/models/math.model.ts
 const AGGREGATION_AVERAGE = "average";
 const AGGREGATION_MAX = "max";
 const AGGREGATION_MIN = "min";
 const AGGREGATION_SUM = "sum";
-//#endregion
 export { AGGREGATION_AVERAGE, AGGREGATION_MAX, AGGREGATION_MIN, AGGREGATION_SUM };

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

@@ -1,4 +1,3 @@
-//#region src/models/misc.model.d.ts
 export declare const EXPRESSION_INTEGER: RegExp;
 export declare const EXPRESSION_NUMBER_BINARY: RegExp;
 export declare const EXPRESSION_NUMBER_OCTAL: RegExp;
@@ -6,5 +5,4 @@ export declare const EXPRESSION_NUMBER_ZEROISH: RegExp;
 export declare const EXPRESSION_NUMERICAL_PREFIX: RegExp;
 export declare const EXPRESSION_WHITESPACE_MULTIPLE: RegExp;
 export declare const EXPRESSION_WHITESPACE_ONLY: RegExp;
-export declare const NUMBER_OCTAL_VALUE = 8;
-//#endregion
+export declare const NUMBER_OCTAL_VALUE = 8;

package/dist/models/misc.model.mjs

@@ -1,4 +1,4 @@
-//#region src/models/misc.model.ts
+// src/models/misc.model.ts
 const EXPRESSION_INTEGER = /^\d+$/;
 const EXPRESSION_NUMBER_BINARY = /^0b[01]+$/i;
 const EXPRESSION_NUMBER_OCTAL = /^0o[0-7]+$/i;
@@ -7,5 +7,4 @@ const EXPRESSION_NUMERICAL_PREFIX = /^\d/;
 const EXPRESSION_WHITESPACE_MULTIPLE = /\s+/g;
 const EXPRESSION_WHITESPACE_ONLY = /^\s*$/;
 const NUMBER_OCTAL_VALUE = 8;
-//#endregion
 export { EXPRESSION_INTEGER, EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZEROISH, EXPRESSION_NUMERICAL_PREFIX, EXPRESSION_WHITESPACE_MULTIPLE, EXPRESSION_WHITESPACE_ONLY, NUMBER_OCTAL_VALUE };

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

@@ -1,5 +1,4 @@
 import { Err, Ok, Result } from "./result.model.mjs";
-//#region src/models/plan.model.d.ts
 /**
  * An immediately failing asynchronous plan
  */
@@ -11,6 +10,10 @@ export type AsyncFailure<Value> = {
    */
   [Symbol.asyncIterator]: () => AsyncGenerator<Err<Value>, never>;
 };
+export type AsyncImmediateState = {
+  generator: () => AsyncGenerator;
+  type: typeof PLAN_FAILURE_ASYNC | typeof PLAN_SUCCESS_ASYNC;
+};
 /**
  * An asynchronous plan of execution that can yield intermediate results and eventually return a result
  */
@@ -28,23 +31,19 @@ export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  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>>>;
+  attempt: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>> : (signal?: AbortSignal) => Promise<Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
-   * @throws {PlanError<Yielded, Returned>}
+   * @throws {PlannedError<Yielded, Returned>}
    * @returns Result
    */
-  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlanReturned<Returned>> : (signal?: AbortSignal) => Promise<PlanReturned<Returned>>;
+  run: Parameters extends [infer _, ...(infer _)[]] ? (parameters: Parameters, signal?: AbortSignal) => Promise<PlannedReturned<Returned>> : (signal?: AbortSignal) => Promise<PlannedReturned<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 AsyncImmediate<Value, Error> = AsyncSuccess<Value> | AsyncFailure<Error>;
 export type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
   type: typeof PLAN_TYPE_ASYNC;
@@ -102,10 +101,19 @@ export type GenericPlanItem = {
 };
 export type GenericPlanItemState = {
   generator: () => AsyncGenerator | Generator;
-  type: PlanType | PlannedType | StepType;
+  type: PlanType | ImmediateType | StepType;
 };
+/**
+ * An immediately succeeding or failing plan
+ */
+export type Immediate<Value, Error> = Success<Value> | Failure<Error>;
+export type ImmediateState = {
+  generator: () => Generator;
+  type: typeof PLAN_FAILURE_SYNC | typeof PLAN_SUCCESS_SYNC;
+};
+export type ImmediateType = "asyncFailure" | "asyncSuccess" | "failure" | "success";
 export type InternalAsyncFailure = {
-  [PLAN_SYMBOL]: AsyncPlannedState;
+  [PLAN_SYMBOL]: AsyncImmediateState;
 } & AsyncFailure<never>;
 export type InternalAsyncPlan = {
   [PLAN_SYMBOL]: AsyncPlanState;
@@ -114,16 +122,16 @@ export type InternalAsyncStep = {
   [PLAN_SYMBOL]: AsyncStepState;
 } & AsyncStep<never>;
 export type InternalAsyncSuccess = {
-  [PLAN_SYMBOL]: AsyncPlannedState;
+  [PLAN_SYMBOL]: AsyncImmediateState;
 } & AsyncSuccess<never>;
 export type InternalFailure = {
-  [PLAN_SYMBOL]: PlannedState;
+  [PLAN_SYMBOL]: ImmediateState;
 } & Failure<never>;
 export type InternalPlan = {
   [PLAN_SYMBOL]: PlanState;
 } & Plan<never, never, unknown[]>;
 export type InternalSuccess = {
-  [PLAN_SYMBOL]: PlannedState;
+  [PLAN_SYMBOL]: ImmediateState;
 } & Success<never>;
 export type InternalStep = {
   [PLAN_SYMBOL]: StepState;
@@ -154,42 +162,33 @@ export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
+  attempt(...parameters: Parameters): Result<PlannedOk<Returned>, PlannedError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
-   * @throws {PlanError<Yielded, Returned>}
+   * @throws {PlannedError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): PlanReturned<Returned>;
+  run(...parameters: Parameters): PlannedReturned<Returned>;
+};
+export type PlanState = {
+  generator(...parameters: unknown[]): Generator;
+  type: typeof PLAN_TYPE_SYNC;
 };
-/**
- * An OK result of a plan execution
- */
-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>;
+export type PlannedError<Yielded, Returned> = [PlannedErrors<Yielded, Returned>] extends [never] ? Error : PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
+type PlannedErrors<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned>;
 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)_
+ * An OK result of a plan execution
  */
-export type PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
+export type PlannedOk<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned;
 /**
- * An immediately succeeding or failing plan
+ * The returned result of a plan execution _(excluding errors, which are thrown)_
  */
-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;
-  type: typeof PLAN_TYPE_SYNC;
-};
+export type PlannedReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
 /**
  * A single step within a plan of execution
  */
@@ -242,5 +241,4 @@ export declare const PLAN_SUCCESS_SYNC: "success";
 export declare const PLAN_SYMBOL: unique symbol;
 export declare const PLAN_TYPE_ASYNC: "asyncPlan";
 export declare const PLAN_TYPE_SYNC: "plan";
-//#endregion
 export {};

package/dist/models/plan.model.mjs

@@ -1,4 +1,4 @@
-//#region src/models/plan.model.ts
+// src/models/plan.model.ts
 const GENERATOR_FUNCTION_TYPE_ASYNC = "[object AsyncGeneratorFunction]";
 const GENERATOR_FUNCTION_TYPE_SYNC = "[object GeneratorFunction]";
 const GENERATOR_TYPE_ASYNC = "[object AsyncGenerator]";
@@ -16,5 +16,4 @@ const PLAN_SUCCESS_SYNC = "success";
 const PLAN_SYMBOL = Symbol("plan");
 const PLAN_TYPE_ASYNC = "asyncPlan";
 const PLAN_TYPE_SYNC = "plan";
-//#endregion
 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/promise.model.d.mts

@@ -1,7 +1,6 @@
 import { ArrayOrPlainObject, GenericCallback, Key } from "./index.mjs";
 import { Aborter } from "./aborter.model.mjs";
 import { Result } from "./result.model.mjs";
-//#region src/models/promise.model.d.ts
 /**
  * A _Promise_ that can be canceled
  */
@@ -65,12 +64,6 @@ export type PromiseParameters = {
  * - `first`: rejects on the first rejected _Promise_, and returns an array of values
  */
 export type PromiseStrategy = "complete" | "first";
-/**
- * An error thrown when a promise times out
- */
-export declare class PromiseTimeoutError extends Error {
-  constructor();
-}
 export type PromisesItems<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Promise<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Promise<Value> : Promise<Items[ItemsKey]>; };
 /**
  * Options for handling multiple _Promises_
@@ -102,11 +95,17 @@ export type RejectedPromise = {
    */
   reason: unknown;
 };
+/**
+ * An error thrown when a promise times out
+ */
+export declare class TimedError extends Error {
+  constructor();
+}
 export declare const PROMISE_ABORT_EVENT = "abort";
 export declare const PROMISE_ABORT_OPTIONS: {
   once: boolean;
 };
-export declare const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+export declare const PROMISE_ERROR_NAME = "TimedError";
 export declare const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
 export declare const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 export declare const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
@@ -115,5 +114,4 @@ export declare const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
 export declare const PROMISE_STRATEGY_ALL: Set<PromiseStrategy>;
 export declare const PROMISE_STRATEGY_DEFAULT: PromiseStrategy;
 export declare const PROMISE_TYPE_FULFILLED = "fulfilled";
-export declare const PROMISE_TYPE_REJECTED = "rejected";
-//#endregion
+export declare const PROMISE_TYPE_REJECTED = "rejected";

package/dist/models/promise.model.mjs

@@ -1,4 +1,4 @@
-//#region src/models/promise.model.ts
+// src/models/promise.model.ts
 /**
 * A _Promise_ that can be canceled
 */
@@ -25,7 +25,7 @@ var CancelablePromise = class extends Promise {
 /**
 * An error thrown when a promise times out
 */
-var PromiseTimeoutError = class extends Error {
+var TimedError = class extends Error {
 	constructor() {
 		super(PROMISE_MESSAGE_TIMEOUT);
 		this.name = PROMISE_ERROR_NAME;
@@ -33,7 +33,7 @@ var PromiseTimeoutError = class extends Error {
 };
 const PROMISE_ABORT_EVENT = "abort";
 const PROMISE_ABORT_OPTIONS = { once: true };
-const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+const PROMISE_ERROR_NAME = "TimedError";
 const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
 const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
@@ -43,5 +43,4 @@ const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
 const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
-//#endregion
-export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError };
+export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, TimedError };