atom.io 0.24.8 → 0.25.0

package/data/src/join.ts

@@ -1,8 +1,9 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import type {
+	CtorToolkit,
 	disposeState,
+	getState,
 	MoleculeFamilyToken,
-	MoleculeTransactors,
 	MutableAtomFamily,
 	MutableAtomFamilyToken,
 	Read,
@@ -11,7 +12,8 @@ import type {
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
 	RegularAtomFamily,
-	Transactors,
+	setState,
+	SetterToolkit,
 	Write,
 } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
@@ -33,6 +35,7 @@ import {
 	isChildStore,
 	makeMoleculeInStore,
 	newest,
+	NotFoundError,
 	seekInStore,
 	setIntoStore,
 	withdraw,
@@ -141,7 +144,7 @@ export class Join<
 > {
 	private options: JoinOptions<ASide, BSide, Cardinality, Content>
 	private defaultContent: Content | undefined
-	private transactors: Transactors & { dispose: typeof disposeState }
+	private toolkit: SetterToolkit & { dispose: typeof disposeState }
 	public retrieve: typeof findState
 	public molecules: Map<string, Molecule<any>> = new Map()
 	public relations: Junction<ASide, BSide, Content>
@@ -154,13 +157,13 @@ export class Join<
 		>
 	}
 	public transact(
-		transactors: Transactors & { dispose: typeof disposeState },
+		toolkit: SetterToolkit & { dispose: typeof disposeState },
 		run: (join: Join<ASide, BSide, Cardinality, Content>) => void,
 	): void {
-		const originalTransactors = this.transactors
-		this.transactors = transactors
+		const originalToolkit = this.toolkit
+		this.toolkit = toolkit
 		run(this)
-		this.transactors = originalTransactors
+		this.toolkit = originalToolkit
 	}
 
 	public store: Store
@@ -194,23 +197,24 @@ export class Join<
 
 		this.store.miscResources.set(`join:${options.key}`, this)
 
-		this.transactors = {
-			get: (token) => getFromStore(token, store),
-			set: (token, value) => {
-				setIntoStore(token, value, store)
-			},
+		this.toolkit = {
+			get: ((...ps: Parameters<typeof getState>) =>
+				getFromStore(...ps, store)) as typeof getState,
+			set: ((...ps: Parameters<typeof setState>) => {
+				setIntoStore(...ps, store)
+			}) as typeof setState,
 			find: ((token, key) => findInStore(token, key, store)) as typeof findState,
 			seek: ((token, key) => seekInStore(token, key, store)) as typeof seekState,
 			json: (token) => getJsonToken(token, store),
-			dispose: (token) => {
-				disposeFromStore(token, store)
-			},
+			dispose: ((...ps: Parameters<typeof disposeState>) => {
+				disposeFromStore(...ps, store)
+			}) as typeof disposeState,
 		}
 		this.retrieve = ((
 			token: ReadableFamilyToken<any, any>,
 			key: Json.Serializable,
 		): ReadableToken<any> => {
-			const maybeToken = this.transactors.seek(token, key)
+			const maybeToken = this.toolkit.seek(token, key)
 			if (maybeToken) {
 				return maybeToken
 			}
@@ -220,7 +224,7 @@ export class Join<
 				return growMoleculeInStore(molecule, family, store)
 			}
 			if (store.config.lifespan === `immortal`) {
-				throw new Error(`No molecule found for key "${stringifyJson(key)}"`)
+				throw new NotFoundError(token, key, store)
 			}
 			return initFamilyMemberInStore(token, key, store)
 		}) as typeof findState
@@ -246,22 +250,22 @@ export class Join<
 			key,
 		) => get(this.retrieve(relatedKeysAtoms, key))
 		const addRelation: Write<(a: string, b: string) => void> = (
-			transactors,
+			toolkit,
 			a,
 			b,
 		) => {
-			const { set } = transactors
+			const { set } = toolkit
 			const aKeysState = this.retrieve(relatedKeysAtoms, a)
 			const bKeysState = this.retrieve(relatedKeysAtoms, b)
 			set(aKeysState, (aKeys) => aKeys.add(b))
 			set(bKeysState, (bKeys) => bKeys.add(a))
 		}
 		const deleteRelation: Write<(a: string, b: string) => void> = (
-			transactors,
+			toolkit,
 			a,
 			b,
 		) => {
-			const { set } = transactors
+			const { set } = toolkit
 			const aKeysState = this.retrieve(relatedKeysAtoms, a)
 			const bKeysState = this.retrieve(relatedKeysAtoms, b)
 			let stringA: string | undefined
@@ -280,24 +284,11 @@ export class Join<
 				}
 				return bKeys
 			})
