@oscarpalmer/atoms 0.212.0 → 0.213.0

package/dist/color/instance.mjs

@@ -1,4 +1,3 @@
-import "../internal/subscription.mjs";
 import { herald } from "../internal/herald.mjs";
 import { COLOR_NAME, COLOR_PROPERTY, COLOR_SYMBOL, COLOR_TYPE, colorSubscription } from "./constants.mjs";
 import { getColorAlpha, setColorAlpha } from "./misc/alpha.mjs";

package/dist/index.d.mts

@@ -63,7 +63,7 @@ type _NestedValue<Value, Path extends string> = Path extends `${infer ItemKey}.$
 /**
  * The nested _(keyed)_ values of an object _(up to 5 levels deep)_
  */
-export type NestedValues<Value extends PlainObject> = { [Path in NestedKeys<Value>]: NestedValue<Value, Path>; };
+export type NestedValues<Value extends PlainObject> = Simplify<{ [Path in NestedKeys<Value>]: NestedValue<Value, Path>; }>;
 /**
  * The numerical keys of an object
  */
@@ -71,7 +71,7 @@ export type NumericalKeys<Value> = { [ItemKey in keyof Value]: ItemKey extends n
 /**
  * The numerical values of an object
  */
-export type NumericalValues<Item extends PlainObject> = { [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey]; };
+export type NumericalValues<Item extends PlainObject> = Simplify<{ [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey]; }>;
 /**
  * An asynchronous function that can only be called once, returning the same value on subsequent calls
  */
@@ -131,7 +131,7 @@ export type Primitive = null | undefined | string | number | boolean | symbol |
 /**
  * Set required keys for a type
  */
-export type RequiredKeys<Model extends object, Keys extends keyof Model> = Required<Pick<Model, Keys>> & Omit<Model, Keys>;
+export type RequiredKeys<Model extends object, Keys extends keyof Model> = Simplify<Required<Pick<Model, Keys>> & Omit<Model, Keys>>;
 /**
  * Flattens the type to improve type hints in IDEs
  *
@@ -4597,22 +4597,22 @@ type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Asynchronous generator
    */
-  [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
+  [Symbol.asyncIterator]: (...parameters: Parameters) => AsyncGenerator<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
+   * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+  attempt(...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): Promise<PlanResult<Returned>>;
+  run(...parameters: Parameters): Promise<PlanReturned<Returned>>;
 };
 /**
  * A plan of execution that can yield intermediate results and eventually return a result
@@ -4623,26 +4623,28 @@ type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Generator
    */
-  [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
+  [Symbol.iterator]: (...parameters: Parameters) => Generator<Yielded, Returned>;
   /**
    * Attempt to run the plan to completion
    *
    * _Returns a {@link Result} instead of a raw value or throwing an error_
    *
-   * @returns Result
+   * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+  attempt(...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): PlanResult<Returned>;
+  run(...parameters: Parameters): PlanReturned<Returned>;
 };
-type PlanErrorValues<Original> = Original extends Error ? Original : Original extends Err<infer Error> ? Error : Original extends Result<infer _, infer Error> ? Error : never;
-type PlanError<Yielded, Returned> = PlanErrorValues<Yielded> | PlanErrorValues<Returned> | Error;
-type PlanResult<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned extends Result<infer Value, infer _> ? Value : Returned;
+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 PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
 //#endregion
 //#region src/plan/result.d.ts
 /**
@@ -4652,7 +4654,7 @@ type PlanResult<Returned> = Returned extends Error ? never : Returned extends Er
  *
  * @returns Promised result
  */
-export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -4660,7 +4662,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<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+export declare function asyncAttemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
 /**
  * Attempt to run the generator to completion
  *
@@ -4668,7 +4670,7 @@ export declare function asyncAttemptRun<Yielded, Returned, Parameters extends un
  *
  * @returns Result
  */
-export declare function attemptRun<Yielded, Returned>(generator: () => Generator<Yielded, Returned, unknown>, ...parameters: Parameters<typeof generator>): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
 /**
  * Attempt to run the plan to completion
  *
@@ -4676,7 +4678,7 @@ export declare function attemptRun<Yielded, Returned>(generator: () => Generator
  *
  * @returns Result
  */
-export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+export declare function attemptRun<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
 export declare namespace attemptRun {
   export var async: typeof asyncAttemptRun;
 }
@@ -4688,28 +4690,28 @@ export declare namespace attemptRun {
  * @param generator Generator to run
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned, unknown>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => AsyncGenerator<Yielded, Returned>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
 /**
  * Run an asynchronous plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanResult<Returned>>;
+export declare function asyncRun<Yielded, Returned, Parameters extends unknown[]>(plan: AsyncPlan<Yielded, Returned, Parameters>, ...parameters: Parameters): Promise<PlanReturned<Returned>>;
 /**
  * Run a generator to completion
  *
  * @param generator Generator to run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned, unknown>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>, ...parameters: Parameters): PlanReturned<Returned>;
 /**
  * Run a plan to completion
  *
  * @param plan Plan to run
  * @returns Result
  */
-export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanResult<Returned> | PlanError<Yielded, Returned>;
+export declare function run<Yielded, Returned, Parameters extends unknown[]>(plan: Plan<Yielded, Returned, Parameters>, ...parameters: Parameters): PlanReturned<Returned>;
 export declare namespace asyncRun {
   export var attempt: typeof asyncAttemptRun;
 }
@@ -4734,14 +4736,7 @@ export declare function plan<Yielded, Returned, Parameters extends unknown[]>(ge
  */
 export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>): Plan<Yielded, Returned, Parameters>;
 //#endregion
-//#region src/internal/plan.d.ts
-/**
- * Create an immediately failing generator
- *
- * @param reason Failure reason
- * @returns Failing generator
- */
-export declare function fail<Reason>(reason: Reason): Generator<unknown, never>;
+//#region src/plan/is.d.ts
 /**
  * Is the value an asynchronous generator function?
  *
@@ -4770,13 +4765,26 @@ 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>;
+//#endregion
+//#region src/plan/misc.d.ts
 /**
- * Create an immediately succeeding generator
+ * Create an immediately failing plan
+ *
+ * @param reason Failure reason
+ * @returns Plan failure
+ */
+export declare function fail<Reason>(reason: Reason): Generator<Reason, void>;
+/**
+ * Create an immediately succeeding plan
  *
  * @param value Success value
- * @returns Succeeding generator
+ * @returns Plan success
  */
-export declare function succeed<Value>(value: Value): Generator<unknown, Value>;
+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;
+}
 //#endregion
 //#region src/internal/aborter.d.ts
 type Aborter = {
@@ -4859,7 +4867,7 @@ export type PromiseStrategy = "complete" | "first";
 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]>; };
+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]>; } extends (infer Result) ? Result : never;
 /**
  * Options for handling multiple _Promises_
  */
@@ -4874,9 +4882,9 @@ export type PromisesOptions = {
   strategy?: PromiseStrategy;
 };
 export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
-export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
+export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; } extends (infer Result) ? Result : never;
+export type PromisesValue<Value> = (FulfilledPromise<Value> | RejectedPromise);
+export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; } extends (infer Result) ? Result : never;
 /**
  * A _Promise_ that was rejected
  */
@@ -6350,7 +6358,7 @@ export declare function pick<Value extends PlainObject, ValueKey extends keyof V
 /**
  * A shaken object, without any `undefined` values
  */
-type Shaken<Value extends PlainObject> = { [Key in keyof Value]: Value[Key] extends undefined ? never : Value[Key]; };
+type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key]; } & { [Key in keyof Value as undefined extends Value[Key] ? [Value[Key]] extends [undefined] ? never : Key : never]?: Exclude<Value[Key], undefined>; }>;
 /**
  * Shake an object, removing all keys with `undefined` values
  *

package/dist/index.mjs

@@ -2756,19 +2756,7 @@ const PLAN_SYMBOL = Symbol("plan");
 const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
 const PLAN_TYPE_PLAN_SYNC = "plan";
 //#endregion
-//#region src/internal/plan.ts
-/**
-* Create an immediately failing generator
-*
-* @param reason Failure reason
-* @returns Failing generator
-*/
-function fail(reason) {
-	return (function* () {
-		yield;
-		throw reason;
-	})();
-}
+//#region src/plan/is.ts
 /**
 * Is the value an asynchronous generator function?
 *
@@ -2811,21 +2799,9 @@ function isPlan(value) {
 function isPlanInstance(type, value) {
 	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
 }
-/**
-* Create an immediately succeeding generator
-*
-* @param value Success value
-* @returns Succeeding generator
-*/
-function succeed(value) {
-	return (function* () {
-		yield;
-		return value;
-	})();
-}
 //#endregion
 //#region src/plan/generate.ts
-async function asyncGenerate(callback, parameters) {
+async function asyncGenerate(callback, parameters, unwrap) {
 	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
@@ -2845,10 +2821,10 @@ async function asyncGenerate(callback, parameters) {
 	} finally {
 		await generator?.return(lastValue);
 	}
-	if (success) return lastValue;
+	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
-function generate(callback, parameters) {
+function generate(callback, parameters, unwrap) {
 	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
@@ -2868,45 +2844,45 @@ function generate(callback, parameters) {
 	} finally {
 		generator.return(lastValue);
 	}
-	if (success) return lastValue;
+	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
 //#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));
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters, true));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRun(input, ...parameters) {
 	if (isPlan(input)) return input.attempt(...parameters);
-	if (isGenerator(input)) return attempt(() => generate(input, parameters));
+	if (isGenerator(input)) return attempt(() => generate(input, parameters, true));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRunAsyncPlan(...parameters) {
-	return asyncAttempt(() => this.run(...parameters));
+	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL].generator, parameters, true));
 }
 function attemptRunPlan(...parameters) {
-	return attempt(() => this.run(...parameters));
+	return attempt(() => generate(this[PLAN_SYMBOL].generator, parameters, true));
 }
 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);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters, false);
 	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);
+	if (isGenerator(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function runAsyncPlan(...parameters) {
-	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters, false);
 }
 function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL].generator, parameters);
+	return generate(this[PLAN_SYMBOL].generator, parameters, false);
 }
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;
@@ -2941,6 +2917,36 @@ function plan(generator) {
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
+//#region src/plan/misc.ts
+/**
+* Create an immediately failing plan
+*
+* @param reason Failure reason
+* @returns Plan failure
+*/
+function fail(reason) {
+	return (function* () {
+		throw reason;
+	})();
+}
+/**
+* Create an immediately succeeding plan
+*
+* @param value Success value
+* @returns Plan success
+*/
+function succeed(value) {
+	return (function* () {
+		return value;
+	})();
+}
+function succeedResult(value) {
+	return (function* () {
+		return ok(value);
+	})();
+}
+succeed.result = succeedResult;
+//#endregion
 //#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
@@ -7043,4 +7049,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, 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 };
+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, 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 };

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

@@ -9,22 +9,22 @@ export type AsyncPlan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Asynchronous generator
    */
-  [Symbol.asyncIterator]: () => AsyncGenerator<Yielded, Returned, unknown>;
+  [Symbol.asyncIterator]: (...parameters: Parameters) => AsyncGenerator<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
+   * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Promise<Result<PlanResult<Returned>, PlanError<Yielded, Returned>>>;
+  attempt(...parameters: Parameters): Promise<Result<PlanOk<Returned>, PlanError<Yielded, Returned>>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): Promise<PlanResult<Returned>>;
+  run(...parameters: Parameters): Promise<PlanReturned<Returned>>;
 };
 type AsyncPlanState = {
   generator(...parameters: unknown[]): AsyncGenerator;
@@ -47,30 +47,32 @@ export type Plan<Yielded, Returned, Parameters extends unknown[]> = {
    *
    * @returns Generator
    */
-  [Symbol.iterator]: () => Generator<Yielded, Returned, unknown>;
+  [Symbol.iterator]: (...parameters: Parameters) => Generator<Yielded, Returned>;
   /**
    * Attempt to run the plan to completion
    *
    * _Returns a {@link Result} instead of a raw value or throwing an error_
    *
-   * @returns Result
+   * @returns Attempted result
    */
-  attempt(...parameters: Parameters): Result<PlanResult<Returned>, PlanError<Yielded, Returned>>;
+  attempt(...parameters: Parameters): Result<PlanOk<Returned>, PlanError<Yielded, Returned>>;
   /**
    * Run the plan to completion
    *
    * @throws {PlanError<Yielded, Returned>}
    * @returns Result
    */
-  run(...parameters: Parameters): PlanResult<Returned>;
+  run(...parameters: Parameters): PlanReturned<Returned>;
 };
-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 extends Err<infer _> ? never : Returned extends Ok<infer Value> ? Value : Returned extends Result<infer Value, infer _> ? Value : Returned;
+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 PlanReturned<Returned> = Returned extends Error ? never : Returned extends Err<infer _> ? never : Returned;
 type PlanState = {
   generator(...parameters: unknown[]): Generator;
 } & BaseState<typeof PLAN_TYPE_PLAN_SYNC>;
-export type PlanType = "asyncPlan" | "plan" | "stop";
+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";

package/dist/internal/string/misc.mjs

@@ -1,5 +1,4 @@
 import { unwrap } from "../result/misc.mjs";
-import "../../result/misc.mjs";
 import { attempt } from "../result/attempt.mjs";
 //#region src/internal/string/misc.ts
 /**

package/dist/models.d.mts

@@ -63,7 +63,7 @@ type _NestedValue<Value, Path extends string> = Path extends `${infer ItemKey}.$
 /**
  * The nested _(keyed)_ values of an object _(up to 5 levels deep)_
  */
