@pumped-fn/core-next 0.5.78 → 0.5.80

package/dist/index.cjs

@@ -11,9 +11,12 @@ var __export = (all) => {
 
 //#endregion
 
+//#region src/tag-types.ts
+const tagSymbol = Symbol.for("@pumped-fn/core/tag");
+
+//#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) {
@@ -97,71 +100,165 @@ function custom() {
 }
 
 //#endregion
-//#region src/meta.ts
-var MetaFunction = class {
+//#region src/tag.ts
+const tagCacheMap = /* @__PURE__ */ new WeakMap();
+function buildTagCache(tags) {
+	const map = /* @__PURE__ */ new Map();
+	for (const tagged of tags) {
+		const existing = map.get(tagged.key);
+		if (existing) existing.push(tagged.value);
+		else map.set(tagged.key, [tagged.value]);
+	}
+	return map;
+}
+function isStore(source) {
+	return typeof source === "object" && source !== null && "get" in source && "set" in source && typeof source.get === "function" && typeof source.set === "function";
+}
+function extract(source, key, schema) {
+	if (source === null || source === void 0) return;
+	if (isStore(source)) {
+		const value = source.get(key);
+		return value === void 0 ? void 0 : validate(schema, value);
+	}
+	let cache = tagCacheMap.get(source);
+	if (!cache) {
+		cache = buildTagCache(Array.isArray(source) ? source : source.tags ?? []);
+		tagCacheMap.set(source, cache);
+	}
+	const values = cache.get(key);
+	return values && values.length > 0 ? validate(schema, values[0]) : void 0;
+}
+function collect(source, key, schema) {
+	if (isStore(source)) {
+		const value = source.get(key);
+		return value === void 0 ? [] : [validate(schema, value)];
+	}
+	let cache = tagCacheMap.get(source);
+	if (!cache) {
+		cache = buildTagCache(Array.isArray(source) ? source : source.tags ?? []);
+		tagCacheMap.set(source, cache);
+	}
+	const values = cache.get(key);
+	return values ? values.map((v) => validate(schema, v)) : [];
+}
+function write(store, key, schema, value) {
+	const validated = validate(schema, value);
+	store.set(key, validated);
+}
+function createTagged(key, schema, value, label) {
+	const tagged = {
+		[tagSymbol]: true,
+		key,
+		schema,
+		value,
+		toString() {
+			return `${label || key.toString()}=${JSON.stringify(value)}`;
+		},
+		get [Symbol.toStringTag]() {
+			return "Tagged";
+		}
+	};
+	Object.defineProperty(tagged, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, opts) {
+		return `Tagged { ${label || "anonymous"}: ${opts.stylize ? opts.stylize(JSON.stringify(value), "string") : JSON.stringify(value)} }`;
+	} });
+	return tagged;
+}
+var TagImpl = class {
 	key;
 	schema;
-	[metaSymbol] = true;
-	constructor(key, schema) {
-		this.key = typeof key === "string" ? Symbol(key) : key;
+	label;
+	default;
+	constructor(schema, options) {
+		this.label = options?.label;
+		this.key = options?.label ? Symbol.for(options.label) : Symbol();
 		this.schema = schema;
+		this.default = options?.default ?? void 0;
 	}
-	__call(value) {
-		return {
-			[metaSymbol]: true,
-			key: this.key,
-			schema: this.schema,
-			value
-		};
+	get(source) {
+		const value = extract(source, this.key, this.schema);
+		if (value === void 0) {
+			if (this.default !== void 0) return this.default;
+			throw new Error(`Value not found for key: ${this.key.toString()}`);
+		}
+		return value;
 	}
-	partial(d) {
-		return Object.assign({}, this.__call({}), d);
+	find(source) {
+		const value = extract(source, this.key, this.schema);
+		return value !== void 0 ? value : this.default;
 	}
 	some(source) {
-		return findValues(source, this);
+		return collect(source, this.key, this.schema);
 	}
-	find(source) {
-		return findValue(source, this);
+	set(target, value) {
+		if (isStore(target)) {
+			write(target, this.key, this.schema, value);
+			return;
+		}
+		const validated = validate(this.schema, value);
+		return createTagged(this.key, this.schema, validated, this.label);
 	}
-	get(source) {
-		const values = findValues(source, this);
-		if (values.length === 0) throw new Error(`Meta value with key ${String(this.key)} not found`);
-		return values[0];
+	entry(value) {
+		const val = value !== void 0 ? value : this.default;
+		if (val === void 0) throw new Error("Value required for entry without default");
+		const validated = validate(this.schema, val);
+		return [this.key, validated];
+	}
+	toString() {
+		return this.label ? `Tag(${this.label})` : `Tag(${this.key.toString()})`;
+	}
+	get [Symbol.toStringTag]() {
+		return this.label ? `Tag<${this.label}>` : "Tag<anonymous>";
+	}
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return this.label ? `Tag { ${this.label} }` : "Tag { anonymous }";
 	}
 };
-const meta = (key, schema) => {
-	const metaFunc = new MetaFunction(key, schema);
-	const fn = ((value) => metaFunc.__call(value));
+function tag(schema, options) {
+	const impl = new TagImpl(schema, options);
+	const fn = ((value) => {
+		const val = value !== void 0 ? value : impl.default;
+		if (val === void 0) throw new Error("Value required for tag without default");
+		const validated = validate(schema, val);
+		return createTagged(impl.key, impl.schema, validated, impl.label);
+	});
 	Object.defineProperty(fn, "key", {
-		value: metaFunc.key,
+		value: impl.key,
 		writable: false,
 		configurable: false
 	});
-	Object.defineProperty(fn, metaSymbol, {
-		value: true,
+	Object.defineProperty(fn, "schema", {
+		value: impl.schema,
 		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);
+	Object.defineProperty(fn, "label", {
+		value: impl.label,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(fn, "default", {
+		value: impl.default,
+		writable: false,
+		configurable: false
+	});
+	fn.get = impl.get.bind(impl);
+	fn.find = impl.find.bind(impl);
+	fn.some = impl.some.bind(impl);
+	fn.set = impl.set.bind(impl);
+	fn.entry = impl.entry.bind(impl);
+	fn.toString = impl.toString.bind(impl);
+	fn.partial = (d) => {
+		return Object.assign({}, createTagged(impl.key, impl.schema, {}, impl.label), d);
+	};
+	Object.defineProperty(fn, Symbol.toStringTag, { get: () => impl[Symbol.toStringTag] });
+	const inspectSymbol = Symbol.for("nodejs.util.inspect.custom");
+	Object.defineProperty(fn, inspectSymbol, { value: impl[inspectSymbol].bind(impl) });
 	return fn;
-};
-function getValue(meta$1) {
-	return validate(meta$1.schema, meta$1.value);
-}
-function findValues(executor, meta$1) {
-	if (!executor) return [];
-	return (Array.isArray(executor) ? executor : executor.metas ?? []).filter((m) => m.key === meta$1.key).map((m) => getValue(m));
-}
-function findValue(executor, meta$1) {
-	return findValues(executor, meta$1).at(0);
 }
 
 //#endregion
 //#region src/executor.ts
-function createExecutor(factory, dependencies, metas) {
+function createExecutor(factory, dependencies, tags) {
 	const executor = {
 		[executorSymbol]: "main",
 		factory: (_, controller) => {
@@ -169,27 +266,27 @@ function createExecutor(factory, dependencies, metas) {
 			return factory(_, controller);
 		},
 		dependencies,
-		metas
+		tags
 	};
 	const lazyExecutor = {
 		[executorSymbol]: "lazy",
 		dependencies: void 0,
 		executor,
 		factory: void 0,
-		metas
+		tags
 	};
 	const reactiveExecutor = {
 		[executorSymbol]: "reactive",
 		executor,
 		factory: void 0,
 		dependencies: void 0,
-		metas
+		tags
 	};
 	const staticExecutor = {
 		[executorSymbol]: "static",
 		dependencies: void 0,
 		factory: void 0,
-		metas,
+		tags,
 		executor
 	};
 	Object.defineProperties(executor, {
@@ -232,12 +329,12 @@ function isExecutor(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 provide(factory, ...tags) {
+	return createExecutor(factory, void 0, tags);
 }
-function derive(pdependencies, pfactory, ...metas) {
+function derive(pdependencies, pfactory, ...tags) {
 	const factory = (deps, ctl) => pfactory(deps, ctl);
-	return createExecutor(factory, pdependencies, metas);
+	return createExecutor(factory, pdependencies, tags);
 }
 function preset(e, v) {
 	const executor = isExecutor(e) ? e : e.escape();
@@ -547,89 +644,12 @@ function buildDependencyChain(executorStack) {
 	return executorStack.map(getExecutorName);
 }
 
-//#endregion
-//#region src/accessor.ts
-function isDataStore(source) {
-	return "get" in source && "set" in source && typeof source.get === "function" && typeof source.set === "function";
-}
-function isMetaArray(source) {
-	return Array.isArray(source);
-}
-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 meta$1 = (source.metas ?? []).find((m) => m.key === key);
-	return meta$1 ? validate(schema, meta$1.value) : void 0;
-}
-function validateAndSet(source, key, schema, value) {
-	if (!isDataStore(source)) throw new Error("set() can only be used with DataStore");
-	const validated = validate(schema, value);
-	source.set(key, validated);
-}
-function validateAndPreset(key, schema, value) {
-	return [key, validate(schema, value)];
-}
-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) {
-		validateAndSet(source, this.key, this.schema, value);
-	}
-	preset(value) {
-		return validateAndPreset(this.key, this.schema, value);
-	}
-};
-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) {
-		return extractFromSource(source, this.key, this.schema) ?? this.defaultValue;
-	}
-	find(source) {
-		return extractFromSource(source, this.key, this.schema) ?? this.defaultValue;
-	}
-	set(source, value) {
-		validateAndSet(source, this.key, this.schema, value);
-	}
-	preset(value) {
-		return validateAndPreset(this.key, this.schema, value);
-	}
-};
-function accessor(key, schema, defaultValue) {
-	if (defaultValue !== void 0) return new AccessorWithDefaultImpl(key, schema, defaultValue);
-	return new AccessorImpl$1(key, schema);
-}
-
 //#endregion
 //#region src/flow.ts
 function isErrorEntry(entry) {
 	return typeof entry === "object" && entry !== null && "__error" in entry;
 }
-function wrapWithExtensions(extensions, baseExecutor, dataStore, operation) {
+function wrapWithExtensions(extensions, baseExecutor, scope, operation) {
 	if (!extensions || extensions.length === 0) return baseExecutor;
 	let executor = baseExecutor;
 	for (let i = extensions.length - 1; i >= 0; i--) {
@@ -637,28 +657,34 @@ function wrapWithExtensions(extensions, baseExecutor, dataStore, operation) {
 		if (extension$1.wrap) {
 			const current = executor;
 			executor = () => {
-				const result = extension$1.wrap(dataStore, current, operation);
+				const result = extension$1.wrap(scope, current, operation);
 				return result instanceof Promised ? result : Promised.create(result);
 			};
 		}
 	}
 	return executor;
 }
-const flowDefinitionMeta = meta("flow.definition", custom());
+const flowDefinitionMeta = tag(custom(), { label: "flow.definition" });
 const flowMeta = {
-	depth: accessor("flow.depth", custom(), 0),
-	flowName: accessor("flow.name", custom()),
-	parentFlowName: accessor("flow.parentName", custom()),
-	isParallel: accessor("flow.isParallel", custom(), false),
-	journal: accessor("flow.journal", custom())
+	depth: tag(custom(), {
+		label: "flow.depth",
+		default: 0
+	}),
+	flowName: tag(custom(), { label: "flow.name" }),
+	parentFlowName: tag(custom(), { label: "flow.parentName" }),
+	isParallel: tag(custom(), {
+		label: "flow.isParallel",
+		default: false
+	}),
+	journal: tag(custom(), { label: "flow.journal" })
 };
 var FlowDefinition = class {
-	constructor(name$1, version, input, output, metas = []) {
+	constructor(name$1, version, input, output, tags = []) {
 		this.name = name$1;
 		this.version = version;
 		this.input = input;
 		this.output = output;
-		this.metas = metas;
+		this.tags = tags;
 	}
 	handler(dependenciesOrHandler, handlerFn) {
 		if (typeof dependenciesOrHandler === "function") {
@@ -668,7 +694,7 @@ var FlowDefinition = class {
 					return noDepsHandler(ctx, input);
 				};
 				return flowHandler;
-			}, void 0, [...this.metas, flowDefinitionMeta(this)]);
+			}, void 0, [...this.tags, flowDefinitionMeta(this)]);
 			executor$1.definition = this;
 			return executor$1;
 		}
@@ -679,26 +705,26 @@ var FlowDefinition = class {
 				return dependentHandler(deps, ctx, input);
 			};
 			return flowHandler;
-		}, dependencies, [...this.metas, flowDefinitionMeta(this)]);
+		}, dependencies, [...this.tags, flowDefinitionMeta(this)]);
 		executor.definition = this;
 		return executor;
 	}
 };
 function define(config) {
-	return new FlowDefinition(config.name, config.version || "1.0.0", config.input, config.output, config.meta);
+	return new FlowDefinition(config.name || "anonymous", config.version || "1.0.0", config.input, config.output, config.tags || []);
 }
 var FlowContext = class FlowContext {
 	contextData = /* @__PURE__ */ new Map();
 	journal = null;
 	scope;
 	reversedExtensions;
-	metas;
-	constructor(scope, extensions, meta$1, parent) {
+	tags;
+	constructor(scope, extensions, tags, parent) {
 		this.extensions = extensions;
 		this.parent = parent;
 		this.scope = scope;
 		this.reversedExtensions = [...extensions].reverse();
-		this.metas = meta$1;
+		this.tags = tags;
 	}
 	resolve(executor) {
 		return this.scope.resolve(executor);
@@ -711,7 +737,7 @@ var FlowContext = class FlowContext {
 		for (const extension$1 of this.reversedExtensions) if (extension$1.wrap) {
 			const current = executor;
 			executor = () => {
-				const result = extension$1.wrap(this, current, operation);
+				const result = extension$1.wrap(this.scope, current, operation);
 				return result instanceof Promised ? result : Promised.create(result);
 			};
 		}
@@ -729,13 +755,17 @@ var FlowContext = class FlowContext {
 		if (typeof accessorOrKey === "object" && accessorOrKey !== null && "get" in accessorOrKey) return accessorOrKey.get(this);
 		const key = accessorOrKey;
 		if (this.contextData.has(key)) return this.contextData.get(key);
+		if (this.tags && typeof key === "symbol") {
+			const tagged = this.tags.find((m) => m.key === key);
+			if (tagged) return tagged.value;
+		}
 		if (this.parent) return this.parent.get(key);
 	}
-	find(accessor$1) {
-		return accessor$1.find(this);
+	find(accessor) {
+		return accessor.find(this);
 	}
 	set(accessorOrKey, value) {
-		if (typeof accessorOrKey === "object" && accessorOrKey !== null && "set" in accessorOrKey) {
+		if (accessorOrKey !== null && accessorOrKey !== void 0 && (typeof accessorOrKey === "object" || typeof accessorOrKey === "function") && "set" in accessorOrKey) {
 			accessorOrKey.set(this, value);
 			return;
 		}
@@ -935,29 +965,30 @@ var FlowContext = class FlowContext {
 			get: (key) => contextDataSnapshot.get(key),
 			set: (_key, _value) => {
 				throw new Error("Cannot set values on execution snapshot");
-			}
+			},
+			tags: this.tags
 		};
 		return { context: {
-			get(accessor$1) {
-				return accessor$1.get(dataStore);
+			get(accessor) {
+				return accessor.get(dataStore);
 			},
-			find(accessor$1) {
-				return accessor$1.find(dataStore);
+			find(accessor) {
+				return accessor.find(dataStore);
 			}
 		} };
 	}
 };
 function execute(flow$1, input, options) {
-	const scope = options?.scope || createScope({ meta: options?.scopeMeta });
+	const scope = options?.scope || createScope({ tags: options?.scopeTags });
 	const shouldDisposeScope = !options?.scope;
 	let resolveSnapshot;
 	const snapshotPromise = new Promise((resolve) => {
 		resolveSnapshot = resolve;
 	});
 	const promise = (async () => {
-		const context = new FlowContext(scope, options?.extensions || [], options?.meta);
+		const context = new FlowContext(scope, options?.extensions || [], options?.tags);
 		try {
-			if (options?.initialContext) for (const [accessor$1, value] of options.initialContext) accessor$1.set(context, value);
+			if (options?.initialContext) for (const [accessor, value] of options.initialContext) accessor.set(context, value);
 			const executeCore = () => {
 				return scope.resolve(flow$1).map(async (handler) => {
 					const definition$1 = flowDefinitionMeta.find(flow$1);
@@ -971,7 +1002,7 @@ function execute(flow$1, input, options) {
 			};
 			const definition = flowDefinitionMeta.find(flow$1);
 			if (!definition) throw new Error("Flow definition not found in executor metadata");
-			const result = await wrapWithExtensions(options?.extensions, executeCore, context, {
+			const result = await wrapWithExtensions(options?.extensions, executeCore, context.scope, {
 				kind: "execute",
 				flow: flow$1,
 				definition,
@@ -1012,129 +1043,100 @@ function execute(flow$1, input, options) {
 	}
 	return Promised.create(promise, snapshotPromise);
 }
-function flowImpl(definitionOrConfigOrDepsOrHandler, dependenciesOrHandler, handlerFn) {
-	if (typeof definitionOrConfigOrDepsOrHandler === "function") {
-		const handler = definitionOrConfigOrDepsOrHandler;
+function flowImpl(first, second, third) {
+	if (typeof first === "function") {
+		const handler = first;
 		return define({
-			name: "anonymous",
-			version: "1.0.0",
 			input: custom(),
 			output: custom()
 		}).handler(handler);
 	}
-	const firstArg = definitionOrConfigOrDepsOrHandler;
-	if (!("name" in firstArg) && dependenciesOrHandler && typeof dependenciesOrHandler === "object" && "name" in dependenciesOrHandler && handlerFn) {
-		const dependencies = firstArg;
-		const definition$1 = dependenciesOrHandler;
-		const hasInput$1 = "input" in definition$1 && definition$1.input !== void 0;
-		const hasOutput$1 = "output" in definition$1 && definition$1.output !== void 0;
-		return define({
-			name: definition$1.name,
-			version: definition$1.version,
-			input: hasInput$1 ? definition$1.input : custom(),
-			output: hasOutput$1 ? definition$1.output : custom(),
-			meta: definition$1.meta
-		}).handler(dependencies, handlerFn);
-	}
-	if (typeof dependenciesOrHandler === "function" && !("name" in firstArg)) {
-		const dependencies = firstArg;
-		const handler = dependenciesOrHandler;
+	if (isExecutor(first)) {
+		if (typeof second !== "function") throw new Error("flow(deps, handler) requires handler as second argument");
+		const dependencies = first;
+		const handler = second;
 		return define({
-			name: "anonymous",
-			version: "1.0.0",
 			input: custom(),
 			output: custom()
 		}).handler(dependencies, handler);
 	}
-	if ("handler" in firstArg) {
-		const config = firstArg;
-		const hasInput$1 = "input" in config && config.input !== void 0;
-		const hasOutput$1 = "output" in config && config.output !== void 0;
-		const def$1 = define({
-			name: config.name,
-			version: config.version,
-			input: hasInput$1 ? config.input : custom(),
-			output: hasOutput$1 ? config.output : custom(),
-			meta: config.meta
-		});
-		if ("dependencies" in config) {
-			const depsConfig = config;
-			return def$1.handler(depsConfig.dependencies, depsConfig.handler);
-		} else {
-			const handlerConfig = config;
-			return def$1.handler(handlerConfig.handler);
+	if (typeof first === "object" && first !== null) {
+		if ("input" in first && "output" in first) {
+			const config = first;
+			if ("handler" in config || "dependencies" in config) throw new Error("Config object cannot contain 'handler' or 'dependencies' properties. Use flow(config, handler) or flow(config, deps, handler) instead.");
+			const def = define(config);
+			if (!second) return def;
+			if (typeof second === "function") return def.handler(second);
+			if (isExecutor(second)) {
+				if (!third) throw new Error("flow(config, deps, handler) requires handler as third argument");
+				return def.handler(second, third);
+			}
+			throw new Error("Invalid flow() call: second argument must be handler function or dependencies");
 		}
+		const isValidDependencyObject = (obj) => {
+			const values = Object.values(obj);
+			if (values.length === 0) return true;
+			return values.every((value) => typeof value === "function" || isExecutor(value));
+		};
+		if (!isValidDependencyObject(first)) throw new Error("Invalid flow() call: first argument must be either a config object with 'input' and 'output' properties, or a valid dependency object containing executors/functions");
+		if (typeof second === "function") {
+			const dependencies = first;
+			const handler = second;
+			return define({
+				input: custom(),
+				output: custom()
+			}).handler(dependencies, handler);
+		}
+		throw new Error("Invalid flow() call: object dependencies require handler function as second argument");
 	}
-	const definition = firstArg;
-	const hasInput = "input" in definition && definition.input !== void 0;
-	const hasOutput = "output" in definition && definition.output !== void 0;
-	const def = define({
-		name: definition.name || "anonymous",
-		version: definition.version,
-		input: hasInput ? definition.input : custom(),
-		output: hasOutput ? definition.output : custom(),
-		meta: definition.meta
-	});
-	if (!dependenciesOrHandler) return def;
-	if (typeof dependenciesOrHandler === "function") return def.handler(dependenciesOrHandler);
-	else return def.handler(dependenciesOrHandler, handlerFn);
+	throw new Error("Invalid flow() call: first argument must be handler, dependencies, or config object");
 }
-const flow = Object.assign(flowImpl, {
-	define,
-	execute
-});
+const flow = Object.assign(flowImpl, { execute });
 
 //#endregion
 //#region src/scope.ts
 var AccessorImpl = class {
-	metas;
+	tags;
 	scope;
 	requestor;
 	currentPromise = null;
 	currentPromised = null;
-	cachedResolvedPromised = null;
 	resolve;
-	constructor(scope, requestor, metas) {
+	constructor(scope, requestor, tags) {
 		this.scope = scope;
 		this.requestor = requestor;
-		this.metas = metas;
+		this.tags = tags;
 		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
-		});
+		const state = this.scope["getOrCreateState"](requestor);
+		if (!state.accessor) state.accessor = this;
 	}
 	async resolveCore() {
 		const { factory, dependencies, immediateValue } = this.processReplacer();
 		if (immediateValue !== void 0) {
 			await new Promise((resolve) => queueMicrotask(resolve));
-			this.scope["cache"].set(this.requestor, {
-				accessor: this,
-				value: {
-					kind: "resolved",
-					value: immediateValue,
-					promised: Promised.create(Promise.resolve(immediateValue))
-				}
-			});
+			const state$1 = this.scope["getOrCreateState"](this.requestor);
+			state$1.accessor = this;
+			state$1.value = {
+				kind: "resolved",
+				value: immediateValue,
+				promised: Promised.create(Promise.resolve(immediateValue))
+			};
 			return immediateValue;
 		}
 		const controller = this.createController();
 		const resolvedDependencies = await this.scope["~resolveDependencies"](dependencies, this.requestor);
 		const result = await this.executeFactory(factory, resolvedDependencies, controller);
 		const processedResult = await this.processChangeEvents(result);
-		this.scope["cache"].set(this.requestor, {
-			accessor: this,
-			value: {
-				kind: "resolved",
-				value: processedResult,
-				promised: Promised.create(Promise.resolve(processedResult))
-			}
-		});
+		const state = this.scope["getOrCreateState"](this.requestor);
+		state.accessor = this;
+		state.value = {
+			kind: "resolved",
+			value: processedResult,
+			promised: Promised.create(Promise.resolve(processedResult))
+		};
 		this.scope["~removeFromResolutionChain"](this.requestor);
 		this.currentPromise = null;
 		this.currentPromised = null;
-		this.cachedResolvedPromised = null;
 		return processedResult;
 	}
 	async resolveWithErrorHandling() {
@@ -1142,15 +1144,14 @@ var AccessorImpl = class {
 			return await this.resolveCore();
 		} catch (error) {
 			const { enhancedError, errorContext, originalError } = this.enhanceResolutionError(error);
-			this.scope["cache"].set(this.requestor, {
-				accessor: this,
-				value: {
-					kind: "rejected",
-					error: originalError,
-					context: errorContext,
-					enhancedError
-				}
-			});
+			const state = this.scope["getOrCreateState"](this.requestor);
+			state.accessor = this;
+			state.value = {
+				kind: "rejected",
+				error: originalError,
+				context: errorContext,
+				enhancedError
+			};
 			this.scope["~removeFromResolutionChain"](this.requestor);
 			this.scope["~triggerError"](enhancedError, this.requestor);
 			this.currentPromise = null;
@@ -1169,23 +1170,18 @@ var AccessorImpl = class {
 			}
 			this.scope["~addToResolutionChain"](this.requestor, this.requestor);
 			this.currentPromise = this.resolveWithErrorHandling();
-			this.scope["cache"].set(this.requestor, {
-				accessor: this,
-				value: {
-					kind: "pending",
-					promise: this.currentPromise
-				}
-			});
+			const state = this.scope["getOrCreateState"](this.requestor);
+			state.accessor = this;
+			state.value = {
+				kind: "pending",
+				promise: this.currentPromise
+			};
 			this.currentPromised = Promised.create(this.currentPromise);
 			return this.currentPromised;
 		};
 	}
 	handleCachedState(cached) {
-		if (cached.kind === "resolved") {
-			if (cached.promised) return cached.promised;
-			if (!this.cachedResolvedPromised) this.cachedResolvedPromised = Promised.create(Promise.resolve(cached.value));
-			return this.cachedResolvedPromised;
-		}
+		if (cached.kind === "resolved") return cached.promised;
 		if (cached.kind === "rejected") throw cached.error;
 		if (!this.currentPromised) this.currentPromised = Promised.create(cached.promise);
 		return this.currentPromised;
@@ -1289,9 +1285,8 @@ var AccessorImpl = class {
 	createController() {
 		return {
 			cleanup: (cleanup) => {
-				const currentSet = this.scope["cleanups"].get(this.requestor) ?? /* @__PURE__ */ new Set();
-				this.scope["cleanups"].set(this.requestor, currentSet);
-				currentSet.add(cleanup);
+				const state = this.scope["getOrCreateState"](this.requestor);
+				this.scope["ensureCleanups"](state).add(cleanup);
 			},
 			release: () => this.scope.release(this.requestor),
 			reload: () => this.scope.resolve(this.requestor, true).map(() => void 0),
@@ -1303,25 +1298,21 @@ function getExecutor(e) {
 	if (isLazyExecutor(e) || isReactiveExecutor(e) || isStaticExecutor(e)) return e.executor;
 	return e;
 }
-var BaseScope = class BaseScope {
+var BaseScope = class {
 	disposed = false;
 	cache = /* @__PURE__ */ new Map();
-	cleanups = /* @__PURE__ */ new Map();
-	onUpdateCallbacks = /* @__PURE__ */ new Map();
-	onUpdateExecutors = /* @__PURE__ */ new Map();
 	onEvents = {
 		change: /* @__PURE__ */ new Set(),
 		release: /* @__PURE__ */ new Set(),
 		error: /* @__PURE__ */ new Set()
 	};
-	onErrors = /* @__PURE__ */ new Map();
 	isDisposing = false;
-	resolutionChain = /* @__PURE__ */ new Map();
+	CIRCULAR_CHECK_THRESHOLD = 15;
 	extensions = [];
 	reversedExtensions = [];
 	registry = [];
 	initialValues = [];
-	metas;
+	tags;
 	static emptyDataStore = {
 		get: () => void 0,
 		set: () => void 0
@@ -1329,11 +1320,39 @@ var BaseScope = class BaseScope {
 	constructor(options) {
 		if (options?.registry) this.registry = [...options.registry];
 		if (options?.initialValues) this.initialValues = options.initialValues;
-		if (options?.meta) this.metas = options.meta;
+		if (options?.tags) this.tags = options.tags;
 		if (options?.extensions) for (const extension$1 of options.extensions) this.useExtension(extension$1);
 	}
+	getOrCreateState(executor) {
+		let state = this.cache.get(executor);
+		if (!state) {
+			state = { accessor: null };
+			this.cache.set(executor, state);
+		}
+		return state;
+	}
+	ensureCleanups(state) {
+		if (!state.cleanups) state.cleanups = /* @__PURE__ */ new Set();
+		return state.cleanups;
+	}
+	ensureCallbacks(state) {
+		if (!state.onUpdateCallbacks) state.onUpdateCallbacks = /* @__PURE__ */ new Set();
+		return state.onUpdateCallbacks;
+	}
+	ensureExecutors(state) {
+		if (!state.onUpdateExecutors) state.onUpdateExecutors = /* @__PURE__ */ new Set();
+		return state.onUpdateExecutors;
+	}
+	ensureErrors(state) {
+		if (!state.onErrors) state.onErrors = /* @__PURE__ */ new Set();
+		return state.onErrors;
+	}
+	ensureResolutionChain(state) {
+		if (!state.resolutionChain) state.resolutionChain = /* @__PURE__ */ new Set();
+		return state.resolutionChain;
+	}
 	"~checkCircularDependency"(executor, resolvingExecutor) {
-		const currentChain = this.resolutionChain.get(resolvingExecutor);
+		const currentChain = this.cache.get(resolvingExecutor)?.resolutionChain;
 		if (currentChain && currentChain.has(executor)) {
 			const chainArray = Array.from(currentChain);
 			const dependencyChain = buildDependencyChain(chainArray);
@@ -1344,40 +1363,46 @@ var BaseScope = class BaseScope {
 		}
 	}
 	"~addToResolutionChain"(executor, resolvingExecutor) {
-		const currentChain = this.resolutionChain.get(resolvingExecutor) || /* @__PURE__ */ new Set();
-		currentChain.add(executor);
-		this.resolutionChain.set(resolvingExecutor, currentChain);
+		const state = this.getOrCreateState(resolvingExecutor);
+		this.ensureResolutionChain(state).add(executor);
 	}
 	"~removeFromResolutionChain"(executor) {
-		this.resolutionChain.delete(executor);
+		const state = this.cache.get(executor);
+		if (state) {
+			delete state.resolutionDepth;
+			delete state.resolutionChain;
+		}
 	}
 	"~propagateResolutionChain"(fromExecutor, toExecutor) {
-		const fromChain = this.resolutionChain.get(fromExecutor);
-		if (fromChain) {
-			const newChain = new Set(fromChain);
+		const fromState = this.cache.get(fromExecutor);
+		if (fromState?.resolutionChain) {
+			const toState = this.getOrCreateState(toExecutor);
+			const newChain = new Set(fromState.resolutionChain);
 			newChain.add(fromExecutor);
-			this.resolutionChain.set(toExecutor, newChain);
+			toState.resolutionChain = newChain;
 		}
 	}
 	async "~triggerCleanup"(e) {
-		const cs = this.cleanups.get(e);
-		if (cs) for (const c of Array.from(cs.values()).reverse()) await c();
+		const state = this.cache.get(e);
+		if (state?.cleanups) {
+			for (const c of Array.from(state.cleanups.values()).reverse()) await c();
+			delete state.cleanups;
+		}
 	}
 	async "~triggerUpdate"(e) {
-		const ce = this.cache.get(e);
-		if (!ce) throw new Error("Executor is not yet resolved");
-		const executors = this.onUpdateExecutors.get(e);
-		if (executors) for (const t of Array.from(executors.values())) {
-			if (this.cleanups.has(t)) this["~triggerCleanup"](t);
-			await this.cache.get(t).accessor.resolve(true);
-			if (this.onUpdateExecutors.has(t) || this.onUpdateCallbacks.has(t)) await this["~triggerUpdate"](t);
+		const state = this.cache.get(e);
+		if (!state) throw new Error("Executor is not yet resolved");
+		if (state.onUpdateExecutors) for (const t of Array.from(state.onUpdateExecutors.values())) {
+			const depState = this.cache.get(t);
+			if (depState?.cleanups) this["~triggerCleanup"](t);
+			await depState.accessor.resolve(true);
+			if (depState.onUpdateExecutors || depState.onUpdateCallbacks) await this["~triggerUpdate"](t);
 		}
-		const callbacks = this.onUpdateCallbacks.get(e);
-		if (callbacks) for (const cb of Array.from(callbacks.values())) await cb(ce.accessor);
+		if (state.onUpdateCallbacks) for (const cb of Array.from(state.onUpdateCallbacks.values())) await cb(state.accessor);
 	}
 	async "~triggerError"(error, executor) {
-		const executorCallbacks = this.onErrors.get(executor);
-		if (executorCallbacks) for (const callback of Array.from(executorCallbacks.values())) try {
+		const state = this.cache.get(executor);
+		if (state?.onErrors) for (const callback of Array.from(state.onErrors.values())) try {
 			await callback(error, executor, this);
 		} catch (callbackError) {
 			console.error("Error in error callback:", callbackError);
@@ -1395,14 +1420,25 @@ var BaseScope = class BaseScope {
 	}
 	async "~resolveExecutor"(ie, ref) {
 		const e = getExecutor(ie);
-		this["~checkCircularDependency"](e, ref);
-		this["~propagateResolutionChain"](ref, e);
+		if (e === ref) {
+			const executorName = getExecutorName(e);
+			throw createDependencyError(codes.CIRCULAR_DEPENDENCY, executorName, [executorName], executorName, void 0, {
+				circularPath: `${executorName} -> ${executorName}`,
+				detectedAt: executorName
+			});
+		}
+		const currentDepth = (this.cache.get(ref)?.resolutionDepth ?? 0) + 1;
+		const state = this.getOrCreateState(e);
+		state.resolutionDepth = currentDepth;
+		if (currentDepth > this.CIRCULAR_CHECK_THRESHOLD) {
+			this["~checkCircularDependency"](e, ref);
+			this["~propagateResolutionChain"](ref, e);
+		}
 		const a = this["~makeAccessor"](e);
 		if (isLazyExecutor(ie)) return a;
 		if (isReactiveExecutor(ie)) {
-			const c = this.onUpdateExecutors.get(ie.executor) ?? /* @__PURE__ */ new Set();
-			this.onUpdateExecutors.set(ie.executor, c);
-			c.add(ref);
+			const parentState = this.getOrCreateState(ie.executor);
+			this.ensureExecutors(parentState).add(ref);
 		}
 		await a.resolve(false);
 		if (isStaticExecutor(ie)) return a;
@@ -1424,12 +1460,12 @@ var BaseScope = class BaseScope {
 	"~ensureNotDisposed"() {
 		if (this.disposed) throw new Error("Scope is disposed");
 	}
-	wrapWithExtensions(baseExecutor, dataStore, operation) {
+	wrapWithExtensions(baseExecutor, operation) {
 		let executor = baseExecutor;
 		for (const extension$1 of this.reversedExtensions) if (extension$1.wrap) {
 			const current = executor;
 			executor = () => {
-				const result = extension$1.wrap(dataStore, current, operation);
+				const result = extension$1.wrap(this, current, operation);
 				return result instanceof Promised ? result : Promised.create(result);
 			};
 		}
@@ -1439,7 +1475,7 @@ var BaseScope = class BaseScope {
 		let requestor = isLazyExecutor(e) || isReactiveExecutor(e) || isStaticExecutor(e) ? e.executor : e;
 		const cachedAccessor = this.cache.get(requestor);
 		if (cachedAccessor && cachedAccessor.accessor) return cachedAccessor.accessor;
-		return new AccessorImpl(this, requestor, e.metas);
+		return new AccessorImpl(this, requestor, e.tags);
 	}
 	accessor(executor) {
 		this["~ensureNotDisposed"]();
@@ -1457,10 +1493,10 @@ var BaseScope = class BaseScope {
 	resolve(executor, force = false) {
 		this["~ensureNotDisposed"]();
 		const coreResolve = () => {
-			const accessor$1 = this["~makeAccessor"](executor);
-			return accessor$1.resolve(force).map(() => accessor$1.get());
+			const accessor = this["~makeAccessor"](executor);
+			return accessor.resolve(force).map(() => accessor.get());
 		};
-		return this.wrapWithExtensions(coreResolve, BaseScope.emptyDataStore, {
+		return this.wrapWithExtensions(coreResolve, {
 			kind: "resolve",
 			executor,
 			scope: this,
@@ -1469,8 +1505,23 @@ var BaseScope = class BaseScope {
 	}
 	resolveAccessor(executor, force = false) {
 		this["~ensureNotDisposed"]();
-		const accessor$1 = this["~makeAccessor"](executor);
-		return accessor$1.resolve(force).map(() => accessor$1);
+		const accessor = this["~makeAccessor"](executor);
+		return accessor.resolve(force).map(() => accessor);
+	}
+	run(dependencies, callback, args) {
+		this["~ensureNotDisposed"]();
+		const dummyExecutor = {
+			[executorSymbol]: "main",
+			factory: void 0,
+			dependencies,
+			tags: {}
+		};
+		return Promised.create((async () => {
+			const deps = dependencies;
+			const resolvedDeps = await this["~resolveDependencies"](deps, dummyExecutor);
+			if (args !== void 0 && args.length > 0) return await callback(resolvedDeps, ...args);
+			return await callback(resolvedDeps, ...[]);
+		})());
 	}
 	update(e, u) {
 		if (this.isDisposing) return Promised.create(Promise.resolve());
@@ -1478,30 +1529,29 @@ var BaseScope = class BaseScope {
 		const coreUpdate = () => {
 			return Promised.create((async () => {
 				this["~triggerCleanup"](e);
-				const accessor$1 = this["~makeAccessor"](e);
+				const accessor = this["~makeAccessor"](e);
 				let value;
-				if (typeof u === "function") value = u(accessor$1.get());
+				if (typeof u === "function") value = u(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: accessor$1,
-					value: {
-						kind: "resolved",
-						value,
-						promised: Promised.create(Promise.resolve(value))
-					}
-				});
+				const state = this.getOrCreateState(e);
+				state.accessor = accessor;
+				state.value = {
+					kind: "resolved",
+					value,
+					promised: Promised.create(Promise.resolve(value))
+				};
 				await this["~triggerUpdate"](e);
 			})());
 		};
 		const baseUpdater = () => {
 			return coreUpdate().map(() => this.accessor(e).get());
 		};
-		return this.wrapWithExtensions(baseUpdater, BaseScope.emptyDataStore, {
+		return this.wrapWithExtensions(baseUpdater, {
 			kind: "resolve",
 			operation: "update",
 			executor: e,
@@ -1514,16 +1564,12 @@ var BaseScope = class BaseScope {
 	release(e, s = false) {
 		this["~ensureNotDisposed"]();
 		const coreRelease = async () => {
-			if (!this.cache.get(e) && !s) throw new Error("Executor is not yet resolved");
+			const state = this.cache.get(e);
+			if (!state && !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 executors = this.onUpdateExecutors.get(e);
-			if (executors) {
-				for (const t of Array.from(executors.values())) await this.release(t, true);
-				this.onUpdateExecutors.delete(e);
-			}
-			this.onUpdateCallbacks.delete(e);
+			if (state?.onUpdateExecutors) for (const t of Array.from(state.onUpdateExecutors.values())) await this.release(t, true);
 			this.cache.delete(e);
 		};
 		return Promised.create(coreRelease());
@@ -1538,28 +1584,22 @@ var BaseScope = class BaseScope {
 			for (const current of currents) await this.release(current, true);
 			this.disposed = true;
 			this.cache.clear();
-			this.cleanups.clear();
-			this.onUpdateCallbacks.clear();
-			this.onUpdateExecutors.clear();
 			this.onEvents.change.clear();
 			this.onEvents.release.clear();
 			this.onEvents.error.clear();
-			this.onErrors.clear();
-			this.resolutionChain.clear();
 		})());
 	}
 	onUpdate(e, cb) {
 		this["~ensureNotDisposed"]();
 		if (this.isDisposing) throw new Error("Cannot register update callback on a disposing scope");
-		const ou = this.onUpdateCallbacks.get(e) ?? /* @__PURE__ */ new Set();
-		this.onUpdateCallbacks.set(e, ou);
-		ou.add(cb);
+		const state = this.getOrCreateState(e);
+		this.ensureCallbacks(state).add(cb);
 		return () => {
 			this["~ensureNotDisposed"]();
-			const ou$1 = this.onUpdateCallbacks.get(e);
-			if (ou$1) {
-				ou$1.delete(cb);
-				if (ou$1.size === 0) this.onUpdateCallbacks.delete(e);
+			const state$1 = this.cache.get(e);
+			if (state$1?.onUpdateCallbacks) {
+				state$1.onUpdateCallbacks.delete(cb);
+				if (state$1.onUpdateCallbacks.size === 0) delete state$1.onUpdateCallbacks;
 			}
 		};
 	}
@@ -1593,15 +1633,14 @@ var BaseScope = class BaseScope {
 		}
 		if (callback) {
 			const executor = executorOrCallback;
-			const errorCallbacks = this.onErrors.get(executor) ?? /* @__PURE__ */ new Set();
-			this.onErrors.set(executor, errorCallbacks);
-			errorCallbacks.add(callback);
+			const state = this.getOrCreateState(executor);
+			this.ensureErrors(state).add(callback);
 			return () => {
 				this["~ensureNotDisposed"]();
-				const callbacks = this.onErrors.get(executor);
-				if (callbacks) {
-					callbacks.delete(callback);
-					if (callbacks.size === 0) this.onErrors.delete(executor);
+				const state$1 = this.cache.get(executor);
+				if (state$1?.onErrors) {
+					state$1.onErrors.delete(callback);
+					if (state$1.onErrors.size === 0) delete state$1.onErrors;
 				}
 			};
 		}
@@ -1631,14 +1670,14 @@ var BaseScope = class BaseScope {
 			scope: this,
 			extensions: options.extensions,
 			initialContext: options.initialContext,
-			meta: options.meta,
+			tags: options.tags,
 			details: true
 		});
 		return flow.execute(flow$1, input, {
 			scope: this,
 			extensions: options?.extensions,
 			initialContext: options?.initialContext,
-			meta: options?.meta,
+			tags: options?.tags,
 			details: false
 		});
 	}
@@ -1725,39 +1764,45 @@ var MultiExecutorImpl = class {
 function createValidatedExecutor(option, key, createExecutorFn) {
 	return createExecutorFn(validate(option.keySchema, key));
 }
-function createMultiExecutor(option, poolId, keyPool, createNewExecutor, providerMetas) {
+function createMultiExecutor(option, poolId, keyPool, createNewExecutor, providerTags) {
 	const impl = new MultiExecutorImpl(option, poolId, keyPool, createNewExecutor);
-	const provider = createExecutor((ctl) => impl.providerFactory(ctl), void 0, providerMetas);
+	const provider = createExecutor((ctl) => impl.providerFactory(ctl), void 0, providerTags);
 	const callableFn = (key) => impl.__call(key);
 	return Object.assign(callableFn, provider, {
 		release: (scope) => impl.release(scope),
 		id: impl.id
 	});
 }
-function provide$1(option, valueFn, ...metas) {
-	const poolId = meta(Symbol(), custom());
+function provide$1(option, valueFn, ...tags) {
+	const poolId = tag(custom(), {
+		label: Symbol().toString(),
+		default: null
+	});
 	const keyPool = /* @__PURE__ */ new Map();
 	const createNewExecutor = (key) => {
-		return createValidatedExecutor(option, key, (validatedKey) => createExecutor((ctl) => valueFn(validatedKey, ctl), void 0, [poolId(void 0), ...metas]));
+		return createValidatedExecutor(option, key, (validatedKey) => createExecutor((ctl) => valueFn(validatedKey, ctl), void 0, [poolId(null), ...tags]));
 	};
-	return createMultiExecutor(option, poolId, keyPool, createNewExecutor, [poolId(void 0), ...metas]);
+	return createMultiExecutor(option, poolId, keyPool, createNewExecutor, [poolId(null), ...tags]);
 }
-function derive$1(option, valueFn, ...metas) {
-	const poolId = meta(Symbol(), custom());
+function derive$1(option, valueFn, ...tags) {
+	const poolId = tag(custom(), {
+		label: Symbol().toString(),
+		default: null
+	});
 	const keyPool = /* @__PURE__ */ new Map();
 	const createNewExecutor = (key) => {
 		return createValidatedExecutor(option, key, (validatedKey) => {
 			const factory = (dependencies, ctl) => valueFn(dependencies, validatedKey, ctl);
 			const deps = option.dependencies;
-			return createExecutor(factory, deps, metas);
+			return createExecutor(factory, deps, tags);
 		});
 	};
-	return createMultiExecutor(option, poolId, keyPool, createNewExecutor, metas);
+	return createMultiExecutor(option, poolId, keyPool, createNewExecutor, tags);
 }
 
 //#endregion
 //#region src/index.ts
-const name = meta("pumped-fn/name", custom());
+const name = tag(custom(), { label: "pumped-fn/name" });
 
 //#endregion
 exports.DependencyResolutionError = DependencyResolutionError;
@@ -1767,7 +1812,6 @@ exports.FlowError = FlowError;
 exports.FlowValidationError = FlowValidationError;
 exports.Promised = Promised;
 exports.SchemaError = SchemaError;
-exports.accessor = accessor;
 exports.createScope = createScope;
 exports.custom = custom;
 exports.derive = derive;
@@ -1779,19 +1823,14 @@ Object.defineProperty(exports, 'errors', {
 });
 exports.executorSymbol = executorSymbol;
 exports.extension = extension;
-exports.findValue = findValue;
-exports.findValues = findValues;
 exports.flow = flow;
 exports.flowMeta = flowMeta;
-exports.getValue = getValue;
 exports.isExecutor = isExecutor;
 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 () {
@@ -1807,4 +1846,6 @@ Object.defineProperty(exports, 'standardSchema', {
   get: function () {
     return ssch_exports;
   }
-});
+});
+exports.tag = tag;
+exports.tagSymbol = tagSymbol;