@e280/strata 0.2.1 → 0.2.3

package/s/tree/parts/trunk.ts

@@ -1,14 +1,14 @@
 
 import {deep} from "@e280/stz"
 import {Branch} from "./branch.js"
-import {signal} from "../../signals/porcelain.js"
+import {Immute} from "./utils/immute.js"
 import {trunkSetup} from "./utils/setup.js"
-import {Derived} from "../../signals/core/derived.js"
-import {Signal} from "../../signals/core/signal.js"
 import {Chronobranch} from "./chronobranch.js"
 import {processOptions} from "./utils/process-options.js"
-import {Branchstate, Chronicle, Immutable, Mutator, Options, Selector, Tree, Trunkstate} from "./types.js"
+import {Branchstate, Mutator, TreeOptions, Selector, Tree, Trunkstate} from "./types.js"
+import {Chronicle} from "../../prism/index.js"
 
+/** @deprecated tree stuff has been replaced by prism/lens stuff */
 export class Trunk<S extends Trunkstate> implements Tree<S> {
 	static setup = trunkSetup
 	static chronicle = <S extends Branchstate>(state: S): Chronicle<S> => ({
@@ -17,47 +17,43 @@ export class Trunk<S extends Trunkstate> implements Tree<S> {
 		future: [],
 	})
 
-	options: Options
-
-	#immutable: Derived<Immutable<S>>
-	#mutable: Signal<S>
+	options: TreeOptions
 	#mutationLock = 0
+	#immute: Immute<S>
 
-	constructor(state: S, options: Partial<Options> = {}) {
+	constructor(state: S, options: Partial<TreeOptions> = {}) {
 		this.options = processOptions(options)
-		this.#mutable = signal(state)
-		this.#immutable = signal.derived(() =>
-			deep.freeze(this.options.clone(this.#mutable.get())) as Immutable<S>
-		)
+		this.#immute = new Immute(state, this.options)
 	}
 
 	get state() {
-		return this.#immutable.get()
+		return this.#immute.immutable
 	}
 
 	get on() {
-		return this.#immutable.on
+		return this.#immute.on
 	}
 
 	async mutate(mutator: Mutator<S>) {
-		const oldState = this.options.clone(this.#mutable.get())
+		const oldState = this.#immute.get()
 		if (this.#mutationLock > 0)
 			throw new Error("nested mutations are forbidden")
+		let promise = Promise.resolve()
 		try {
 			this.#mutationLock++
-			const value = this.#mutable.get()
-			mutator(value)
-			const newState = value
+			const newState = this.options.clone(oldState)
+			mutator(newState)
 			const isChanged = !deep.equal(newState, oldState)
 			if (isChanged)
-				await this.overwrite(newState)
+				promise = this.overwrite(newState)
 		}
 		finally { this.#mutationLock-- }
-		return this.#immutable.get()
+		await promise
+		return this.state
 	}
 
 	async overwrite(state: S) {
-		await this.#mutable.set(state, true)
+		await this.#immute.set(state)
 	}
 
 	branch<Sub extends Branchstate>(selector: Selector<Sub, S>): Branch<Sub, S> {

package/s/tree/parts/types.ts

@@ -1,32 +1,37 @@
 
+import { EzStore, Versioned } from "../../prism/index.js"
+import { Immutable } from "../../prism/types.js"
 import {Branch} from "./branch.js"
 
-export type Options = {
+export type TreeOptions = {
 	clone: <X>(x: X) => X
 }
 
+/** @deprecated renamed to `TreeOptions` */
+export type Options = TreeOptions
+
 export type Selector<Sub, S> = (state: S) => Sub
 export type Mutator<S> = (state: S) => void
 
 export type Trunkstate = {}
 export type Branchstate = {} | null | undefined
 
-export type Versioned<S extends Trunkstate> = {
-	state: S
-	version: number
-}
-
-export type Immutable<T> =
-	T extends (...args: any[]) => any ? T :
-	T extends readonly any[] ? ReadonlyArray<Immutable<T[number]>> :
-	T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } :
-	T
-
-export type Mutable<T> =
-	T extends (...args: any[]) => any ? T :
-	T extends ReadonlyArray<infer U> ? Mutable<U>[] :
-	T extends object ? { -readonly [K in keyof T]: Mutable<T[K]> } :
-	T
+// export type Versioned<S extends Trunkstate> = {
+// 	state: S
+// 	version: number
+// }
+//
+// export type Immutable<T> =
+// 	T extends (...args: any[]) => any ? T :
+// 	T extends readonly any[] ? ReadonlyArray<Immutable<T[number]>> :
+// 	T extends object ? { readonly [K in keyof T]: Immutable<T[K]> } :
+// 	T
+//
+// export type Mutable<T> =
+// 	T extends (...args: any[]) => any ? T :
+// 	T extends ReadonlyArray<infer U> ? Mutable<U>[] :
+// 	T extends object ? { -readonly [K in keyof T]: Mutable<T[K]> } :
+// 	T
 
 export type Tree<S extends Branchstate> = {
 	get state(): Immutable<S>
@@ -42,21 +47,21 @@ export type SetupOptions<S extends Trunkstate> = {
 	persistence?: Persistence<Versioned<S>>
 }
 
-export type Chronicle<S extends Branchstate> = {
-	// [abc] d [efg]
-	//    \   \   \
-	//     \   \   future
-	//      \   present
-	//       past
-	past: S[]
-	present: S
-	future: S[]
-}
+// export type Chronicle<S extends Branchstate> = {
+// 	// [abc] d [efg]
+// 	//    \   \   \
+// 	//     \   \   future
+// 	//      \   present
+// 	//       past
+// 	past: S[]
+// 	present: S
+// 	future: S[]
+// }
 
-export type EzStore<X> = {
-	get(): Promise<X | undefined>
-	set(state: X | undefined): Promise<void>
-}
+// export type EzStore<X> = {
+// 	get(): Promise<X | undefined>
+// 	set(state: X | undefined): Promise<void>
+// }
 
 export type Persistence<X> = {
 	store: EzStore<X>

package/s/tree/parts/utils/immute.ts

@@ -0,0 +1,43 @@
+
+import {deep, sub} from "@e280/stz"
+import {TreeOptions} from "../types.js"
+import {tracker} from "../../../tracker/tracker.js"
+import {Immutable} from "../../../prism/types.js"
+
+export class Immute<S> {
+	#mutable: S
+	#immutable: Immutable<S>
+
+	constructor(mutable: S, private options: TreeOptions) {
+		this.#mutable = mutable
+		this.#immutable = this.#petrify(mutable)
+	}
+
+	#petrify<X>(x: X) {
+		return deep.freeze(
+			this.options.clone(x)
+		) as Immutable<X>
+	}
+
+	on = sub<[Immutable<S>]>()
+
+	get() {
+		tracker.notifyRead(this)
+		return this.#mutable
+	}
+
+	async set(mutable: S) {
+		this.#mutable = mutable
+		this.#immutable = deep.freeze(this.options.clone(this.get())) as Immutable<S>
+		await Promise.all([
+			this.on.publish(this.#immutable),
+			tracker.notifyWrite(this),
+		])
+	}
+
+	get immutable() {
+		tracker.notifyRead(this)
+		return this.#immutable
+	}
+}
+

package/s/tree/parts/utils/process-options.ts

@@ -1,7 +1,7 @@
 
-import {Options} from "../types.js"
+import {TreeOptions} from "../types.js"
 
-export const processOptions = (options: Partial<Options>): Options => ({
+export const processOptions = (options: Partial<TreeOptions>): TreeOptions => ({
 	clone: options.clone ?? (<X>(x: X) => structuredClone(x)),
 })
 

package/s/tree/tree.test.ts

@@ -56,13 +56,15 @@ export default Science.suite({
 			expect(mutationCount).is(2)
 		}),
 
-		"signal.on is debounced": Science.test(async() => {
+		"trunk.on is debounced": Science.test.skip(async() => {
 			const trunk = new Trunk({count: 0})
 			let mutationCount = 0
 			trunk.on.sub(() => {mutationCount++})
-			const promise = trunk.mutate(state => state.count++)
-			expect(mutationCount).is(0)
-			await promise
+			await Promise.all([
+				trunk.mutate(state => state.count++),
+				trunk.mutate(state => state.count++),
+				trunk.mutate(state => state.count++),
+			])
 			expect(mutationCount).is(1)
 		}),
 
@@ -75,19 +77,30 @@ export default Science.suite({
 			expect(trunk.state.items.length).is(3)
 		}),
 
-		"prevent mutation loops": Science.test(async() => {
+		// // conceptually incompatible with sequential synchronous mutations
+		// "prevent mutation loops": Science.test(async() => {
+		// 	const trunk = new Trunk({count: 0})
+		// 	let mutationCount = 0
+		// 	trunk.on.sub(async() => {
+		// 		mutationCount++
+		// 		if (mutationCount > 100)
+		// 			return
+		// 		await trunk.mutate(s => s.count++)
+		// 	})
+		// 	await expect(async() => {
+		// 		await trunk.mutate(state => state.count++)
+		// 	}).throwsAsync()
+		// 	expect(mutationCount).is(1)
+		// }),
+
+		"sync coherence": Science.test(async() => {
 			const trunk = new Trunk({count: 0})
-			let mutationCount = 0
-			trunk.on.sub(async() => {
-				mutationCount++
-				if (mutationCount > 100)
-					return
-				await trunk.mutate(s => s.count++)
-			})
-			await expect(async() => {
-				await trunk.mutate(state => state.count++)
-			}).throwsAsync()
-			expect(mutationCount).is(1)
+			const p1 = trunk.mutate(s => s.count++)
+			expect(trunk.state.count).is(1)
+			const p2 = trunk.mutate(s => s.count++)
+			expect(trunk.state.count).is(2)
+			await p1
+			await p2
 		}),
 	}),
 
@@ -98,9 +111,32 @@ export default Science.suite({
 			expect(branch.state.rofls).is(0)
 		}),
 
+		"mutation triggers effect": Science.test(async() => {
+			const trunk = new Trunk({a: {x: 0}})
+			const branch = trunk.branch(s => s.a)
+			expect(branch.state.x).is(0)
+			let triggered = 0
+			effect(() => {
+				void branch.state.x
+				triggered++
+			})
+			expect(triggered).is(1)
+			await branch.mutate(s => s.x++)
+			expect(triggered).is(2)
+		}),
+
+		"sync coherence": Science.test(async() => {
+			const trunk = new Trunk({count: 0, sub: {rofls: 0}})
+			const branch = trunk.branch(s => s.sub)
+			expect(branch.state.rofls).is(0)
+			const p = branch.mutate(s => s.rofls++)
+			expect(branch.state.rofls).is(1)
+			await p
+		}),
+
 		"nullable selector": Science.test(async () => {
 			const trunk = new Trunk({
-				a: {b: 0}  as (null | {b: number}),
+				a: {b: 0} as (null | {b: number}),
 			})
 			const a = trunk.branch(s => s.a)
 			expect(trunk.state.a?.b).is(0)
@@ -139,17 +175,31 @@ export default Science.suite({
 			expect(b.state.c).is(103)
 		}),
 
-		"signal.on ignores outside mutations": Science.test(async() => {
+		"branch.on ignores outside mutations": Science.test(async() => {
 			const trunk = new Trunk({a: {x: 0}, b: {x: 0}})
 			const a = trunk.branch(s => s.a)
 			const b = trunk.branch(s => s.b)
 			let counted = 0
-			b.on.sub(() => {counted++})
+			b.on(() => {counted++})
 			expect(counted).is(0)
 			await a.mutate(a => a.x = 1)
 			expect(counted).is(0)
 		}),
 
+		"effects ignore outside mutations": Science.test(async() => {
+			const trunk = new Trunk({a: {x: 0}, b: {x: 0}})
+			const a = trunk.branch(s => s.a)
+			const b = trunk.branch(s => s.b)
+			let counted = 0
+			effect(() => {
+				void b.state.x
+				counted++
+			})
+			expect(counted).is(1)
+			await a.mutate(a => a.x++)
+			expect(counted).is(1)
+		}),
+
 		"forbid submutation in mutation": Science.test(async() => {
 			const trunk = new Trunk({a: {b: 0}})
 			const a = trunk.branch(s => s.a)

package/x/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./prism/index.js";
 export * from "./signals/index.js";
 export * from "./tracker/index.js";
 export * from "./tree/index.js";

package/x/index.js

@@ -1,3 +1,4 @@
+export * from "./prism/index.js";
 export * from "./signals/index.js";
 export * from "./tracker/index.js";
 export * from "./tree/index.js";

package/x/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../s/index.ts"],"names":[],"mappings":"AACA,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../s/index.ts"],"names":[],"mappings":"AACA,cAAc,kBAAkB,CAAA;AAChC,cAAc,oBAAoB,CAAA;AAClC,cAAc,oBAAoB,CAAA;AAClC,cAAc,iBAAiB,CAAA"}

package/x/prism/chrono/chronicle.d.ts

@@ -0,0 +1,2 @@
+import { Chronicle } from "./types.js";
+export declare function chronicle<State>(state: State): Chronicle<State>;

package/x/prism/chrono/chronicle.js

@@ -0,0 +1,8 @@
+export function chronicle(state) {
+    return {
+        past: [],
+        present: state,
+        future: [],
+    };
+}
+//# sourceMappingURL=chronicle.js.map

package/x/prism/chrono/chronicle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chronicle.js","sourceRoot":"","sources":["../../../s/prism/chrono/chronicle.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,SAAS,CAAQ,KAAY;IAC5C,OAAO;QACN,IAAI,EAAE,EAAE;QACR,OAAO,EAAE,KAAK;QACd,MAAM,EAAE,EAAE;KACV,CAAA;AACF,CAAC"}

package/x/prism/chrono/chrono.d.ts

@@ -0,0 +1,26 @@
+import { Lens } from "../lens.js";
+import { Chronicle } from "./types.js";
+import { LensLike } from "../types.js";
+export declare class Chrono<State> implements LensLike<State> {
+    #private;
+    limit: number;
+    private basis;
+    constructor(limit: number, basis: Lens<Chronicle<State>>);
+    get chronicle(): {
+        readonly past: readonly import("../types.js").Immutable<State>[];
+        readonly present: import("../types.js").Immutable<State>;
+        readonly future: readonly import("../types.js").Immutable<State>[];
+    };
+    get state(): import("../types.js").Immutable<State>;
+    get undoable(): number;
+    get redoable(): number;
+    /** progress forwards, depositing history into the past */
+    mutate<R>(fn: (state: State) => R): Promise<R>;
+    /** step backwards into the past, by n steps */
+    undo(n?: number): Promise<void>;
+    /** step forwards into the future, by n steps */
+    redo(n?: number): Promise<void>;
+    /** wipe past and future snapshots */
+    wipe(): Promise<void>;
+    lens<State2>(selector: (state: State) => State2): Lens<State2>;
+}

package/x/prism/chrono/chrono.js

@@ -0,0 +1,79 @@
+import { deep } from "@e280/stz";
+import { Lens } from "../lens.js";
+import { _optic } from "../utils/optic-symbol.js";
+export class Chrono {
+    limit;
+    basis;
+    constructor(limit, basis) {
+        this.limit = limit;
+        this.basis = basis;
+    }
+    get chronicle() {
+        return this.basis.state;
+    }
+    get state() {
+        return this.basis.state.present;
+    }
+    get undoable() {
+        return this.chronicle.past.length;
+    }
+    get redoable() {
+        return this.chronicle.future.length;
+    }
+    #mut(chronicle, fn) {
+        const limit = Math.max(0, this.limit);
+        const snapshot = deep.clone(this.chronicle.present);
+        const result = fn(chronicle.present);
+        chronicle.past.push(snapshot);
+        chronicle.past = chronicle.past.slice(-limit);
+        chronicle.future = [];
+        return result;
+    }
+    /** progress forwards, depositing history into the past */
+    async mutate(fn) {
+        return this.basis.mutate(chronicle => this.#mut(chronicle, fn));
+    }
+    /** step backwards into the past, by n steps */
+    async undo(n = 1) {
+        await this.basis.mutate(chronicle => {
+            const snapshots = chronicle.past.slice(-n);
+            if (snapshots.length >= n) {
+                const oldPresent = chronicle.present;
+                chronicle.present = snapshots.shift();
+                chronicle.past = chronicle.past.slice(0, -n);
+                chronicle.future.unshift(oldPresent, ...snapshots);
+            }
+        });
+    }
+    /** step forwards into the future, by n steps */
+    async redo(n = 1) {
+        await this.basis.mutate(chronicle => {
+            const snapshots = chronicle.future.slice(0, n);
+            if (snapshots.length >= n) {
+                const oldPresent = chronicle.present;
+                chronicle.present = snapshots.shift();
+                chronicle.past.push(oldPresent, ...snapshots);
+                chronicle.future = chronicle.future.slice(n);
+            }
+        });
+    }
+    /** wipe past and future snapshots */
+    async wipe() {
+        await this.basis.mutate(chronicle => {
+            chronicle.past = [];
+            chronicle.future = [];
+        });
+    }
+    lens(selector) {
+        const lens = new Lens({
+            registerLens: this.basis[_optic].registerLens,
+            getState: () => selector(this.basis[_optic].getState().present),
+            mutate: fn => this.basis[_optic].mutate(chronicle => {
+                return this.#mut(chronicle, state => fn(selector(state)));
+            }),
+        });
+        this.basis[_optic].registerLens(lens);
+        return lens;
+    }
+}
+//# sourceMappingURL=chrono.js.map

package/x/prism/chrono/chrono.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chrono.js","sourceRoot":"","sources":["../../../s/prism/chrono/chrono.ts"],"names":[],"mappings":"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"}

package/x/prism/chrono/types.d.ts

@@ -0,0 +1,5 @@
+export type Chronicle<State> = {
+    past: State[];
+    present: State;
+    future: State[];
+};

package/x/prism/chrono/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/x/prism/chrono/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../s/prism/chrono/types.ts"],"names":[],"mappings":""}

package/x/prism/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./chrono/chronicle.js";
+export * from "./chrono/chrono.js";
+export * from "./chrono/types.js";
+export * from "./vault/local-store.js";
+export * from "./vault/vault.js";
+export * from "./vault/types.js";
+export * from "./lens.js";
+export * from "./prism.js";
+export * from "./types.js";

package/x/prism/index.js

@@ -0,0 +1,10 @@
+export * from "./chrono/chronicle.js";
+export * from "./chrono/chrono.js";
+export * from "./chrono/types.js";
+export * from "./vault/local-store.js";
+export * from "./vault/vault.js";
+export * from "./vault/types.js";
+export * from "./lens.js";
+export * from "./prism.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/x/prism/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../s/prism/index.ts"],"names":[],"mappings":"AACA,cAAc,uBAAuB,CAAA;AACrC,cAAc,oBAAoB,CAAA;AAClC,cAAc,mBAAmB,CAAA;AACjC,cAAc,wBAAwB,CAAA;AACtC,cAAc,kBAAkB,CAAA;AAChC,cAAc,kBAAkB,CAAA;AAChC,cAAc,WAAW,CAAA;AACzB,cAAc,YAAY,CAAA;AAC1B,cAAc,YAAY,CAAA"}

package/x/prism/lens.d.ts

@@ -0,0 +1,13 @@
+import { _optic } from "./utils/optic-symbol.js";
+import { Immutable, LensLike, Optic } from "./types.js";
+/** reactive view into a state prism, with formalized mutations */
+export declare class Lens<State> implements LensLike<State> {
+    #private;
+    on: import("@e280/stz").Sub<[state: Immutable<State>]>;
+    [_optic]: Optic<State>;
+    constructor(optic: Optic<State>);
+    update(): Promise<void>;
+    get state(): Immutable<State>;
+    mutate<R>(fn: (state: State) => R): Promise<R>;
+    lens<State2>(selector: (state: State) => State2): Lens<State2>;
+}

package/x/prism/lens.js

@@ -0,0 +1,45 @@
+import { deep, microbounce, sub } from "@e280/stz";
+import { immute } from "./utils/immute.js";
+import { tracker } from "../tracker/tracker.js";
+import { _optic } from "./utils/optic-symbol.js";
+import { CacheCell } from "./utils/cache-cell.js";
+/** reactive view into a state prism, with formalized mutations */
+export class Lens {
+    on = sub();
+    [_optic];
+    #previous;
+    #immutable;
+    #onPublishDebounced = microbounce(() => this.on.publish(this.state));
+    constructor(optic) {
+        this[_optic] = optic;
+        this.#previous = deep.clone(optic.getState());
+        this.#immutable = new CacheCell(() => immute(optic.getState()));
+    }
+    async update() {
+        const state = this[_optic].getState();
+        const isChanged = !deep.equal(state, this.#previous);
+        if (isChanged) {
+            this.#immutable.invalidate();
+            this.#previous = deep.clone(state);
+            this.#onPublishDebounced();
+            await tracker.notifyWrite(this);
+        }
+    }
+    get state() {
+        tracker.notifyRead(this);
+        return this.#immutable.get();
+    }
+    async mutate(fn) {
+        return this[_optic].mutate(fn);
+    }
+    lens(selector) {
+        const lens = new Lens({
+            getState: () => selector(this[_optic].getState()),
+            mutate: fn => this[_optic].mutate(state => fn(selector(state))),
+            registerLens: this[_optic].registerLens,
+        });
+        this[_optic].registerLens(lens);
+        return lens;
+    }
+}
+//# sourceMappingURL=lens.js.map

package/x/prism/lens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lens.js","sourceRoot":"","sources":["../../s/prism/lens.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,IAAI,EAAE,WAAW,EAAE,GAAG,EAAC,MAAM,WAAW,CAAA;AAChD,OAAO,EAAC,MAAM,EAAC,MAAM,mBAAmB,CAAA;AACxC,OAAO,EAAC,OAAO,EAAC,MAAM,uBAAuB,CAAA;AAC7C,OAAO,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAA;AAC9C,OAAO,EAAC,SAAS,EAAC,MAAM,uBAAuB,CAAA;AAG/C,kEAAkE;AAClE,MAAM,OAAO,IAAI;IAChB,EAAE,GAAG,GAAG,EAA6B,CAEpC;IAAA,CAAC,MAAM,CAAC,CAAc;IACvB,SAAS,CAAO;IAChB,UAAU,CAA6B;IACvC,mBAAmB,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;IAEpE,YAAY,KAAmB;QAC9B,IAAI,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;QACpB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAA;QAC7C,IAAI,CAAC,UAAU,GAAG,IAAI,SAAS,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAA;IAChE,CAAC;IAED,KAAK,CAAC,MAAM;QACX,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAA;QACrC,MAAM,SAAS,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAA;QACpD,IAAI,SAAS,EAAE,CAAC;YACf,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAA;YAC5B,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;YAClC,IAAI,CAAC,mBAAmB,EAAE,CAAA;YAC1B,MAAM,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;QAChC,CAAC;IACF,CAAC;IAED,IAAI,KAAK;QACR,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QACxB,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,EAAE,CAAA;IAC7B,CAAC;IAED,KAAK,CAAC,MAAM,CAAI,EAAuB;QACtC,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAA;IAC/B,CAAC;IAED,IAAI,CAAS,QAAkC;QAC9C,MAAM,IAAI,GAAG,IAAI,IAAI,CAAS;YAC7B,QAAQ,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;YACjD,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC;YAC/D,YAAY,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,YAAY;SACvC,CAAC,CAAA;QACF,IAAI,CAAC,MAAM,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QAC/B,OAAO,IAAI,CAAA;IACZ,CAAC;CACD"}

package/x/prism/prism.d.ts

@@ -0,0 +1,10 @@
+import { Lens } from "./lens.js";
+/** state mangagement source-of-truth */
+export declare class Prism<State> {
+    #private;
+    on: import("@e280/stz").Sub<[state: State]>;
+    constructor(state: State);
+    get(): State;
+    set(state: State): Promise<void>;
+    lens<State2>(selector: (state: State) => State2): Lens<State2>;
+}

package/x/prism/prism.js

@@ -0,0 +1,34 @@
+import { microbounce, sub } from "@e280/stz";
+import { Lens } from "./lens.js";
+/** state mangagement source-of-truth */
+export class Prism {
+    #state;
+    #lenses = new Set();
+    on = sub();
+    #onPublishDebounced = microbounce(() => this.on.publish(this.#state));
+    constructor(state) {
+        this.#state = state;
+    }
+    get() {
+        return this.#state;
+    }
+    async set(state) {
+        this.#state = state;
+        await Promise.all([...this.#lenses].map(lens => lens.update()));
+        await this.#onPublishDebounced();
+    }
+    lens(selector) {
+        const lens = new Lens({
+            getState: () => selector(this.#state),
+            mutate: async (fn) => {
+                const result = fn(selector(this.#state));
+                await this.set(this.#state);
+                return result;
+            },
+            registerLens: lens => this.#lenses.add(lens),
+        });
+        this.#lenses.add(lens);
+        return lens;
+    }
+}
+//# sourceMappingURL=prism.js.map