bunja 1.0.0 → 2.0.0-alpha.2

package/dist/bunja-bUA1rGXy.cjs

@@ -0,0 +1,305 @@
+"use strict";
+
+//#region bunja.ts
+const bunja = bunjaFn;
+function bunjaFn(init) {
+	return new Bunja(init);
+}
+bunjaFn.use = invalidUse;
+bunjaFn.effect = invalidEffect;
+function createScope(hash) {
+	return new Scope(hash);
+}
+function createBunjaStore() {
+	return new BunjaStore();
+}
+function invalidUse() {
+	throw new Error("`bunja.use` can only be used inside a bunja init function.");
+}
+function invalidEffect() {
+	throw new Error("`bunja.effect` can only be used inside a bunja init function.");
+}
+var BunjaStore = class {
+	#bunjas = {};
+	#scopes = new Map();
+	#bakingContext;
+	dispose() {
+		for (const instance of Object.values(this.#bunjas)) instance.dispose();
+		for (const instanceMap of Object.values(this.#scopes)) for (const instance of instanceMap.values()) instance.dispose();
+		this.#bunjas = {};
+		this.#scopes = new Map();
+	}
+	get(bunja$1, readScope) {
+		const originalUse = bunjaFn.use;
+		try {
+			const { bunjaInstance, bunjaInstanceMap, scopeInstanceMap } = bunja$1.baked ? this.#getBaked(bunja$1, readScope) : this.#getUnbaked(bunja$1, readScope);
+			return {
+				value: bunjaInstance.value,
+				mount: () => {
+					bunjaInstanceMap.forEach((instance) => instance.add());
+					bunjaInstance.add();
+					scopeInstanceMap.forEach((instance) => instance.add());
+					const unmount = () => {
+						setTimeout(() => {
+							bunjaInstanceMap.forEach((instance) => instance.sub());
+							bunjaInstance.sub();
+							scopeInstanceMap.forEach((instance) => instance.sub());
+						});
+					};
+					return unmount;
+				},
+				deps: Array.from(scopeInstanceMap.values()).map(({ value }) => value)
+			};
+		} finally {
+			bunjaFn.use = originalUse;
+		}
+	}
+	#getBaked(bunja$1, readScope) {
+		const scopeInstanceMap = new Map(bunja$1.relatedScopes.map((scope) => [scope, this.#getScopeInstance(scope, readScope(scope))]));
+		const bunjaInstanceMap = new Map(bunja$1.relatedBunjas.map((relatedBunja) => [relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap)]));
+		bunjaFn.use = (dep) => {
+			if (dep instanceof Bunja) return bunjaInstanceMap.get(dep).value;
+			if (dep instanceof Scope) return scopeInstanceMap.get(dep).value;
+			throw new Error("`bunja.use` can only be used with Bunja or Scope.");
+		};
+		const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
+		return {
+			bunjaInstance,
+			bunjaInstanceMap,
+			scopeInstanceMap
+		};
+	}
+	#getUnbaked(bunja$1, readScope) {
+		const bunjaInstanceMap = new Map();
+		const scopeInstanceMap = new Map();
+		function getUse(map, addDep, getInstance) {
+			return (dep) => {
+				const d = dep;
+				addDep(d);
+				if (map.has(d)) return map.get(d).value;
+				const instance = getInstance(d);
+				map.set(d, instance);
+				return instance.value;
+			};
+		}
+		const useScope = getUse(scopeInstanceMap, (dep) => this.#bakingContext.currentBunja.addScope(dep), (dep) => this.#getScopeInstance(dep, readScope(dep)));
+		const useBunja = getUse(bunjaInstanceMap, (dep) => this.#bakingContext.currentBunja.addParent(dep), (dep) => {
+			if (dep.baked) for (const scope of dep.relatedScopes) useScope(scope);
+			return this.#getBunjaInstance(dep, scopeInstanceMap);
+		});
+		bunjaFn.use = (dep) => {
+			if (dep instanceof Bunja) return useBunja(dep);
+			if (dep instanceof Scope) return useScope(dep);
+			throw new Error("`bunja.use` can only be used with Bunja or Scope.");
+		};
+		try {
+			this.#bakingContext = { currentBunja: bunja$1 };
+			const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
+			return {
+				bunjaInstance,
+				bunjaInstanceMap,
+				scopeInstanceMap
+			};
+		} finally {
+			this.#bakingContext = undefined;
+		}
+	}
+	#getBunjaInstance(bunja$1, scopeInstanceMap) {
+		const originalEffect = bunjaFn.effect;
+		const prevBunja = this.#bakingContext?.currentBunja;
+		try {
+			const effects = [];
+			bunjaFn.effect = (callback) => {
+				effects.push(callback);
+			};
+			if (this.#bakingContext) this.#bakingContext.currentBunja = bunja$1;
+			if (bunja$1.baked) {
+				const id = bunja$1.calcInstanceId(scopeInstanceMap);
+				if (id in this.#bunjas) return this.#bunjas[id];
+				const bunjaInstanceValue = bunja$1.init();
+				return this.#createBunjaInstance(id, bunjaInstanceValue, effects);
+			} else {
+				const bunjaInstanceValue = bunja$1.init();
+				bunja$1.bake();
+				const id = bunja$1.calcInstanceId(scopeInstanceMap);
+				return this.#createBunjaInstance(id, bunjaInstanceValue, effects);
+			}
+		} finally {
+			bunjaFn.effect = originalEffect;
+			if (this.#bakingContext) this.#bakingContext.currentBunja = prevBunja;
+		}
+	}
+	#getScopeInstance(scope, value) {
+		const key = scope.hash(value);
+		const instanceMap = this.#scopes.get(scope) ?? this.#scopes.set(scope, new Map()).get(scope);
+		return instanceMap.get(key) ?? instanceMap.set(key, new ScopeInstance(value, () => instanceMap.delete(key))).get(key);
+	}
+	#createBunjaInstance(id, value, effects) {
+		const effect = () => {
+			const cleanups = effects.map((effect$1) => effect$1()).filter(Boolean);
+			return () => cleanups.forEach((cleanup) => cleanup());
+		};
+		const dispose = () => delete this.#bunjas[id];
+		const bunjaInstance = new BunjaInstance(id, value, effect, dispose);
+		this.#bunjas[id] = bunjaInstance;
+		return bunjaInstance;
+	}
+};
+var Bunja = class Bunja {
+	static counter = 0;
+	id = String(Bunja.counter++);
+	debugLabel = "";
+	#phase = {
+		baked: false,
+		parents: new Set(),
+		scopes: new Set()
+	};
+	constructor(init) {
+		this.init = init;
+	}
+	get baked() {
+		return this.#phase.baked;
+	}
+	get parents() {
+		if (this.#phase.baked) return this.#phase.parents;
+		return Array.from(this.#phase.parents);
+	}
+	get relatedBunjas() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return this.#phase.relatedBunjas;
+	}
+	get relatedScopes() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return this.#phase.relatedScopes;
+	}
+	addParent(bunja$1) {
+		if (this.#phase.baked) return;
+		this.#phase.parents.add(bunja$1);
+	}
+	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 parents = this.parents;
+		const relatedBunjas = toposort(parents);
+		const relatedScopes = Array.from(new Set([...relatedBunjas.flatMap((bunja$1) => bunja$1.relatedScopes), ...scopes]));
+		this.#phase = {
+			baked: true,
+			parents,
+			relatedBunjas,
+			relatedScopes
+		};
+	}
+	calcInstanceId(scopeInstanceMap) {
+		const scopeInstanceIds = this.relatedScopes.map((scope) => scopeInstanceMap.get(scope).id);
+		return `${this.id}:${scopeInstanceIds.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;
+	}
+	static identity(x) {
+		return x;
+	}
+	toString() {
+		const { id, debugLabel } = this;
+		return `[Scope:${id}${debugLabel && ` - ${debugLabel}`}]`;
+	}
+};
+const noop = () => {};
+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;
+	constructor(id, value, effect, _dispose) {
+		super();
+		this.id = id;
+		this.value = value;
+		this.effect = effect;
+		this._dispose = _dispose;
+	}
+	dispose() {
+		this.#cleanup?.();
+		this._dispose();
+	}
+	add() {
+		this.#cleanup ??= this.effect() ?? noop;
+		super.add();
+	}
+};
+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) {
+	const visited = new Set();
+	const result = [];
+	function visit(current) {
+		if (visited.has(current)) return;
+		visited.add(current);
+		for (const parent of current.parents) visit(parent);
+		result.push(current);
+	}
+	for (const node of nodes) visit(node);
+	return result;
+}
+
+//#endregion
+Object.defineProperty(exports, 'Bunja', {
+  enumerable: true,
+  get: function () {
+    return Bunja;
+  }
+});Object.defineProperty(exports, 'BunjaStore', {
+  enumerable: true,
+  get: function () {
+    return BunjaStore;
+  }
+});Object.defineProperty(exports, 'Scope', {
+  enumerable: true,
+  get: function () {
+    return Scope;
+  }
+});Object.defineProperty(exports, 'bunja', {
+  enumerable: true,
+  get: function () {
+    return bunja;
+  }
+});Object.defineProperty(exports, 'createBunjaStore', {
+  enumerable: true,
+  get: function () {
+    return createBunjaStore;
+  }
+});Object.defineProperty(exports, 'createScope', {
+  enumerable: true,
+  get: function () {
+    return createScope;
+  }
+});

package/dist/bunja-wcx846sL.js

@@ -0,0 +1,274 @@
+
+//#region bunja.ts
+const bunja = bunjaFn;
+function bunjaFn(init) {
+	return new Bunja(init);
+}
+bunjaFn.use = invalidUse;
+bunjaFn.effect = invalidEffect;
+function createScope(hash) {
+	return new Scope(hash);
+}
+function createBunjaStore() {
+	return new BunjaStore();
+}
+function invalidUse() {
+	throw new Error("`bunja.use` can only be used inside a bunja init function.");
+}
+function invalidEffect() {
+	throw new Error("`bunja.effect` can only be used inside a bunja init function.");
+}
+var BunjaStore = class {
+	#bunjas = {};
+	#scopes = new Map();
+	#bakingContext;
+	dispose() {
+		for (const instance of Object.values(this.#bunjas)) instance.dispose();
+		for (const instanceMap of Object.values(this.#scopes)) for (const instance of instanceMap.values()) instance.dispose();
+		this.#bunjas = {};
+		this.#scopes = new Map();
+	}
+	get(bunja$1, readScope) {
+		const originalUse = bunjaFn.use;
+		try {
+			const { bunjaInstance, bunjaInstanceMap, scopeInstanceMap } = bunja$1.baked ? this.#getBaked(bunja$1, readScope) : this.#getUnbaked(bunja$1, readScope);
+			return {
+				value: bunjaInstance.value,
+				mount: () => {
+					bunjaInstanceMap.forEach((instance) => instance.add());
+					bunjaInstance.add();
+					scopeInstanceMap.forEach((instance) => instance.add());
+					const unmount = () => {
+						setTimeout(() => {
+							bunjaInstanceMap.forEach((instance) => instance.sub());
+							bunjaInstance.sub();
+							scopeInstanceMap.forEach((instance) => instance.sub());
+						});
+					};
+					return unmount;
+				},
+				deps: Array.from(scopeInstanceMap.values()).map(({ value }) => value)
+			};
+		} finally {
+			bunjaFn.use = originalUse;
+		}
+	}
+	#getBaked(bunja$1, readScope) {
+		const scopeInstanceMap = new Map(bunja$1.relatedScopes.map((scope) => [scope, this.#getScopeInstance(scope, readScope(scope))]));
+		const bunjaInstanceMap = new Map(bunja$1.relatedBunjas.map((relatedBunja) => [relatedBunja, this.#getBunjaInstance(relatedBunja, scopeInstanceMap)]));
+		bunjaFn.use = (dep) => {
+			if (dep instanceof Bunja) return bunjaInstanceMap.get(dep).value;
+			if (dep instanceof Scope) return scopeInstanceMap.get(dep).value;
+			throw new Error("`bunja.use` can only be used with Bunja or Scope.");
+		};
+		const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
+		return {
+			bunjaInstance,
+			bunjaInstanceMap,
+			scopeInstanceMap
+		};
+	}
+	#getUnbaked(bunja$1, readScope) {
+		const bunjaInstanceMap = new Map();
+		const scopeInstanceMap = new Map();
+		function getUse(map, addDep, getInstance) {
+			return (dep) => {
+				const d = dep;
+				addDep(d);
+				if (map.has(d)) return map.get(d).value;
+				const instance = getInstance(d);
+				map.set(d, instance);
+				return instance.value;
+			};
+		}
+		const useScope = getUse(scopeInstanceMap, (dep) => this.#bakingContext.currentBunja.addScope(dep), (dep) => this.#getScopeInstance(dep, readScope(dep)));
+		const useBunja = getUse(bunjaInstanceMap, (dep) => this.#bakingContext.currentBunja.addParent(dep), (dep) => {
+			if (dep.baked) for (const scope of dep.relatedScopes) useScope(scope);
+			return this.#getBunjaInstance(dep, scopeInstanceMap);
+		});
+		bunjaFn.use = (dep) => {
+			if (dep instanceof Bunja) return useBunja(dep);
+			if (dep instanceof Scope) return useScope(dep);
+			throw new Error("`bunja.use` can only be used with Bunja or Scope.");
+		};
+		try {
+			this.#bakingContext = { currentBunja: bunja$1 };
+			const bunjaInstance = this.#getBunjaInstance(bunja$1, scopeInstanceMap);
+			return {
+				bunjaInstance,
+				bunjaInstanceMap,
+				scopeInstanceMap
+			};
+		} finally {
+			this.#bakingContext = undefined;
+		}
+	}
+	#getBunjaInstance(bunja$1, scopeInstanceMap) {
+		const originalEffect = bunjaFn.effect;
+		const prevBunja = this.#bakingContext?.currentBunja;
+		try {
+			const effects = [];
+			bunjaFn.effect = (callback) => {
+				effects.push(callback);
+			};
+			if (this.#bakingContext) this.#bakingContext.currentBunja = bunja$1;
+			if (bunja$1.baked) {
+				const id = bunja$1.calcInstanceId(scopeInstanceMap);
+				if (id in this.#bunjas) return this.#bunjas[id];
+				const bunjaInstanceValue = bunja$1.init();
+				return this.#createBunjaInstance(id, bunjaInstanceValue, effects);
+			} else {
+				const bunjaInstanceValue = bunja$1.init();
+				bunja$1.bake();
+				const id = bunja$1.calcInstanceId(scopeInstanceMap);
+				return this.#createBunjaInstance(id, bunjaInstanceValue, effects);
+			}
+		} finally {
+			bunjaFn.effect = originalEffect;
+			if (this.#bakingContext) this.#bakingContext.currentBunja = prevBunja;
+		}
+	}
+	#getScopeInstance(scope, value) {
+		const key = scope.hash(value);
+		const instanceMap = this.#scopes.get(scope) ?? this.#scopes.set(scope, new Map()).get(scope);
+		return instanceMap.get(key) ?? instanceMap.set(key, new ScopeInstance(value, () => instanceMap.delete(key))).get(key);
+	}
+	#createBunjaInstance(id, value, effects) {
+		const effect = () => {
+			const cleanups = effects.map((effect$1) => effect$1()).filter(Boolean);
+			return () => cleanups.forEach((cleanup) => cleanup());
+		};
+		const dispose = () => delete this.#bunjas[id];
+		const bunjaInstance = new BunjaInstance(id, value, effect, dispose);
+		this.#bunjas[id] = bunjaInstance;
+		return bunjaInstance;
+	}
+};
+var Bunja = class Bunja {
+	static counter = 0;
+	id = String(Bunja.counter++);
+	debugLabel = "";
+	#phase = {
+		baked: false,
+		parents: new Set(),
+		scopes: new Set()
+	};
+	constructor(init) {
+		this.init = init;
+	}
+	get baked() {
+		return this.#phase.baked;
+	}
+	get parents() {
+		if (this.#phase.baked) return this.#phase.parents;
+		return Array.from(this.#phase.parents);
+	}
+	get relatedBunjas() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return this.#phase.relatedBunjas;
+	}
+	get relatedScopes() {
+		if (!this.#phase.baked) throw new Error("Bunja is not baked yet.");
+		return this.#phase.relatedScopes;
+	}
+	addParent(bunja$1) {
+		if (this.#phase.baked) return;
+		this.#phase.parents.add(bunja$1);
+	}
+	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 parents = this.parents;
+		const relatedBunjas = toposort(parents);
+		const relatedScopes = Array.from(new Set([...relatedBunjas.flatMap((bunja$1) => bunja$1.relatedScopes), ...scopes]));
+		this.#phase = {
+			baked: true,
+			parents,
+			relatedBunjas,
+			relatedScopes
+		};
+	}
+	calcInstanceId(scopeInstanceMap) {
+		const scopeInstanceIds = this.relatedScopes.map((scope) => scopeInstanceMap.get(scope).id);
+		return `${this.id}:${scopeInstanceIds.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;
+	}
+	static identity(x) {
+		return x;
+	}
+	toString() {
+		const { id, debugLabel } = this;
+		return `[Scope:${id}${debugLabel && ` - ${debugLabel}`}]`;
+	}
+};
+const noop = () => {};
+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;
+	constructor(id, value, effect, _dispose) {
+		super();
+		this.id = id;
+		this.value = value;
+		this.effect = effect;
+		this._dispose = _dispose;
+	}
+	dispose() {
+		this.#cleanup?.();
+		this._dispose();
+	}
+	add() {
+		this.#cleanup ??= this.effect() ?? noop;
+		super.add();
+	}
+};
+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) {
+	const visited = new Set();
+	const result = [];
+	function visit(current) {
+		if (visited.has(current)) return;
+		visited.add(current);
+		for (const parent of current.parents) visit(parent);
+		result.push(current);
+	}
+	for (const node of nodes) visit(node);
+	return result;
+}
+
+//#endregion
+export { Bunja, BunjaStore, Scope, bunja, createBunjaStore, createScope };

package/dist/bunja.cjs

@@ -1,5 +1,5 @@
 "use strict";
-const require_bunja = require('./bunja-Q0ZusYIM.cjs');
+const require_bunja = require('./bunja-bUA1rGXy.cjs');
 
 exports.Bunja = require_bunja.Bunja
 exports.BunjaStore = require_bunja.BunjaStore

package/dist/bunja.d.cts

@@ -1,55 +1,64 @@
+export interface BunjaFn {
+    <T>(init: () => T): Bunja<T>;
+    use: BunjaUseFn;
+    effect: BunjaEffectFn;
+}
+export declare const bunja: BunjaFn;
+export type BunjaUseFn = <T>(dep: Dep<T>) => T;
+export type BunjaEffectFn = (callback: BunjaEffectCallback) => void;
+export type BunjaEffectCallback = () => (() => void) | void;
+export declare function createScope<T>(hash?: HashFn<T>): Scope<T>;
+export declare function createBunjaStore(): BunjaStore;
 export type Dep<T> = Bunja<T> | Scope<T>;
-declare const bunjaEffectSymbol: unique symbol;
-type BunjaEffectSymbol = typeof bunjaEffectSymbol;
+export declare class BunjaStore {
+    #private;
+    dispose(): void;
+    get<T>(bunja: Bunja<T>, readScope: ReadScope): BunjaStoreGetResult<T>;
+}
+export type ReadScope = <T>(scope: Scope<T>) => T;
+export interface BunjaStoreGetResult<T> {
+    value: T;
+    mount: () => () => void;
+    deps: unknown[];
+}
 export declare class Bunja<T> {
-    deps: Dep<any>[];
-    parents: Bunja<any>[];
-    relatedBunjas: Bunja<any>[];
-    relatedScopes: Scope<any>[];
-    init: (...args: any[]) => T & BunjaValue;
-    static readonly bunjas: Bunja<any>[];
-    readonly id: number;
+    #private;
+    init: () => T;
+    private static counter;
+    readonly id: string;
     debugLabel: string;
-    constructor(deps: Dep<any>[], // one depth dependencies
-    parents: Bunja<any>[], // one depth parents
-    relatedBunjas: Bunja<any>[], // toposorted parents without self
-    relatedScopes: Scope<any>[], // deduped
-    init: (...args: any[]) => T & BunjaValue);
-    static readonly effect: BunjaEffectSymbol;
+    constructor(init: () => T);
+    get baked(): boolean;
+    get parents(): Bunja<unknown>[];
+    get relatedBunjas(): Bunja<unknown>[];
+    get relatedScopes(): Scope<unknown>[];
+    addParent(bunja: Bunja<unknown>): void;
+    addScope(scope: Scope<unknown>): void;
+    bake(): void;
+    calcInstanceId(scopeInstanceMap: Map<Scope<unknown>, ScopeInstance>): string;
     toString(): string;
 }
-export type HashFn<T = any, U = any> = (value: T) => U;
 export declare class Scope<T> {
-    readonly hash: HashFn;
-    static readonly scopes: Scope<any>[];
-    readonly id: number;
+    readonly hash: HashFn<T>;
+    private static counter;
+    readonly id: string;
     debugLabel: string;
-    constructor(hash?: HashFn);
+    constructor(hash?: HashFn<T>);
+    private static identity;
     toString(): string;
 }
-export type ReadScope = <T>(scope: Scope<T>) => T;
-export declare class BunjaStore {
+export type HashFn<T> = (value: T) => unknown;
+declare abstract class RefCounter {
     #private;
-    get<T>(bunja: Bunja<T>, readScope: ReadScope): {
-        value: T;
-        mount: () => () => void;
-        deps: any[];
-    };
+    abstract dispose(): void;
+    add(): void;
+    sub(): void;
 }
-export declare const createBunjaStore: () => BunjaStore;
-export type BunjaEffectFn = () => () => void;
-export interface BunjaValue {
-    [Bunja.effect]?: BunjaEffectFn;
+declare class ScopeInstance extends RefCounter {
+    readonly value: unknown;
+    readonly dispose: () => void;
+    private static counter;
+    readonly id: string;
+    constructor(value: unknown, dispose: () => void);
 }
-export declare const bunja: {
-    <T>(deps: [], init: () => T & BunjaValue): Bunja<T>;
-    <T, U>(deps: [Dep<U>], init: (u: U) => T & BunjaValue): Bunja<T>;
-    <T, U, V>(deps: [Dep<U>, Dep<V>], init: (u: U, v: V) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W>(deps: [Dep<U>, Dep<V>, Dep<W>], init: (u: U, v: V, w: W) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W, X>(deps: [Dep<U>, Dep<V>, Dep<W>, Dep<X>], init: (u: U, v: V, w: W, x: X) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W, X, Y>(deps: [Dep<U>, Dep<V>, Dep<W>, Dep<X>, Dep<Y>], init: (u: U, v: V, w: W, x: X, y: Y) => T & BunjaValue): Bunja<T>;
-    <T, U, V, W, X, Y, Z>(deps: [Dep<U>, Dep<V>, Dep<W>, Dep<X>, Dep<Y>, Dep<Z>], init: (u: U, v: V, w: W, x: X, y: Y, z: Z) => T & BunjaValue): Bunja<T>;
-    readonly effect: BunjaEffectSymbol;
-};
-export declare function createScope<T>(hash?: HashFn): Scope<T>;
 export {};