@pumped-fn/core-next 0.5.53 → 0.5.55

package/dist/index.cjs

@@ -0,0 +1,1294 @@
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+	for (var name$1 in all) __defProp(target, name$1, {
+		get: all[name$1],
+		enumerable: true
+	});
+};
+
+//#endregion
+
+//#region src/types.ts
+const executorSymbol = Symbol.for("@pumped-fn/core/executor");
+const metaSymbol = Symbol.for("@pumped-fn/core/meta");
+var SchemaError = class extends Error {
+	issues;
+	constructor(issues) {
+		super(issues[0].message);
+		this.name = "SchemaError";
+		this.issues = issues;
+	}
+};
+var ExecutorResolutionError = class extends Error {
+	context;
+	code;
+	category;
+	constructor(message, context, code, category = "USER_ERROR", options) {
+		super(message);
+		if (options && "cause" in options) this.cause = options.cause;
+		this.name = "ExecutorResolutionError";
+		this.context = context;
+		this.code = code;
+		this.category = category;
+	}
+};
+var FactoryExecutionError = class extends ExecutorResolutionError {
+	constructor(message, context, code, options) {
+		super(message, {
+			...context,
+			resolutionStage: "factory-execution"
+		}, code, "USER_ERROR", options);
+		this.name = "FactoryExecutionError";
+	}
+};
+var DependencyResolutionError = class extends ExecutorResolutionError {
+	missingDependency;
+	constructor(message, context, code, missingDependency, options) {
+		super(message, {
+			...context,
+			resolutionStage: "dependency-resolution"
+		}, code, "USER_ERROR", options);
+		this.name = "DependencyResolutionError";
+		this.missingDependency = missingDependency;
+	}
+};
+
+//#endregion
+//#region src/ssch.ts
+function validate(schema, data$1) {
+	const result = schema["~standard"].validate(data$1);
+	if ("then" in result) throw new Error("validating async is not supported");
+	if (result.issues) throw new SchemaError(result.issues);
+	return result.value;
+}
+async function validateAsync(schema, data$1) {
+	const result = schema["~standard"].validate(data$1);
+	if ("then" in result) {
+		const result_1 = await result;
+		if (result_1.issues) throw new SchemaError(result_1.issues);
+		return result_1.value;
+	}
+	if (result.issues) throw new SchemaError(result.issues);
+	return Promise.resolve(result.value);
+}
+function custom() {
+	return { "~standard": {
+		vendor: "pumped-fn",
+		version: 1,
+		validate: (value) => {
+			return { value };
+		}
+	} };
+}
+
+//#endregion
+//#region src/meta.ts
+const meta = (key, schema) => {
+	const _key = typeof key === "string" ? Symbol(key) : key;
+	const fn = (value) => ({
+		[metaSymbol]: true,
+		key: _key,
+		schema,
+		value
+	});
+	Object.defineProperty(fn, "key", {
+		value: _key,
+		configurable: false,
+		enumerable: false,
+		writable: false
+	});
+	Object.defineProperty(fn, metaSymbol, {
+		value: true,
+		configurable: false,
+		enumerable: false,
+		writable: false
+	});
+	Object.defineProperties(fn, {
+		partial: {
+			value: (d) => {
+				return Object.assign({}, fn({}), d);
+			},
+			configurable: false,
+			enumerable: false,
+			writable: false
+		},
+		some: {
+			value: (source) => findValues(source, fn),
+			configurable: false,
+			enumerable: false,
+			writable: false
+		},
+		find: {
+			value: (source) => findValue(source, fn),
+			configurable: false,
+			enumerable: false,
+			writable: false
+		},
+		get: {
+			value: (source) => getValue(findValue(source, fn)),
+			configurable: false,
+			enumerable: false,
+			writable: false
+		}
+	});
+	return fn;
+};
+function getValue(meta$1) {
+	return validate(meta$1.schema, meta$1.value);
+}
+function findValues(executor, meta$1) {
+	if (!executor) return [];
+	const metas = Array.isArray(executor) ? executor : executor.metas ?? [];
+	const maybeMeta = metas.filter((m) => m.key === meta$1.key);
+	return maybeMeta.map((m) => getValue(m));
+}
+function findValue(executor, meta$1) {
+	const values = findValues(executor, meta$1);
+	return values.at(0);
+}
+
+//#endregion
+//#region src/executor.ts
+function createExecutor(factory, dependencies, metas) {
+	const executor = {
+		[executorSymbol]: "main",
+		factory: (_, controller) => {
+			if (dependencies === void 0) {
+				const f$1 = factory;
+				return f$1(controller);
+			}
+			const f = factory;
+			return f(_, controller);
+		},
+		dependencies,
+		metas
+	};
+	const lazyExecutor = {
+		[executorSymbol]: "lazy",
+		dependencies: void 0,
+		executor,
+		factory: void 0,
+		metas
+	};
+	const reactiveExecutor = {
+		[executorSymbol]: "reactive",
+		executor,
+		factory: void 0,
+		dependencies: void 0,
+		metas
+	};
+	const staticExecutor = {
+		[executorSymbol]: "static",
+		dependencies: void 0,
+		factory: void 0,
+		metas,
+		executor
+	};
+	Object.defineProperties(executor, {
+		lazy: {
+			value: lazyExecutor,
+			writable: false,
+			configurable: false,
+			enumerable: false
+		},
+		reactive: {
+			value: reactiveExecutor,
+			writable: false,
+			configurable: false,
+			enumerable: false
+		},
+		static: {
+			value: staticExecutor,
+			writable: false,
+			configurable: false,
+			enumerable: false
+		}
+	});
+	return executor;
+}
+function isLazyExecutor(executor) {
+	return executor[executorSymbol] === "lazy";
+}
+function isReactiveExecutor(executor) {
+	return executor[executorSymbol] === "reactive";
+}
+function isStaticExecutor(executor) {
+	return executor[executorSymbol] === "static";
+}
+function isMainExecutor(executor) {
+	return isExecutor(executor) && executor[executorSymbol] === "main";
+}
+function isExecutor(input) {
+	return typeof input === "object" && input !== null && executorSymbol in input;
+}
+function isPreset(input) {
+	return typeof input === "object" && input !== null && executorSymbol in input && input[executorSymbol] === "preset";
+}
+function provide(factory, ...metas) {
+	return createExecutor(factory, void 0, metas);
+}
+function derive(pdependencies, pfactory, ...metas) {
+	return createExecutor(pfactory, pdependencies, metas);
+}
+function preset(e, v) {
+	const executor = isExecutor(e) ? e : e.escape();
+	return {
+		[executorSymbol]: "preset",
+		value: v,
+		executor
+	};
+}
+
+//#endregion
+//#region src/multi.ts
+var multi_exports = {};
+__export(multi_exports, {
+	derive: () => derive$2,
+	provide: () => provide$2
+});
+function createMultiExecutor(option, poolId, keyPool, createNewExecutor, providerMetas) {
+	const processKey = (key) => {
+		const validatedKey = validate(option.keySchema, key);
+		const transformedKey = option.keyTransform ? option.keyTransform(validatedKey) : validatedKey;
+		return {
+			validatedKey,
+			transformedKey
+		};
+	};
+	const newProvider = (key) => {
+		const { transformedKey } = processKey(key);
+		const executor = createNewExecutor(key);
+		keyPool.set(transformedKey, executor);
+		return executor;
+	};
+	const provider = createExecutor((ctl) => {
+		return (key) => {
+			const { transformedKey } = processKey(key);
+			let executor = keyPool.get(transformedKey);
+			if (!executor) executor = newProvider(key);
+			return ctl.scope.accessor(executor);
+		};
+	}, void 0, providerMetas);
+	const multiExecutor = (key) => {
+		const { transformedKey } = processKey(key);
+		return keyPool.get(transformedKey) || newProvider(key);
+	};
+	Object.assign(multiExecutor, provider);
+	multiExecutor.release = async (scope) => {
+		const entries = scope.entries();
+		for (const [executor] of entries) {
+			const check = poolId.some ? poolId.some(executor) : poolId.find(executor);
+			if (check && (Array.isArray(check) ? check.length > 0 : check)) await scope.release(executor);
+		}
+	};
+	multiExecutor.id = poolId;
+	return multiExecutor;
+}
+function provide$2(option, valueFn, ...metas) {
+	const poolId = meta(Symbol(), custom());
+	const keyPool = new Map();
+	const createNewExecutor = (key) => {
+		const validatedKey = validate(option.keySchema, key);
+		return createExecutor((ctl) => valueFn(validatedKey, ctl), void 0, [poolId(void 0), ...metas]);
+	};
+	return createMultiExecutor(option, poolId, keyPool, createNewExecutor, [poolId(void 0), ...metas]);
+}
+function derive$2(option, valueFn, ...metas) {
+	const poolId = meta(Symbol(), custom());
+	const keyPool = new Map();
+	const createNewExecutor = (key) => {
+		const validatedKey = validate(option.keySchema, key);
+		return createExecutor((dependencies, ctl) => valueFn(dependencies, validatedKey, ctl), option.dependencies, metas);
+	};
+	return createMultiExecutor(option, poolId, keyPool, createNewExecutor, metas);
+}
+
+//#endregion
+//#region src/generator-utils.ts
+function isGenerator(value) {
+	return value != null && typeof value === "object" && typeof value[Symbol.iterator] === "function" && typeof value.next === "function" && typeof value.return === "function" && typeof value.throw === "function";
+}
+function isAsyncGenerator(value) {
+	return value != null && typeof value === "object" && typeof value[Symbol.asyncIterator] === "function" && typeof value.next === "function" && typeof value.return === "function" && typeof value.throw === "function";
+}
+function isGeneratorFunction(fn) {
+	return typeof fn === "function" && fn.constructor && fn.constructor.name === "GeneratorFunction";
+}
+function isAsyncGeneratorFunction(fn) {
+	return typeof fn === "function" && fn.constructor && fn.constructor.name === "AsyncGeneratorFunction";
+}
+function isIterableOrAsyncIterable(value) {
+	return isGenerator(value) || isAsyncGenerator(value);
+}
+async function collectFromGenerator(gen) {
+	const yielded = [];
+	let returned;
+	try {
+		let result;
+		do {
+			result = await gen.next();
+			if (!result.done) yielded.push(result.value);
+			else returned = result.value;
+		} while (!result.done);
+		return {
+			yielded,
+			returned
+		};
+	} catch (error) {
+		await gen.return?.(void 0);
+		throw error;
+	}
+}
+async function processGenerator(gen, handler) {
+	let index = 0;
+	try {
+		let result;
+		do {
+			result = await gen.next();
+			if (!result.done) await handler.onYield?.(result.value, index++);
+			else {
+				await handler.onReturn?.(result.value);
+				return result.value;
+			}
+		} while (true);
+	} catch (error) {
+		await handler.onError?.(error);
+		await gen.return?.(void 0);
+		throw error;
+	}
+}
+
+//#endregion
+//#region src/error-codes.ts
+/**
+* Systematic error codes for Pumped Functions
+*/
+const ErrorCodes = {
+	FACTORY_EXECUTION_FAILED: "F001",
+	FACTORY_THREW_ERROR: "F002",
+	FACTORY_RETURNED_INVALID_TYPE: "F003",
+	FACTORY_ASYNC_ERROR: "F004",
+	FACTORY_GENERATOR_ERROR: "F005",
+	DEPENDENCY_NOT_FOUND: "D001",
+	CIRCULAR_DEPENDENCY: "D002",
+	DEPENDENCY_RESOLUTION_FAILED: "D003",
+	INVALID_DEPENDENCY_TYPE: "D004",
+	DEPENDENCY_CHAIN_TOO_DEEP: "D005",
+	SCOPE_DISPOSED: "S001",
+	EXECUTOR_NOT_RESOLVED: "S002",
+	INVALID_SCOPE_STATE: "S003",
+	SCOPE_CLEANUP_FAILED: "S004",
+	REACTIVE_EXECUTOR_IN_POD: "S005",
+	UPDATE_CALLBACK_ON_DISPOSING_SCOPE: "S006",
+	SCHEMA_VALIDATION_FAILED: "V001",
+	META_VALIDATION_FAILED: "V002",
+	INPUT_TYPE_MISMATCH: "V003",
+	OUTPUT_TYPE_MISMATCH: "V004",
+	ASYNC_VALIDATION_NOT_SUPPORTED: "V005",
+	INTERNAL_RESOLUTION_ERROR: "SYS001",
+	CACHE_CORRUPTION: "SYS002",
+	MEMORY_LEAK_DETECTED: "SYS003",
+	PLUGIN_SYSTEM_ERROR: "SYS004",
+	INVALID_EXECUTOR_CONFIG: "C001",
+	MALFORMED_DEPENDENCIES: "C002",
+	INVALID_FACTORY_SIGNATURE: "C003",
+	PRESET_APPLICATION_FAILED: "C004",
+	FLOW_EXECUTION_FAILED: "FL001",
+	FLOW_CONTEXT_MISSING: "FL002",
+	FLOW_PLUGIN_ERROR: "FL003",
+	FLOW_INPUT_VALIDATION_FAILED: "FL004",
+	FLOW_OUTPUT_VALIDATION_FAILED: "FL005"
+};
+/**
+* Error message templates with placeholder support
+*/
+const ErrorMessages = {
+	[ErrorCodes.FACTORY_EXECUTION_FAILED]: "Factory function execution failed for executor '{executorName}'. {cause}",
+	[ErrorCodes.FACTORY_THREW_ERROR]: "Factory function threw an error in executor '{executorName}': {originalMessage}",
+	[ErrorCodes.FACTORY_RETURNED_INVALID_TYPE]: "Factory function returned invalid type. Expected {expectedType}, got {actualType}",
+	[ErrorCodes.FACTORY_ASYNC_ERROR]: "Async factory function failed with error: {originalMessage}",
+	[ErrorCodes.FACTORY_GENERATOR_ERROR]: "Generator factory function failed during execution: {originalMessage}",
+	[ErrorCodes.DEPENDENCY_NOT_FOUND]: "Dependency '{dependencyName}' could not be resolved in the current scope",
+	[ErrorCodes.CIRCULAR_DEPENDENCY]: "Circular dependency detected in chain: {dependencyChain}",
+	[ErrorCodes.DEPENDENCY_RESOLUTION_FAILED]: "Failed to resolve dependencies for executor '{executorName}': {cause}",
+	[ErrorCodes.INVALID_DEPENDENCY_TYPE]: "Invalid dependency type provided. Expected Executor, got {actualType}",
+	[ErrorCodes.DEPENDENCY_CHAIN_TOO_DEEP]: "Dependency resolution chain exceeded maximum depth of {maxDepth}",
+	[ErrorCodes.SCOPE_DISPOSED]: "Cannot perform operation on disposed scope",
+	[ErrorCodes.EXECUTOR_NOT_RESOLVED]: "Executor '{executorName}' is not resolved. Call resolve() first or check if resolution failed",
+	[ErrorCodes.INVALID_SCOPE_STATE]: "Scope is in invalid state for this operation: {currentState}",
+	[ErrorCodes.SCOPE_CLEANUP_FAILED]: "Scope cleanup failed: {cause}",
+	[ErrorCodes.REACTIVE_EXECUTOR_IN_POD]: "Reactive executors cannot be used in pod environments",
+	[ErrorCodes.UPDATE_CALLBACK_ON_DISPOSING_SCOPE]: "Cannot register update callback on a disposing scope",
+	[ErrorCodes.SCHEMA_VALIDATION_FAILED]: "Schema validation failed: {validationMessage}",
+	[ErrorCodes.META_VALIDATION_FAILED]: "Meta validation failed for key '{metaKey}': {validationMessage}",
+	[ErrorCodes.INPUT_TYPE_MISMATCH]: "Input type validation failed: {validationMessage}",
+	[ErrorCodes.OUTPUT_TYPE_MISMATCH]: "Output type validation failed: {validationMessage}",
+	[ErrorCodes.ASYNC_VALIDATION_NOT_SUPPORTED]: "Async validation is not currently supported",
+	[ErrorCodes.INTERNAL_RESOLUTION_ERROR]: "Internal error during executor resolution. This is likely a bug in Pumped Functions",
+	[ErrorCodes.CACHE_CORRUPTION]: "Executor cache corruption detected. Scope integrity compromised",
+	[ErrorCodes.MEMORY_LEAK_DETECTED]: "Potential memory leak detected in scope {scopeId}",
+	[ErrorCodes.PLUGIN_SYSTEM_ERROR]: "Plugin system error: {pluginName} - {cause}",
+	[ErrorCodes.INVALID_EXECUTOR_CONFIG]: "Invalid executor configuration: {configError}",
+	[ErrorCodes.MALFORMED_DEPENDENCIES]: "Malformed dependency structure: {dependencyError}",
+	[ErrorCodes.INVALID_FACTORY_SIGNATURE]: "Factory function has invalid signature. Expected (dependencies, controller) => value",
+	[ErrorCodes.PRESET_APPLICATION_FAILED]: "Failed to apply preset: {presetError}",
+	[ErrorCodes.FLOW_EXECUTION_FAILED]: "Flow execution failed: {flowName}",
+	[ErrorCodes.FLOW_CONTEXT_MISSING]: "Flow execution context is missing or invalid",
+	[ErrorCodes.FLOW_PLUGIN_ERROR]: "Flow plugin '{pluginName}' failed: {cause}",
+	[ErrorCodes.FLOW_INPUT_VALIDATION_FAILED]: "Flow input validation failed: {validationMessage}",
+	[ErrorCodes.FLOW_OUTPUT_VALIDATION_FAILED]: "Flow output validation failed: {validationMessage}"
+};
+/**
+* Utility function to format error messages with context
+*/
+function formatErrorMessage(code, context = {}) {
+	let message = ErrorMessages[code];
+	for (const [key, value] of Object.entries(context)) {
+		const placeholder = `{${key}}`;
+		message = message.replace(new RegExp(placeholder, "g"), String(value));
+	}
+	return message;
+}
+/**
+* Utility functions for creating enhanced errors with proper context
+*/
+function createFactoryError(code, executorName, dependencyChain, originalError, additionalContext = {}) {
+	const context = {
+		executorName,
+		dependencyChain,
+		timestamp: Date.now(),
+		additionalInfo: additionalContext
+	};
+	const messageContext = {
+		executorName,
+		originalMessage: originalError instanceof Error ? originalError.message : String(originalError),
+		cause: originalError instanceof Error ? originalError.message : String(originalError),
+		...additionalContext
+	};
+	const message = formatErrorMessage(code, messageContext);
+	return new FactoryExecutionError(message, context, code, { cause: originalError });
+}
+function createDependencyError(code, executorName, dependencyChain, missingDependency, originalError, additionalContext = {}) {
+	const context = {
+		executorName,
+		dependencyChain,
+		timestamp: Date.now(),
+		additionalInfo: additionalContext
+	};
+	const messageContext = {
+		executorName,
+		dependencyName: missingDependency,
+		dependencyChain: dependencyChain.join(" -> "),
+		cause: originalError instanceof Error ? originalError.message : String(originalError),
+		...additionalContext
+	};
+	const message = formatErrorMessage(code, messageContext);
+	return new DependencyResolutionError(message, context, code, missingDependency, { cause: originalError });
+}
+function createSystemError(code, executorName, dependencyChain, originalError, additionalContext = {}) {
+	const context = {
+		executorName,
+		dependencyChain,
+		resolutionStage: "post-processing",
+		timestamp: Date.now(),
+		additionalInfo: additionalContext
+	};
+	const messageContext = {
+		executorName,
+		cause: originalError instanceof Error ? originalError.message : String(originalError),
+		...additionalContext
+	};
+	const message = formatErrorMessage(code, messageContext);
+	return new ExecutorResolutionError(message, context, code, "SYSTEM_ERROR", { cause: originalError });
+}
+/**
+* Helper to extract executor name from executor object for error context
+*/
+function getExecutorName(executor) {
+	if (executor?.metas && Array.isArray(executor.metas)) for (const meta$1 of executor.metas) {
+		if (meta$1?.key && typeof meta$1.key === "symbol") {
+			const keyString = meta$1.key.toString();
+			if (keyString.includes("name") || keyString.includes("pumped-fn/name")) return String(meta$1.value);
+		}
+		if (typeof meta$1?.key === "string" && meta$1.key.includes("name")) return String(meta$1.value);
+	}
+	if (executor?.factory?.name && executor.factory.name !== "factory") return executor.factory.name;
+	if (executor) {
+		const kind = executor[Symbol.for("@pumped-fn/core/executor")] || "unknown";
+		return `${kind}-executor-${Math.random().toString(36).substr(2, 9)}`;
+	}
+	return "unknown-executor";
+}
+/**
+* Helper to build dependency chain for error context
+*/
+function buildDependencyChain(executorStack) {
+	return executorStack.map((executor) => getExecutorName(executor));
+}
+
+//#endregion
+//#region src/scope.ts
+function getExecutor(e) {
+	if (isLazyExecutor(e) || isReactiveExecutor(e) || isStaticExecutor(e)) return e.executor;
+	return e;
+}
+var BaseScope = class {
+	disposed = false;
+	cache = new Map();
+	cleanups = new Map();
+	onUpdates = new Map();
+	onEvents = {
+		change: new Set(),
+		release: new Set()
+	};
+	isPod;
+	isDisposing = false;
+	plugins = [];
+	registry = [];
+	initialValues = [];
+	constructor(options) {
+		this.isPod = options?.pod || false;
+		if (options?.registry) this.registry = [...options.registry];
+		if (options?.initialValues) this.initialValues = options.initialValues;
+		if (options?.plugins) for (const plugin$1 of options.plugins) this.use(plugin$1);
+	}
+	async "~triggerCleanup"(e) {
+		const cs = this.cleanups.get(e);
+		if (cs) for (const c of Array.from(cs.values()).reverse()) await c();
+	}
+	async "~triggerUpdate"(e) {
+		const ce = this.cache.get(e);
+		if (!ce) throw new Error("Executor is not yet resolved");
+		const ou = this.onUpdates.get(e);
+		if (ou) for (const t of Array.from(ou.values())) if (isMainExecutor(t)) {
+			if (this.cleanups.has(t)) this["~triggerCleanup"](t);
+			const a = this.cache.get(t);
+			await a.accessor.resolve(true);
+			if (this.onUpdates.has(t)) await this["~triggerUpdate"](t);
+		} else await t(ce.accessor);
+	}
+	async "~resolveExecutor"(ie, ref) {
+		const e = getExecutor(ie);
+		const a = this["~makeAccessor"](e);
+		if (isLazyExecutor(ie)) return a;
+		if (isReactiveExecutor(ie)) {
+			const c = this.onUpdates.get(ie.executor) ?? new Set();
+			this.onUpdates.set(ie.executor, c);
+			c.add(ref);
+		}
+		await a.resolve(false);
+		if (isStaticExecutor(ie)) return a;
+		return a.get();
+	}
+	async "~resolveDependencies"(ie, ref) {
+		if (ie === void 0) return void 0;
+		if (isExecutor(ie)) return this["~resolveExecutor"](ie, ref);
+		if (Array.isArray(ie)) return await Promise.all(ie.map((item) => this["~resolveDependencies"](item, ref)));
+		const r = {};
+		for (const k of Object.keys(ie)) {
+			const t = ie[k];
+			const rd = await this["~resolveDependencies"](t, ref);
+			r[k] = rd;
+		}
+		return r;
+	}
+	"~ensureNotDisposed"() {
+		if (this.disposed) throw new Error("Scope is disposed");
+	}
+	"~makeAccessor"(e) {
+		let requestor = isLazyExecutor(e) || isReactiveExecutor(e) || isStaticExecutor(e) ? e.executor : e;
+		const cachedAccessor = this.cache.get(requestor);
+		if (cachedAccessor) return cachedAccessor.accessor;
+		const accessor = {};
+		const controller = {
+			cleanup: (cleanup) => {
+				const currentSet = this.cleanups.get(requestor) ?? new Set();
+				this.cleanups.set(requestor, currentSet);
+				currentSet.add(cleanup);
+			},
+			release: async () => this.release(requestor),
+			reload: async () => {
+				await this.resolve(requestor, true);
+			},
+			scope: this
+		};
+		const resolve = (force) => {
+			this["~ensureNotDisposed"]();
+			const entry = this.cache.get(requestor);
+			const cached = entry?.value;
+			if (cached && !force) if (cached.kind === "resolved") return Promise.resolve(cached.value);
+			else if (cached.kind === "rejected") throw cached.error;
+			else return cached.promise;
+			const promise = new Promise((resolve$1, reject) => {
+				const replacer = this.initialValues.find((item) => item.executor === requestor);
+				let factory = requestor.factory;
+				let dependencies = requestor.dependencies;
+				if (replacer) {
+					const value = replacer.value;
+					if (!isExecutor(value)) return setTimeout(() => {
+						this.cache.set(requestor, {
+							accessor,
+							value: {
+								kind: "resolved",
+								value: replacer.value
+							}
+						});
+						resolve$1(replacer.value);
+					}, 0);
+					factory = value.factory;
+					dependencies = value.dependencies;
+				}
+				this["~resolveDependencies"](dependencies, requestor).then((dependencies$1) => {
+					try {
+						const factoryResult = factory(dependencies$1, controller);
+						if (factoryResult instanceof Promise) return factoryResult.catch((asyncError) => {
+							const executorName = getExecutorName(requestor);
+							const dependencyChain = [executorName];
+							const factoryError = createFactoryError(ErrorCodes.FACTORY_ASYNC_ERROR, executorName, dependencyChain, asyncError, {
+								dependenciesResolved: dependencies$1 !== void 0,
+								factoryType: typeof factory,
+								isAsyncFactory: true
+							});
+							throw factoryError;
+						});
+						return factoryResult;
+					} catch (error) {
+						const executorName = getExecutorName(requestor);
+						const dependencyChain = [executorName];
+						const factoryError = createFactoryError(ErrorCodes.FACTORY_THREW_ERROR, executorName, dependencyChain, error, {
+							dependenciesResolved: dependencies$1 !== void 0,
+							factoryType: typeof factory,
+							isAsyncFactory: false
+						});
+						throw factoryError;
+					}
+				}).then(async (result) => {
+					let current = result;
+					if (isGenerator(result) || isAsyncGenerator(result)) try {
+						const { returned } = await collectFromGenerator(result);
+						current = returned;
+					} catch (generatorError) {
+						const executorName = getExecutorName(requestor);
+						const dependencyChain = [executorName];
+						const factoryError = createFactoryError(ErrorCodes.FACTORY_GENERATOR_ERROR, executorName, dependencyChain, generatorError, {
+							generatorType: isGenerator(result) ? "sync" : "async",
+							factoryType: typeof factory
+						});
+						throw factoryError;
+					}
+					const events = this.onEvents.change;
+					for (const event of events) {
+						const updated = await event("resolve", requestor, current, this);
+						if (updated !== void 0 && updated.executor === requestor) current = updated.value;
+					}
+					this.cache.set(requestor, {
+						accessor,
+						value: {
+							kind: "resolved",
+							value: current
+						}
+					});
+					resolve$1(current);
+				}).catch((error) => {
+					let enhancedError = error;
+					let errorContext = void 0;
+					if (error?.context && error?.code) {
+						enhancedError = error;
+						errorContext = error.context;
+					} else {
+						const executorName = getExecutorName(requestor);
+						const dependencyChain = [executorName];
+						enhancedError = createSystemError(ErrorCodes.INTERNAL_RESOLUTION_ERROR, executorName, dependencyChain, error, {
+							errorType: error?.constructor?.name || "UnknownError",
+							resolutionPhase: "post-factory"
+						});
+						errorContext = enhancedError.context;
+					}
+					this.cache.set(requestor, {
+						accessor,
+						value: {
+							kind: "rejected",
+							error,
+							context: errorContext,
+							enhancedError
+						}
+					});
+					reject(enhancedError);
+				});
+			});
+			this.cache.set(requestor, {
+				accessor,
+				value: {
+					kind: "pending",
+					promise
+				}
+			});
+			return promise;
+		};
+		return Object.assign(accessor, {
+			get: () => {
+				this["~ensureNotDisposed"]();
+				const cacheEntry = this.cache.get(requestor)?.value;
+				if (!cacheEntry || cacheEntry.kind === "pending") throw new Error("Executor is not resolved");
+				if (cacheEntry.kind === "rejected") throw cacheEntry.enhancedError || cacheEntry.error;
+				return cacheEntry.value;
+			},
+			lookup: () => {
+				this["~ensureNotDisposed"]();
+				const cacheEntry = this.cache.get(requestor);
+				if (!cacheEntry) return void 0;
+				return cacheEntry.value;
+			},
+			metas: e.metas,
+			resolve,
+			release: async (soft = false) => {
+				this.release(requestor, soft);
+			},
+			update: (updateFn) => {
+				return this.update(requestor, updateFn);
+			},
+			set: async (value) => {
+				return this.update(requestor, value);
+			},
+			subscribe: (cb) => {
+				this["~ensureNotDisposed"]();
+				return this.onUpdate(requestor, cb);
+			}
+		});
+	}
+	accessor(executor) {
+		this["~ensureNotDisposed"]();
+		return this["~makeAccessor"](executor);
+	}
+	entries() {
+		return Array.from(this.cache.entries()).map(([executor, entry]) => {
+			return [executor, entry.accessor];
+		});
+	}
+	async resolve(executor, force = false) {
+		this["~ensureNotDisposed"]();
+		const accessor = this["~makeAccessor"](executor);
+		await accessor.resolve(force);
+		return accessor.get();
+	}
+	async resolveAccessor(executor, force = false) {
+		this["~ensureNotDisposed"]();
+		const accessor = this["~makeAccessor"](executor);
+		await accessor.resolve(force);
+		return accessor;
+	}
+	async update(e, u) {
+		if (this.isDisposing) return;
+		this["~ensureNotDisposed"]();
+		this["~triggerCleanup"](e);
+		const accessor = this["~makeAccessor"](e);
+		let value;
+		if (typeof u === "function") {
+			const fn = u;
+			value = fn(accessor.get());
+		} else value = u;
+		const events = this.onEvents.change;
+		for (const event of events) {
+			const updated = await event("update", e, value, this);
+			if (updated !== void 0 && e === updated.executor) value = updated.value;
+		}
+		this.cache.set(e, {
+			accessor,
+			value: {
+				kind: "resolved",
+				value
+			}
+		});
+		await this["~triggerUpdate"](e);
+	}
+	async set(e, value) {
+		return this.update(e, value);
+	}
+	async release(e, s = false) {
+		this["~ensureNotDisposed"]();
+		const ce = this.cache.get(e);
+		if (!ce && !s) throw new Error("Executor is not yet resolved");
+		await this["~triggerCleanup"](e);
+		const events = this.onEvents.release;
+		for (const event of events) await event("release", e, this);
+		const ou = this.onUpdates.get(e);
+		if (ou) {
+			for (const t of Array.from(ou.values())) if (isMainExecutor(t)) await this.release(t, true);
+			this.onUpdates.delete(e);
+		}
+		this.cache.delete(e);
+	}
+	async dispose() {
+		this["~ensureNotDisposed"]();
+		this.isDisposing = true;
+		for (const pod of this.pods) await this.disposePod(pod);
+		const disposeEvents = this.plugins.map((m) => m.dispose?.(this) ?? Promise.resolve());
+		await Promise.all(disposeEvents);
+		const currents = this.cache.keys();
+		for (const current of currents) await this.release(current, true);
+		this.disposed = true;
+		this.cache.clear();
+		this.cleanups.clear();
+		this.onUpdates.clear();
+		this.onEvents.change.clear();
+		this.onEvents.release.clear();
+	}
+	onUpdate(e, cb) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
+		const ou = this.onUpdates.get(e) ?? new Set();
+		this.onUpdates.set(e, ou);
+		ou.add(cb);
+		return () => {
+			this["~ensureNotDisposed"]();
+			const ou$1 = this.onUpdates.get(e);
+			if (ou$1) {
+				ou$1.delete(cb);
+				if (ou$1.size === 0) this.onUpdates.delete(e);
+			}
+		};
+	}
+	onChange(callback) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
+		this.onEvents["change"].add(callback);
+		return () => {
+			this["~ensureNotDisposed"]();
+			this.onEvents["change"].delete(callback);
+		};
+	}
+	onRelease(cb) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
+		this.onEvents["release"].add(cb);
+		return () => {
+			this["~ensureNotDisposed"]();
+			this.onEvents["release"].delete(cb);
+		};
+	}
+	use(plugin$1) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
+		this.plugins.push(plugin$1);
+		plugin$1.init?.(this, { registry: this.registry });
+		return () => {
+			this["~ensureNotDisposed"]();
+			this.plugins = this.plugins.filter((m) => m !== plugin$1);
+		};
+	}
+	pods = new Set();
+	pod(...preset$1) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
+		const pod = new Pod(this, { initialValues: preset$1 });
+		this.pods.add(pod);
+		return pod;
+	}
+	async disposePod(pod) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) return;
+		await pod.dispose();
+		this.pods.delete(pod);
+	}
+};
+function createScope(...opt) {
+	if (opt.at(0) === void 0) return new BaseScope();
+	if (opt.length === 1 && !isPreset(opt[0])) return new BaseScope(opt[0]);
+	return new BaseScope({ initialValues: opt });
+}
+function plugin(m) {
+	return m;
+}
+var Pod = class extends BaseScope {
+	parentScope;
+	constructor(scope, option) {
+		super(option);
+		this.parentScope = scope;
+	}
+	/**
+	* Expect to resolve everything in pod. Unless it's already resolved in the main
+	* @param executor
+	* @param force
+	* @returns
+	*/
+	async resolve(executor, force) {
+		if (this.cache.has(executor)) return super.resolve(executor, force);
+		if (this.parentScope["cache"].has(executor)) {
+			const { value } = this.parentScope["cache"].get(executor);
+			const accessor = super["~makeAccessor"](executor);
+			this["cache"].set(executor, {
+				accessor,
+				value
+			});
+			if (value.kind === "rejected") throw value.error;
+			if (value.kind === "resolved") return value.value;
+			if (value.kind === "pending") return await value.promise;
+		}
+		return await super.resolve(executor, force);
+	}
+	async "~resolveExecutor"(ie, ref) {
+		if (isReactiveExecutor(ie)) throw new Error("Reactive executors cannot be used in pod");
+		const t = getExecutor(ie);
+		const a = this["~makeAccessor"](t);
+		if (this.parentScope["cache"].has(t)) {
+			const { value } = this.parentScope["cache"].get(t);
+			this["cache"].set(t, {
+				accessor: a,
+				value
+			});
+		}
+		return await super["~resolveExecutor"](ie, ref);
+	}
+};
+
+//#endregion
+//#region src/flow.ts
+var flow_exports = {};
+__export(flow_exports, {
+	FlowError: () => FlowError,
+	createInitialContext: () => createInitialContext,
+	derive: () => derive$1,
+	execute: () => execute,
+	provide: () => provide$1
+});
+function createInitialContext(initializers) {
+	const context = new Map();
+	for (const [_, config] of Object.entries(initializers)) {
+		const { accessor, value } = config;
+		context.set(accessor.key, value);
+	}
+	return context;
+}
+function provide$1(config, handler) {
+	const executor = createExecutor(() => ({
+		execution: handler,
+		input: config.input,
+		output: config.output,
+		plugins: config.plugins || [],
+		metas: config.metas || [],
+		name: config.name,
+		description: config.description
+	}), void 0, config.metas || []);
+	Object.assign(executor, config);
+	return executor;
+}
+function derive$1({ dependencies,...config }, handler) {
+	const executor = createExecutor((deps) => ({
+		execution: (input, controller) => handler(deps, input, controller),
+		input: config.input,
+		output: config.output,
+		plugins: config.plugins || [],
+		metas: config.metas || [],
+		name: config.name,
+		description: config.description
+	}), dependencies, config.metas || []);
+	Object.assign(executor, config);
+	return executor;
+}
+var FlowError = class extends Error {
+	code;
+	category;
+	constructor(message, details) {
+		super(message);
+		this.details = details;
+		if (details && "cause" in details) this.cause = details.cause;
+		this.name = "FlowError";
+		if (details?.enhancedError) {
+			this.code = details.errorCode || ErrorCodes.FLOW_EXECUTION_FAILED;
+			this.category = details.errorCategory || "USER_ERROR";
+		} else {
+			this.code = ErrorCodes.FLOW_EXECUTION_FAILED;
+			this.category = "USER_ERROR";
+		}
+	}
+	/**
+	* Get the original enhanced error if available
+	*/
+	getEnhancedError() {
+		return this.details?.enhancedError;
+	}
+	/**
+	* Get the error context from enhanced error if available
+	*/
+	getErrorContext() {
+		return this.details?.errorContext;
+	}
+	/**
+	* Get flow-specific context
+	*/
+	getFlowContext() {
+		return {
+			flowName: this.details?.flowName,
+			flowDescription: this.details?.flowDescription
+		};
+	}
+};
+function createController(context, opt) {
+	const controller = {
+		context,
+		safeExecute: async (flowDef, param, opts) => {
+			try {
+				let resolvedFlow;
+				if ("execution" in flowDef && typeof flowDef.execution === "function") resolvedFlow = flowDef;
+				else if (context.scope) resolvedFlow = await context.scope.pod().resolve(flowDef);
+				else throw new FlowError("Cannot resolve executor without a scope");
+				const validatedInput = validate(resolvedFlow.input, param);
+				const childData = new Map(context.data);
+				if (opts?.initialContext) for (const [key, value] of opts.initialContext) childData.set(key, value);
+				const childContext = {
+					data: childData,
+					parent: context,
+					scope: context.scope,
+					plugins: [...context.plugins, ...opts?.plugins || []],
+					flow: resolvedFlow,
+					get(key) {
+						return childData.get(key);
+					},
+					set(key, value) {
+						return childData.set(key, value);
+					}
+				};
+				const childController = createController(childContext, opt);
+				let execution = async () => resolvedFlow.execution(validatedInput, childController);
+				for (let i = childContext.plugins.length - 1; i >= 0; i--) {
+					const plugin$1 = childContext.plugins[i];
+					const prevExecution = execution;
+					execution = () => plugin$1.wrap(childContext, prevExecution);
+				}
+				const result = await execution();
+				return {
+					kind: "success",
+					value: result
+				};
+			} catch (error) {
+				const wrappedError = error instanceof FlowError ? error : new FlowError(error instanceof Error ? error.message : "Flow execution failed", { cause: error });
+				return {
+					kind: "error",
+					error: wrappedError
+				};
+			}
+		},
+		execute: async (flowDef, param, opts) => {
+			const result = await controller.safeExecute(flowDef, param, opts);
+			if (result.kind === "error") throw result.error;
+			return result.value;
+		}
+	};
+	return controller;
+}
+async function execute(executor, input, opt) {
+	const isOwnScope = !opt?.scope;
+	const scope = opt?.scope || createScope();
+	const pod = scope.pod(...opt?.presets || []);
+	let flow;
+	try {
+		flow = await pod.resolve(executor);
+	} catch (error) {
+		if (error instanceof ExecutorResolutionError || error instanceof FactoryExecutionError) throw new FlowError(`Flow execution failed: ${error.message}`, {
+			cause: error,
+			enhancedError: error,
+			errorCode: error.code,
+			errorCategory: error.category,
+			errorContext: error.context,
+			flowName: opt?.name,
+			flowDescription: opt?.description
+		});
+		else {
+			const errorMessage = error instanceof Error ? error.message : String(error);
+			throw new FlowError(`Failed to resolve executor: ${errorMessage}`, {
+				cause: error,
+				flowName: opt?.name,
+				flowDescription: opt?.description
+			});
+		}
+	}
+	const contextData = opt?.initialContext || new Map();
+	const context = {
+		data: contextData,
+		parent: void 0,
+		scope,
+		plugins: opt?.plugins || [],
+		flow,
+		get(key) {
+			return contextData.get(key);
+		},
+		set(key, value) {
+			return contextData.set(key, value);
+		}
+	};
+	const controller = createController(context, opt);
+	const flowWithContext = {
+		...flow,
+		context
+	};
+	let executionResult;
+	try {
+		const validatedInput = validate(flow.input, input);
+		let execution = async () => flow.execution(validatedInput, controller);
+		for (let i = context.plugins.length - 1; i >= 0; i--) {
+			const plugin$1 = context.plugins[i];
+			const prevExecution = execution;
+			execution = () => plugin$1.wrap(context, prevExecution);
+		}
+		const result = await execution();
+		executionResult = {
+			kind: "success",
+			value: result
+		};
+	} catch (error) {
+		const wrappedError = error instanceof FlowError ? error : new FlowError(error instanceof Error ? error.message : "Flow execution failed", { cause: error });
+		executionResult = {
+			kind: "error",
+			error: wrappedError
+		};
+	}
+	if (isOwnScope) await scope.dispose();
+	else await scope.disposePod(pod);
+	return {
+		context: flowWithContext.context,
+		result: executionResult
+	};
+}
+
+//#endregion
+//#region src/data-accessor.ts
+const data = (key, schema) => {
+	const _key = typeof key === "string" ? Symbol(key) : key;
+	return {
+		key: _key,
+		get(store) {
+			const value = store.get(_key);
+			if (value === void 0) throw new Error(`Data not found for key: ${String(key)}`);
+			return validate(schema, value);
+		},
+		find(store) {
+			const maybeValue = store.get(_key);
+			if (maybeValue) return validate(schema, maybeValue);
+			return void 0;
+		},
+		set(store, value) {
+			const validated = validate(schema, value);
+			store.set(_key, validated);
+		},
+		preset(value) {
+			return [_key, value];
+		}
+	};
+};
+
+//#endregion
+//#region src/helpers.ts
+async function resolves(scope, executors) {
+	const objectOutput = {};
+	const arrayOutput = [];
+	const isArray = Array.isArray(executors);
+	for (const [index, executor] of Object.entries(executors)) {
+		const target = !isExecutor(executor) ? executor.escape() : isLazyExecutor(executor) || isReactiveExecutor(executor) || isStaticExecutor(executor) ? executor.executor : executor;
+		const result$1 = await scope.resolve(target);
+		if (isArray) arrayOutput.push(result$1);
+		else Object.assign(objectOutput, { [index]: result$1 });
+	}
+	const result = isArray ? arrayOutput : objectOutput;
+	return result;
+}
+function prepare(scope, executor) {
+	const fn = async () => {
+		return await scope.resolve(executor);
+	};
+	return Object.assign(fn, { escape: () => {
+		return executor;
+	} });
+}
+function adapt(scope, executor) {
+	const fn = async (...args) => {
+		const fn$1 = await scope.resolve(executor);
+		return await fn$1(...args);
+	};
+	return Object.assign(fn, { escape: () => {
+		return executor;
+	} });
+}
+
+//#endregion
+//#region src/plugins.ts
+var plugins_exports = {};
+__export(plugins_exports, { eager: () => eager });
+const eager = {
+	meta: meta(Symbol.for("@pumped-fn/plugin/eager"), custom()),
+	plugin: () => ({ init(scope, { registry }) {
+		for (const executor of registry) {
+			const isEager = eager.meta.find(executor);
+			if (isEager) scope.resolve(executor);
+		}
+	} })
+};
+
+//#endregion
+//#region src/index.ts
+const name = meta("pumped-fn/name", custom());
+
+//#endregion
+exports.DependencyResolutionError = DependencyResolutionError;
+exports.ErrorCodes = ErrorCodes;
+exports.ErrorMessages = ErrorMessages;
+exports.ExecutorResolutionError = ExecutorResolutionError;
+exports.FactoryExecutionError = FactoryExecutionError;
+exports.FlowError = FlowError;
+exports.SchemaError = SchemaError;
+exports.adapt = adapt;
+exports.buildDependencyChain = buildDependencyChain;
+exports.collectFromGenerator = collectFromGenerator;
+exports.createDependencyError = createDependencyError;
+exports.createFactoryError = createFactoryError;
+exports.createScope = createScope;
+exports.createSystemError = createSystemError;
+exports.custom = custom;
+exports.dataAccessor = data;
+exports.derive = derive;
+exports.executorSymbol = executorSymbol;
+exports.findValue = findValue;
+exports.findValues = findValues;
+Object.defineProperty(exports, 'flow', {
+  enumerable: true,
+  get: function () {
+    return flow_exports;
+  }
+});
+exports.formatErrorMessage = formatErrorMessage;
+exports.getExecutorName = getExecutorName;
+exports.getValue = getValue;
+exports.isAsyncGenerator = isAsyncGenerator;
+exports.isAsyncGeneratorFunction = isAsyncGeneratorFunction;
+exports.isExecutor = isExecutor;
+exports.isGenerator = isGenerator;
+exports.isGeneratorFunction = isGeneratorFunction;
+exports.isIterableOrAsyncIterable = isIterableOrAsyncIterable;
+exports.isLazyExecutor = isLazyExecutor;
+exports.isMainExecutor = isMainExecutor;
+exports.isPreset = isPreset;
+exports.isReactiveExecutor = isReactiveExecutor;
+exports.isStaticExecutor = isStaticExecutor;
+exports.meta = meta;
+exports.metaSymbol = metaSymbol;
+Object.defineProperty(exports, 'multi', {
+  enumerable: true,
+  get: function () {
+    return multi_exports;
+  }
+});
+exports.name = name;
+exports.plugin = plugin;
+Object.defineProperty(exports, 'plugins', {
+  enumerable: true,
+  get: function () {
+    return plugins_exports;
+  }
+});
+exports.prepare = prepare;
+exports.preset = preset;
+exports.processGenerator = processGenerator;
+exports.provide = provide;
+exports.resolves = resolves;
+exports.validate = validate;
+exports.validateAsync = validateAsync;