-export type NestedValues<Value extends PlainObject> = { [Path in NestedKeys<Value>]: NestedValue<Value, Path>; };
+export type NestedValues<Value extends PlainObject> = Simplify<{ [Path in NestedKeys<Value>]: NestedValue<Value, Path>; }>;
 /**
  * The numerical keys of an object
  */
@@ -71,7 +71,7 @@ export type NumericalKeys<Value> = { [ItemKey in keyof Value]: ItemKey extends n
 /**
  * The numerical values of an object
  */
-export type NumericalValues<Item extends PlainObject> = { [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey]; };
+export type NumericalValues<Item extends PlainObject> = Simplify<{ [ItemKey in keyof Item as Item[ItemKey] extends number ? ItemKey : never]: Item[ItemKey]; }>;
 /**
  * An asynchronous function that can only be called once, returning the same value on subsequent calls
  */
@@ -131,7 +131,7 @@ export type Primitive = null | undefined | string | number | boolean | symbol |
 /**
  * Set required keys for a type
  */
-export type RequiredKeys<Model extends object, Keys extends keyof Model> = Required<Pick<Model, Keys>> & Omit<Model, Keys>;
+export type RequiredKeys<Model extends object, Keys extends keyof Model> = Simplify<Required<Pick<Model, Keys>> & Omit<Model, Keys>>;
 /**
  * Flattens the type to improve type hints in IDEs
  *

package/dist/plan/generate.d.mts

@@ -1,4 +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;
+export declare function asyncGenerate(callback: (...parameters: unknown[]) => AsyncGenerator, parameters: unknown[], unwrap: boolean): Promise<unknown>;
+export declare function generate(callback: (...parameters: unknown[]) => Generator, parameters: unknown[], unwrap: boolean): unknown;
 //#endregion

package/dist/plan/generate.mjs

@@ -1,6 +1,6 @@
-import { isError } from "../internal/result/misc.mjs";
+import { isError, isOk } from "../internal/result/misc.mjs";
 //#region src/plan/generate.ts
-async function asyncGenerate(callback, parameters) {
+async function asyncGenerate(callback, parameters, unwrap) {
 	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
@@ -20,10 +20,10 @@ async function asyncGenerate(callback, parameters) {
 	} finally {
 		await generator?.return(lastValue);
 	}
-	if (success) return lastValue;
+	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
-function generate(callback, parameters) {
+function generate(callback, parameters, unwrap) {
 	const generator = callback(...parameters);
 	let success = true;
 	let lastValue;
@@ -43,7 +43,7 @@ function generate(callback, parameters) {
 	} finally {
 		generator.return(lastValue);
 	}
-	if (success) return lastValue;
+	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
 //#endregion

package/dist/plan/index.mjs

@@ -1,5 +1,5 @@
 import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
-import { isAsyncGenerator, isGenerator } from "../internal/plan.mjs";
+import { isAsyncGenerator, isGenerator } from "./is.mjs";
 import { asyncAttemptRun, attemptRun, attemptRunAsyncPlan, attemptRunPlan } from "./result.mjs";
 import { asyncRun, run, runAsyncPlan, runPlan } from "./run.mjs";
 //#region src/plan/index.ts

package/dist/plan/is.d.mts

@@ -1,2 +1,31 @@
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
-export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };
+import { AsyncPlan, Plan } from "../internal/models/plan.model.mjs";
+//#region src/plan/is.d.ts
+/**
+ * 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;
+/**
+ * Is the value an asynchronous plan?
+ *
+ * @param value Value to check
+ * @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 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;
+/**
+ * Is the value a plan?
+ *
+ * @param value Value to check
+ * @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>;
+//#endregion

package/dist/plan/is.mjs

@@ -1,2 +1,46 @@
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "../internal/models/plan.model.mjs";
+//#region src/plan/is.ts
+/**
+* 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);
+}
+/**
+* Is the value an asynchronous plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
+*/
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
+}
+/**
+* Is the value a generator function?
+*
+* @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 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";
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+//#endregion
 export { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan };

package/dist/plan/misc.d.mts

@@ -1,2 +1,21 @@
-import { fail, succeed } from "../internal/plan.mjs";
-export { fail, succeed };
+import { Ok } from "../internal/models/result.model.mjs";
+//#region src/plan/misc.d.ts
+/**
+ * Create an immediately failing plan
+ *
+ * @param reason Failure reason
+ * @returns Plan failure
+ */
+export declare function fail<Reason>(reason: Reason): Generator<Reason, void>;
+/**
+ * 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;
+}
+//#endregion

package/dist/plan/misc.mjs

@@ -1,2 +1,32 @@
-import { fail, succeed } from "../internal/plan.mjs";
-export { fail, succeed };
+import { ok } from "../internal/result/misc.mjs";
+//#region src/plan/misc.ts
+/**
+* Create an immediately failing plan
+*
+* @param reason Failure reason
+* @returns Plan failure
+*/
+function fail(reason) {
+	return (function* () {
+		throw reason;
+	})();
+}
+/**
+* Create an immediately succeeding plan
+*
+* @param value Success value
+* @returns Plan success
+*/
+function succeed(value) {
+	return (function* () {
+		return value;
+	})();
+}
+function succeedResult(value) {
+	return (function* () {
+		return ok(value);
+	})();
+}
+succeed.result = succeedResult;
+//#endregion
+export { fail, succeed, succeedResult };

