@pumped-fn/core-next 0.5.55 → 0.5.58

package/dist/index.cjs

@@ -56,22 +56,12 @@ var DependencyResolutionError = class extends ExecutorResolutionError {
 
 //#endregion
 //#region src/ssch.ts
-function validate(schema, data$1) {
-	const result = schema["~standard"].validate(data$1);
+function validate(schema, data) {
+	const result = schema["~standard"].validate(data);
 	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",
@@ -84,54 +74,52 @@ function custom() {
 
 //#endregion
 //#region src/meta.ts
+var MetaFunction = class {
+	key;
+	schema;
+	[metaSymbol] = true;
+	constructor(key, schema) {
+		this.key = typeof key === "string" ? Symbol(key) : key;
+		this.schema = schema;
+	}
+	__call(value) {
+		return {
+			[metaSymbol]: true,
+			key: this.key,
+			schema: this.schema,
+			value
+		};
+	}
+	partial(d) {
+		return Object.assign({}, this.__call({}), d);
+	}
+	some(source) {
+		return findValues(source, this);
+	}
+	find(source) {
+		return findValue(source, this);
+	}
+	get(source) {
+		return getValue(findValue(source, this));
+	}
+};
 const meta = (key, schema) => {
-	const _key = typeof key === "string" ? Symbol(key) : key;
-	const fn = (value) => ({
-		[metaSymbol]: true,
-		key: _key,
-		schema,
-		value
-	});
+	const metaFunc = new MetaFunction(key, schema);
+	const fn = (value) => metaFunc.__call(value);
 	Object.defineProperty(fn, "key", {
-		value: _key,
-		configurable: false,
-		enumerable: false,
-		writable: false
+		value: metaFunc.key,
+		writable: false,
+		configurable: 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
-		}
+		writable: false,
+		configurable: false
 	});
+	fn.partial = metaFunc.partial.bind(metaFunc);
+	fn.some = metaFunc.some.bind(metaFunc);
+	fn.find = metaFunc.find.bind(metaFunc);
+	fn.get = metaFunc.get.bind(metaFunc);
 	return fn;
 };
 function getValue(meta$1) {
@@ -149,214 +137,81 @@ function findValue(executor, meta$1) {
 }
 
 //#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;
+//#region src/accessor.ts
+function isDataStore(source) {
+	return "get" in source && "set" in source;
 }
-function isLazyExecutor(executor) {
-	return executor[executorSymbol] === "lazy";
+function isMetaArray(source) {
+	return Array.isArray(source);
 }
-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;
+function extractFromSource(source, key, schema) {
+	if (isDataStore(source)) {
+		const value = source.get(key);
+		return value === void 0 ? void 0 : validate(schema, value);
 	}
+	if (isMetaArray(source)) {
+		const meta$2 = source.find((m) => m.key === key);
+		return meta$2 ? validate(schema, meta$2.value) : void 0;
+	}
+	const metas = source.metas ?? [];
+	const meta$1 = metas.find((m) => m.key === key);
+	return meta$1 ? validate(schema, meta$1.value) : void 0;
 }
-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;
+var AccessorImpl$1 = class {
+	key;
+	schema;
+	constructor(key, schema) {
+		this.key = typeof key === "string" ? Symbol(key) : key;
+		this.schema = schema;
 	}
+	get(source) {
+		const value = extractFromSource(source, this.key, this.schema);
+		if (value === void 0) throw new Error(`Value not found for key: ${this.key.toString()}`);
+		return value;
+	}
+	find(source) {
+		return extractFromSource(source, this.key, this.schema);
+	}
+	set(source, value) {
+		if (!isDataStore(source)) throw new Error("set() can only be used with DataStore");
+		const validated = validate(this.schema, value);
+		source.set(this.key, validated);
+	}
+	preset(value) {
+		const validated = validate(this.schema, value);
+		return [this.key, validated];
+	}
+};
+var AccessorWithDefaultImpl = class {
+	key;
+	schema;
+	defaultValue;
+	constructor(key, schema, defaultValue) {
+		this.key = typeof key === "string" ? Symbol(key) : key;
+		this.schema = schema;
+		this.defaultValue = validate(schema, defaultValue);
+	}
+	get(source) {
+		const value = extractFromSource(source, this.key, this.schema);
+		return value ?? this.defaultValue;
+	}
+	find(source) {
+		const value = extractFromSource(source, this.key, this.schema);
+		return value ?? this.defaultValue;
+	}
+	set(source, value) {
+		if (!isDataStore(source)) throw new Error("set() can only be used with DataStore");
+		const validated = validate(this.schema, value);
+		source.set(this.key, validated);
+	}
+	preset(value) {
+		const validated = validate(this.schema, value);
+		return [this.key, validated];
+	}
+};
+function accessor(key, schema, defaultValue) {
+	if (defaultValue !== void 0) return new AccessorWithDefaultImpl(key, schema, defaultValue);
+	return new AccessorImpl$1(key, schema);
 }
 
 //#endregion
@@ -528,122 +383,345 @@ function buildDependencyChain(executorStack) {
 }
 
 //#endregion
-//#region src/scope.ts
-function getExecutor(e) {
-	if (isLazyExecutor(e) || isReactiveExecutor(e) || isStaticExecutor(e)) return e.executor;
-	return e;
+//#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;
 }
-var BaseScope = class {
-	disposed = false;
-	cache = new Map();
-	cleanups = new Map();
-	onUpdates = new Map();
-	onEvents = {
-		change: new Set(),
-		release: new Set()
+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
 	};
-	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);
+}
+
+//#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 "~triggerCleanup"(e) {
-		const cs = this.cleanups.get(e);
-		if (cs) for (const c of Array.from(cs.values()).reverse()) await c();
+}
+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;
 	}
-	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);
+}
+
+//#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;
+}
+var PreparedExecutorImpl = class {
+	scope;
+	executor;
+	constructor(scope, executor) {
+		this.scope = scope;
+		this.executor = executor;
+	}
+	async __call() {
+		return await this.scope.resolve(this.executor);
+	}
+	escape() {
+		return this.executor;
+	}
+};
+function prepare(scope, executor) {
+	const impl = new PreparedExecutorImpl(scope, executor);
+	const fn = async () => impl.__call();
+	fn.escape = () => impl.escape();
+	return fn;
+}
+var AdaptedExecutorImpl = class {
+	scope;
+	executor;
+	constructor(scope, executor) {
+		this.scope = scope;
+		this.executor = executor;
+	}
+	async __call(...args) {
+		const fn = await this.scope.resolve(this.executor);
+		return await fn(...args);
+	}
+	escape() {
+		return this.executor;
+	}
+};
+function adapt(scope, executor) {
+	const impl = new AdaptedExecutorImpl(scope, executor);
+	const fn = async (...args) => impl.__call(...args);
+	fn.escape = () => impl.escape();
+	return fn;
+}
+
+//#endregion
+//#region src/multi.ts
+var multi_exports = {};
+__export(multi_exports, {
+	derive: () => derive$1,
+	provide: () => provide$1
+});
+var MultiExecutorImpl = class {
+	option;
+	poolId;
+	keyPool;
+	createNewExecutor;
+	id;
+	constructor(option, poolId, keyPool, createNewExecutor) {
+		this.option = option;
+		this.poolId = poolId;
+		this.keyPool = keyPool;
+		this.createNewExecutor = createNewExecutor;
+		this.id = poolId;
+	}
+	processKey(key) {
+		const validatedKey = validate(this.option.keySchema, key);
+		const transformedKey = this.option.keyTransform ? this.option.keyTransform(validatedKey) : validatedKey;
+		return {
+			validatedKey,
+			transformedKey
+		};
+	}
+	newProvider(key) {
+		const { transformedKey } = this.processKey(key);
+		const executor = this.createNewExecutor(key);
+		this.keyPool.set(transformedKey, executor);
+		return executor;
+	}
+	__call(key) {
+		const { transformedKey } = this.processKey(key);
+		return this.keyPool.get(transformedKey) || this.newProvider(key);
 	}
-	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();
+	providerFactory(ctl) {
+		return (key) => {
+			const { transformedKey } = this.processKey(key);
+			let executor = this.keyPool.get(transformedKey);
+			if (!executor) executor = this.newProvider(key);
+			return ctl.scope.accessor(executor);
+		};
 	}
-	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;
+	async release(scope) {
+		const entries = scope.entries();
+		for (const [executor] of entries) {
+			const check = this.poolId.some ? this.poolId.some(executor) : this.poolId.find(executor);
+			if (check && (Array.isArray(check) ? check.length > 0 : check)) await scope.release(executor);
 		}
-		return r;
 	}
-	"~ensureNotDisposed"() {
-		if (this.disposed) throw new Error("Scope is disposed");
+};
+function createMultiExecutor(option, poolId, keyPool, createNewExecutor, providerMetas) {
+	const impl = new MultiExecutorImpl(option, poolId, keyPool, createNewExecutor);
+	const provider = createExecutor((ctl) => impl.providerFactory(ctl), void 0, providerMetas);
+	const multiExecutor = (key) => impl.__call(key);
+	Object.assign(multiExecutor, provider);
+	multiExecutor.release = (scope) => impl.release(scope);
+	multiExecutor.id = impl.id;
+	return multiExecutor;
+}
+function provide$1(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$1(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/scope.ts
+var AccessorImpl = class {
+	metas;
+	scope;
+	requestor;
+	currentPromise = null;
+	resolve;
+	constructor(scope, requestor, metas) {
+		this.scope = scope;
+		this.requestor = requestor;
+		this.metas = metas;
+		this.resolve = this.createResolveFunction();
+		const existing = this.scope["cache"].get(requestor);
+		if (!existing || !existing.accessor) this.scope["cache"].set(requestor, {
+			accessor: this,
+			value: existing?.value || void 0
+		});
 	}
-	"~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);
+	createResolveFunction() {
+		return (force = false) => {
+			this.scope["~ensureNotDisposed"]();
+			const entry = this.scope["cache"].get(this.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 (this.currentPromise && !force) return this.currentPromise;
+			this.scope["~addToResolutionChain"](this.requestor, this.requestor);
+			this.currentPromise = new Promise((resolve, reject) => {
+				const replacer = this.scope["initialValues"].find((item) => item.executor === this.requestor);
+				let factory = this.requestor.factory;
+				let dependencies = this.requestor.dependencies;
 				if (replacer) {
 					const value = replacer.value;
 					if (!isExecutor(value)) return setTimeout(() => {
-						this.cache.set(requestor, {
-							accessor,
+						this.scope["cache"].set(this.requestor, {
+							accessor: this,
 							value: {
 								kind: "resolved",
 								value: replacer.value
 							}
 						});
-						resolve$1(replacer.value);
+						resolve(replacer.value);
 					}, 0);
 					factory = value.factory;
 					dependencies = value.dependencies;
 				}
-				this["~resolveDependencies"](dependencies, requestor).then((dependencies$1) => {
+				const controller = this.createController();
+				this.scope["~resolveDependencies"](dependencies, this.requestor).then((dependencies$1) => {
 					try {
 						const factoryResult = factory(dependencies$1, controller);
 						if (factoryResult instanceof Promise) return factoryResult.catch((asyncError) => {
-							const executorName = getExecutorName(requestor);
+							const executorName = getExecutorName(this.requestor);
 							const dependencyChain = [executorName];
 							const factoryError = createFactoryError(ErrorCodes.FACTORY_ASYNC_ERROR, executorName, dependencyChain, asyncError, {
 								dependenciesResolved: dependencies$1 !== void 0,
@@ -654,7 +732,7 @@ var BaseScope = class {
 						});
 						return factoryResult;
 					} catch (error) {
-						const executorName = getExecutorName(requestor);
+						const executorName = getExecutorName(this.requestor);
 						const dependencyChain = [executorName];
 						const factoryError = createFactoryError(ErrorCodes.FACTORY_THREW_ERROR, executorName, dependencyChain, error, {
 							dependenciesResolved: dependencies$1 !== void 0,
@@ -669,7 +747,7 @@ var BaseScope = class {
 						const { returned } = await collectFromGenerator(result);
 						current = returned;
 					} catch (generatorError) {
-						const executorName = getExecutorName(requestor);
+						const executorName = getExecutorName(this.requestor);
 						const dependencyChain = [executorName];
 						const factoryError = createFactoryError(ErrorCodes.FACTORY_GENERATOR_ERROR, executorName, dependencyChain, generatorError, {
 							generatorType: isGenerator(result) ? "sync" : "async",
@@ -677,19 +755,21 @@ var BaseScope = class {
 						});
 						throw factoryError;
 					}
-					const events = this.onEvents.change;
+					const events = this.scope["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;
+						const updated = await event("resolve", this.requestor, current, this.scope);
+						if (updated !== void 0 && updated.executor === this.requestor) current = updated.value;
 					}
-					this.cache.set(requestor, {
-						accessor,
+					this.scope["cache"].set(this.requestor, {
+						accessor: this,
 						value: {
 							kind: "resolved",
 							value: current
 						}
 					});
-					resolve$1(current);
+					this.scope["~removeFromResolutionChain"](this.requestor);
+					this.currentPromise = null;
+					resolve(current);
 				}).catch((error) => {
 					let enhancedError = error;
 					let errorContext = void 0;
@@ -697,7 +777,7 @@ var BaseScope = class {
 						enhancedError = error;
 						errorContext = error.context;
 					} else {
-						const executorName = getExecutorName(requestor);
+						const executorName = getExecutorName(this.requestor);
 						const dependencyChain = [executorName];
 						enhancedError = createSystemError(ErrorCodes.INTERNAL_RESOLUTION_ERROR, executorName, dependencyChain, error, {
 							errorType: error?.constructor?.name || "UnknownError",
@@ -705,8 +785,8 @@ var BaseScope = class {
 						});
 						errorContext = enhancedError.context;
 					}
-					this.cache.set(requestor, {
-						accessor,
+					this.scope["cache"].set(this.requestor, {
+						accessor: this,
 						value: {
 							kind: "rejected",
 							error,
@@ -714,48 +794,186 @@ var BaseScope = class {
 							enhancedError
 						}
 					});
+					this.scope["~removeFromResolutionChain"](this.requestor);
+					this.scope["~triggerError"](enhancedError, this.requestor);
+					this.currentPromise = null;
 					reject(enhancedError);
 				});
 			});
-			this.cache.set(requestor, {
-				accessor,
+			this.scope["cache"].set(this.requestor, {
+				accessor: this,
 				value: {
 					kind: "pending",
-					promise
+					promise: this.currentPromise
 				}
 			});
-			return promise;
+			return this.currentPromise;
 		};
-		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);
+	}
+	lookup() {
+		this.scope["~ensureNotDisposed"]();
+		const cacheEntry = this.scope["cache"].get(this.requestor);
+		if (!cacheEntry) return void 0;
+		return cacheEntry.value || void 0;
+	}
+	get() {
+		this.scope["~ensureNotDisposed"]();
+		const cacheEntry = this.scope["cache"].get(this.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;
+	}
+	async release(soft = false) {
+		this.scope.release(this.requestor, soft);
+	}
+	async update(updateFn) {
+		return this.scope.update(this.requestor, updateFn);
+	}
+	async set(value) {
+		return this.scope.update(this.requestor, value);
+	}
+	subscribe(cb) {
+		this.scope["~ensureNotDisposed"]();
+		return this.scope.onUpdate(this.requestor, cb);
+	}
+	createController() {
+		return {
+			cleanup: (cleanup) => {
+				const currentSet = this.scope["cleanups"].get(this.requestor) ?? new Set();
+				this.scope["cleanups"].set(this.requestor, currentSet);
+				currentSet.add(cleanup);
 			},
-			set: async (value) => {
-				return this.update(requestor, value);
+			release: async () => this.scope.release(this.requestor),
+			reload: async () => {
+				await this.scope.resolve(this.requestor, true);
 			},
-			subscribe: (cb) => {
-				this["~ensureNotDisposed"]();
-				return this.onUpdate(requestor, cb);
-			}
-		});
+			scope: this.scope
+		};
+	}
+};
+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(),
+		error: new Set()
+	};
+	onErrors = new Map();
+	isPod;
+	isDisposing = false;
+	resolutionChain = new Map();
+	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);
+	}
+	"~checkCircularDependency"(executor, resolvingExecutor) {
+		const currentChain = this.resolutionChain.get(resolvingExecutor);
+		if (currentChain && currentChain.has(executor)) {
+			const chainArray = Array.from(currentChain);
+			const dependencyChain = buildDependencyChain(chainArray);
+			throw createDependencyError(ErrorCodes.CIRCULAR_DEPENDENCY, getExecutorName(executor), dependencyChain, getExecutorName(executor), void 0, {
+				circularPath: dependencyChain.join(" -> ") + " -> " + getExecutorName(executor),
+				detectedAt: getExecutorName(resolvingExecutor)
+			});
+		}
+	}
+	"~addToResolutionChain"(executor, resolvingExecutor) {
+		const currentChain = this.resolutionChain.get(resolvingExecutor) || new Set();
+		currentChain.add(executor);
+		this.resolutionChain.set(resolvingExecutor, currentChain);
+	}
+	"~removeFromResolutionChain"(executor) {
+		this.resolutionChain.delete(executor);
+	}
+	"~propagateResolutionChain"(fromExecutor, toExecutor) {
+		const fromChain = this.resolutionChain.get(fromExecutor);
+		if (fromChain) {
+			const newChain = new Set(fromChain);
+			newChain.add(fromExecutor);
+			this.resolutionChain.set(toExecutor, newChain);
+		}
+	}
+	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 "~triggerError"(error, executor) {
+		const executorCallbacks = this.onErrors.get(executor);
+		if (executorCallbacks) for (const callback of Array.from(executorCallbacks.values())) try {
+			await callback(error, executor, this);
+		} catch (callbackError) {
+			console.error("Error in error callback:", callbackError);
+		}
+		for (const callback of Array.from(this.onEvents.error.values())) try {
+			await callback(error, executor, this);
+		} catch (callbackError) {
+			console.error("Error in global error callback:", callbackError);
+		}
+		for (const plugin$1 of this.plugins) if (plugin$1.onError) try {
+			await plugin$1.onError(error, executor, this);
+		} catch (pluginError) {
+			console.error("Error in plugin error handler:", pluginError);
+		}
+	}
+	async "~resolveExecutor"(ie, ref) {
+		const e = getExecutor(ie);
+		this["~checkCircularDependency"](e, ref);
+		this["~propagateResolutionChain"](ref, e);
+		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 && cachedAccessor.accessor) return cachedAccessor.accessor;
+		const accessor$1 = new AccessorImpl(this, requestor, e.metas);
+		return accessor$1;
 	}
 	accessor(executor) {
 		this["~ensureNotDisposed"]();
@@ -768,25 +986,25 @@ var BaseScope = class {
 	}
 	async resolve(executor, force = false) {
 		this["~ensureNotDisposed"]();
-		const accessor = this["~makeAccessor"](executor);
-		await accessor.resolve(force);
-		return accessor.get();
+		const accessor$1 = this["~makeAccessor"](executor);
+		await accessor$1.resolve(force);
+		return accessor$1.get();
 	}
 	async resolveAccessor(executor, force = false) {
 		this["~ensureNotDisposed"]();
-		const accessor = this["~makeAccessor"](executor);
-		await accessor.resolve(force);
-		return accessor;
+		const accessor$1 = this["~makeAccessor"](executor);
+		await accessor$1.resolve(force);
+		return accessor$1;
 	}
 	async update(e, u) {
 		if (this.isDisposing) return;
 		this["~ensureNotDisposed"]();
 		this["~triggerCleanup"](e);
-		const accessor = this["~makeAccessor"](e);
+		const accessor$1 = this["~makeAccessor"](e);
 		let value;
 		if (typeof u === "function") {
 			const fn = u;
-			value = fn(accessor.get());
+			value = fn(accessor$1.get());
 		} else value = u;
 		const events = this.onEvents.change;
 		for (const event of events) {
@@ -794,7 +1012,7 @@ var BaseScope = class {
 			if (updated !== void 0 && e === updated.executor) value = updated.value;
 		}
 		this.cache.set(e, {
-			accessor,
+			accessor: accessor$1,
 			value: {
 				kind: "resolved",
 				value
@@ -833,6 +1051,9 @@ var BaseScope = class {
 		this.onUpdates.clear();
 		this.onEvents.change.clear();
 		this.onEvents.release.clear();
+		this.onEvents.error.clear();
+		this.onErrors.clear();
+		this.resolutionChain.clear();
 	}
 	onUpdate(e, cb) {
 		this["~ensureNotDisposed"]();
@@ -867,6 +1088,32 @@ var BaseScope = class {
 			this.onEvents["release"].delete(cb);
 		};
 	}
+	onError(executorOrCallback, callback) {
+		this["~ensureNotDisposed"]();
+		if (this.isDisposing) throw new Error("Cannot register error callback on a disposing scope");
+		if (typeof executorOrCallback === "function") {
+			this.onEvents["error"].add(executorOrCallback);
+			return () => {
+				this["~ensureNotDisposed"]();
+				this.onEvents["error"].delete(executorOrCallback);
+			};
+		}
+		if (callback) {
+			const executor = executorOrCallback;
+			const errorCallbacks = this.onErrors.get(executor) ?? new Set();
+			this.onErrors.set(executor, errorCallbacks);
+			errorCallbacks.add(callback);
+			return () => {
+				this["~ensureNotDisposed"]();
+				const callbacks = this.onErrors.get(executor);
+				if (callbacks) {
+					callbacks.delete(callback);
+					if (callbacks.size === 0) this.onErrors.delete(executor);
+				}
+			};
+		}
+		throw new Error("Invalid arguments for onError");
+	}
 	use(plugin$1) {
 		this["~ensureNotDisposed"]();
 		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
@@ -916,9 +1163,9 @@ var Pod = class extends BaseScope {
 		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);
+			const accessor$1 = super["~makeAccessor"](executor);
 			this["cache"].set(executor, {
-				accessor,
+				accessor: accessor$1,
 				value
 			});
 			if (value.kind === "rejected") throw value.error;
@@ -930,6 +1177,8 @@ var Pod = class extends BaseScope {
 	async "~resolveExecutor"(ie, ref) {
 		if (isReactiveExecutor(ie)) throw new Error("Reactive executors cannot be used in pod");
 		const t = getExecutor(ie);
+		this["~checkCircularDependency"](t, ref);
+		this["~propagateResolutionChain"](ref, t);
 		const a = this["~makeAccessor"](t);
 		if (this.parentScope["cache"].has(t)) {
 			const { value } = this.parentScope["cache"].get(t);
@@ -944,270 +1193,135 @@ var Pod = class extends BaseScope {
 
 //#endregion
 //#region src/flow.ts
-var flow_exports = {};
-__export(flow_exports, {
-	FlowError: () => FlowError,
-	createInitialContext: () => createInitialContext,
-	derive: () => derive$1,
-	execute: () => execute,
-	provide: () => provide$1
+const ok = (data) => ({
+	type: "ok",
+	data
 });
-function createInitialContext(initializers) {
-	const context = new Map();
-	for (const [_, config] of Object.entries(initializers)) {
-		const { accessor, value } = config;
-		context.set(accessor.key, value);
+const ko = (data) => ({
+	type: "ko",
+	data
+});
+const FlowExecutionContext = {
+	depth: accessor("flow.depth", custom(), 0),
+	flowName: accessor("flow.name", custom()),
+	parentFlowName: accessor("flow.parentName", custom()),
+	isParallel: accessor("flow.isParallel", custom(), false)
+};
+var FlowDefinition = class {
+	constructor(name$1, version, input, success, error) {
+		this.name = name$1;
+		this.version = version;
+		this.input = input;
+		this.success = success;
+		this.error = error;
 	}
-	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;
+	provide(handler) {
+		return createExecutor(() => {
+			const flowHandler = async (ctx) => {
+				return handler(ctx, ctx.input);
+			};
+			flowHandler.def = this;
+			return flowHandler;
+		}, void 0, void 0);
+	}
+	derive(dependencies, handler) {
+		return createExecutor((deps) => {
+			const flowHandler = async (ctx) => {
+				return handler(deps, ctx, ctx.input);
+			};
+			flowHandler.def = this;
+			return flowHandler;
+		}, dependencies, void 0);
+	}
+};
+function flow(config) {
+	return new FlowDefinition(config.name, config.version || "1.0.0", config.input, config.success, config.error);
 }
-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";
-		}
+var FlowContext = class FlowContext {
+	contextData = new Map();
+	constructor(input, pod, plugins, parent) {
+		this.input = input;
+		this.pod = pod;
+		this.plugins = plugins;
+		this.parent = parent;
 	}
-	/**
-	* Get the original enhanced error if available
-	*/
-	getEnhancedError() {
-		return this.details?.enhancedError;
+	initializeExecutionContext(flowName, isParallel = false) {
+		const currentDepth = this.parent ? (FlowExecutionContext.depth.find(this.parent) || 0) + 1 : 0;
+		const parentFlowName = this.parent ? FlowExecutionContext.flowName.find(this.parent) : void 0;
+		FlowExecutionContext.depth.set(this, currentDepth);
+		FlowExecutionContext.flowName.set(this, flowName);
+		FlowExecutionContext.parentFlowName.set(this, parentFlowName);
+		FlowExecutionContext.isParallel.set(this, isParallel);
 	}
-	/**
-	* Get the error context from enhanced error if available
-	*/
-	getErrorContext() {
-		return this.details?.errorContext;
+	ok = (data) => ok(data);
+	ko = (data) => ko(data);
+	get(key) {
+		if (this.contextData.has(key)) return this.contextData.get(key);
+		return this.parent?.get(key);
 	}
-	/**
-	* Get flow-specific context
-	*/
-	getFlowContext() {
-		return {
-			flowName: this.details?.flowName,
-			flowDescription: this.details?.flowDescription
-		};
+	set(key, value) {
+		this.contextData.set(key, value);
+		return value;
 	}
-};
-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;
-		}
+	output = (success, value) => {
+		return success ? this.ok(value) : this.ko(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
-			});
-		}
+	async execute(flow$1, input) {
+		const handler = await this.pod.resolve(flow$1);
+		const childContext = new FlowContext(input, this.pod, this.plugins, this);
+		childContext.initializeExecutionContext(handler.def.name, false);
+		return await this.executeWithPlugins(handler, childContext);
 	}
-	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);
+	async executeParallel(flows) {
+		return Promise.all(flows.map(async ([flow$1, input]) => {
+			const childContext = new FlowContext(input, this.pod, this.plugins, this);
+			const handler = await this.pod.resolve(flow$1);
+			childContext.initializeExecutionContext(handler.def.name, true);
+			return this.executeWithPlugins(handler, childContext);
+		}));
+	}
+	async executeWithPlugins(handler, context) {
+		const executeCore = async () => handler(context);
+		let executor = executeCore;
+		for (const plugin$1 of [...this.plugins].reverse()) if (plugin$1.wrap) {
+			const currentExecutor = executor;
+			executor = async () => plugin$1.wrap(context, currentExecutor);
 		}
-	};
-	const controller = createController(context, opt);
-	const flowWithContext = {
-		...flow,
-		context
-	};
-	let executionResult;
+		return executor();
+	}
+};
+async function execute(flow$1, input, options) {
+	const scope = options?.scope || createScope();
+	const shouldDisposeScope = !options?.scope;
+	const pod = scope.pod(...options?.presets || []);
 	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 context = new FlowContext(input, pod, options?.plugins || []);
+		if (options?.initialContext) {
+			if (Array.isArray(options.initialContext)) for (const [accessor$1, value] of options.initialContext) accessor$1.set(context, value);
+			else if (options.initialContext instanceof Map) for (const [key, value] of options.initialContext) context.set(key, value);
 		}
-		const result = await execution();
-		executionResult = {
-			kind: "success",
-			value: result
+		for (const plugin$1 of options?.plugins || []) await plugin$1.init?.(pod, context);
+		const executeCore = async () => {
+			const handler = await pod.resolve(flow$1);
+			const validated = validate(handler.def.input, input);
+			context.input = validated;
+			context.initializeExecutionContext(handler.def.name, false);
+			const result = await handler(context);
+			if (result.type === "ok") validate(handler.def.success, result.data);
+			else validate(handler.def.error, result.data);
+			return 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];
+		let executor = executeCore;
+		for (const plugin$1 of [...options?.plugins || []].reverse()) if (plugin$1.wrap) {
+			const currentExecutor = executor;
+			executor = () => plugin$1.wrap(context, currentExecutor);
 		}
-	};
-};
-
-//#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 });
+		return await executor();
+	} finally {
+		for (const plugin$1 of options?.plugins || []) await plugin$1.dispose?.(pod);
+		await scope.disposePod(pod);
+		if (shouldDisposeScope) await scope.dispose();
 	}
-	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
@@ -1234,8 +1348,9 @@ exports.ErrorCodes = ErrorCodes;
 exports.ErrorMessages = ErrorMessages;
 exports.ExecutorResolutionError = ExecutorResolutionError;
 exports.FactoryExecutionError = FactoryExecutionError;
-exports.FlowError = FlowError;
+exports.FlowExecutionContext = FlowExecutionContext;
 exports.SchemaError = SchemaError;
+exports.accessor = accessor;
 exports.adapt = adapt;
 exports.buildDependencyChain = buildDependencyChain;
 exports.collectFromGenerator = collectFromGenerator;
@@ -1244,17 +1359,12 @@ exports.createFactoryError = createFactoryError;
 exports.createScope = createScope;
 exports.createSystemError = createSystemError;
 exports.custom = custom;
-exports.dataAccessor = data;
 exports.derive = derive;
+exports.execute = execute;
 exports.executorSymbol = executorSymbol;
 exports.findValue = findValue;
 exports.findValues = findValues;
-Object.defineProperty(exports, 'flow', {
-  enumerable: true,
-  get: function () {
-    return flow_exports;
-  }
-});
+exports.flow = flow;
 exports.formatErrorMessage = formatErrorMessage;
 exports.getExecutorName = getExecutorName;
 exports.getValue = getValue;
@@ -1290,5 +1400,4 @@ exports.preset = preset;
 exports.processGenerator = processGenerator;
 exports.provide = provide;
 exports.resolves = resolves;
-exports.validate = validate;
-exports.validateAsync = validateAsync;
+exports.validate = validate;