atom.io 0.24.1 → 0.24.3

package/dist/index.cjs

@@ -81,13 +81,6 @@ function moleculeFamily(options) {
 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);
@@ -196,5 +189,3 @@ exports.subscribe = subscribe;
 exports.timeline = timeline;
 exports.transaction = transaction;
 exports.undo = undo;
-exports.useMolecule = useMolecule;
-exports.useMoleculeFromStore = useMoleculeFromStore;

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, 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, 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 { seekState } from 'atom.io/immortal';
 import { JoinToken } from 'atom.io/data';
@@ -110,14 +110,14 @@ type TransactionUpdate<F extends Func> = {
     output: ReturnType<F>;
 };
 type Transactors = Readonly<{
-    get: <S>(state: ReadableToken<S>) => S;
+    get: typeof getState$1;
     set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
     find: typeof findState;
     seek: typeof seekState;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
 }>;
 type TransactorsWithRunAndEnv = Readonly<{
-    get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
+    get: typeof getState$1;
     set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
     find: typeof findState;
     seek: typeof seekState;
@@ -204,6 +204,9 @@ type MoleculeTransactors<K extends Json.Serializable> = Flat$1<Omit<TransactorsW
     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>;
+    claim(below: MoleculeToken<any>, options: {
+        exclusive: boolean;
+    }): any;
     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>;
 }>;
@@ -234,8 +237,6 @@ type MoleculeToken<M extends MoleculeConstructor> = {
 };
 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>;
@@ -244,6 +245,7 @@ declare function makeRootMolecule(key: string, store?: Store): MoleculeToken<Obj
 declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
 
 declare function getState<T>(token: ReadableToken<T>): T;
+declare function getState<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M> | undefined;
 
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
@@ -424,4 +426,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, useMolecule, useMoleculeFromStore };
+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 };

package/dist/index.js

@@ -60,13 +60,6 @@ function moleculeFamily(options) {
 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);
@@ -152,4 +145,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, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo, useMolecule, useMoleculeFromStore };
+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 };

package/internal/dist/index.cjs

@@ -1062,6 +1062,14 @@ function getEnvironmentData(store) {
 
 // internal/src/get-state/get-from-store.ts
 function getFromStore(token, store) {
+  if (token.type === `molecule`) {
+    try {
+      const molecule = withdraw(token, store);
+      return molecule.instance;
+    } catch (_) {
+      return void 0;
+    }
+  }
   const state = withdraw(token, store);
   return readOrComputeValue(state, store);
 }
@@ -1136,6 +1144,23 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
       withdraw(f, store),
       newest(store)
     ),
+    claim: (below, options) => {
+      const { exclusive } = options;
+      const belowMolecule = newest(store).molecules.get(json.stringifyJson(below.key));
+      if (belowMolecule) {
+        if (exclusive) {
+          for (const value of belowMolecule.above.values()) {
+            value.below.delete(belowMolecule.stringKey);
+          }
+          belowMolecule.above.clear();
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        } else {
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        }
+      }
+    },
     join: (joinToken) => {
       const join = data.getJoin(joinToken, store);
       join.molecules.set(json.stringifyJson(key), molecule);
@@ -1540,6 +1565,20 @@ function disposeMolecule(token, store) {
     return;
   }
   const { family } = token;
+  for (const state of molecule.tokens.values()) {
+    disposeFromStore(state, store);
+  }
+  for (const child of molecule.below.values()) {
+    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
+      disposeMolecule(child, store);
+    } else {
+      child.above.delete(molecule.stringKey);
+      if (child.above.size === 0) {
+        disposeMolecule(child, store);
+      }
+    }
+  }
+  molecule.below.clear();
   if (family) {
     const Formula = withdraw(family, store);
     const disposalEvent = {
@@ -1563,19 +1602,6 @@ function disposeMolecule(token, store) {
     }
     store.molecules.delete(molecule.stringKey);
   }
-  for (const state of molecule.tokens.values()) {
-    disposeFromStore(state, store);
-  }
-  for (const child of molecule.below.values()) {
-    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
-      disposeMolecule(child, store);
-    } else {
-      child.above.delete(molecule.stringKey);
-      if (child.above.size === 0) {
-        disposeMolecule(child, store);
-      }
-    }
-  }
   for (const join of molecule.joins.values()) {
     join.molecules.delete(molecule.stringKey);
   }

package/internal/dist/index.d.ts

@@ -432,6 +432,8 @@ type EnvironmentData = {
 declare function getEnvironmentData(store: Store): EnvironmentData;
 
 declare function getFromStore<T>(token: ReadableToken<T>, store: Store): T;
+declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): InstanceType<M> | undefined;
+declare function getFromStore<T, M extends MoleculeConstructor, Token extends MoleculeToken<M> | ReadableToken<T>>(token: Token, store: Store): InstanceType<M> | T | undefined;
 
 declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
 

package/internal/dist/index.js