package/dist/plan/result.d.mts

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

package/dist/plan/result.mjs

@@ -1,23 +1,23 @@
 import { asyncAttempt, attempt } from "../internal/result/attempt.mjs";
-import { PLAN_MESSAGE_RUN_INPUT } from "../internal/models/plan.model.mjs";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/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));
+	if (isAsyncGenerator(input)) return asyncAttempt(() => asyncGenerate(input, parameters, true));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRun(input, ...parameters) {
 	if (isPlan(input)) return input.attempt(...parameters);
-	if (isGenerator(input)) return attempt(() => generate(input, parameters));
+	if (isGenerator(input)) return attempt(() => generate(input, parameters, true));
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function attemptRunAsyncPlan(...parameters) {
-	return asyncAttempt(() => this.run(...parameters));
+	return asyncAttempt(() => asyncGenerate(this[PLAN_SYMBOL].generator, parameters, true));
 }
 function attemptRunPlan(...parameters) {
-	return attempt(() => this.run(...parameters));
+	return attempt(() => generate(this[PLAN_SYMBOL].generator, parameters, true));
 }
 attemptRun.async = asyncAttemptRun;
 //#endregion

package/dist/plan/run.d.mts

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

package/dist/plan/run.mjs

@@ -1,23 +1,23 @@
 import { PLAN_MESSAGE_RUN_INPUT, PLAN_SYMBOL } from "../internal/models/plan.model.mjs";
-import { isAsyncGenerator, isAsyncPlan, isGenerator, isPlan } from "../internal/plan.mjs";
+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);
+	if (isAsyncGenerator(input)) return asyncGenerate(input, parameters, false);
 	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);
