atom.io 0.23.5 → 0.24.1

package/data/src/join.ts

@@ -1,42 +1,41 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import type {
+	disposeState,
+	MoleculeFamilyToken,
+	MoleculeTransactors,
 	MutableAtomFamily,
 	MutableAtomFamilyToken,
 	Read,
 	ReadableFamilyToken,
+	ReadableToken,
 	ReadonlySelectorFamily,
 	ReadonlySelectorToken,
 	RegularAtomFamily,
 	Transactors,
 	Write,
 } from "atom.io"
-import { disposeState } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
-import type {
-	MoleculeFamilyToken,
-	MoleculeToken,
-	seekState,
-} from "atom.io/immortal"
+import type { seekState } from "atom.io/immortal"
+import type { Molecule, Store } from "atom.io/internal"
 import {
 	createMoleculeFamily,
-	makeMoleculeInStore,
-	Molecule,
-} from "atom.io/immortal"
-import type { Store } from "atom.io/internal"
-import {
 	createMutableAtomFamily,
 	createRegularAtomFamily,
 	createSelectorFamily,
+	disposeFromStore,
 	findInStore,
 	getFromStore,
 	getJsonFamily,
 	getJsonToken,
+	growMoleculeInStore,
 	IMPLICIT,
-	initFamilyMember,
+	initFamilyMemberInStore,
 	isChildStore,
+	makeMoleculeInStore,
 	newest,
 	seekInStore,
 	setIntoStore,
+	withdraw,
 } from "atom.io/internal"
 import { type Json, stringifyJson } from "atom.io/json"
 import type { SetRTXJson } from "atom.io/transceivers/set-rtx"
@@ -142,7 +141,7 @@ export class Join<
 > {
 	private options: JoinOptions<ASide, BSide, Cardinality, Content>
 	private defaultContent: Content | undefined
-	private transactors: Transactors
+	private transactors: Transactors & { dispose: typeof disposeState }
 	public retrieve: typeof findState
 	public molecules: Map<string, Molecule<any>> = new Map()
 	public relations: Junction<ASide, BSide, Content>
@@ -155,7 +154,7 @@ export class Join<
 		>
 	}
 	public transact(
-		transactors: Transactors,
+		transactors: Transactors & { dispose: typeof disposeState },
 		run: (join: Join<ASide, BSide, Cardinality, Content>) => void,
 	): void {
 		const originalTransactors = this.transactors
@@ -203,24 +202,28 @@ export class Join<
 			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)
+			},
 		}
-		this.retrieve = (
+		this.retrieve = ((
 			token: ReadableFamilyToken<any, any>,
 			key: Json.Serializable,
-		) => {
+		): ReadableToken<any> => {
 			const maybeToken = this.transactors.seek(token, key)
 			if (maybeToken) {
 				return maybeToken
 			}
 			const molecule = this.molecules.get(stringifyJson(key))
-			if (!molecule) {
-				if (store.config.lifespan === `immortal`) {
-					throw new Error(`No molecule found for key "${stringifyJson(key)}"`)
-				}
-				return initFamilyMember(token, key, store)
+			if (molecule) {
+				const family = withdraw(token, store)
+				return growMoleculeInStore(molecule, family, store)
 			}
-			return molecule.bond(token) as any
-		}
+			if (store.config.lifespan === `immortal`) {
+				throw new Error(`No molecule found for key "${stringifyJson(key)}"`)
+			}
+			return initFamilyMemberInStore(token, key, store)
+		}) as typeof findState
 		const aSide: ASide = options.between[0]
 		const bSide: BSide = options.between[1]
 		const relatedKeysAtoms = createMutableAtomFamily<
@@ -278,13 +281,17 @@ export class Join<
 				return bKeys
 			})
 
