@virentia/effector 0.2.1 → 0.3.1

package/dist/index.d.mts

@@ -1,10 +1,7 @@
 import * as virentia from "@virentia/core";
 import { Effect, EventCallable, Scope, Unit, UnitTargetable } from "effector";
 
-//#region lib/index.d.ts
-interface EffectorCompatibilityOptions {
-  name?: string;
-}
+//#region lib/types.d.ts
 interface EffectorAssociationConfig {
   virentia: virentia.Scope;
   effector: Scope;
@@ -13,24 +10,31 @@ interface EffectorAssociationLookup {
   virentia?: virentia.Scope;
   effector?: Scope;
 }
-type EffectorPayloadMap<From, To> = (payload: From) => To;
-type EffectorCompatibilityUnsubscribe = () => void;
 interface EffectorAssociation {
-  dispose(): void;
+  readonly virentia: virentia.Scope;
+  readonly effector: Scope;
 }
-interface EffectorCompatibility {
-  associate(config: EffectorAssociationConfig): EffectorAssociation;
-  ensureAssociation(config?: EffectorAssociationLookup): EffectorAssociation;
-  link<From, To = From>(from: Unit<From> | VirentiaUnit<From>, to: UnitTargetable<To> | VirentiaTarget<To>, map?: EffectorPayloadMap<From, To>): EffectorCompatibilityUnsubscribe;
-  asEffector<T>(unit: virentia.Effect<T, any, any>): Effect<T, any, unknown>;
-  asEffector<T>(unit: VirentiaUnit<T>): EventCallable<T>;
-  asEffector<T>(unit: Unit<T>): Unit<T>;
-  asVirentia<T>(unit: VirentiaUnit<T>): VirentiaUnit<T>;
-  asVirentia<T>(unit: Effect<T, any, any>): virentia.Effect<T, any, unknown>;
-  asVirentia<T>(unit: Unit<T>): virentia.EventCallable<T>;
+interface EffectorAssociations {
+  readonly byVirentia: WeakMap<virentia.Scope, EffectorAssociation>;
+  readonly byEffector: WeakMap<Scope, EffectorAssociation>;
 }
 type VirentiaUnit<T = unknown> = virentia.Event<T> | virentia.EventCallable<T> | virentia.Effect<T, any, any> | virentia.Store<T> | virentia.StoreWritable<T>;
 type VirentiaTarget<T = unknown> = virentia.EventCallable<T> | virentia.Effect<T, any, any> | virentia.StoreWritable<T>;
-declare function createEffectorCompatibility(_options?: EffectorCompatibilityOptions): EffectorCompatibility;
 //#endregion
-export { EffectorAssociation, EffectorAssociationConfig, EffectorAssociationLookup, EffectorCompatibility, EffectorCompatibilityOptions, EffectorCompatibilityUnsubscribe, EffectorPayloadMap, VirentiaTarget, VirentiaUnit, createEffectorCompatibility };
+//#region lib/associations.d.ts
+declare const effectorAssociations: EffectorAssociations;
+declare function associate(config: EffectorAssociationConfig): EffectorAssociation;
+declare function ensureAssociation(config?: EffectorAssociationLookup): EffectorAssociation;
+//#endregion
+//#region lib/fool.d.ts
+declare function fool<Params, Done, Fail>(unit: virentia.Effect<Params, Done, Fail>): virentia.Effect<Params, Done, Fail> & Effect<Params, Done, Fail>;
+declare function fool<T>(unit: virentia.EventCallable<T>): virentia.EventCallable<T> & EventCallable<T>;
+declare function fool<T>(unit: virentia.Event<T>): virentia.Event<T> & EventCallable<T>;
+declare function fool<T>(unit: virentia.StoreWritable<T>): virentia.StoreWritable<T> & EventCallable<T>;
+declare function fool<T>(unit: virentia.Store<T>): virentia.Store<T> & EventCallable<T>;
+declare function fool<Params, Done, Fail>(unit: Effect<Params, Done, Fail>): Effect<Params, Done, Fail> & virentia.Effect<Params, Done, Fail>;
+declare function fool<T>(unit: EventCallable<T>): EventCallable<T> & virentia.EventCallable<T>;
+declare function fool<T>(unit: UnitTargetable<T>): UnitTargetable<T> & virentia.EventCallable<T>;
+declare function fool<T>(unit: Unit<T>): Unit<T> & virentia.EventCallable<T>;
+//#endregion
+export { EffectorAssociation, EffectorAssociationConfig, EffectorAssociationLookup, EffectorAssociations, VirentiaTarget, VirentiaUnit, associate, effectorAssociations, ensureAssociation, fool };

package/dist/index.mjs

@@ -1,240 +1,185 @@
 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))
