@oscarpalmer/atoms 0.211.0 → 0.213.0

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

@@ -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.211.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