-			if (stringA && this.molecules.has(stringA)) {
-				this.molecules.get(stringA)?.clear()
-				this.molecules.delete(stringA)
+			if (stringA) {
+				const molecule = this.molecules.get(stringA)
+				if (molecule) {
+					this.transactors.dispose(molecule)
+				}
 			}
-			if (stringB && this.molecules.has(stringB)) {
-				this.molecules.get(stringB)?.clear()
-				this.molecules.delete(stringB)
+			if (stringB) {
+				const molecule = this.molecules.get(stringB)
+				if (molecule) {
+					this.transactors.dispose(molecule)
+				}
 			}
 		}
 		const replaceRelationsSafely: Write<
@@ -333,8 +340,9 @@ export class Join<
 							}
 							for (const previousOwner of previousOwnersToDispose) {
 								const molecule = this.molecules.get(previousOwner)
-								molecule?.clear()
-								this.molecules.delete(previousOwner)
+								if (molecule) {
+									this.transactors.dispose(molecule)
+								}
 								const sorted = [newRelationB, previousOwner].sort()
 								const compositeKey = `"${sorted[0]}:${sorted[1]}"`
 								this.molecules.delete(compositeKey)
@@ -399,7 +407,11 @@ export class Join<
 		}
 		let externalStore: ExternalStoreConfiguration<Content>
 		let contentAtoms: RegularAtomFamily<Content, string>
-		let contentMolecules: MoleculeFamilyToken<string, any, any>
+		let contentMolecules: MoleculeFamilyToken<
+			new (
+				..._: any[]
+			) => { key: string }
+		>
 		if (defaultContent) {
 			contentAtoms = createRegularAtomFamily<Content, string>(
 				{
@@ -408,18 +420,24 @@ export class Join<
 				},
 				store,
 			)
+			const joinToken = {
+				key: options.key,
+				type: `join`,
+				a: options.between[0],
+				b: options.between[1],
+				cardinality: options.cardinality,
+			} as const satisfies JoinToken<ASide, BSide, Cardinality, Content>
 			contentMolecules = createMoleculeFamily(
 				{
 					key: `${options.key}/content-molecules`,
-					new: (s) =>
-						class ContentMolecule extends Molecule<string> {
-							public constructor(
-								context: Molecule<any>[],
-								token: MoleculeToken<string, any, any>,
-							) {
-								super(s, context, token)
-							}
-						},
+					new: class ContentMolecule {
+						public constructor(
+							transactors: MoleculeTransactors<string>,
+							public key: string,
+						) {
+							transactors.join(joinToken)
+						}
+					},
 				},
 				store,
 			)
@@ -436,8 +454,11 @@ export class Join<
 				_,
 				compositeKey,
 			) => {
-				disposeState(this.retrieve(contentAtoms, compositeKey))
-				this.molecules.delete(`"${compositeKey}"`)
+				const contentMolecule = store.molecules.get(`"${compositeKey}"`)
+				if (contentMolecule) {
+					this.transactors.dispose(contentMolecule)
+					this.molecules.delete(`"${compositeKey}"`)
+				}
 			}
 			const externalStoreWithContentConfiguration = {
 				getContent: (contentKey: string) => {
@@ -468,10 +489,17 @@ export class Join<
 					this.molecules.get(stringifyJson(key)),
 				)
 				if (store.config.lifespan === `immortal` && m0 && m1) {
-					const composite = m0.with(m1)(compositeKey)
-					this.molecules.set(`"${compositeKey}"`, composite)
 					const target = newest(store)
-					makeMoleculeInStore(target, [m0, m1], contentMolecules, compositeKey)
+					const moleculeToken = makeMoleculeInStore(
+						target,
+						[m0, m1],
+						contentMolecules,
+						compositeKey,
+					)
+					this.molecules.set(
+						`"${compositeKey}"`,
+						withdraw(moleculeToken, target),
+					)
 				}
 				return compositeKey
 			},

package/dist/chunk-BF4MVQF6.js

@@ -0,0 +1,44 @@
+// ../anvl/src/json/json-interface.ts
+var stringSetJsonInterface = {
+  toJson: (stringSet) => Array.from(stringSet),
+  fromJson: (json) => new Set(json)
+};
+
+// ../anvl/src/json/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+// ../anvl/src/primitive/index.ts
+var isString = (input) => {
+  return typeof input === `string`;
+};
+var isNumber = (input) => {
+  return typeof input === `number`;
+};
+var isBoolean = (input) => {
+  return typeof input === `boolean`;
+};
+var isNull = (input) => {
+  return input === null;
+};
+var isPrimitive = (input) => {
+  return isString(input) || isNumber(input) || isBoolean(input) || isNull(input);
+};
+
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson };

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var Internal = require('atom.io/internal');
+var json = require('atom.io/json');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -74,6 +75,27 @@ var AtomIOLogger = class {
     };
   }
 };
