@pumped-fn/core-next 0.5.72 → 0.5.73

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @pumped-fn/core-next
 
+## 0.5.73
+
+### Patch Changes
+
+- bdf29a0: Add Promised.create static factory method and make extension API accept both Promise and Promised types
+
+  - Add `Promised.create()` static method as preferred way to create Promised instances
+  - Replace all 43 internal uses of `new Promised` with `Promised.create`
+  - Extension API now accepts both `Promise<T>` and `Promised<T>` return types
+  - Extension methods (init, initPod, wrap, dispose, disposePod) handle both types seamlessly
+  - Internal automatic wrapping to Promised for better ergonomics
+  - No breaking changes - fully backward compatible
+
 ## 0.5.72
 
 ### Patch Changes

package/dist/index.cjs

@@ -257,28 +257,31 @@ var Promised = class Promised {
 		this.promise = promise instanceof Promised ? promise.promise : promise;
 		this.executionDataPromise = executionDataPromise;
 	}
+	static create(promise, executionDataPromise) {
+		return new Promised(promise, executionDataPromise);
+	}
 	map(fn) {
-		return new Promised(this.promise.then(fn), this.executionDataPromise);
+		return Promised.create(this.promise.then(fn), this.executionDataPromise);
 	}
 	switch(fn) {
-		return new Promised(this.promise.then(fn), this.executionDataPromise);
+		return Promised.create(this.promise.then(fn), this.executionDataPromise);
 	}
 	mapError(fn) {
-		return new Promised(this.promise.catch((error) => {
+		return Promised.create(this.promise.catch((error) => {
 			throw fn(error);
 		}), this.executionDataPromise);
 	}
 	switchError(fn) {
-		return new Promised(this.promise.catch(fn), this.executionDataPromise);
+		return Promised.create(this.promise.catch(fn), this.executionDataPromise);
 	}
 	then(onfulfilled, onrejected) {
-		return new Promised(this.promise.then(onfulfilled, onrejected), this.executionDataPromise);
+		return Promised.create(this.promise.then(onfulfilled, onrejected), this.executionDataPromise);
 	}
 	catch(onrejected) {
-		return new Promised(this.promise.catch(onrejected), this.executionDataPromise);
+		return Promised.create(this.promise.catch(onrejected), this.executionDataPromise);
 	}
 	finally(onfinally) {
-		return new Promised(this.promise.finally(onfinally), this.executionDataPromise);
+		return Promised.create(this.promise.finally(onfinally), this.executionDataPromise);
 	}
 	toPromise() {
 		return this.promise;
@@ -308,24 +311,25 @@ var Promised = class Promised {
 	}
 	static all(values) {
 		const promises = values.map((v) => v instanceof Promised ? v.toPromise() : Promise.resolve(v));
-		return new Promised(Promise.all(promises));
+		return Promised.create(Promise.all(promises));
 	}
 	static race(values) {
 		const promises = values.map((v) => v instanceof Promised ? v.toPromise() : Promise.resolve(v));
-		return new Promised(Promise.race(promises));
+		return Promised.create(Promise.race(promises));
 	}
 	static allSettled(values) {
 		const promises = values.map((v) => v instanceof Promised ? v.toPromise() : Promise.resolve(v));
-		return new Promised(Promise.allSettled(promises));
+		return Promised.create(Promise.allSettled(promises));
 	}
 	static try(fn) {
-		return new Promised(new Promise((resolve, reject) => {
+		const promise = new Promise((resolve, reject) => {
 			try {
 				resolve(fn());
 			} catch (error) {
 				reject(error);
 			}
-		}));
+		});
+		return Promised.create(promise);
 	}
 	static extractResults(value) {
 		if (Array.isArray(value)) return value;
@@ -634,7 +638,10 @@ function wrapWithExtensions(extensions, baseExecutor, dataStore, operation) {
 		const extension$1 = extensions[i];
 		if (extension$1.wrap) {
 			const current = executor;
-			executor = () => extension$1.wrap(dataStore, current, operation);
+			executor = () => {
+				const result = extension$1.wrap(dataStore, current, operation);
+				return result instanceof Promised ? result : Promised.create(result);
+			};
 		}
 	}
 	return executor;
@@ -699,7 +706,10 @@ var FlowContext = class FlowContext {
 		let executor = baseExecutor;
 		for (const extension$1 of this.reversedExtensions) if (extension$1.wrap) {
 			const current = executor;
-			executor = () => extension$1.wrap(this, current, operation);
+			executor = () => {
+				const result = extension$1.wrap(this, current, operation);
+				return result instanceof Promised ? result : Promised.create(result);
+			};
 		}
 		return executor;
 	}
@@ -734,14 +744,14 @@ var FlowContext = class FlowContext {
 		const flowName = this.find(flowMeta.flowName) || "unknown";
 		const depth = this.get(flowMeta.depth);
 		const journalKey = `${flowName}:${depth}:${key}`;
-		return new Promised((async () => {
+		const promise = (async () => {
 			const journal = this.journal;
 			const isReplay = journal.has(journalKey);
 			const executeCore = () => {
 				if (isReplay) {
 					const entry = journal.get(journalKey);
 					if (isErrorEntry(entry)) throw entry.error;
-					return new Promised(Promise.resolve(entry));
+					return Promised.create(Promise.resolve(entry));
 				}
 				return Promised.try(async () => {
 					const result = params.length > 0 ? await fn(...params) : await fn();
@@ -764,7 +774,8 @@ var FlowContext = class FlowContext {
 				pod: this.pod,
 				params: params.length > 0 ? params : void 0
 			})();
-		})());
+		})();
+		return Promised.create(promise);
 	}
 	exec(keyOrFlow, flowOrInput, inputOrUndefined) {
 		if (typeof keyOrFlow === "string") {
@@ -775,13 +786,13 @@ var FlowContext = class FlowContext {
 			const parentFlowName = this.find(flowMeta.flowName);
 			const depth = this.get(flowMeta.depth);
 			const journalKey = `${this.find(flowMeta.flowName) || "unknown"}:${depth}:${key}`;
-			return new Promised((async () => {
+			const promise$1 = (async () => {
 				const journal = this.journal;
 				const executeCore = () => {
 					if (journal.has(journalKey)) {
 						const entry = journal.get(journalKey);
 						if (isErrorEntry(entry)) throw entry.error;
-						return new Promised(Promise.resolve(entry));
+						return Promised.create(Promise.resolve(entry));
 					}
 					return Promised.try(async () => {
 						const handler = await this.pod.resolve(flow$2);
@@ -812,11 +823,12 @@ var FlowContext = class FlowContext {
 					depth,
 					pod: this.pod
 				})();
-			})());
+			})();
+			return Promised.create(promise$1);
 		}
 		const flow$1 = keyOrFlow;
 		const input = flowOrInput;
-		return new Promised((async () => {
+		const promise = (async () => {
 			const parentFlowName = this.find(flowMeta.flowName);
 			const depth = this.get(flowMeta.depth);
 			const executeCore = () => {
@@ -840,14 +852,15 @@ var FlowContext = class FlowContext {
 				depth,
 				pod: this.pod
 			})();
-		})());
+		})();
+		return Promised.create(promise);
 	}
 	parallel(promises) {
 		const parentFlowName = this.find(flowMeta.flowName);
 		const depth = this.get(flowMeta.depth);
-		return new Promised((async () => {
+		const promise = (async () => {
 			const executeCore = () => {
-				return new Promised(Promise.all(promises).then((results) => ({
+				return Promised.create(Promise.all(promises).then((results) => ({
 					results,
 					stats: {
 						total: results.length,
@@ -864,14 +877,15 @@ var FlowContext = class FlowContext {
 				parentFlowName,
 				pod: this.pod
 			})();
-		})());
+		})();
+		return Promised.create(promise);
 	}
 	parallelSettled(promises) {
 		const parentFlowName = this.find(flowMeta.flowName);
 		const depth = this.get(flowMeta.depth);
-		return new Promised((async () => {
+		const promise = (async () => {
 			const executeCore = () => {
-				return new Promised(Promise.allSettled(promises).then((results) => {
+				return Promised.create(Promise.allSettled(promises).then((results) => {
 					const succeeded = results.filter((r) => r.status === "fulfilled").length;
 					const failed = results.filter((r) => r.status === "rejected").length;
 					return {
@@ -892,10 +906,11 @@ var FlowContext = class FlowContext {
 				parentFlowName,
 				pod: this.pod
 			})();
-		})());
+		})();
+		return Promised.create(promise);
 	}
 	executeWithExtensions(handler, context, flow$1, input) {
-		const executeCore = () => new Promised(handler(context));
+		const executeCore = () => Promised.create(handler(context));
 		const definition = flowDefinitionMeta.find(flow$1);
 		if (!definition) throw new Error("Flow definition not found in executor metadata");
 		return context.wrapWithExtensions(executeCore, {
@@ -931,7 +946,10 @@ var FlowContext = class FlowContext {
 function execute(flow$1, input, options) {
 	const scope = options?.scope || createScope();
 	const shouldDisposeScope = !options?.scope;
-	const pod = scope.pod({ initialValues: options?.presets });
+	const pod = scope.pod({
+		initialValues: options?.presets,
+		meta: options?.meta
+	});
 	let resolveSnapshot;
 	const snapshotPromise = new Promise((resolve) => {
 		resolveSnapshot = resolve;
@@ -975,24 +993,27 @@ function execute(flow$1, input, options) {
 			if (shouldDisposeScope) await scope.dispose();
 		}
 	})();
-	if (options?.details) return new Promised(Promised.try(async () => {
-		const [result, ctx] = await Promise.all([promise, snapshotPromise]);
-		if (!ctx) throw new Error("Execution context not available");
-		return {
-			success: true,
-			result,
-			ctx
-		};
-	}).catch(async (error) => {
-		const ctx = await snapshotPromise;
-		if (!ctx) throw new Error("Execution context not available");
-		return {
-			success: false,
-			error,
-			ctx
-		};
-	}), snapshotPromise);
-	return new Promised(promise, snapshotPromise);
+	if (options?.details) {
+		const detailsPromise = Promised.try(async () => {
+			const [result, ctx] = await Promise.all([promise, snapshotPromise]);
+			if (!ctx) throw new Error("Execution context not available");
+			return {
+				success: true,
+				result,
+				ctx
+			};
+		}).catch(async (error) => {
+			const ctx = await snapshotPromise;
+			if (!ctx) throw new Error("Execution context not available");
+			return {
+				success: false,
+				error,
+				ctx
+			};
+		});
+		return Promised.create(detailsPromise, snapshotPromise);
+	}
+	return Promised.create(promise, snapshotPromise);
 }
 function flowImpl(definitionOrConfigOrDepsOrHandler, dependenciesOrHandler, handlerFn) {
 	if (typeof definitionOrConfigOrDepsOrHandler === "function") {
@@ -1096,7 +1117,7 @@ var AccessorImpl = class {
 				value: {
 					kind: "resolved",
 					value: immediateValue,
-					promised: new Promised(Promise.resolve(immediateValue))
+					promised: Promised.create(Promise.resolve(immediateValue))
 				}
 			});
 			return immediateValue;
@@ -1110,7 +1131,7 @@ var AccessorImpl = class {
 			value: {
 				kind: "resolved",
 				value: processedResult,
-				promised: new Promised(Promise.resolve(processedResult))
+				promised: Promised.create(Promise.resolve(processedResult))
 			}
 		});
 		this.scope["~removeFromResolutionChain"](this.requestor);
@@ -1146,7 +1167,7 @@ var AccessorImpl = class {
 			const cached = this.scope["cache"].get(this.requestor)?.value;
 			if (cached && !force) return this.handleCachedState(cached);
 			if (this.currentPromise && !force) {
-				if (!this.currentPromised) this.currentPromised = new Promised(this.currentPromise);
+				if (!this.currentPromised) this.currentPromised = Promised.create(this.currentPromise);
 				return this.currentPromised;
 			}
 			this.scope["~addToResolutionChain"](this.requestor, this.requestor);
@@ -1158,18 +1179,18 @@ var AccessorImpl = class {
 					promise: this.currentPromise
 				}
 			});
-			this.currentPromised = new Promised(this.currentPromise);
+			this.currentPromised = Promised.create(this.currentPromise);
 			return this.currentPromised;
 		};
 	}
 	handleCachedState(cached) {
 		if (cached.kind === "resolved") {
 			if (cached.promised) return cached.promised;
-			if (!this.cachedResolvedPromised) this.cachedResolvedPromised = new Promised(Promise.resolve(cached.value));
+			if (!this.cachedResolvedPromised) this.cachedResolvedPromised = Promised.create(Promise.resolve(cached.value));
 			return this.cachedResolvedPromised;
 		}
 		if (cached.kind === "rejected") throw cached.error;
-		if (!this.currentPromised) this.currentPromised = new Promised(cached.promise);
+		if (!this.currentPromised) this.currentPromised = Promised.create(cached.promise);
 		return this.currentPromised;
 	}
 	processReplacer() {
@@ -1412,7 +1433,10 @@ var BaseScope = class BaseScope {
 		let executor = baseExecutor;
 		for (const extension$1 of this.reversedExtensions) if (extension$1.wrap) {
 			const current = executor;
-			executor = () => extension$1.wrap(dataStore, current, operation);
+			executor = () => {
+				const result = extension$1.wrap(dataStore, current, operation);
+				return result instanceof Promised ? result : Promised.create(result);
+			};
 		}
 		return executor;
 	}
@@ -1454,10 +1478,10 @@ var BaseScope = class BaseScope {
 		return accessor$1.resolve(force).map(() => accessor$1);
 	}
 	update(e, u) {
-		if (this.isDisposing) return new Promised(Promise.resolve());
+		if (this.isDisposing) return Promised.create(Promise.resolve());
 		this["~ensureNotDisposed"]();
 		const coreUpdate = () => {
-			return new Promised((async () => {
+			return Promised.create((async () => {
 				this["~triggerCleanup"](e);
 				const accessor$1 = this["~makeAccessor"](e);
 				let value;
@@ -1473,7 +1497,7 @@ var BaseScope = class BaseScope {
 					value: {
 						kind: "resolved",
 						value,
-						promised: new Promised(Promise.resolve(value))
+						promised: Promised.create(Promise.resolve(value))
 					}
 				});
 				await this["~triggerUpdate"](e);
@@ -1507,12 +1531,12 @@ var BaseScope = class BaseScope {
 			this.onUpdateCallbacks.delete(e);
 			this.cache.delete(e);
 		};
-		return new Promised(coreRelease());
+		return Promised.create(coreRelease());
 	}
 	dispose() {
 		this["~ensureNotDisposed"]();
 		this.isDisposing = true;
-		return new Promised((async () => {
+		return Promised.create((async () => {
 			for (const pod of this.pods) await this.disposePod(pod);
 			const extensionDisposeEvents = this.extensions.map((ext) => ext.dispose?.(this) ?? Promise.resolve());
 			await Promise.all(extensionDisposeEvents);
@@ -1620,19 +1644,28 @@ var BaseScope = class BaseScope {
 	}
 	disposePod(pod) {
 		this["~ensureNotDisposed"]();
-		if (this.isDisposing) return new Promised(Promise.resolve());
+		if (this.isDisposing) return Promised.create(Promise.resolve());
 		return pod.dispose().map(() => {
 			this.pods.delete(pod);
 		});
 	}
 	exec(flow$1, input, options) {
 		this["~ensureNotDisposed"]();
+		if (options?.details === true) return flow.execute(flow$1, input, {
+			scope: this,
+			extensions: options.extensions,
+			initialContext: options.initialContext,
+			presets: options.presets,
+			meta: options.meta,
+			details: true
+		});
 		return flow.execute(flow$1, input, {
 			scope: this,
 			extensions: options?.extensions,
 			initialContext: options?.initialContext,
 			presets: options?.presets,
-			details: options?.details
+			meta: options?.meta,
+			details: false
 		});
 	}
 };
@@ -1665,8 +1698,8 @@ var Pod = class extends BaseScope {
 			});
 			if (value) {
 				if (value.kind === "rejected") throw value.error;
-				if (value.kind === "resolved") return new Promised(Promise.resolve(value.value));
-				if (value.kind === "pending") return new Promised(value.promise);
+				if (value.kind === "resolved") return Promised.create(Promise.resolve(value.value));
+				if (value.kind === "pending") return Promised.create(value.promise);
 			}
 		}
 		return super.resolve(executor, force);
@@ -1689,7 +1722,7 @@ var Pod = class extends BaseScope {
 		return await super["~resolveExecutor"](ie, ref);
 	}
 	dispose() {
-		return new Promised((async () => {
+		return Promised.create((async () => {
 			const extensionDisposeEvents = this.extensions.map((ext) => ext.disposePod?.(this) ?? Promise.resolve());
 			await Promise.all(extensionDisposeEvents);
 			await super.dispose();
@@ -1761,7 +1794,7 @@ var MultiExecutorImpl = class {
 		};
 	}
 	release(scope) {
-		return new Promised((async () => {
+		return Promised.create((async () => {
 			const entries = scope.entries();
 			for (const [executor] of entries) {
 				const check = this.poolId.some ? this.poolId.some(executor) : this.poolId.find(executor);

package/dist/index.d.cts

@@ -4,6 +4,7 @@ declare class Promised<T> implements PromiseLike<T> {
   private executionDataPromise?;
   private promise;
   constructor(promise: Promise<T> | Promised<T>, executionDataPromise?: Promise<Flow.ExecutionData | undefined>);
+  static create<T>(promise: Promise<T> | Promised<T>, executionDataPromise?: Promise<Flow.ExecutionData | undefined>): Promised<T>;
   map<U>(fn: (value: T) => U | Promise<U>): Promised<U>;
   switch<U>(fn: (value: T) => Promised<U>): Promised<U>;
   mapError(fn: (error: unknown) => unknown): Promised<T>;
@@ -255,18 +256,20 @@ declare namespace Core {
       meta?: Meta.Meta[];
     }): Pod;
     disposePod(scope: Pod): Promised<void>;
-    exec<S, I>(flow: Core.Executor<Flow.Handler<S, I>>, input: I, options: {
+    exec<S, I = undefined>(flow: Core.Executor<Flow.Handler<S, I>>, input?: I, options?: {
       extensions?: Extension.Extension[];
       initialContext?: Array<[Accessor.Accessor<any> | Accessor.AccessorWithDefault<any>, any]>;
       presets?: Preset<unknown>[];
-      details: true;
-    }): Promised<Flow.ExecutionDetails<S>>;
-    exec<S, I>(flow: Core.Executor<Flow.Handler<S, I>>, input: I, options?: {
+      meta?: Meta.Meta[];
+      details?: false;
+    }): Promised<S>;
+    exec<S, I = undefined>(flow: Core.Executor<Flow.Handler<S, I>>, input: I | undefined, options: {
       extensions?: Extension.Extension[];
       initialContext?: Array<[Accessor.Accessor<any> | Accessor.AccessorWithDefault<any>, any]>;
       presets?: Preset<unknown>[];
-      details?: false;
-    }): Promised<S>;
+      meta?: Meta.Meta[];
+      details: true;
+    }): Promised<Flow.ExecutionDetails<S>>;
   }
 }
 declare class FlowError extends Error {
@@ -405,13 +408,13 @@ declare namespace Extension {
   };
   interface Extension {
     name: string;
-    init?(scope: Core.Scope): void | Promised<void>;
-    initPod?(pod: Core.Pod, context: Accessor.DataStore): void | Promised<void>;
-    wrap?<T>(context: Accessor.DataStore, next: () => Promised<T>, operation: Operation): Promised<T>;
+    init?(scope: Core.Scope): void | Promise<void> | Promised<void>;
+    initPod?(pod: Core.Pod, context: Accessor.DataStore): void | Promise<void> | Promised<void>;
+    wrap?<T>(context: Accessor.DataStore, next: () => Promised<T>, operation: Operation): Promise<T> | Promised<T>;
     onError?(error: ExecutorResolutionError | FactoryExecutionError | DependencyResolutionError, scope: Core.Scope): void;
     onPodError?(error: unknown, pod: Core.Pod, context: Accessor.DataStore): void;
-    dispose?(scope: Core.Scope): void | Promised<void>;
-    disposePod?(pod: Core.Pod): void | Promised<void>;
+    dispose?(scope: Core.Scope): void | Promise<void> | Promised<void>;
+    disposePod?(pod: Core.Pod): void | Promise<void> | Promised<void>;
   }
 }
 declare namespace Accessor {
@@ -553,6 +556,7 @@ declare function execute<S, I>(flow: Core.Executor<Flow.Handler<S, I>> | Flow.Fl
   extensions?: Extension.Extension[];
   initialContext?: Array<[Accessor.Accessor<any> | Accessor.AccessorWithDefault<any>, any]>;
   presets?: Core.Preset<unknown>[];
+  meta?: Meta.Meta[];
   details: true;
 }): Promised<Flow.ExecutionDetails<S>>;
 declare function execute<S, I>(flow: Core.Executor<Flow.Handler<S, I>> | Flow.Flow<I, S>, input: I, options?: {
@@ -560,6 +564,7 @@ declare function execute<S, I>(flow: Core.Executor<Flow.Handler<S, I>> | Flow.Fl
   extensions?: Extension.Extension[];
   initialContext?: Array<[Accessor.Accessor<any> | Accessor.AccessorWithDefault<any>, any]>;
   presets?: Core.Preset<unknown>[];
+  meta?: Meta.Meta[];
   details?: false;
 }): Promised<S>;
 declare function flowImpl<I, S>(handler: (ctx: Flow.Context, input: I) => Promise<S> | S): Flow.Flow<I, S>;