@@ -784,6 +784,14 @@ function getEnvironmentData(store) {
 
 // internal/src/get-state/get-from-store.ts
 function getFromStore(token, store) {
+  if (token.type === `molecule`) {
+    try {
+      const molecule = withdraw(token, store);
+      return molecule.instance;
+    } catch (_) {
+      return void 0;
+    }
+  }
   const state = withdraw(token, store);
   return readOrComputeValue(state, store);
 }
@@ -858,6 +866,23 @@ function makeMoleculeInStore(store, context, familyToken, key, ...params) {
       withdraw(f, store),
       newest(store)
     ),
+    claim: (below, options) => {
+      const { exclusive } = options;
+      const belowMolecule = newest(store).molecules.get(stringifyJson(below.key));
+      if (belowMolecule) {
+        if (exclusive) {
+          for (const value of belowMolecule.above.values()) {
+            value.below.delete(belowMolecule.stringKey);
+          }
+          belowMolecule.above.clear();
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        } else {
+          belowMolecule.above.set(molecule.stringKey, molecule);
+          molecule.below.set(belowMolecule.stringKey, belowMolecule);
+        }
+      }
+    },
     join: (joinToken) => {
       const join = getJoin(joinToken, store);
       join.molecules.set(stringifyJson(key), molecule);
@@ -1262,6 +1287,20 @@ function disposeMolecule(token, store) {
     return;
   }
   const { family } = token;
+  for (const state of molecule.tokens.values()) {
+    disposeFromStore(state, store);
+  }
+  for (const child of molecule.below.values()) {
+    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
+      disposeMolecule(child, store);
+    } else {
+      child.above.delete(molecule.stringKey);
+      if (child.above.size === 0) {
+        disposeMolecule(child, store);
+      }
+    }
+  }
+  molecule.below.clear();
   if (family) {
     const Formula = withdraw(family, store);
     const disposalEvent = {
@@ -1285,19 +1324,6 @@ function disposeMolecule(token, store) {
     }
     store.molecules.delete(molecule.stringKey);
   }
-  for (const state of molecule.tokens.values()) {
-    disposeFromStore(state, store);
-  }
-  for (const child of molecule.below.values()) {
-    if (((_a = child.family) == null ? void 0 : _a.dependsOn) === `all`) {
-      disposeMolecule(child, store);
-    } else {
-      child.above.delete(molecule.stringKey);
-      if (child.above.size === 0) {
-        disposeMolecule(child, store);
-      }
-    }
-  }
   for (const join of molecule.joins.values()) {
     join.molecules.delete(molecule.stringKey);
   }

package/internal/src/get-state/get-from-store.ts

@@ -1,10 +1,39 @@
-import type { ReadableToken } from "atom.io"
+import type { MoleculeConstructor, MoleculeToken, ReadableToken } from "atom.io"
 
 import type { Store } from "../store"
 import { withdraw } from "../store"
 import { readOrComputeValue } from "./read-or-compute-value"
 
-export function getFromStore<T>(token: ReadableToken<T>, store: Store): T {
+export function getFromStore<T>(token: ReadableToken<T>, store: Store): T
+export function getFromStore<M extends MoleculeConstructor>(
+	token: MoleculeToken<M>,
+	store: Store,
+): InstanceType<M> | undefined
+export function getFromStore<
+	T,
+	M extends MoleculeConstructor,
+	Token extends MoleculeToken<M> | ReadableToken<T>,
+>(token: Token, store: Store): InstanceType<M> | T | undefined
+export function getFromStore<
+	Token extends MoleculeToken<any> | ReadableToken<any>,
+>(
+	token: Token,
+	store: Store,
+):
+	| (Token extends MoleculeToken<infer M>
+			? InstanceType<M>
+			: Token extends ReadableToken<infer T>
+				? T
+				: never)
+	| undefined {
+	if (token.type === `molecule`) {
+		try {
+			const molecule = withdraw(token, store)
+			return molecule.instance
+		} catch (_) {
+			return undefined
+		}
+	}
 	const state = withdraw(token, store)
 	return readOrComputeValue(state, store)
 }

package/internal/src/molecule/dispose-molecule.ts

@@ -30,6 +30,21 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 		return
 	}
 	const { family } = token
+
+	for (const state of molecule.tokens.values()) {
+		disposeFromStore(state, store)
+	}
+	for (const child of molecule.below.values()) {
+		if (child.family?.dependsOn === `all`) {
+			disposeMolecule(child, store)
+		} else {
+			child.above.delete(molecule.stringKey)
+			if (child.above.size === 0) {
+				disposeMolecule(child, store)
+			}
+		}
+	}
+	molecule.below.clear()
 	if (family) {
 		const Formula = withdraw(family, store)
 		const disposalEvent: MoleculeDisposal = {
@@ -54,19 +69,6 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 		store.molecules.delete(molecule.stringKey)
 	}
 
-	for (const state of molecule.tokens.values()) {
-		disposeFromStore(state, store)
-	}
-	for (const child of molecule.below.values()) {
-		if (child.family?.dependsOn === `all`) {
-			disposeMolecule(child, store)
-		} else {
-			child.above.delete(molecule.stringKey)
-			if (child.above.size === 0) {
-				disposeMolecule(child, store)
-			}
-		}
-	}
 	for (const join of molecule.joins.values()) {
 		join.molecules.delete(molecule.stringKey)
 	}

package/internal/src/molecule/make-molecule-in-store.ts

@@ -84,6 +84,23 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 				withdraw(f, store),
 				newest(store),
 			)) as MoleculeTransactors<MK<M>>[`bond`],
+		claim: (below, options) => {
+			const { exclusive } = options
+			const belowMolecule = newest(store).molecules.get(stringifyJson(below.key))
+			if (belowMolecule) {
+				if (exclusive) {
+					for (const value of belowMolecule.above.values()) {
+						value.below.delete(belowMolecule.stringKey)
+					}
+					belowMolecule.above.clear()
+					belowMolecule.above.set(molecule.stringKey, molecule)
+					molecule.below.set(belowMolecule.stringKey, belowMolecule)
+				} else {
+					belowMolecule.above.set(molecule.stringKey, molecule)
+					molecule.below.set(belowMolecule.stringKey, belowMolecule)
+				}
+			}
+		},
 		join: (joinToken: JoinToken<any, any, any, any>) => {
 			const join = getJoin(joinToken, store)
 			join.molecules.set(stringifyJson(key), molecule)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.24.1",
+  "version": "0.24.3",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -65,8 +65,8 @@
     "drizzle-orm": "0.30.10",
     "eslint": "npm:eslint@8.57.0",
     "eslint-v9": "npm:eslint@9.3.0",
-    "framer-motion": "11.2.6",
-    "happy-dom": "14.11.2",
+    "framer-motion": "11.2.9",
+    "happy-dom": "14.11.4",
     "http-proxy": "1.18.1",
     "npmlog": "7.0.1",
     "postgres": "3.4.4",

package/src/get-state.ts

@@ -1,7 +1,11 @@
 import * as Internal from "atom.io/internal"
 
-import type { ReadableToken } from "."
+import type { MoleculeConstructor, MoleculeToken, ReadableToken } from "."
 
-export function getState<T>(token: ReadableToken<T>): T {
+export function getState<T>(token: ReadableToken<T>): T
+export function getState<M extends MoleculeConstructor>(
+	token: MoleculeToken<M>,
+): InstanceType<M> | undefined
+export function getState(token: MoleculeToken<any> | ReadableToken<any>): any {
 	return Internal.getFromStore(token, Internal.IMPLICIT.STORE)
 }

package/src/molecule.ts

@@ -37,6 +37,8 @@ export type MoleculeTransactors<K extends Json.Serializable> = Flat<
 		bond<T>(family: WritableFamilyToken<T, K>): WritableToken<T>
 		bond<T>(family: ReadableFamilyToken<T, K>): ReadableToken<T>
 
+		claim(below: MoleculeToken<any>, options: { exclusive: boolean })
+
 		join(joinToken: JoinToken<any, any, any, any>): void
 
 		spawn<Key extends Json.Serializable, Ctor extends MoleculeConstructor>(
@@ -98,19 +100,6 @@ export function makeMolecule<M extends MoleculeConstructor>(
 	return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params)
 }
 
-export function useMoleculeFromStore<M extends MoleculeConstructor>(
-	token: MoleculeToken<M>,
-	store: Store,
-): InstanceType<M> | undefined {
-	const molecule = store.molecules.get(stringifyJson(token.key))
-	return molecule?.instance
-}
-export function useMolecule<M extends MoleculeConstructor>(
-	token: MoleculeToken<M>,
-): InstanceType<M> | undefined {
-	return useMoleculeFromStore(token, IMPLICIT.STORE)
-}
-
 export type MoleculeType<T extends MoleculeFamilyToken<any>> =
 	T extends MoleculeFamilyToken<infer M>
 		? M

package/src/transaction.ts

@@ -1,4 +1,5 @@
 import type {
+	getState,
 	makeMolecule,
 	MoleculeConstructor,
 	MoleculeFamilyToken,
@@ -78,7 +79,7 @@ export type TransactionUpdate<F extends Func> = {
 }
 
 export type Transactors = Readonly<{
-	get: <S>(state: ReadableToken<S>) => S
+	get: typeof getState
 	set: <S, New extends S>(
 		state: WritableToken<S>,
 		newValue: New | ((oldValue: S) => New),
@@ -90,7 +91,7 @@ export type Transactors = Readonly<{
 	) => WritableSelectorToken<J>
 }>
 export type TransactorsWithRunAndEnv = Readonly<{
-	get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S
+	get: typeof getState
 	set: <S, New extends S>(
 		state: WritableToken<S>,
 		newValue: New | ((oldValue: S) => New),