+function moleculeFamily(options) {
+  return Internal.createMoleculeFamily(options, Internal.IMPLICIT.STORE);
+}
+function makeMolecule(context, family, key, ...params) {
+  return Internal.makeMoleculeInStore(Internal.IMPLICIT.STORE, context, family, key, ...params);
+}
+function useMoleculeFromStore(token, store) {
+  const molecule = store.molecules.get(json.stringifyJson(token.key));
+  return molecule == null ? void 0 : molecule.instance;
+}
+function useMolecule(token) {
+  return useMoleculeFromStore(token, Internal.IMPLICIT.STORE);
+}
+function makeRootMolecule(key, store = Internal.IMPLICIT.STORE) {
+  const molecule = new Internal.Molecule(void 0, key);
+  store.molecules.set(json.stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
 function selector(options) {
   return Internal.createStandaloneSelector(options, Internal.IMPLICIT.STORE);
 }
@@ -160,6 +182,9 @@ exports.belongsTo = belongsTo;
 exports.disposeState = disposeState;
 exports.getState = getState;
 exports.isToken = isToken;
+exports.makeMolecule = makeMolecule;
+exports.makeRootMolecule = makeRootMolecule;
+exports.moleculeFamily = moleculeFamily;
 exports.redo = redo;
 exports.runTransaction = runTransaction;
 exports.selector = selector;
@@ -171,3 +196,5 @@ exports.subscribe = subscribe;
 exports.timeline = timeline;
 exports.transaction = transaction;
 exports.undo = undo;
+exports.useMolecule = useMolecule;
+exports.useMoleculeFromStore = useMoleculeFromStore;

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 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, 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 { findState } from 'atom.io/ephemeral';
-import { MoleculeToken, MoleculeFamilyToken, seekState, makeMolecule } from 'atom.io/immortal';
-import { ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, RegularAtomToken as RegularAtomToken$1, MutableAtomToken as MutableAtomToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableToken as WritableToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, WritableFamilyToken as WritableFamilyToken$1 } from 'atom.io';
+import { seekState } from 'atom.io/immortal';
+import { JoinToken } from 'atom.io/data';
 
 type Effectors<T> = {
     setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
@@ -84,21 +85,21 @@ type StateDisposal<Token extends ReadableToken<any>> = {
     token: Token;
     value?: TokenType<Token>;
 };
-type MoleculeCreation<Key extends Json.Serializable> = {
+type MoleculeCreation<M extends MoleculeConstructor$1> = {
     type: `molecule_creation`;
-    token: MoleculeToken<Key, any, any>;
-    family: MoleculeFamilyToken<Key, any, any>;
-    context: MoleculeToken<any, any, any>[];
-    params: any[];
+    token: MoleculeToken$1<M>;
+    family: MoleculeFamilyToken$1<M>;
+    context: MoleculeToken$1<any>[];
+    params: MoleculeParams$1<M>;
 };
-type MoleculeDisposal<Key extends Json.Serializable> = {
+type MoleculeDisposal = {
     type: `molecule_disposal`;
-    token: MoleculeToken<Key, any, any>;
-    family: MoleculeFamilyToken<any, any, any>;
-    context: MoleculeToken<any, any, any>[];
+    token: MoleculeToken$1<any>;
+    family: MoleculeFamilyToken$1<any>;
+    context: MoleculeToken$1<any>[];
     familyKeys: string[];
 };
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal<any> | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
 type TransactionUpdate<F extends Func> = {
     type: `transaction_update`;
     key: string;
@@ -121,7 +122,7 @@ type TransactorsWithRunAndEnv = Readonly<{
     find: typeof findState;
     seek: typeof seekState;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
-    make: typeof makeMolecule;
+    make: typeof makeMolecule$1;
     dispose: typeof disposeState;
     run: typeof runTransaction;
     env: () => EnvironmentData;
@@ -196,7 +197,51 @@ 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>;
 
-declare function disposeState(token: MoleculeToken<any, any, any> | ReadableToken<any>): void;
+type MoleculeTransactors<K extends Json.Serializable> = Flat$1<Omit<TransactorsWithRunAndEnv$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>;
+    join(joinToken: JoinToken<any, any, any, any>): 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 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> = {
+    key: string;
+    dependsOn?: `all` | `any`;
+    new: M;
+};
+type MoleculeFamilyToken<M extends MoleculeConstructor> = {
+    key: string;
+    type: `molecule_family`;
+    dependsOn: `all` | `any`;
+    __M?: M;
+};
+type MoleculeFamily<M extends MoleculeConstructor> = Flat$1<MoleculeFamilyToken<M> & {
+    subject: Subject<MoleculeCreation$1<M> | MoleculeDisposal$1>;
+    dependsOn: `all` | `any`;
+    new: M;
+}>;
+type MoleculeToken<M extends MoleculeConstructor> = {
+    key: MK<M>;
+    type: `molecule`;
+    family?: MoleculeFamilyToken<M>;
+    __M?: M;
+};
+declare function moleculeFamily<M extends MoleculeConstructor>(options: MoleculeFamilyOptions<M>): MoleculeFamilyToken<M>;
+declare function makeMolecule<M extends MoleculeConstructor>(context: MoleculeToken<any> | MoleculeToken<any>[], family: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
+declare function useMoleculeFromStore<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): InstanceType<M> | undefined;
+declare function useMolecule<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M> | undefined;
+type MoleculeType<T extends MoleculeFamilyToken<any>> = T extends MoleculeFamilyToken<infer M> ? M : T extends MoleculeToken<infer M> ? M : never;
+type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`];
+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 getState<T>(token: ReadableToken<T>): T;
 
@@ -252,7 +297,7 @@ declare const LoggerIconDictionary: {
     readonly "\uD83D\uDC41": "Determining perspective";
 };
 type LoggerIcon = keyof typeof LoggerIconDictionary;
-type TokenDenomination = `atom` | `continuity` | `mutable_atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
+type TokenDenomination = `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
 declare const LOG_LEVELS: readonly ["info", "warn", "error"];
 type LogLevel = (typeof LOG_LEVELS)[number];
 type LogFn = (icon: LoggerIcon, denomination: TokenDenomination, tokenKey: string, message: string, ...rest: unknown[]) => void;
@@ -313,10 +358,10 @@ type TimelineToken<M> = {
 };
 type TimelineOptions<ManagedAtom extends TimelineManageable> = {
     key: string;
-    scope: (ManagedAtom | MoleculeFamilyToken<any, any, any>)[];
+    scope: (ManagedAtom | MoleculeFamilyToken$1<any>)[];
     shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
 };
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation<any> | TimelineMoleculeDisposal<any> | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation<any> | TimelineMoleculeDisposal | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
 declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
 declare const redo: (tl: TimelineToken<any>) => void;
 declare const undo: (tl: TimelineToken<any>) => void;
@@ -379,4 +424,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 MoleculeCreation, type MoleculeDisposal, 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, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+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, useMolecule, useMoleculeFromStore };

package/dist/index.js

@@ -1,7 +1,7 @@
-export { getState } from './chunk-PNIHPILQ.js';
 import './chunk-F2X4B4VY.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, 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, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
+import { stringifyJson } from 'atom.io/json';
 
 function atom(options) {
   return createStandaloneAtom(options, IMPLICIT.STORE);
@@ -12,6 +12,9 @@ function atomFamily(options) {
 function disposeState(token) {
   Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
 }
+function getState(token) {
+  return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
+}
 
 // src/logger.ts
 var LOG_LEVELS = [`info`, `warn`, `error`];
@@ -51,6 +54,27 @@ var AtomIOLogger = class {
     };
   }
 };
+function moleculeFamily(options) {
+  return createMoleculeFamily(options, IMPLICIT.STORE);
+}
+function makeMolecule(context, family, key, ...params) {
+  return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
+}
+function useMoleculeFromStore(token, store) {
+  const molecule = store.molecules.get(stringifyJson(token.key));
+  return molecule == null ? void 0 : molecule.instance;
+}
+function useMolecule(token) {
+  return useMoleculeFromStore(token, IMPLICIT.STORE);
+}
+function makeRootMolecule(key, store = IMPLICIT.STORE) {
+  const molecule = new Molecule(void 0, key);
+  store.molecules.set(stringifyJson(key), molecule);
+  return {
+    key,
+    type: `molecule`
+  };
+}
 function selector(options) {
   return createStandaloneSelector(options, IMPLICIT.STORE);
 }
@@ -128,4 +152,4 @@ function belongsTo(family, unknownToken) {
   return family.key === ((_a = unknownToken.family) == null ? void 0 : _a.key);
 }
 
-export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo, useMolecule, useMoleculeFromStore };