-	};
-	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;
-		}
-		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;
-	}
-	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");
+import { allSettled, clearNode, createEffect, createEvent, createNode, is, launch, step } from "effector";
+//#region lib/errors.ts
+function createMissingAssociationError(config) {
+	if (config.effector) return /* @__PURE__ */ new Error("Effector association is missing for provided Effector scope");
+	if (config.virentia) return /* @__PURE__ */ new Error("Effector association is missing for provided Virentia scope");
+	return /* @__PURE__ */ new Error("Effector association is missing. Call associate({ virentia, effector }) before using fooled units.");
+}
+//#endregion
+//#region lib/associations.ts
+const effectorAssociations = {
+	byVirentia: /* @__PURE__ */ new WeakMap(),
+	byEffector: /* @__PURE__ */ new WeakMap()
+};
+function associate(config) {
+	if (!config.virentia) throw new Error("Effector association requires a Virentia scope");
+	if (!config.effector) throw new Error("Effector association requires an Effector scope");
+	const existingByVirentia = effectorAssociations.byVirentia.get(config.virentia);
+	const existingByEffector = effectorAssociations.byEffector.get(config.effector);
+	if (existingByVirentia && existingByVirentia.effector !== config.effector) throw new Error("Virentia scope is already associated with another Effector scope");
+	if (existingByEffector && existingByEffector.virentia !== config.virentia) throw new Error("Effector scope is already associated with another Virentia scope");
+	const existing = existingByVirentia ?? existingByEffector;
+	if (existing) {
+		effectorAssociations.byVirentia.set(config.virentia, existing);
+		effectorAssociations.byEffector.set(config.effector, existing);
+		return existing;
 	}
-	function ensureAssociation(config = {}) {
-		const runtime = findRuntime(config);
-		if (!runtime) throw createMissingRuntimeError(config);
-		return runtime;
+	const association = {
+		virentia: config.virentia,
+		effector: config.effector
+	};
+	effectorAssociations.byVirentia.set(config.virentia, association);
+	effectorAssociations.byEffector.set(config.effector, association);
+	return association;
+}
+function ensureAssociation(config = {}) {
+	const association = findAssociation(config);
+	if (!association) throw createMissingAssociationError(config);
+	return association;
+}
+function findAssociation(config = {}) {
+	let association;
+	if (config.virentia) {
+		association = effectorAssociations.byVirentia.get(config.virentia);
+		if (association && config.effector && association.effector !== config.effector) return null;
+		if (association) return association;
 	}
-	function findRuntime(config = {}) {
-		if (config.virentia) {
-			const effectorScope = effectorByVirentia.get(config.virentia);
-			const runtime = effectorScope ? findRuntimeByPair(config.virentia, effectorScope) : null;
-			if (runtime) return runtime;
-		}
-		if (config.effector) {
-			const virentiaScope = virentiaByEffector.get(config.effector);
-			const runtime = virentiaScope ? findRuntimeByPair(virentiaScope, config.effector) : null;
-			if (runtime) return runtime;
-		}
-		return null;
+	if (config.effector) {
+		association = effectorAssociations.byEffector.get(config.effector);
+		if (association && config.virentia && association.virentia !== config.virentia) return null;
+		if (association) return association;
 	}
-	function findRuntimeByPair(virentiaScope, effectorScope) {
-		for (const runtime of runtimes) if (runtime.virentia === virentiaScope && runtime.effector === effectorScope) return runtime;
-		return null;
+	return null;
+}
+//#endregion
+//#region lib/association-state.ts
+const associationState = /* @__PURE__ */ new WeakMap();
+function shouldSkipEffector(association, unit) {
+	return (getAssociationState(association).suppressedEffector.get(unit) ?? 0) > 0;
+}
+function shouldSkipVirentia(association, unit) {
+	return (getAssociationState(association).suppressedVirentia.get(unit) ?? 0) > 0;
+}
+function suppressEffector(association, unit, fn) {
+	const state = getAssociationState(association);
+	incrementSuppression(state.suppressedEffector, unit);
+	try {
+		return fn();
+	} finally {
+		decrementSuppression(state.suppressedEffector, unit);
 	}
-	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 suppressVirentia(association, unit) {
+	const state = getAssociationState(association);
+	incrementSuppression(state.suppressedVirentia, unit);
+	return () => {
+		decrementSuppression(state.suppressedVirentia, unit);
+	};
+}
+function getAssociationState(association) {
+	let state = associationState.get(association);
+	if (!state) {
+		state = {
+			suppressedEffector: /* @__PURE__ */ new Map(),
+			suppressedVirentia: /* @__PURE__ */ new Map()
 		};
+		associationState.set(association, state);
 	}
-	function createEffectorAdapter(unit) {
-		if (isEffectorUnit(unit)) return unit;
-		if (isVirentiaEffect(unit)) {
-			const scopeQueue = [];
-			const adapter = createEffect((payload) => {
-				return resolveRuntimeFromEffectorScope(scopeQueue.shift()).call(unit, payload);
-			});
-			createEffectorScopeNode(adapter, (_payload, scope) => {
-				scopeQueue.push(scope);
-			});
-			return adapter;
+	return state;
+}
+function incrementSuppression(map, unit) {
+	map.set(unit, (map.get(unit) ?? 0) + 1);
+}
+function decrementSuppression(map, unit) {
+	const next = (map.get(unit) ?? 0) - 1;
+	if (next <= 0) map.delete(unit);
+	else map.set(unit, next);
+}
+//#endregion
+//#region lib/guards.ts
+function isEffectorUnit(value) {
+	return is.unit(value);
+}
+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 isObjectLike(value) {
+	return (typeof value === "object" || typeof value === "function") && value !== null;
+}
+//#endregion
+//#region lib/runtime.ts
+function installVirentiaToEffectorLink(from, to) {
+	installVirentiaToTargetLink(from, to, identity, true);
+}
+function installVirentiaToTargetLink(from, to, map, suppressEffectorWatch) {
+	const watcher = virentia.reaction({
+		on: from,
+		run(payload) {
+			const association = resolveAssociationFromVirentiaScope();
+			if (shouldSkipVirentia(association, from)) return;
+			runBridgeTarget(association, to, map(payload), { suppressWatch: suppressEffectorWatch });
 		}
-		const adapter = createEvent();
-		createEffectorScopeNode(adapter, (payload, scope) => {
-			const runtime = resolveRuntimeFromEffectorScope(scope);
-			if (runtime.shouldSkipEffector(adapter)) return;
-			runtime.emitVirentia(unit, payload, { suppressReaction: true });
-		});
-		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);
-		});
-		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 () => {
+		watcher.stop();
+	};
 }
-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;
+function runBridgeTarget(association, to, payload, options = {}) {
+	if (isEffectorUnit(to)) {
+		launchEffector(association, to, payload, { suppressWatch: options.suppressWatch });
+		return;
 	}
-	async call(unit, payload) {
-		this.assertAlive();
-		if (isEffectorUnit(unit)) return allSettled(unit, {
+	emitVirentia(association, to, payload, { suppressReaction: options.suppressReaction });
+}
+async function callAssociation(association, unit, payload) {
+	if (isEffectorUnit(unit)) return allSettled(unit, {
+		params: payload,
+		scope: association.effector
+	});
+	if (isVirentiaEffect(unit)) return virentia.scoped(association.virentia, () => unit(payload));
+	await virentia.allSettled(unit, {
+		payload,
+		scope: association.virentia
+	});
+}
+function launchEffector(association, unit, payload, options = {}) {
+	const launchUnit = () => {
+		launch({
+			target: unit,
 			params: payload,
-			scope: this.effector
+			scope: association.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
-			});
-		} 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);
+	};
+	if (options.suppressWatch) {
+		suppressEffector(association, unit, launchUnit);
+		return;
 	}
-};
+	launchUnit();
+}
+function emitVirentia(association, unit, payload, options = {}) {
+	const release = options.suppressReaction ? suppressVirentia(association, unit) : null;
+	const settled = virentia.allSettled(unit, {
+		payload,
+		scope: association.virentia
+	});
+	if (release) settled.finally(release);
+}
+function resolveAssociationFromEffectorScope(scope) {
+	if (!scope) throw createMissingAssociationError({});
+	const association = ensureAssociation({ effector: scope });
+	const activeVirentiaScope = virentia.getCurrentScope();
+	if (activeVirentiaScope && activeVirentiaScope !== association.virentia) throw new Error("Effector scope is associated with another Virentia scope");
+	return association;
+}
+function resolveAssociationFromVirentiaScope() {
+	const activeVirentiaScope = virentia.getCurrentScope();
+	if (!activeVirentiaScope) throw createMissingAssociationError({});
+	return ensureAssociation({ virentia: activeVirentiaScope });
+}
 function createEffectorScopeNode(unit, fn) {
 	const node = createNode({
 		parent: [unit],
@@ -250,62 +195,95 @@ function createEffectorScopeNode(unit, fn) {
 		clearNode(node);
 	};
 }
-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;
-			}
-			runtime.emitVirentia(definition.to, nextPayload, { suppressReaction: true });
-		}
-	}));
-	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();
-		};
-	}
-	throw new Error("Effector compatibility link expects Effector or Virentia units");
+function identity(value) {
+	return value;
 }