-
-			if (stringA) {
-				const molecule = this.molecules.get(stringA)
-				if (molecule) {
-					this.transactors.dispose(molecule)
-				}
-			}
-			if (stringB) {
-				const molecule = this.molecules.get(stringB)
-				if (molecule) {
-					this.transactors.dispose(molecule)
-				}
-			}
 		}
 		const replaceRelationsSafely: Write<
 			(a: string, newRelationsOfA: string[]) => void
-		> = (transactors, a, newRelationsOfA) => {
-			const { get, set } = transactors
+		> = (toolkit, a, newRelationsOfA) => {
+			const { get, set } = toolkit
 			const relationsOfAState = this.retrieve(relatedKeysAtoms, a)
 			const currentRelationsOfA = get(relationsOfAState)
 			for (const currentRelationB of currentRelationsOfA) {
@@ -318,7 +309,7 @@ export class Join<
 				relationsOfA.transaction((nextRelationsOfA) => {
 					nextRelationsOfA.clear()
 					for (const newRelationB of newRelationsOfA) {
-						const relationsOfB = getRelatedKeys(transactors, newRelationB)
+						const relationsOfB = getRelatedKeys(toolkit, newRelationB)
 						const newRelationBIsAlreadyRelated = relationsOfB.has(a)
 						if (this.relations.cardinality === `1:n`) {
 							const previousOwnersToDispose: string[] = []
@@ -327,7 +318,7 @@ export class Join<
 									continue
 								}
 								const previousOwnerRelations = getRelatedKeys(
-									transactors,
+									toolkit,
 									previousOwner,
 								)
 								previousOwnerRelations.delete(newRelationB)
@@ -339,10 +330,6 @@ export class Join<
 								relationsOfB.clear()
 							}
 							for (const previousOwner of previousOwnersToDispose) {
-								const molecule = this.molecules.get(previousOwner)
-								if (molecule) {
-									this.transactors.dispose(molecule)
-								}
 								const sorted = [newRelationB, previousOwner].sort()
 								const compositeKey = `"${sorted[0]}:${sorted[1]}"`
 								this.molecules.delete(compositeKey)
@@ -360,8 +347,8 @@ export class Join<
 		}
 		const replaceRelationsUnsafely: Write<
 			(a: string, newRelationsOfA: string[]) => void
-		> = (transactors, a, newRelationsOfA) => {
-			const { set } = transactors
+		> = (toolkit, a, newRelationsOfA) => {
+			const { set } = toolkit
 			const relationsOfAState = this.retrieve(relatedKeysAtoms, a)
 			set(relationsOfAState, (relationsOfA) => {
 				relationsOfA.transaction((nextRelationsOfA) => {
@@ -381,29 +368,25 @@ export class Join<
 			}
 			return true
 		}
-		const has: Read<(a: string, b?: string) => boolean> = (
-			transactors,
-			a,
-			b,
-		) => {
-			const aKeys = getRelatedKeys(transactors, a)
+		const has: Read<(a: string, b?: string) => boolean> = (toolkit, a, b) => {
+			const aKeys = getRelatedKeys(toolkit, a)
 			return b ? aKeys.has(b) : aKeys.size > 0
 		}
 		const baseExternalStoreConfiguration: BaseExternalStoreConfiguration = {
-			getRelatedKeys: (key) => getRelatedKeys(this.transactors, key),
+			getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
 			addRelation: (a, b) => {
-				addRelation(this.transactors, a, b)
+				addRelation(this.toolkit, a, b)
 			},
 			deleteRelation: (a, b) => {
-				deleteRelation(this.transactors, a, b)
+				deleteRelation(this.toolkit, a, b)
 			},
 			replaceRelationsSafely: (a, bs) => {
-				replaceRelationsSafely(this.transactors, a, bs)
+				replaceRelationsSafely(this.toolkit, a, bs)
 			},
 			replaceRelationsUnsafely: (a, bs) => {
-				replaceRelationsUnsafely(this.transactors, a, bs)
+				replaceRelationsUnsafely(this.toolkit, a, bs)
 			},
-			has: (a, b) => has(this.transactors, a, b),
+			has: (a, b) => has(this.toolkit, a, b),
 		}
 		let externalStore: ExternalStoreConfiguration<Content>
 		let contentAtoms: RegularAtomFamily<Content, string>
@@ -432,10 +415,10 @@ export class Join<
 					key: `${options.key}/content-molecules`,
 					new: class ContentMolecule {
 						public constructor(
-							transactors: MoleculeTransactors<string>,
+							toolkit: CtorToolkit<string>,
 							public key: string,
 						) {
-							transactors.join(joinToken)
+							toolkit.bond(joinToken, { as: null } as any)
 						}
 					},
 				},
@@ -456,20 +439,20 @@ export class Join<
 			) => {
 				const contentMolecule = store.molecules.get(`"${compositeKey}"`)
 				if (contentMolecule) {
-					this.transactors.dispose(contentMolecule)
+					this.toolkit.dispose(contentMolecule)
 					this.molecules.delete(`"${compositeKey}"`)
 				}
 			}
 			const externalStoreWithContentConfiguration = {
 				getContent: (contentKey: string) => {
-					const content = getContent(this.transactors, contentKey)
+					const content = getContent(this.toolkit, contentKey)
 					return content
 				},
 				setContent: (contentKey: string, content: Content) => {
-					setContent(this.transactors, contentKey, content)
+					setContent(this.toolkit, contentKey, content)
 				},
 				deleteContent: (contentKey: string) => {
-					deleteContent(this.transactors, contentKey)
+					deleteContent(this.toolkit, contentKey)
 				},
 			}
 			externalStore = Object.assign(
@@ -950,8 +933,8 @@ export function editRelationsInStore<
 	const myJoin = getJoin(token, store)
 	const target = newest(store)
 	if (isChildStore(target)) {
-		const { transactors } = target.transactionMeta
-		myJoin.transact(transactors, ({ relations }) => {
+		const { toolkit } = target.transactionMeta
+		myJoin.transact(toolkit, ({ relations }) => {
 			change(relations)
 		})
 	} else {

package/dist/index.cjs

@@ -30,10 +30,21 @@ function atom(options) {
 function atomFamily(options) {
   return Internal.createAtomFamily(options, Internal.IMPLICIT.STORE);
 }
-function disposeState(token) {
-  Internal__namespace.disposeFromStore(token, Internal__namespace.IMPLICIT.STORE);
+function disposeState(token, key) {
+  if (key) {
+    Internal__namespace.disposeFromStore(token, key, Internal__namespace.IMPLICIT.STORE);
+  } else {
+    Internal__namespace.disposeFromStore(token, Internal__namespace.IMPLICIT.STORE);
+  }
 }
-function getState(token) {
+function getState(token, key) {
+  if (key) {
+    return Internal__namespace.getFromStore(
+      token,
+      key,
+      Internal__namespace.IMPLICIT.STORE
+    );
+  }
   return Internal__namespace.getFromStore(token, Internal__namespace.IMPLICIT.STORE);
 }
 
@@ -95,8 +106,12 @@ function selector(options) {
 function selectorFamily(options) {
   return Internal.createSelectorFamily(options, Internal.IMPLICIT.STORE);
 }
-function setState(token, value) {
-  Internal__namespace.setIntoStore(token, value, Internal__namespace.IMPLICIT.STORE);
+function setState(token, p1, p2) {
+  if (p2) {
+    Internal__namespace.setIntoStore(token, p1, p2, Internal__namespace.IMPLICIT.STORE);
+  } else {
+    Internal__namespace.setIntoStore(token, p1, Internal__namespace.IMPLICIT.STORE);
+  }
 }
 var Silo = class {
   constructor(config, fromStore = null) {
@@ -115,9 +130,12 @@ var Silo = class {
     this.transaction = (options) => Internal.createTransaction(options, s);
     this.timeline = (options) => Internal.createTimeline(options, s);
     this.findState = (token, key) => Internal.findInStore(token, key, s);
-    this.getState = (token) => Internal.getFromStore(token, s);
-    this.setState = (token, newValue) => {
-      Internal.setIntoStore(token, newValue, s);
+    this.getState = (...params) => Internal.getFromStore(...params, s);
+    this.setState = (...params) => {
+      Internal.setIntoStore(...params, s);
+    };
+    this.disposeState = (...params) => {
+      Internal.disposeFromStore(...params, s);
     };
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
     this.undo = (token) => {

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { Transceiver, Subject, Store, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
 import { Json, JsonInterface } from 'atom.io/json';
-import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, makeMolecule as makeMolecule$1, Flat as Flat$1, TransactorsWithRunAndEnv as TransactorsWithRunAndEnv$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, MoleculeCreation as MoleculeCreation$1, MoleculeDisposal as MoleculeDisposal$1 } from 'atom.io';
+import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, setState as setState$1, makeMolecule as makeMolecule$1, Flat as Flat$1, ActorToolkit as ActorToolkit$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, MutableAtomToken as MutableAtomToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, RegularAtomToken as RegularAtomToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableFamilyToken as WritableFamilyToken$1, WritableToken as WritableToken$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, MoleculeCreation as MoleculeCreation$1, MoleculeDisposal as MoleculeDisposal$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
 import { JoinToken } from 'atom.io/data';
@@ -109,16 +109,17 @@ type TransactionUpdate<F extends Func> = {
     params: Parameters<F>;
     output: ReturnType<F>;
 };
-type Transactors = Readonly<{
+type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json` | `seek`>;
+type SetterToolkit = Readonly<{
     get: typeof getState$1;
-    set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
+    set: typeof setState$1;
     find: typeof findState;
     seek: typeof seekState;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
 }>;
-type TransactorsWithRunAndEnv = Readonly<{
+type ActorToolkit = Readonly<{
     get: typeof getState$1;
-    set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
+    set: typeof setState$1;
     find: typeof findState;
     seek: typeof seekState;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
@@ -127,10 +128,9 @@ type TransactorsWithRunAndEnv = Readonly<{
     run: typeof runTransaction;
     env: () => EnvironmentData;
 }>;
-type ReadonlyTransactors = Pick<Transactors, `find` | `get` | `json` | `seek`>;
-type Read<F extends Func> = (transactors: ReadonlyTransactors, ...parameters: Parameters<F>) => ReturnType<F>;
-type Write<F extends Func> = (transactors: Transactors, ...parameters: Parameters<F>) => ReturnType<F>;
-type Transact<F extends Func> = (transactors: TransactorsWithRunAndEnv, ...parameters: Parameters<F>) => ReturnType<F>;
+type Read<F extends Func> = (toolkit: GetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Write<F extends Func> = (toolkit: SetterToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
+type Transact<F extends Func> = (toolkit: ActorToolkit, ...parameters: Parameters<F>) => ReturnType<F>;
 type TransactionOptions<F extends Func> = {
     key: string;
     do: Transact<F>;
@@ -197,20 +197,30 @@ type SelectorFamilyToken<T, K extends Json.Serializable> = ReadonlySelectorFamil
 declare function selectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyTokenWithCall<T, K>;
 declare function selectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyTokenWithCall<T, K>;
 
-type MoleculeTransactors<K extends Json.Serializable> = Flat$1<Omit<TransactorsWithRunAndEnv$1, `find`> & {
+type CtorToolkit<K extends Json.Serializable> = Flat$1<Omit<ActorToolkit$1, `find`> & {
     bond<T extends Transceiver<any>, J extends Json.Serializable>(family: MutableAtomFamilyToken$1<T, J, K>): MutableAtomToken$1<T, J>;
     bond<T>(family: RegularAtomFamilyToken$1<T, K>): RegularAtomToken$1<T>;
     bond<T>(family: WritableSelectorFamilyToken$1<T, K>): WritableSelectorToken$1<T>;
     bond<T>(family: ReadonlySelectorFamilyToken$1<T, K>): ReadonlySelectorToken$1<T>;
     bond<T>(family: WritableFamilyToken$1<T, K>): WritableToken$1<T>;
     bond<T>(family: ReadableFamilyToken$1<T, K>): ReadableToken$1<T>;
+    bond<J extends JoinToken<any, any, any, any>>(joinToken: J, role: {
+        as: J extends JoinToken<infer A, infer B, any, any> ? A | B : never;
+    }): J extends JoinToken<any, any, any, infer Content> ? Content extends null ? {
+        relatedKeys: ReadonlySelectorToken$1<string[]>;
+    } : {
+        relatedKeys: ReadonlySelectorToken$1<string[]>;
+        relatedEntries: ReadonlySelectorToken$1<[
+            key: string,
+            value: Content
+        ][]>;
+    } : never;
     claim(below: MoleculeToken<any>, options: {
         exclusive: boolean;
-    }): any;
-    join<J extends JoinToken<any, any, any, any>>(joinToken: J): J;
+    }): void;
     spawn<Key extends Json.Serializable, Ctor extends MoleculeConstructor>(family: MoleculeFamilyToken<Ctor>, key: Key, ...params: MoleculeParams<Ctor>): MoleculeToken<Ctor>;
 }>;
-type MoleculeConstructor = new (transactors: MoleculeTransactors<any>, key: any, ...params: any) => any;
+type MoleculeConstructor = new (toolkit: CtorToolkit<any>, key: any, ...params: any) => any;
 type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[];
 type MoleculeParams<M extends MoleculeConstructor> = Tail<Tail<ConstructorParameters<M>>>;
 type MoleculeFamilyOptions<M extends MoleculeConstructor> = {
@@ -243,9 +253,13 @@ type MK<M extends MoleculeConstructor> = MoleculeKey<M>;
 declare function makeRootMolecule(key: string, store?: Store): MoleculeToken<ObjectConstructor>;
 
 declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
+declare function disposeState<K extends Json.Serializable>(token: ReadableFamilyToken<any, K>, key: K): void;
+declare function disposeState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
 
 declare function getState<T>(token: ReadableToken<T>): T;
-declare function getState<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M> | undefined;
+declare function getState<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M>;
+declare function getState<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, key: K): T;
+declare function getState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: Json.Serializable): InstanceType<M>;
 
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
@@ -317,7 +331,14 @@ declare class AtomIOLogger implements Logger {
     warn: LogFn;
 }
 
+type primitive = boolean | number | string | null;
+
+type Serializable = primitive | Readonly<{
+    [key: string]: Serializable;
+}> | ReadonlyArray<Serializable>;
+
 declare function setState<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New)): void;
+declare function setState<T, K extends Serializable, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
 
 declare class Silo {
     store: Store;
@@ -330,6 +351,7 @@ declare class Silo {
     findState: typeof findState;
     getState: typeof getState;
     setState: typeof setState;
+    disposeState: typeof disposeState;
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
@@ -426,4 +448,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type Effectors, type FamilyMetadata, type Flat, type Func, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MK, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeTransactors, type MoleculeType, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type ReadonlyTransactors, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, Silo, type StateCreation, type StateDisposal, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type Transactors, type TransactorsWithRunAndEnv, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { type ActorToolkit, type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type Flat, type Func, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MK, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, Silo, type StateCreation, type StateDisposal, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,6 +1,6 @@
 import './chunk-S4N6XNPH.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 
 function atom(options) {
@@ -9,10 +9,21 @@ function atom(options) {
 function atomFamily(options) {
   return createAtomFamily(options, IMPLICIT.STORE);
 }
-function disposeState(token) {
-  Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
+function disposeState(token, key) {
+  if (key) {
+    Internal.disposeFromStore(token, key, Internal.IMPLICIT.STORE);
+  } else {
+    Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
+  }
 }
-function getState(token) {
+function getState(token, key) {
+  if (key) {
+    return Internal.getFromStore(
+      token,
+      key,
+      Internal.IMPLICIT.STORE
+    );
+  }
   return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
 }
 
@@ -74,8 +85,12 @@ function selector(options) {
 function selectorFamily(options) {
   return createSelectorFamily(options, IMPLICIT.STORE);
 }
-function setState(token, value) {
-  Internal.setIntoStore(token, value, Internal.IMPLICIT.STORE);
+function setState(token, p1, p2) {
+  if (p2) {
+    Internal.setIntoStore(token, p1, p2, Internal.IMPLICIT.STORE);
+  } else {
+    Internal.setIntoStore(token, p1, Internal.IMPLICIT.STORE);
+  }
 }
 var Silo = class {
   constructor(config, fromStore = null) {
@@ -94,9 +109,12 @@ var Silo = class {
     this.transaction = (options) => createTransaction(options, s);
     this.timeline = (options) => createTimeline(options, s);
     this.findState = (token, key) => findInStore(token, key, s);
-    this.getState = (token) => getFromStore(token, s);
-    this.setState = (token, newValue) => {
-      setIntoStore(token, newValue, s);
+    this.getState = (...params) => getFromStore(...params, s);
+    this.setState = (...params) => {
+      setIntoStore(...params, s);
+    };
+    this.disposeState = (...params) => {
+      disposeFromStore(...params, s);
     };
     this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
     this.undo = (token) => {