bunja 2.1.0 → 3.0.0-alpha.3

package/dist/bunja-CtHOS4_Q.js

@@ -0,0 +1,634 @@
+//#region bunja.ts
+const __DEV__ = process.env.NODE_ENV !== "production";
+const bunja = bunjaFn;
+function bunjaFn(init) {
+	return new Bunja(() => init(), NO_SEED);
+}
+const NO_SEED = Symbol("bunja.noSeed");
+bunjaFn.withSeed = function withSeed(defaultSeed, init) {
+	return new Bunja(init, defaultSeed);
+};
+bunjaFn.use = ((dep, scopeValuePairs) => getCurrentFrame("`bunja.use`").use(dep, scopeValuePairs));
+bunjaFn.will = ((dep, scopeValuePairs) => getCurrentFrame("`bunja.will`").will(dep, scopeValuePairs));
+bunjaFn.effect = ((callback) => getCurrentFrame("`bunja.effect`").effect(callback));
+function createScope(hash) {
+	return new Scope(hash);
+}
+function createBunjaStore(config) {
+	const { wrapInstance = defaultWrapInstanceFn } = config ?? {};
+	const store = new BunjaStore();
+	store.wrapInstance = wrapInstance;
+	return store;
+}
+const frameStack = [];
+function getCurrentFrame(api) {
+	const frame = frameStack[frameStack.length - 1];
+	if (!frame) throw new Error(`${api} can only be used inside a bunja init function.`);
+	return frame;
+}
+function runWithFrame(frame, fn) {
+	frameStack.push(frame);
+	try {
+		return fn();
+	} finally {
+		frameStack.pop();
+	}
+}
+const defaultWrapInstanceFn = (fn) => fn(noop);
+function normalizeBunjaRuntimeRef(bunjaOrRef, scopeValuePairs = []) {
+	if (bunjaOrRef instanceof Bunja) return {
+		bunja: bunjaOrRef,
+		scopeValuePairs,
+		seed: bunjaOrRef.defaultSeed
+	};
+	const { bunja: bunja$1, with: refScopeValuePairs = [] } = bunjaOrRef;
+	return {
+		bunja: bunja$1,
+		scopeValuePairs: refScopeValuePairs,
+		seed: "seed" in bunjaOrRef ? bunjaOrRef.seed : bunja$1.defaultSeed
+	};
+}
+function normalizeBunjaPrebakeRef(bunjaOrRef) {
+	if (bunjaOrRef instanceof Bunja) return {
+		bunja: bunjaOrRef,
+		scopeValuePairs: []
+	};
+	if ("seed" in bunjaOrRef) throw new Error("A bunja seed cannot be provided to `store.prebake`.");
+	const { bunja: bunja$1, with: refScopeValuePairs = [] } = bunjaOrRef;
+	return {
+		bunja: bunja$1,
+		scopeValuePairs: refScopeValuePairs
+	};
+}
+function toBunjaGraphRef(bunjaRef) {
+	return {
+		bunja: bunjaRef.bunja,
+		scopeValuePairs: bunjaRef.scopeValuePairs
+	};
+}
+function isBunjaRef(value) {
+	return typeof value === "object" && value !== null && "bunja" in value && value.bunja instanceof Bunja;
+}
+function getBoundScopeSet(scopeValuePairs) {
+	return new Set(scopeValuePairs.map(([scope]) => scope));
+}
+function getScopeInstances(scopes, scopeInstanceMap, excludeScopes = /* @__PURE__ */ new Set()) {
+	return scopes.filter((scope) => !excludeScopes.has(scope)).map((scope) => scopeInstanceMap.get(scope));
+}
+function dedupeScopeInstances(scopeInstances) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const scopeInstance of scopeInstances) {
+		if (seen.has(scopeInstance.id)) continue;
+		seen.add(scopeInstance.id);
+		result.push(scopeInstance);
+	}
+	return result;
+}
+function dedupeBunjas(bunjas) {
+	return Array.from(new Set(bunjas));
+}
+function addUniqueBunjaRef(refs, ref) {
+	if (!refs.includes(ref)) refs.push(ref);
+}
+function createBunjaPrebakeContext() {
+	return {
+		inProgressBunjas: /* @__PURE__ */ new Set(),
+		values: /* @__PURE__ */ new Map()
+	};
+}
+var BunjaStore = class BunjaStore {
+	static counter = 0;
+	id = String(BunjaStore.counter++);
+	#bunjas = {};
+	#bunjaBuckets = /* @__PURE__ */ new Map();
+	#scopes = /* @__PURE__ */ new Map();
+	wrapInstance = defaultWrapInstanceFn;
+	constructor() {
+		if (__DEV__) devtoolsGlobalHook.emit("storeCreated", { storeId: this.id });
+	}
+	get _internalState() {
+		if (__DEV__) return {
+			bunjas: this.#bunjas,
+			scopes: this.#scopes,
+			get instantiating() {
+				return frameStack.length > 0;
+			}
+		};
+	}
+	dispose() {
+		for (const instance of Object.values(this.#bunjas)) instance.dispose();
+		for (const instanceMap of this.#scopes.values()) for (const instance of instanceMap.values()) instance.dispose();
+		this.#bunjas = {};
+		this.#bunjaBuckets = /* @__PURE__ */ new Map();
+		this.#scopes = /* @__PURE__ */ new Map();
+		if (__DEV__) devtoolsGlobalHook.emit("storeDisposed", { storeId: this.id });
+	}
+	get(bunjaOrRef, readScope) {
+		const bunjaRef = normalizeBunjaRuntimeRef(bunjaOrRef);
+		const resolved = this.#resolveBunjaRef(toBunjaGraphRef(bunjaRef), readScope, /* @__PURE__ */ new Set(), bunjaRef.seed);
+		const result = {
+			value: resolved.value,
+			mount: resolved.mount,
+			deps: resolved.deps.map(({ value }) => value)
+		};
+		if (__DEV__) {
+			result.bunjaInstance = resolved.instance;
+			devtoolsGlobalHook.emit("getCalled", {
+				storeId: this.id,
+				bunjaInstanceId: resolved.instance.id
+			});
+		}
+		return result;
+	}
+	prebake(bunjaOrRef, readScope) {
+		const bunjaRef = normalizeBunjaPrebakeRef(bunjaOrRef);
+		this.#prebakeBunjaRef(bunjaRef, readScope, createBunjaPrebakeContext());
+		return {
+			relatedBunjas: bunjaRef.bunja.relatedBunjas,
+			requiredScopes: bunjaRef.bunja.requiredScopes
+		};
+	}
+	#resolveBunjaRef(bunjaRef, readScope, inProgressBunjas, seed = bunjaRef.bunja.defaultSeed) {
+		const { bunja: bunja$1 } = bunjaRef;
+		if (inProgressBunjas.has(bunja$1)) throw new Error("Circular bunja dependency detected.");
+		const resolvedReadScope = bunjaRef.scopeValuePairs.length > 0 ? createReadScopeFn(bunjaRef.scopeValuePairs, readScope) : readScope;
+		inProgressBunjas.add(bunja$1);
+		try {
+			if (!bunja$1.baked) return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed);
+			const scopeInstanceMap = this.#resolveScopeInstanceMap(bunja$1, resolvedReadScope);
+			const boundScopes = getBoundScopeSet(bunjaRef.scopeValuePairs);
+			const scopeInstances = getScopeInstances(bunja$1.requiredScopes, scopeInstanceMap);
+			const directDeps = getScopeInstances(bunja$1.requiredScopes, scopeInstanceMap, boundScopes);
+			const baseId = bunja$1.calcBaseInstanceId(scopeInstanceMap);
+			const bucket = this.#bunjaBuckets.get(baseId);
+			if (bucket) for (const candidateId of Array.from(bucket)) {
+				const candidate = this.#bunjas[candidateId];
+				if (!candidate) {
+					bucket.delete(candidateId);
+					continue;
+				}
+				const activeDeps = this.#resolveActiveDependencyRecipe(candidate.recipe, resolvedReadScope, inProgressBunjas);
+				const currentId = bunja$1.calcInstanceId(scopeInstanceMap, activeDeps.activeDependencyIds);
+				const instance = currentId === candidate.id ? candidate : this.#bunjas[currentId];
+				if (!instance) continue;
+				return this.#toResolvedBunja(instance, scopeInstances, directDeps, activeDeps.deps);
+			}
+			return this.#createResolvedBunja(bunjaRef, resolvedReadScope, inProgressBunjas, seed, scopeInstanceMap);
+		} finally {
+			inProgressBunjas.delete(bunja$1);
+		}
+	}
+	#createResolvedBunja(bunjaRef, readScope, inProgressBunjas, seed, initialScopeInstanceMap = /* @__PURE__ */ new Map()) {
+		const { bunja: bunja$1 } = bunjaRef;
+		return this.wrapInstance((dispose) => {
+			let instanceCreated = false;
+			let disposed = false;
+			const disposeOnce = () => {
+				if (disposed) return;
+				disposed = true;
+				dispose();
+			};
+			try {
+				const frame = this.#createInitFrame(bunja$1, readScope, initialScopeInstanceMap, inProgressBunjas);
+				const value = runWithFrame(frame, () => bunja$1.init(seed));
+				if (!bunja$1.baked) bunja$1.bake();
+				this.#ensureRequiredScopeInstances(bunja$1, frame.scopeInstanceMap, readScope);
+				const boundScopes = getBoundScopeSet(bunjaRef.scopeValuePairs);
+				const scopeInstances = getScopeInstances(bunja$1.requiredScopes, frame.scopeInstanceMap);
+				const directDeps = getScopeInstances(bunja$1.requiredScopes, frame.scopeInstanceMap, boundScopes);
+				const baseId = bunja$1.calcBaseInstanceId(frame.scopeInstanceMap);
+				const id = bunja$1.calcInstanceId(frame.scopeInstanceMap, frame.activeDependencyIds);
+				const existing = this.#bunjas[id];
+				if (existing) {
+					disposeOnce();
+					return this.#toResolvedBunja(existing, scopeInstances, directDeps, frame.activeDependencyDeps);
+				}
+				const instance = this.#createBunjaInstance(id, baseId, value, Array.from(frame.activeDependencyMounts.values()), frame.effects, { activeDependencies: frame.activeDependencyRecipes }, dispose);
+				instanceCreated = true;
+				return this.#toResolvedBunja(instance, scopeInstances, directDeps, frame.activeDependencyDeps);
+			} finally {
+				if (!instanceCreated) disposeOnce();
+			}
+		});
+	}
+	#toResolvedBunja(instance, scopeInstances, directDeps, activeDependencyDeps) {
+		const deps = dedupeScopeInstances([...directDeps, ...activeDependencyDeps]);
+		return {
+			value: instance.value,
+			instance,
+			deps,
+			mount: () => {
+				for (const scopeInstance of scopeInstances) scopeInstance.add();
+				instance.add();
+				return () => {
+					instance.sub();
+					for (const scopeInstance of scopeInstances) scopeInstance.sub();
+				};
+			}
+		};
+	}
+	#createInitFrame(currentBunja, readScope, scopeInstanceMap, inProgressBunjas) {
+		const frame = {
+			currentBunja,
+			readScope,
+			scopeInstanceMap,
+			inProgressBunjas,
+			effects: [],
+			activeDependencyIds: /* @__PURE__ */ new Set(),
+			activeDependencyRecipes: [],
+			activeDependencyMounts: /* @__PURE__ */ new Map(),
+			activeDependencyDeps: [],
+			use: ((dep, scopeValuePairs) => {
+				if (dep instanceof Scope) return this.#useScopeInFrame(frame, dep);
+				if (dep instanceof Bunja || isBunjaRef(dep)) return this.#useBunjaDependencyInFrame(frame, normalizeBunjaRuntimeRef(dep, scopeValuePairs), "required");
+				throw new Error("`bunja.use` can only be used with Bunja or Scope.");
+			}),
+			will: ((dep, scopeValuePairs) => {
+				if (!(dep instanceof Bunja || isBunjaRef(dep))) throw new Error("`bunja.will` can only be used with Bunja.");
+				const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
+				currentBunja.addOptionalBunjaRef(toBunjaGraphRef(bunjaRef));
+				return () => {
+					if (frameStack[frameStack.length - 1] !== frame) throw new Error("A thunk returned by `bunja.will` can only be called inside the same bunja init function.");
+					return this.#useBunjaDependencyInFrame(frame, bunjaRef, "optional");
+				};
+			}),
+			effect: ((callback) => {
+				frame.effects.push(callback);
+			})
+		};
+		return frame;
+	}
+	#useScopeInFrame(frame, scope) {
+		if (!frame.currentBunja.baked) frame.currentBunja.addScope(scope);
+		let scopeInstance = frame.scopeInstanceMap.get(scope);
+		if (!scopeInstance) {
+			if (frame.currentBunja.baked) throw new Error("`bunja.use(scope)` cannot introduce a new scope after the bunja is baked.");
+			scopeInstance = this.#getScopeInstance(scope, frame.readScope(scope));
+			frame.scopeInstanceMap.set(scope, scopeInstance);
+		}
+		return scopeInstance.value;
+	}
+	#useBunjaDependencyInFrame(frame, bunjaRef, edge) {
+		const graphRef = toBunjaGraphRef(bunjaRef);
+		if (edge === "optional" || graphRef.scopeValuePairs.length > 0) frame.currentBunja.addOptionalBunjaRef(graphRef);
+		else if (edge === "required") frame.currentBunja.addRequiredBunjaRef(graphRef);
+		const resolved = this.#resolveBunjaRef(graphRef, frame.readScope, frame.inProgressBunjas, bunjaRef.seed);
+		frame.activeDependencyIds.add(resolved.instance.id);
+		frame.activeDependencyRecipes.push({
+			ref: graphRef,
+			seed: bunjaRef.seed
+		});
+		if (!frame.activeDependencyMounts.has(resolved.instance.id)) frame.activeDependencyMounts.set(resolved.instance.id, resolved.mount);
+		frame.activeDependencyDeps.push(...resolved.deps);
+		return resolved.value;
+	}
+	#resolveActiveDependencyRecipe(recipe, readScope, inProgressBunjas) {
+		const activeDependencyIds = /* @__PURE__ */ new Set();
+		const deps = [];
+		for (const { ref, seed } of recipe.activeDependencies) {
+			const resolved = this.#resolveBunjaRef(ref, readScope, inProgressBunjas, seed);
+			activeDependencyIds.add(resolved.instance.id);
+			deps.push(...resolved.deps);
+		}
+		return {
+			activeDependencyIds,
+			deps: dedupeScopeInstances(deps)
+		};
+	}
+	#prebakeBunjaRef(bunjaRef, readScope, prebakeContext) {
+		const { bunja: bunja$1 } = bunjaRef;
+		if (prebakeContext.values.has(bunja$1)) return prebakeContext.values.get(bunja$1);
+		const { inProgressBunjas } = prebakeContext;
+		if (inProgressBunjas.has(bunja$1)) throw new Error("Circular bunja dependency detected.");
+		const resolvedReadScope = bunjaRef.scopeValuePairs.length > 0 ? createReadScopeFn(bunjaRef.scopeValuePairs, readScope) : readScope;
+		inProgressBunjas.add(bunja$1);
+		try {
+			return this.wrapInstance((dispose) => {
+				try {
+					const value = runWithFrame(this.#createPrebakeFrame(bunja$1, resolvedReadScope, prebakeContext), () => bunja$1.init(bunja$1.defaultSeed));
+					if (!bunja$1.baked) bunja$1.bake();
+					for (const ref of [...bunja$1.requiredBunjaRefs, ...bunja$1.optionalBunjaRefs]) this.#prebakeBunjaRef(ref, resolvedReadScope, prebakeContext);
+					prebakeContext.values.set(bunja$1, value);
+					return value;
+				} finally {
+					dispose();
+				}
+			});
+		} finally {
+			inProgressBunjas.delete(bunja$1);
+		}
+	}
+	#createPrebakeFrame(currentBunja, readScope, prebakeContext) {
+		const frame = {
+			currentBunja,
+			readScope,
+			prebakeContext,
+			use: ((dep, scopeValuePairs) => {
+				if (dep instanceof Scope) {
+					if (!currentBunja.baked) currentBunja.addScope(dep);
+					return readScope(dep);
+				}
+				if (dep instanceof Bunja || isBunjaRef(dep)) {
+					const bunjaRef = normalizeBunjaRuntimeRef(dep, scopeValuePairs);
+					return this.#prebakeBunjaDependencyInFrame(frame, toBunjaGraphRef(bunjaRef), "required");
+				}
+				throw new Error("`bunja.use` can only be used with Bunja or Scope.");
+			}),
+			will: ((dep, scopeValuePairs) => {
+				if (!(dep instanceof Bunja || isBunjaRef(dep))) throw new Error("`bunja.will` can only be used with Bunja.");
+				const bunjaRef = toBunjaGraphRef(normalizeBunjaRuntimeRef(dep, scopeValuePairs));
+				currentBunja.addOptionalBunjaRef(bunjaRef);
+				const value = this.#prebakeBunjaRef(bunjaRef, readScope, prebakeContext);
+				return () => {
+					if (frameStack[frameStack.length - 1] !== frame) throw new Error("A thunk returned by `bunja.will` can only be called inside the same bunja init function.");
+					return value;
+				};
+			}),
+			effect: noop
+		};
+		return frame;
+	}
+	#prebakeBunjaDependencyInFrame(frame, bunjaRef, edge) {
+		if (edge === "optional" || bunjaRef.scopeValuePairs.length > 0) frame.currentBunja.addOptionalBunjaRef(bunjaRef);
+		else if (edge === "required") frame.currentBunja.addRequiredBunjaRef(bunjaRef);
+		return this.#prebakeBunjaRef(bunjaRef, frame.readScope, frame.prebakeContext);
+	}
+	#resolveScopeInstanceMap(bunja$1, readScope) {
+		const scopeInstanceMap = /* @__PURE__ */ new Map();
+		this.#ensureRequiredScopeInstances(bunja$1, scopeInstanceMap, readScope);
+		return scopeInstanceMap;
+	}
+	#ensureRequiredScopeInstances(bunja$1, scopeInstanceMap, readScope) {
+		for (const scope of bunja$1.requiredScopes) {
+			if (scopeInstanceMap.has(scope)) continue;
+			scopeInstanceMap.set(scope, this.#getScopeInstance(scope, readScope(scope)));
+		}
+	}
+	#getScopeInstance(scope, value) {
+		const key = scope.hash(value);
+		const instanceMap = this.#scopes.get(scope) ?? this.#scopes.set(scope, /* @__PURE__ */ new Map()).get(scope);
+		return instanceMap.get(key) ?? instanceMap.set(key, this.#createScopeInstance(scope, key, value, () => {
+			instanceMap.delete(key);
+			if (__DEV__) devtoolsGlobalHook.emit("scopeInstanceUnmounted", {
+				storeId: this.id,
+				scope,
+				key
+			});
+		})).get(key);
+	}
+	#createBunjaInstance(id, baseId, value, dependencyMounts, effects, recipe, dispose) {
+		const bunjaInstance = new BunjaInstance(id, baseId, value, dependencyMounts, effects, recipe, () => {
+			if (__DEV__) devtoolsGlobalHook.emit("bunjaInstanceUnmounted", {
+				storeId: this.id,
+				bunjaInstanceId: id
+			});
+			dispose();
+			delete this.#bunjas[id];
+			const bucket = this.#bunjaBuckets.get(baseId);
+			bucket?.delete(id);
+			if (bucket?.size === 0) this.#bunjaBuckets.delete(baseId);
+		});
+		this.#bunjas[id] = bunjaInstance;
+		(this.#bunjaBuckets.get(baseId) ?? this.#bunjaBuckets.set(baseId, /* @__PURE__ */ new Set()).get(baseId)).add(id);
+		if (__DEV__) devtoolsGlobalHook.emit("bunjaInstanceMounted", {
+			storeId: this.id,
+			bunjaInstanceId: id
+		});
+		return bunjaInstance;
+	}
+	#createScopeInstance(scope, key, value, dispose) {
+		if (__DEV__) devtoolsGlobalHook.emit("scopeInstanceMounted", {
+			storeId: this.id,
+			scope,
+			key
+		});
+		return new ScopeInstance(value, dispose);
+	}
+};
+function createReadScopeFn(scopeValuePairs, readScope) {
+	const map = new Map(scopeValuePairs);
+	return (scope) => {
+		if (map.has(scope)) return map.get(scope);
+		return readScope(scope);
+	};
+}
+function delayUnmount(mount, ms = 0) {
+	return () => {
+		const unmount = mount();
+		return () => setTimeout(unmount, ms);
+	};
+}
+var Bunja = class Bunja {
+	static counter = 0;
+	id = String(Bunja.counter++);
+	debugLabel = "";
+	#phase = {
+		baked: false,
+		requiredBunjaRefs: [],
+		optionalBunjaRefs: [],
+		scopes: /* @__PURE__ */ new Set()
+	};
+	constructor(init, defaultSeed) {
+		this.init = init;
+		this.defaultSeed = defaultSeed;
+		if (__DEV__) {
+			devtoolsGlobalHook.bunjas[this.id] = this;
+			devtoolsGlobalHook.emit("bunjaCreated", { bunjaId: this.id });
+		}
+	}
+	get baked() {
+		return this.#phase.baked;
+	}
+	get requiredBunjas() {
+		return dedupeBunjas(this.#phase.requiredBunjaRefs.map(({ bunja: bunja$1 }) => bunja$1));
+	}
+	get optionalBunjas() {
+		return dedupeBunjas(this.#phase.optionalBunjaRefs.map(({ bunja: bunja$1 }) => bunja$1));
+	}
+	get requiredBunjaRefs() {
+		return this.#phase.requiredBunjaRefs;
+	}
+	get optionalBunjaRefs() {
+		return this.#phase.optionalBunjaRefs;
+	}
+	get expandedRequiredBunjas() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return this.#phase.expandedRequiredBunjas;
+	}
+	get relatedBunjas() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return toposortRelatedBunjas([...this.requiredBunjas, ...this.optionalBunjas]);
+	}
+	get requiredScopes() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return this.#phase.requiredScopes;
+	}
+	addRequiredBunjaRef(ref) {
+		if (this.#phase.baked) return;
+		addUniqueBunjaRef(this.#phase.requiredBunjaRefs, ref);
+	}
+	addOptionalBunjaRef(ref) {
+		if (this.#phase.baked) return;
+		addUniqueBunjaRef(this.#phase.optionalBunjaRefs, ref);
+	}
+	addScope(scope) {
+		if (this.#phase.baked) return;
+		this.#phase.scopes.add(scope);
+	}
+	bake() {
+		if (this.#phase.baked) throw new Error("Bunja is already baked.");
+		const scopes = this.#phase.scopes;
+		const requiredBunjaRefs = this.#phase.requiredBunjaRefs;
+		const optionalBunjaRefs = this.#phase.optionalBunjaRefs;
+		const requiredBunjas = this.requiredBunjas;
+		const expandedRequiredBunjas = toposortRequiredBunjas(requiredBunjas);
+		const requiredScopeSet = /* @__PURE__ */ new Set();
+		for (const bunja$1 of expandedRequiredBunjas) for (const scope of bunja$1.requiredScopes) requiredScopeSet.add(scope);
+		for (const scope of scopes) requiredScopeSet.add(scope);
+		this.#phase = {
+			baked: true,
+			requiredBunjaRefs,
+			optionalBunjaRefs,
+			expandedRequiredBunjas,
+			requiredScopes: Array.from(requiredScopeSet)
+		};
+	}
+	calcBaseInstanceId(scopeInstanceMap) {
+		const scopeInstanceIds = this.requiredScopes.map((scope) => scopeInstanceMap.get(scope).id);
+		return `${this.id}:${scopeInstanceIds.join(",")}`;
+	}
+	calcInstanceId(scopeInstanceMap, activeDependencyIds = []) {
+		return `${this.calcBaseInstanceId(scopeInstanceMap)}:${Array.from(activeDependencyIds).join(",")}`;
+	}
+	toString() {
+		const { id, debugLabel } = this;
+		return `[Bunja:${id}${debugLabel && ` - ${debugLabel}`}]`;
+	}
+};
+var Scope = class Scope {
+	static counter = 0;
+	id = String(Scope.counter++);
+	debugLabel = "";
+	constructor(hash = Scope.identity) {
+		this.hash = hash;
+		if (__DEV__) {
+			devtoolsGlobalHook.scopes[this.id] = this;
+			devtoolsGlobalHook.emit("scopeCreated", { scopeId: this.id });
+		}
+	}
+	static identity(x) {
+		return x;
+	}
+	bind(value) {
+		return [this, value];
+	}
+	toString() {
+		const { id, debugLabel } = this;
+		return `[Scope:${id}${debugLabel && ` - ${debugLabel}`}]`;
+	}
+};
+var RefCounter = class {
+	#count = 0;
+	add() {
+		++this.#count;
+	}
+	sub() {
+		--this.#count;
+		if (this.#count < 1) {
+			this.dispose();
+			this.dispose = noop;
+		}
+	}
+};
+var BunjaInstance = class extends RefCounter {
+	#cleanup;
+	#disposed = false;
+	constructor(id, baseId, value, dependencyMounts, effects, recipe, _dispose) {
+		super();
+		this.id = id;
+		this.baseId = baseId;
+		this.value = value;
+		this.dependencyMounts = dependencyMounts;
+		this.effects = effects;
+		this.recipe = recipe;
+		this._dispose = _dispose;
+	}
+	dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		this.#cleanup?.();
+		this.#cleanup = void 0;
+		this._dispose();
+	}
+	add() {
+		this.#cleanup ??= this.#mount();
+		super.add();
+	}
+	#mount() {
+		const dependencyCleanups = this.dependencyMounts.map((mount) => mount());
+		const effectCleanups = this.effects.map((effect) => effect()).filter(Boolean);
+		return () => {
+			for (const cleanup of dependencyCleanups) cleanup();
+			for (const cleanup of effectCleanups) cleanup();
+		};
+	}
+};
+var ScopeInstance = class ScopeInstance extends RefCounter {
+	static counter = 0;
+	id = String(ScopeInstance.counter++);
+	constructor(value, dispose) {
+		super();
+		this.value = value;
+		this.dispose = dispose;
+	}
+};
+function toposort(nodes, getDependencies) {
+	const visited = /* @__PURE__ */ new Set();
+	const result = [];
+	function visit(current) {
+		if (visited.has(current)) return;
+		visited.add(current);
+		for (const dependency of getDependencies(current)) visit(dependency);
+		result.push(current);
+	}
+	for (const node of nodes) visit(node);
+	return result;
+}
+function toposortRequiredBunjas(bunjas) {
+	return toposort(bunjas, (bunja$1) => bunja$1.requiredBunjas);
+}
+function toposortRelatedBunjas(bunjas) {
+	return toposort(bunjas, (bunja$1) => [...bunja$1.requiredBunjas, ...bunja$1.optionalBunjas]);
+}
+const noop = () => {};
+let devtoolsGlobalHook;
+if (__DEV__) if (globalThis.__BUNJA_DEVTOOLS_GLOBAL_HOOK__) devtoolsGlobalHook = globalThis.__BUNJA_DEVTOOLS_GLOBAL_HOOK__;
+else {
+	devtoolsGlobalHook = {
+		bunjas: {},
+		scopes: {},
+		listeners: {
+			bunjaCreated: /* @__PURE__ */ new Set(),
+			scopeCreated: /* @__PURE__ */ new Set(),
+			storeCreated: /* @__PURE__ */ new Set(),
+			storeDisposed: /* @__PURE__ */ new Set(),
+			getCalled: /* @__PURE__ */ new Set(),
+			bunjaInstanceMounted: /* @__PURE__ */ new Set(),
+			bunjaInstanceUnmounted: /* @__PURE__ */ new Set(),
+			scopeInstanceMounted: /* @__PURE__ */ new Set(),
+			scopeInstanceUnmounted: /* @__PURE__ */ new Set()
+		},
+		emit: (type, event) => {
+			for (const fn of devtoolsGlobalHook.listeners[type]) fn(event);
+		},
+		on: (type, listener) => {
+			devtoolsGlobalHook.listeners[type].add(listener);
+			return () => devtoolsGlobalHook.listeners[type].delete(listener);
+		}
+	};
+	globalThis.__BUNJA_DEVTOOLS_GLOBAL_HOOK__ = devtoolsGlobalHook;
+}
+
+//#endregion
+export { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createReadScopeFn, createScope, delayUnmount };