@virentia/effector 0.1.1 → 0.2.1

package/dist/index.mjs

@@ -1,499 +1,311 @@
-import * as core from "@virentia/core";
-//#region lib/types.ts
-const unitKind = Symbol("virentia.effector.unit");
-//#endregion
-//#region lib/guards.ts
-const is = {
-	unit(value) {
-		return isUnit(value);
-	},
-	event(value) {
-		return isEvent(value);
-	},
-	store(value) {
-		return isStore(value);
-	},
-	effect(value) {
-		return isEffect(value);
-	},
-	targetable(value) {
-		return isTargetable(value);
-	}
-};
-function isUnit(value) {
-	return Boolean(value && (typeof value === "object" || typeof value === "function") && unitKind in value);
-}
-function isEvent(value) {
-	return isUnit(value) && value[unitKind] === "event";
-}
-function isStore(value) {
-	return isUnit(value) && value[unitKind] === "store";
-}
-function isEffect(value) {
-	return isUnit(value) && value[unitKind] === "effect";
-}
-function isTargetable(value) {
-	return isEvent(value) || isEffect(value) || isStore(value) && typeof value.setState === "function";
-}
-function isScope(value) {
-	return Boolean(value && typeof value === "object" && "__core" in value && !(unitKind in value));
-}
-function isScopeError(error) {
-	return error instanceof Error && error.message === "Scope is required";
-}
-//#endregion
-//#region lib/shared.ts
-const defaultScope = core.scope();
-const compatScopes = /* @__PURE__ */ new WeakMap();
-const storesBySid = /* @__PURE__ */ new Map();
-const nativeStoreKeys = new Set([
-	"node",
-	"writable",
-	"subscribe",
-	"map",
-	"filter",
-	"filterMap"
-]);
-function createCompatScope(scope) {
-	const existing = compatScopes.get(scope);
-	if (existing) return existing;
-	const compatScope = {
-		__core: scope,
-		__changedSids: /* @__PURE__ */ new Set(),
-		getState(store) {
-			return store.getState(this);
-		}
+import * as virentia from "@virentia/core";
+import { allSettled, clearNode, createEffect, createEvent, createNode, createWatch, is, launch, step } from "effector";
+//#region lib/index.ts
+function createEffectorCompatibility(_options = {}) {
+	const runtimes = /* @__PURE__ */ new Set();
+	const effectorByVirentia = /* @__PURE__ */ new WeakMap();
+	const virentiaByEffector = /* @__PURE__ */ new WeakMap();
+	const installers = /* @__PURE__ */ new Set();
+	return {
+		associate,
+		ensureAssociation(config = {}) {
+			return ensureAssociation(config);
+		},
+		link(from, to, map) {
+			const definition = {
+				from,
+				to,
+				map
+			};
+			const installer = (runtime) => installLink(runtime, definition);
+			return registerInstaller(installer);
+		},
+		asEffector: ((unit) => createEffectorAdapter(unit)),
+		asVirentia: ((unit) => createVirentiaAdapter(unit))
 	};
-	compatScopes.set(scope, compatScope);
-	return compatScope;
-}
-function inScope(scope, fn) {
-	if (scope) return core.scoped(scope.__core, fn);
-	try {
-		return fn();
-	} catch (error) {
-		if (!isScopeError(error)) throw error;
-		return core.scoped(defaultScope, fn);
-	}
-}
-function callWithFallback(unit) {
-	return ((...args) => {
-		try {
-			return unit(...args).catch((error) => {
-				if (!isScopeError(error)) throw error;
-				return core.scoped(defaultScope, () => unit(...args));
-			});
-		} catch (error) {
-			if (!isScopeError(error)) throw error;
-			return core.scoped(defaultScope, () => unit(...args));
+	function associate(config) {
+		if (!config.virentia) throw new Error("Effector compatibility association requires a Virentia scope");
+		if (!config.effector) throw new Error("Effector compatibility association requires an Effector scope");
+		assertScopesAvailable(config);
+		const existing = findRuntime(config);
+		if (existing) {
+			existing.assertSamePair(config);
+			return existing;
 		}
-	});
-}
-function readSource(source) {
-	if (isStore(source)) return source.getState();
-	if (Array.isArray(source)) return source.map((store) => store.getState());
-	return Object.fromEntries(Object.entries(source).map(([key, store]) => [key, store.getState()]));
-}
-function sourceToClock(source) {
-	if (!source) throw new Error("sample: clock or source is required");
-	if (isStore(source)) return source;
-	return Object.values(source);
-}
-function passesFilter(filter, source, clock) {
-	if (!filter) return true;
-	if (isStore(filter)) return filter.getState();
-	return filter(source, clock);
-}
-function launchTarget(target, payload) {
-	for (const unit of toArray(target)) if (isStore(unit)) unit.setState(payload);
-	else unit(payload);
-}
-function computeCombined(shape, fn) {
-	const value = readSource(shape);
-	return fn ? fn(value) : value;
-}
-function registerStore(store) {
-	if (store.sid) storesBySid.set(store.sid, store);
-}
-function markScopeChanged(scope, sid) {
-	if (sid) createCompatScope(scope ?? defaultScope).__changedSids.add(sid);
-}
-function applyStoreValues(scope, values) {
-	if (Array.isArray(values)) {
-		for (const [store, value] of values) store.setState(value, scope);
-		return;
+		const runtime = new EffectorRuntimeImpl({
+			...config,
+			release: () => {
+				runtimes.delete(runtime);
+				effectorByVirentia.delete(config.virentia);
+				virentiaByEffector.delete(config.effector);
+			}
+		});
+		runtimes.add(runtime);
+		effectorByVirentia.set(config.virentia, config.effector);
+		virentiaByEffector.set(config.effector, config.virentia);
+		for (const installer of installers) runtime.addInstaller(installer);
+		return runtime;
 	}
-	if (values instanceof Map) {
-		for (const [store, value] of values) applyStoreValue(scope, store, value);
-		return;
+	function assertScopesAvailable(config) {
+		const existingEffector = effectorByVirentia.get(config.virentia);
+		if (existingEffector && existingEffector !== config.effector) throw new Error("Virentia scope is already associated with another Effector scope");
+		const existingVirentia = virentiaByEffector.get(config.effector);
+		if (existingVirentia && existingVirentia !== config.virentia) throw new Error("Effector scope is already associated with another Virentia scope");
 	}
-	for (const [sid, value] of Object.entries(values)) applyStoreValue(scope, sid, value);
-}
-function getName(input) {
-	if (typeof input === "string") return input;
-	if (input && (typeof input === "object" || typeof input === "function") && "shortName" in input) return String(input.shortName ?? "unit");
-	if (input && (typeof input === "object" || typeof input === "function") && "name" in input) return String(input.name ?? "unit");
-	return "unit";
-}
-function toArray(value) {
-	return Array.isArray(value) ? value : [value];
-}
-function applyStoreValue(scope, storeOrSid, value) {
-	if (typeof storeOrSid === "string") {
-		storesBySid.get(storeOrSid)?.setState(value, scope);
-		return;
+	function ensureAssociation(config = {}) {
+		const runtime = findRuntime(config);
+		if (!runtime) throw createMissingRuntimeError(config);
+		return runtime;
 	}
-	storeOrSid.setState(value, scope);
-}
-//#endregion
-//#region lib/store.ts
-function createStore(defaultState, config) {
-	const box = core.store({ value: defaultState });
-	const updates = createEvent({ name: `${config?.name ?? "store"} updates` });
-	const store = createStoreFromBox(box, updates, defaultState, config?.name, config?.sid);
-	registerStore(store);
-	box.subscribe((next, scope) => {
-		markScopeChanged(scope, store.sid);
-		core.run({
-			unit: updates.__core.node,
-			payload: next.value,
-			scope
-		});
-	});
-	return store;
-}
-function createStoreFromBox(box, updates, defaultState, name = "store", sid) {
-	const result = {
-		[unitKind]: "store",
-		__box: box,
-		__core: updates,
-		node: updates.__core.node,
-		shortName: name,
-		sid,
-		defaultState,
-		updates,
-		getType: () => name,
-		getState(scope) {
-			return readBox(box, scope);
-		},
-		setState(value, scope) {
-			writeBox(box, value, scope);
-		},
-		watch(fn) {
-			fn(readBox(box));
-			return box.subscribe((next) => {
-				fn(next.value);
-			});
-		},
-		map(fn) {
-			const mapped = createStore(fn(result.getState()));
-			core.scoped(defaultScope, () => {
-				core.reaction(() => {
-					mapped.setState(fn(result.getState()));
-				});
-			});
-			return mapped;
-		},
-		on(trigger, reducer) {
-			core.reaction({
-				on: trigger,
-				run: (payload) => {
-					result.setState(reducer(result.getState(), payload));
-				}
-			});
-			return result;
-		},
-		reset(trigger) {
-			for (const unit of toArray(trigger)) core.reaction({
-				on: unit,
-				run: () => {
-					result.setState(defaultState);
-				}
-			});
-			return result;
+	function findRuntime(config = {}) {
+		if (config.virentia) {
+			const effectorScope = effectorByVirentia.get(config.virentia);
+			const runtime = effectorScope ? findRuntimeByPair(config.virentia, effectorScope) : null;
+			if (runtime) return runtime;
 		}
-	};
-	return result;
-}
-function wrapNativeStore(store, defaultState, name) {
-	const updates = createEvent(`${name}.updates`);
-	const result = {
-		[unitKind]: "store",
-		__core: updates,
-		node: updates.__core.node,
-		shortName: name,
-		defaultState,
-		updates,
-		getType: () => name,
-		getState(scope) {
-			return readNativeStore(store, scope);
-		},
-		watch(fn) {
-			fn(readNativeStore(store));
-			return store.subscribe((next) => {
-				fn(next);
+		if (config.effector) {
+			const virentiaScope = virentiaByEffector.get(config.effector);
+			const runtime = virentiaScope ? findRuntimeByPair(virentiaScope, config.effector) : null;
+			if (runtime) return runtime;
+		}
+		return null;
+	}
+	function findRuntimeByPair(virentiaScope, effectorScope) {
+		for (const runtime of runtimes) if (runtime.virentia === virentiaScope && runtime.effector === effectorScope) return runtime;
+		return null;
+	}
+	function registerInstaller(installer) {
+		installers.add(installer);
+		for (const runtime of runtimes) runtime.addInstaller(installer);
+		return () => {
+			installers.delete(installer);
+			for (const runtime of runtimes) runtime.removeInstaller(installer);
+		};
+	}
+	function createEffectorAdapter(unit) {
+		if (isEffectorUnit(unit)) return unit;
+		if (isVirentiaEffect(unit)) {
+			const scopeQueue = [];
+			const adapter = createEffect((payload) => {
+				return resolveRuntimeFromEffectorScope(scopeQueue.shift()).call(unit, payload);
 			});
-		},
-		map(fn) {
-			const mapped = createStore(fn(result.getState()));
-			core.scoped(defaultScope, () => {
-				core.reaction(() => {
-					mapped.setState(fn(result.getState()));
-				});
+			createEffectorScopeNode(adapter, (_payload, scope) => {
+				scopeQueue.push(scope);
 			});
-			return mapped;
-		},
-		on() {
-			throw new Error("Store is read-only");
-		},
-		reset() {
-			throw new Error("Store is read-only");
+			return adapter;
 		}
-	};
-	store.subscribe((next, scope) => {
-		core.run({
-			unit: updates.__core.node,
-			payload: next,
-			scope
+		const adapter = createEvent();
+		createEffectorScopeNode(adapter, (payload, scope) => {
+			const runtime = resolveRuntimeFromEffectorScope(scope);
+			if (runtime.shouldSkipEffector(adapter)) return;
+			runtime.emitVirentia(unit, payload, { suppressReaction: true });
 		});
-	});
-	return result;
-}
-function readBox(box, scope) {
-	return inScope(scope, () => box.value);
-}
-function writeBox(box, value, scope) {
-	inScope(scope, () => {
-		box.value = value;
-	});
-}
-function readNativeStore(store, scope) {
-	return inScope(scope, () => {
-		const keys = Reflect.ownKeys(store).filter((key) => !nativeStoreKeys.has(key));
-		if (keys.length === 1 && keys[0] === "value") return Reflect.get(store, "value");
-		return Object.fromEntries(keys.map((key) => [key, Reflect.get(store, key)]));
-	});
-}
-//#endregion
-//#region lib/operators.ts
-function sample(config) {
-	const target = config.target ?? createEvent();
-	const clocks = toArray(config.clock ?? sourceToClock(config.source));
-	for (const clock of clocks) core.reaction({
-		on: clock,
-		run: (clockPayload) => {
-			const sourceValue = config.source === void 0 ? void 0 : readSource(config.source);
-			if (!passesFilter(config.filter, sourceValue, clockPayload)) return;
-			launchTarget(target, config.fn ? config.source === void 0 ? config.fn(clockPayload, clockPayload) : config.fn(sourceValue, clockPayload) : config.source === void 0 ? clockPayload : sourceValue);
-		}
-	});
-	return Array.isArray(target) ? target[0] : target;
-}
-function combine(...args) {
-	const fn = typeof args[args.length - 1] === "function" ? args.pop() : void 0;
-	const shape = args.length === 1 ? args[0] : args;
-	const result = createStore(computeCombined(shape, fn));
-	core.scoped(defaultScope, () => {
-		core.reaction(() => {
-			result.setState(computeCombined(shape, fn));
+		registerInstaller((runtime) => installLink(runtime, {
+			from: unit,
+			to: adapter
+		}));
+		return adapter;
+	}
+	function createVirentiaAdapter(unit) {
+		if (isVirentiaUnit(unit)) return unit;
+		if (is.effect(unit)) return virentia.effect((payload) => {
+			return resolveRuntimeFromVirentiaScope().call(unit, payload);
 		});
-	});
-	return result;
-}
-function split(sourceOrConfig, maybeCases) {
-	const source = "source" in sourceOrConfig ? sourceOrConfig.source : sourceOrConfig;
-	const match = "source" in sourceOrConfig ? sourceOrConfig.match : maybeCases ?? {};
-	const result = {};
-	if (typeof match === "function") {
-		const configuredCases = "source" in sourceOrConfig ? sourceOrConfig.cases ?? {} : {};
-		for (const key of Object.keys(configuredCases)) result[key] = configuredCases[key] ?? createEvent();
-	} else for (const key of Object.keys(match)) result[key] = createEvent();
-	result.__ = createEvent();
-	core.reaction({
-		on: source,
-		run: (payload) => {
-			launchTarget(result[(typeof match === "function" ? match(payload) : Object.keys(match).find((caseName) => match[caseName](payload))) ?? "__"] ?? result.__, payload);
-		}
-	});
-	return result;
-}
-function createApi(store, reducers) {
-	const result = {};
-	for (const key of Object.keys(reducers)) {
-		const event = createEvent(String(key));
-		store.on(event, reducers[key]);
-		result[key] = event;
+		const adapter = virentia.event();
+		createEffectorScopeNode(unit, (payload, scope) => {
+			const runtime = resolveRuntimeFromEffectorScope(scope);
+			if (runtime.shouldSkipEffector(unit)) return;
+			runtime.emitVirentia(adapter, payload, { suppressReaction: true });
+		});
+		registerInstaller((runtime) => installLink(runtime, {
+			from: adapter,
+			to: unit
+		}));
+		return adapter;
+	}
+	function resolveRuntimeFromEffectorScope(scope) {
+		if (!scope) throw createMissingRuntimeError({});
+		const runtime = ensureAssociation({ effector: scope });
+		const activeVirentiaScope = virentia.getCurrentScope();
+		if (activeVirentiaScope && activeVirentiaScope !== runtime.virentia) throw new Error("Effector scope is associated with another Virentia scope");
+		return runtime;
+	}
+	function resolveRuntimeFromVirentiaScope() {
+		const activeVirentiaScope = virentia.getCurrentScope();
+		if (!activeVirentiaScope) throw createMissingRuntimeError({});
+		return ensureAssociation({ virentia: activeVirentiaScope });
 	}
-	return result;
-}
-function restore(unit, defaultState) {
-	const store = createStore(defaultState);
-	const source = isEffect(unit) ? unit.doneData : unit;
-	store.on(source, (_, payload) => payload);
-	return store;
-}
-//#endregion
-//#region lib/watch.ts
-function watchUnit(unit, fn) {
-	const subscription = core.reaction({
-		on: unit,
-		run: fn
-	});
-	return () => subscription.stop();
-}
-//#endregion
-//#region lib/event.ts
-function createEvent(nameOrConfig) {
-	const name = typeof nameOrConfig === "string" ? nameOrConfig : nameOrConfig?.name ?? "unit";
-	return wrapEvent(core.event(), name);
-}
-function wrapEvent(event, name = "event") {
-	const result = callWithFallback(typeof event === "function" ? event : ((...payload) => core.allSettled(event, { payload: payload[0] })));
-	Object.assign(result, {
-		[unitKind]: "event",
-		__core: event,
-		node: event.node,
-		shortName: name,
-		getType: () => name,
-		watch(fn) {
-			return watchUnit(result, fn);
-		},
-		map(fn) {
-			return wrapEvent(event.map(fn));
-		},
-		filter(config) {
-			const fn = typeof config === "function" ? config : config.fn;
-			return wrapEvent(event.filter(fn));
-		},
-		filterMap(fn) {
-			return wrapEvent(event.filterMap(fn));
-		},
-		prepend(fn) {
-			const prepended = createEvent();
-			sample({
-				clock: prepended,
-				fn,
-				target: result
-			});
-			return prepended;
-		}
-	});
-	return result;
 }
-//#endregion
-//#region lib/effect.ts
-function createEffect(handlerOrConfig) {
-	let handler = typeof handlerOrConfig === "function" ? handlerOrConfig : handlerOrConfig?.handler;
-	const effectName = getName(handlerOrConfig);
-	const fx = core.effect((params) => {
-		if (!handler) throw new Error("Effect handler is not defined");
-		return handler(params);
-	});
-	const result = callWithFallback(((...params) => fx(...params)));
-	Object.assign(result, {
-		[unitKind]: "effect",
-		__core: fx,
-		node: fx.node,
-		shortName: effectName,
-		getType: () => effectName,
-		watch(fn) {
-			return watchUnit(wrapEvent(fx.started), fn);
-		},
-		done: wrapEvent(fx.done),
-		fail: wrapEvent(fx.fail),
-		finally: wrapEvent(fx.finally),
-		doneData: wrapEvent(fx.doneData),
-		failData: wrapEvent(fx.failData),
-		pending: wrapNativeStore(fx.$pending, false, `${effectName}.pending`),
-		inFlight: wrapNativeStore(fx.$inFlight, 0, `${effectName}.inFlight`),
-		prepend(fn) {
-			const prepended = createEvent();
-			sample({
-				clock: prepended,
-				fn,
-				target: result
+var EffectorRuntimeImpl = class {
+	virentia;
+	effector;
+	disposed = false;
+	cleanups = /* @__PURE__ */ new Set();
+	cleanupByInstaller = /* @__PURE__ */ new Map();
+	releaseAssociation;
+	suppressedEffector = /* @__PURE__ */ new Map();
+	suppressedVirentia = /* @__PURE__ */ new Map();
+	constructor(config) {
+		this.virentia = config.virentia;
+		this.effector = config.effector;
+		this.releaseAssociation = config.release;
+	}
+	async call(unit, payload) {
+		this.assertAlive();
+		if (isEffectorUnit(unit)) return allSettled(unit, {
+			params: payload,
+			scope: this.effector
+		});
+		if (isVirentiaEffect(unit)) return virentia.scoped(this.virentia, () => unit(payload));
+		await virentia.allSettled(unit, {
+			payload,
+			scope: this.virentia
+		});
+	}
+	trackCleanup(unsubscribe) {
+		this.cleanups.add(unsubscribe);
+		return () => {
+			this.cleanups.delete(unsubscribe);
+			unsubscribe();
+		};
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const cleanup of [...this.cleanups]) cleanup();
+		this.cleanups.clear();
+		this.cleanupByInstaller.clear();
+		this.releaseAssociation();
+	}
+	addInstaller(installer) {
+		if (this.disposed || this.cleanupByInstaller.has(installer)) return;
+		const cleanup = installer(this);
+		this.cleanupByInstaller.set(installer, cleanup);
+		this.cleanups.add(cleanup);
+	}
+	removeInstaller(installer) {
+		const cleanup = this.cleanupByInstaller.get(installer);
+		if (!cleanup) return;
+		this.cleanupByInstaller.delete(installer);
+		this.cleanups.delete(cleanup);
+		cleanup();
+	}
+	assertSamePair(config) {
+		if (config.virentia !== this.virentia || config.effector !== this.effector) throw new Error("Effector compatibility association is already bound to another scope pair");
+	}
+	launchEffector(unit, payload, options = {}) {
+		this.assertAlive();
+		if (options.suppressWatch) this.incrementSuppression(this.suppressedEffector, unit);
+		try {
+			launch({
+				target: unit,
+				params: payload,
+				scope: this.effector
 			});
-			return prepended;
+		} finally {
+			if (options.suppressWatch) this.decrementSuppression(this.suppressedEffector, unit);
 		}
+	}
+	emitVirentia(unit, payload, options = {}) {
+		this.assertAlive();
+		if (options.suppressReaction) this.incrementSuppression(this.suppressedVirentia, unit);
+		const settled = virentia.allSettled(unit, {
+			payload,
+			scope: this.virentia
+		});
+		if (options.suppressReaction) settled.finally(() => {
+			this.decrementSuppression(this.suppressedVirentia, unit);
+		});
+	}
+	shouldSkipEffector(unit) {
+		return (this.suppressedEffector.get(unit) ?? 0) > 0;
+	}
+	shouldSkipVirentia(unit) {
+		return (this.suppressedVirentia.get(unit) ?? 0) > 0;
+	}
+	assertAlive() {
+		if (this.disposed) throw new Error("Effector compatibility association is disposed");
+	}
+	incrementSuppression(map, unit) {
+		map.set(unit, (map.get(unit) ?? 0) + 1);
+	}
+	decrementSuppression(map, unit) {
+		const next = (map.get(unit) ?? 0) - 1;
+		if (next <= 0) map.delete(unit);
+		else map.set(unit, next);
+	}
+};
+function createEffectorScopeNode(unit, fn) {
+	const node = createNode({
+		parent: [unit],
+		node: [...is.store(unit) ? [step.mov({
+			store: unit.stateRef,
+			to: "stack"
+		})] : [], step.run({ fn(payload, _local, stack) {
+			fn(payload, stack.scope);
+		} })],
+		family: { owners: [unit] }
 	});
-	const use = ((nextHandler) => {
-		handler = nextHandler;
-		return result;
-	});
-	use.getCurrent = () => {
-		if (!handler) throw new Error("Effect handler is not defined");
-		return handler;
+	return () => {
+		clearNode(node);
 	};
-	result.use = use;
-	return result;
 }
-//#endregion
-//#region lib/attach.ts
-function attach(config) {
-	return createEffect({
-		name: config.name ?? getName(config.effect),
-		handler: (params) => {
-			const hasSource = config.source !== void 0;
-			const sourceValue = hasSource ? readSource(config.source) : void 0;
-			if (isEffect(config.effect)) {
-				const nextParams = config.mapParams ? config.mapParams(params, sourceValue) : params;
-				return config.effect.use.getCurrent()(nextParams);
+function installLink(runtime, definition) {
+	const map = definition.map ?? identity;
+	if (isEffectorUnit(definition.from)) return toUnsubscribe(createWatch({
+		unit: definition.from,
+		scope: runtime.effector,
+		fn(payload) {
+			if (runtime.shouldSkipEffector(definition.from)) return;
+			const nextPayload = map(payload);
+			if (isEffectorUnit(definition.to)) {
+				runtime.launchEffector(definition.to, nextPayload);
+				return;
 			}
-			return hasSource ? config.effect(sourceValue, params) : config.effect(params);
+			runtime.emitVirentia(definition.to, nextPayload, { suppressReaction: true });
 		}
-	});
-}
-//#endregion
-//#region lib/persistence.ts
-function serialize(scope, config = {}) {
-	const compatScope = createCompatScope(scope.__core);
-	const onlyChanges = config.onlyChanges ?? true;
-	const ignored = new Set((config.ignore ?? []).map((item) => typeof item === "string" ? item : item.sid).filter((sid) => typeof sid === "string"));
-	const result = {};
-	for (const [sid, store] of storesBySid) {
-		if (ignored.has(sid)) continue;
-		if (onlyChanges && !compatScope.__changedSids.has(sid)) continue;
-		result[sid] = store.getState(compatScope);
+	}));
+	if (isVirentiaUnit(definition.from)) {
+		const watcher = virentia.reaction({
+			on: definition.from,
+			scope: runtime.virentia,
+			run(payload) {
+				if (runtime.shouldSkipVirentia(definition.from)) return;
+				const nextPayload = map(payload);
+				if (isEffectorUnit(definition.to)) {
+					runtime.launchEffector(definition.to, nextPayload, { suppressWatch: true });
+					return;
+				}
+				runtime.emitVirentia(definition.to, nextPayload);
+			}
+		});
+		return () => {
+			watcher.stop();
+		};
 	}
-	return result;
+	throw new Error("Effector compatibility link expects Effector or Virentia units");
 }
-function hydrate(scope, config) {
-	applyStoreValues(scope, config.values);
+function createMissingRuntimeError(config) {
+	if (config.effector) return /* @__PURE__ */ new Error("Effector compatibility association is missing for provided Effector scope");
+	if (config.virentia) return /* @__PURE__ */ new Error("Effector compatibility association is missing for provided Virentia scope");
+	return /* @__PURE__ */ new Error("Effector compatibility association is missing. Call associate({ virentia, effector }) before using adapters.");
 }
-//#endregion
-//#region lib/scope.ts
-function fork(config) {
-	const nextScope = createCompatScope(core.scope());
-	if (config?.values) hydrate(nextScope, { values: config.values });
-	return nextScope;
+function isEffectorUnit(value) {
+	return is.unit(value);
 }
-async function allSettled(unitOrScope, options = {}) {
-	if (isScope(unitOrScope)) return;
-	const scope = options.scope ?? createCompatScope(defaultScope);
-	const unit = unitOrScope;
-	if (isStore(unit)) {
-		unit.setState(options.params, scope);
-		return;
-	}
-	if (isEffect(unit)) try {
-		return {
-			status: "done",
-			value: await core.scoped(scope.__core, () => unit(options.params))
-		};
-	} catch (value) {
-		return {
-			status: "fail",
-			value
-		};
-	}
-	await core.allSettled(unit.__core, {
-		scope: scope.__core,
-		payload: options.params
-	});
+function isVirentiaUnit(value) {
+	return Boolean(value && (typeof value === "object" || typeof value === "function") && "node" in value && !isEffectorUnit(value));
+}
+function isVirentiaEffect(value) {
+	return Boolean(isVirentiaUnit(value) && "doneData" in value && "$pending" in value);
+}
+function toUnsubscribe(subscription) {
+	return () => {
+		subscription.unsubscribe();
+	};
 }
-function scopeBind(unit, config) {
-	const scope = config?.scope ?? createCompatScope(defaultScope);
-	return (...payload) => core.scoped(scope.__core, () => unit(...payload));
+function identity(value) {
+	return value;
 }
 //#endregion
-export { allSettled, attach, combine, createApi, createEffect, createEvent, createStore, fork, hydrate, is, restore, sample, scopeBind, serialize, split };
+export { createEffectorCompatibility };