@oscarpalmer/atoms 0.210.0 → 0.212.0

package/dist/index.mjs

@@ -2737,7 +2737,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: +nextPath + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -2765,6 +2765,7 @@ const PLAN_TYPE_PLAN_SYNC = "plan";
 */
 function fail(reason) {
 	return (function* () {
+		yield;
 		throw reason;
 	})();
 }
@@ -2818,33 +2819,14 @@ function isPlanInstance(type, value) {
 */
 function succeed(value) {
 	return (function* () {
+		yield;
 		return value;
 	})();
 }
 //#endregion
-//#region src/plan/index.ts
-function AsyncPlan(generator) {
-	this[PLAN_SYMBOL] = {
-		generator,
-		type: PLAN_TYPE_PLAN_ASYNC
-	};
-}
-AsyncPlan.prototype[Symbol.asyncIterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-AsyncPlan.prototype.run = runAsyncPlan;
-function Plan(generator) {
-	this[PLAN_SYMBOL] = {
-		generator,
-		type: PLAN_TYPE_PLAN_SYNC
-	};
-}
-Plan.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-Plan.prototype.run = runPlan;
-async function asyncExecute(callback) {
-	const generator = callback();
+//#region src/plan/generate.ts
+async function asyncGenerate(callback, parameters) {
+	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
 	try {
@@ -2853,6 +2835,7 @@ async function asyncExecute(callback) {
 			const { done } = next;
 			let { value } = next;
 			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
 			lastValue = value;
 			if (done === true) break;
 		}
@@ -2860,21 +2843,22 @@ async function asyncExecute(callback) {
 		lastValue = error;
 		success = false;
 	} finally {
-		generator?.return(lastValue);
+		await generator?.return(lastValue);
 	}
 	if (success) return lastValue;
 	throw lastValue;
 }
-function execute(callback) {
-	const generator = callback();
+function generate(callback, parameters) {
+	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
 	try {
 		while (true) {
 			const next = generator.next(lastValue);
 			const done = next.done === true;
-			let { value } = next;
+			const { value } = next;
 			if (value instanceof Error) throw value;
+			if (isError(value)) throw value.error;
 			lastValue = value;
 			if (done) break;
 		}
@@ -2887,22 +2871,74 @@ function execute(callback) {
 	if (success) return lastValue;
 	throw lastValue;
 }
-function plan(generator) {
-	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
-	if (isGenerator(generator)) return new Plan(generator);
-	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
+//#endregion
+//#region src/plan/result.ts
+function asyncAttemptRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.attempt(...parameters);
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters));
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function run(input) {
-	if (isAsyncPlan(input) || isPlan(input)) return input.run();
-	if (isAsyncGenerator(input)) return asyncExecute(input);
-	if (isGenerator(input)) return execute(input);
+function attemptRun(input, ...parameters) {
+	if (isPlan(input)) return input.attempt(...parameters);
+	if (isGenerator(input)) return attempt(() => generate(input, parameters));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
-function runAsyncPlan() {
-	return asyncExecute(this[PLAN_SYMBOL].generator);
+function attemptRunAsyncPlan(...parameters) {
+	return asyncAttempt(() => this.run(...parameters));
 }
-function runPlan() {
-	return execute(this[PLAN_SYMBOL].generator);
+function attemptRunPlan(...parameters) {
+	return attempt(() => this.run(...parameters));
+}
+attemptRun.async = asyncAttemptRun;
+//#endregion
+//#region src/plan/run.ts
+function asyncRun(input, ...parameters) {
+	if (isAsyncPlan(input)) return input.run(...parameters);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function run(input, ...parameters) {
+	if (isPlan(input)) return input.run(...parameters);
+	if (isGenerator(input)) return generate(input, parameters);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function runAsyncPlan(...parameters) {
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL].generator, parameters);
+}
+asyncRun.attempt = asyncAttemptRun;
+run.async = asyncRun;
+run.attempt = attemptRun;
+//#endregion
+//#region src/plan/index.ts
+function AsyncPlan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_ASYNC
+	};
+}
+AsyncPlan.prototype[Symbol.asyncIterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
+AsyncPlan.prototype.run = runAsyncPlan;
+function Plan(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_TYPE_PLAN_SYNC
+	};
+}
+Plan.prototype[Symbol.iterator] = function() {
+	return this[PLAN_SYMBOL].generator();
+};
+Plan.prototype.attempt = attemptRunPlan;
+Plan.prototype.run = runPlan;
+function plan(generator) {
+	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
+	if (isGenerator(generator)) return new Plan(generator);
+	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
 //#region src/internal/aborter.ts
@@ -4811,10 +4847,20 @@ const beaconSubscription = {
 	value: SUBSCRIPTION_NAME
 };
 //#endregion
-//#region src/internal/herald.ts
+//#region src/internal/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
+//#region src/internal/herald.ts
 function Events(herald, state) {
 	for (const key of state.keys) Object.defineProperty(this, key, { value: (callback, signal) => herald.subscribe(key, callback, signal) });
 }
@@ -4901,7 +4947,7 @@ function isHeraldEvents(value) {
 	return isHeraldInstance(HERALD_NAME_EVENTS, value);
 }
 function isHeraldInstance(name, value) {
-	return typeof value === "object" && value !== null && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
+	return typeof value === "object" && value !== null && "$herald" in value && value["$herald"] === name;
 }
 /**
 * Is the value a herald subscription?
@@ -4910,7 +4956,7 @@ function isHeraldInstance(name, value) {
 * @returns `true` if the value is a herald subscription, otherwise `false`
 */
 function isHeraldSubscription(value) {
-	return isSubscription(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === "subscription";
+	return isSubscription(value) && "$herald" in value && value["$herald"] === "subscription";
 }
 function subscribeToHerald(key, callback, signal) {
 	const { state } = this[HERALD_SYMBOL];
@@ -4922,14 +4968,6 @@ function subscribeToHerald(key, callback, signal) {
 	if (!existing) state.onCreate?.(key, callback, subscription);
 	return subscription;
 }
-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_SYMBOL = Symbol(HERALD_PROPERTY);
-const heraldSubscription = {
-	key: HERALD_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
 //#endregion
 //#region src/color/constants.ts
 const COLOR_ALPHA = {
@@ -7005,4 +7043,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, fail, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };

package/dist/internal/aborter.d.mts

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

package/dist/internal/herald.d.mts

@@ -1,43 +1,7 @@
 import { GenericCallback } from "../models.mjs";
-import { Subscription, SubscriptionProperty } from "./subscription.mjs";
+import { Subscription } from "./subscription.mjs";
+import { Herald, HeraldEvents, HeraldOptions } from "./models/herald.model.mjs";
 //#region src/internal/herald.d.ts
-export type Herald<Events extends Record<string, GenericCallback>> = {
-  readonly events: HeraldEvents<Events>;
-  /**
-   * Remove all event subscribers
-   */
-  clear(): void;
-  /**
-   * Emit an event with parameters
-   *
-   * @param event Event name
-   * @param parameters Event parameters
-   */
-  emit<Event extends keyof Events>(event: Event, ...parameters: Parameters<Events[Event]>): void;
-  /**
-   * Is the event observed by any subscribers?
-   *
-   * @param event Event name
-   * @returns `true` if the event is observed, otherwise `false`
-   */
-  observed<Event extends keyof Events>(event: Event): boolean;
-  /**
-   * Subscribe to an event with a callback
-   *
-   * @param event Event name
-   * @param callback Callback function
-   * @param signal Optional abort signal to cancel the subscription
-   * @returns Subscription instance
-   */
-  subscribe<Event extends keyof Events>(event: Event, callback: Events[Event], signal?: AbortSignal): Subscription;
-};
-export type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends "*" ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
-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>;
-};
 /**
  * Create a _Herald_ for announcing named events
  *

package/dist/internal/herald.mjs

@@ -1,9 +1,7 @@
 import { isPlainObject } from "./is.mjs";
-import { SUBSCRIPTION_NAME, isSubscription, subscriptions } from "./subscription.mjs";
+import { isSubscription, subscriptions } from "./subscription.mjs";
+import { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_MESSAGE_PROPERTY, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_PROPERTY, HERALD_SYMBOL, heraldSubscription } from "./models/herald.model.mjs";
 //#region src/internal/herald.ts
-const HERALD_NAME_EVENTS = "events";
-const HERALD_NAME_HERALD = "herald";
-const HERALD_PROPERTY = "$herald";
 function Events(herald, state) {
 	for (const key of state.keys) Object.defineProperty(this, key, { value: (callback, signal) => herald.subscribe(key, callback, signal) });
 }
@@ -91,7 +89,7 @@ function isHeraldEvents(value) {
 	return isHeraldInstance(HERALD_NAME_EVENTS, value);
 }
 function isHeraldInstance(name, value) {
-	return typeof value === "object" && value !== null && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
+	return typeof value === "object" && value !== null && "$herald" in value && value["$herald"] === name;
 }
 /**
 * Is the value a herald subscription?
@@ -100,7 +98,7 @@ function isHeraldInstance(name, value) {
 * @returns `true` if the value is a herald subscription, otherwise `false`
 */
 function isHeraldSubscription(value) {
-	return isSubscription(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === "subscription";
+	return isSubscription(value) && "$herald" in value && value["$herald"] === "subscription";
 }
 function subscribeToHerald(key, callback, signal) {
 	const { state } = this[HERALD_SYMBOL];
@@ -112,13 +110,5 @@ function subscribeToHerald(key, callback, signal) {
 	if (!existing) state.onCreate?.(key, callback, subscription);
 	return subscription;
 }
-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_SYMBOL = Symbol(HERALD_PROPERTY);
-const heraldSubscription = {
-	key: HERALD_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
 //#endregion
 export { herald, isHerald, isHeraldEvents, isHeraldSubscription };

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

@@ -0,0 +1,60 @@
+import { GenericCallback } from "../../models.mjs";
+import { Subscription, SubscriptionProperty, Subscriptions } from "../subscription.mjs";
+//#region src/internal/models/herald.model.d.ts
+export type Herald<Events extends Record<string, GenericCallback>> = {
+  readonly events: HeraldEvents<Events>;
+  /**
+   * Remove all event subscribers
+   */
+  clear(): void;
+  /**
+   * Emit an event with parameters
+   *
+   * @param event Event name
+   * @param parameters Event parameters
+   */
+  emit<Event extends keyof Events>(event: Event, ...parameters: Parameters<Events[Event]>): void;
+  /**
+   * Is the event observed by any subscribers?
+   *
+   * @param event Event name
+   * @returns `true` if the event is observed, otherwise `false`
+   */
+  observed<Event extends keyof Events>(event: Event): boolean;
+  /**
+   * Subscribe to an event with a callback
+   *
+   * @param event Event name
+   * @param callback Callback function
+   * @param signal Optional abort signal to cancel the subscription
+   * @returns Subscription instance
+   */
+  subscribe<Event extends keyof Events>(event: Event, callback: Events[Event], signal?: AbortSignal): Subscription;
+};
+export type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends "*" ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
+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 = {
+  keys: Set<string>;
+  store: Subscriptions<GenericCallback>;
+  onCreate?: HeraldOnCreate<Record<string, GenericCallback>>;
+};
+export type InternalHerald = {
+  [HERALD_SYMBOL]: {
+    events: HeraldEvents<Record<string, GenericCallback>>;
+    state: HeraldState;
+  };
+} & Herald<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

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

@@ -0,0 +1,15 @@
+import { SUBSCRIPTION_NAME } from "../subscription.mjs";
+//#region src/internal/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 };

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

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

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

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

package/dist/internal/plan.d.mts

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

package/dist/internal/plan.mjs

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

package/dist/internal/subscription.d.mts

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

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

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

package/dist/internal/value/set.mjs

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

package/dist/models.d.mts

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

package/dist/plan/generate.d.mts

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