+	if (isGenerator(input)) return generate(input, parameters, false);
 	throw new Error(PLAN_MESSAGE_RUN_INPUT);
 }
 function runAsyncPlan(...parameters) {
-	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters);
+	return asyncGenerate(this[PLAN_SYMBOL].generator, parameters, false);
 }
 function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL].generator, parameters);
+	return generate(this[PLAN_SYMBOL].generator, parameters, false);
 }
 asyncRun.attempt = asyncAttemptRun;
 run.async = asyncRun;

package/dist/promise/models.d.mts

@@ -72,7 +72,7 @@ export type PromiseStrategy = "complete" | "first";
 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]>; };
+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]>; } extends (infer Result) ? Result : never;
 /**
  * Options for handling multiple _Promises_
  */
@@ -87,9 +87,9 @@ export type PromisesOptions = {
   strategy?: PromiseStrategy;
 };
 export type PromisesResult<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? Result<Awaited<Value>> : never; };
-export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; };
-export type PromisesValue<Value> = FulfilledPromise<Value> | RejectedPromise;
-export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; };
+export type PromisesUnwrapped<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends GenericCallback ? ReturnType<Items[ItemsKey]> extends Promise<infer Value> ? Awaited<Value> : never : Items[ItemsKey] extends Promise<infer Value> ? Awaited<Value> : never; } extends (infer Result) ? Result : never;
+export type PromisesValue<Value> = (FulfilledPromise<Value> | RejectedPromise);
+export type PromisesValues<Items extends ArrayOrPlainObject> = { [ItemsKey in keyof Items]: Items[ItemsKey] extends Promise<infer Value> ? PromisesValue<Awaited<Value>> : never; } extends (infer Result) ? Result : never;
 /**
  * A _Promise_ that was rejected
  */