-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/fool.ts
+const fooledUnit = Symbol("virentia.effector.fooledUnit");
+const fooledUnits = /* @__PURE__ */ new WeakMap();
+function fool(unit) {
+	if (!isObjectLike(unit)) throw new Error("fool() expects an Effector or Virentia unit");
+	if (unit[fooledUnit]) return unit;
+	const cached = fooledUnits.get(unit);
+	if (cached) return cached;
+	const fooled = isEffectorUnit(unit) ? createFooledEffectorUnit(unit) : isVirentiaUnit(unit) ? createFooledVirentiaUnit(unit) : null;
+	if (!fooled) throw new Error("fool() expects an Effector or Virentia unit");
+	markFooledUnit(fooled);
+	fooledUnits.set(unit, fooled);
+	return fooled;
 }
-function isEffectorUnit(value) {
-	return is.unit(value);
+function createFooledVirentiaUnit(unit) {
+	const effectorUnit = createEffectorAdapter(unit);
+	const base = typeof unit === "function" ? createCallableBridge((...args) => unit(...args)) : {};
+	copyUnitProperties(base, effectorUnit);
+	copyUnitProperties(base, unit);
+	return base;
 }
-function isVirentiaUnit(value) {
-	return Boolean(value && (typeof value === "object" || typeof value === "function") && "node" in value && !isEffectorUnit(value));
+function createFooledEffectorUnit(unit) {
+	const virentiaUnit = createVirentiaAdapter(unit);
+	const base = typeof unit === "function" || typeof virentiaUnit === "function" ? createCallableBridge((...args) => {
+		if (virentia.getCurrentScope() && typeof virentiaUnit === "function") return virentiaUnit(...args);
+		if (typeof unit === "function") return unit(...args);
+		throw new Error("Effector store cannot be called");
+	}) : {};
+	copyUnitProperties(base, virentiaUnit);
+	copyUnitProperties(base, unit);
+	return base;
 }
-function isVirentiaEffect(value) {
-	return Boolean(isVirentiaUnit(value) && "doneData" in value && "$pending" in value);
+function createCallableBridge(call) {
+	return (...args) => call(...args);
 }
-function toUnsubscribe(subscription) {
-	return () => {
-		subscription.unsubscribe();
-	};
+function createEffectorAdapter(unit) {
+	if (isEffectorUnit(unit)) return unit;
+	if (isVirentiaEffect(unit)) {
+		const scopeQueue = [];
+		const adapter = createEffect((payload) => {
+			return callAssociation(resolveAssociationFromEffectorScope(scopeQueue.shift()), unit, payload);
+		});
+		createEffectorScopeNode(adapter, (_payload, scope) => {
+			scopeQueue.push(scope);
+		});
+		return adapter;
+	}
+	const adapter = createEvent();
+	createEffectorScopeNode(adapter, (payload, scope) => {
+		const association = resolveAssociationFromEffectorScope(scope);
+		if (shouldSkipEffector(association, adapter)) return;
+		emitVirentia(association, unit, payload, { suppressReaction: true });
+	});
+	installVirentiaToEffectorLink(unit, adapter);
+	return adapter;
 }
-function identity(value) {
-	return value;
+function createVirentiaAdapter(unit) {
+	if (isVirentiaUnit(unit)) return unit;
+	if (is.effect(unit)) return virentia.effect((payload) => {
+		return callAssociation(resolveAssociationFromVirentiaScope(), unit, payload);
+	});
+	const adapter = virentia.event();
+	createEffectorScopeNode(unit, (payload, scope) => {
+		const association = resolveAssociationFromEffectorScope(scope);
+		if (shouldSkipEffector(association, unit)) return;
+		emitVirentia(association, adapter, payload, { suppressReaction: true });
+	});
+	installVirentiaToEffectorLink(adapter, unit);
+	return adapter;
+}
+function copyUnitProperties(target, source) {
+	for (const key of Reflect.ownKeys(source)) {
+		if (key === "length" || key === "name" || key === "prototype") continue;
+		const descriptor = Object.getOwnPropertyDescriptor(source, key);
+		if (!descriptor) continue;
+		const existing = Object.getOwnPropertyDescriptor(target, key);
+		if (existing && !existing.configurable) continue;
+		Object.defineProperty(target, key, descriptor);
+	}
+}
+function markFooledUnit(unit) {
+	Object.defineProperty(unit, fooledUnit, {
+		enumerable: false,
+		value: true
+	});
 }
 //#endregion
-export { createEffectorCompatibility };
+export { associate, effectorAssociations, ensureAssociation, fool };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virentia/effector",
-  "version": "0.2.1",
+  "version": "0.3.1",
   "description": "Compatibility layer between @virentia/core and the real Effector package",
   "keywords": [],
   "homepage": "https://movpushmov.dev/virentia/effector/",
@@ -35,7 +35,7 @@
     "effector": "^23.0.0"
   },
   "dependencies": {
-    "@virentia/core": "0.2.1"
+    "@virentia/core": "0.3.1"
   },
   "scripts": {
     "build": "tsdown",