package/dist/result/work/flow.mjs

@@ -1,7 +1,6 @@
 import { isError, isOk } from "../../internal/result/misc.mjs";
 import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
 import { asyncFlow, flow } from "../../internal/function/work.mjs";
-import "../index.mjs";
 //#region src/result/work/flow.ts
 function attemptAsyncFlow(...fns) {
 	let Flow;

package/dist/result/work/pipe.mjs

@@ -1,7 +1,6 @@
 import { isError, isOk } from "../../internal/result/misc.mjs";
 import { asyncAttempt, attempt } from "../../internal/result/attempt.mjs";
 import { asyncPipe, pipe } from "../../internal/function/work.mjs";
-import "../index.mjs";
 //#region src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
 	return asyncAttempt(() => {

package/dist/value/shake.d.mts

@@ -1,9 +1,9 @@
-import { PlainObject } from "../models.mjs";
+import { PlainObject, Simplify } from "../models.mjs";
 //#region src/value/shake.d.ts
 /**
  * A shaken object, without any `undefined` values
  */
-export type Shaken<Value extends PlainObject> = { [Key in keyof Value]: Value[Key] extends undefined ? never : Value[Key]; };
+export type Shaken<Value extends PlainObject> = Simplify<{ [Key in keyof Value as undefined extends Value[Key] ? never : Key]: Value[Key]; } & { [Key in keyof Value as undefined extends Value[Key] ? [Value[Key]] extends [undefined] ? never : Key : never]?: Exclude<Value[Key], undefined>; }>;
 /**
  * Shake an object, removing all keys with `undefined` values
  *

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oscarpalmer/atoms",
-	"version": "0.212.0",
+	"version": "0.213.0",
 	"description": "Atomic utilities for making your JavaScript better.",
 	"keywords": [
 		"array",
@@ -295,6 +295,7 @@
 			"default": "./dist/value/transform.mjs"
 		}
 	},
+	"sideEffects": false,
 	"scripts": {
 		"build": "npx vp pack && npm run tsdown:build",
 		"tsdown:build": "npx tsdown -c ./tsdown.config.ts",

package/dist/internal/plan.d.mts

@@ -1,45 +0,0 @@
-import { AsyncPlan, Plan } from "./models/plan.model.mjs";
-//#region src/internal/plan.d.ts
-/**
- * Create an immediately failing generator
- *
- * @param reason Failure reason
- * @returns Failing generator
- */
-export declare function fail<Reason>(reason: Reason): Generator<unknown, never>;
-/**
- * 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;
-/**
- * Is the value an asynchronous plan?
- *
- * @param value Value to check
- * @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 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;
-/**
- * Is the value a plan?
- *
- * @param value Value to check
- * @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>;
-/**
- * Create an immediately succeeding generator
- *
- * @param value Success value
- * @returns Succeeding generator
- */
-export declare function succeed<Value>(value: Value): Generator<unknown, Value>;
-//#endregion

package/dist/internal/plan.mjs

@@ -1,70 +0,0 @@
-import { GENERATOR_NAME_ASYNC, GENERATOR_NAME_SYNC, PLAN_SYMBOL, PLAN_TYPE_PLAN_ASYNC, PLAN_TYPE_PLAN_SYNC } from "./models/plan.model.mjs";
-//#region src/internal/plan.ts
-/**
-* Create an immediately failing generator
-*
-* @param reason Failure reason
-* @returns Failing generator
-*/
-function fail(reason) {
-	return (function* () {
-		yield;
-		throw reason;
-	})();
-}
-/**
-* 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);
-}
-/**
-* Is the value an asynchronous plan?
-*
-* @param value Value to check
-* @returns `true` if the value is an asynchronous plan, otherwise `false`
-*/
-function isAsyncPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
-}
-/**
-* Is the value a generator function?
-*
-* @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 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";
-}
-/**
-* Is the value a plan?
-*
-* @param value Value to check
-* @returns `true` if the value is a plan, otherwise `false`
-*/
-function isPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
-}
-function isPlanInstance(type, value) {
-	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
-}
-/**
-* Create an immediately succeeding generator
-*
-* @param value Success value
-* @returns Succeeding generator
-*/
-function succeed(value) {
-	return (function* () {
-		yield;
-		return value;
-	})();
-}
-//#endregion
-export { fail, isAsyncGenerator, isAsyncPlan, isGenerator, isPlan, succeed };