atom.io 0.22.0 → 0.23.1

package/data/dist/index.cjs

@@ -2,6 +2,7 @@
 
 var internal = require('atom.io/internal');
 var atom_io = require('atom.io');
+var immortal = require('atom.io/immortal');
 var json = require('atom.io/json');
 var setRtx = require('atom.io/transceivers/set-rtx');
 
@@ -299,7 +300,8 @@ var Join = class _Join {
         internal.setIntoStore(token, value, store);
       },
       find: (token, key) => internal.findInStore(token, key, store),
-      seek: (token, key) => internal.seekInStore(token, key, store)
+      seek: (token, key) => internal.seekInStore(token, key, store),
+      json: (token) => internal.getJsonToken(token, store)
     };
     this.retrieve = (token, key) => {
       const maybeToken = this.transactors.seek(token, key);
@@ -470,6 +472,7 @@ var Join = class _Join {
     };
     let externalStore;
     let contentAtoms;
+    let contentMolecules;
     if (defaultContent) {
       contentAtoms = internal.createRegularAtomFamily(
         {
@@ -478,6 +481,17 @@ var Join = class _Join {
         },
         store
       );
+      contentMolecules = immortal.createMoleculeFamily(
+        {
+          key: `${options.key}/content-molecules`,
+          new: (s) => class ContentMolecule extends immortal.Molecule {
+            constructor(context, token) {
+              super(s, context, token);
+            }
+          }
+        },
+        store
+      );
       const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
       const setContent = ({ set }, key, content) => {
         set(this.retrieve(contentAtoms, key), content);
@@ -516,6 +530,8 @@ var Join = class _Join {
         if (store.config.lifespan === `immortal` && m0 && m1) {
           const composite = m0.with(m1)(compositeKey);
           this.molecules.set(`"${compositeKey}"`, composite);
+          const target = internal.newest(store);
+          immortal.makeMoleculeInStore(target, [m0, m1], contentMolecules, compositeKey);
         }
         return compositeKey;
       }

package/data/dist/index.js

@@ -1,4 +1,4 @@
-export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-JA4V7TJY.js';
+export { Join, editRelations, editRelationsInStore, findRelations, findRelationsInStore, getInternalRelations, getInternalRelationsFromStore, getJoin, getJoinMap, join } from '../../dist/chunk-7DT3PVS3.js';
 import '../../dist/chunk-FTONNX2R.js';
 import '../../dist/chunk-F2X4B4VY.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, createRegularAtom, createRegularAtomFamily, createSelectorFamily } from 'atom.io/internal';

package/data/src/join.ts

@@ -12,7 +12,16 @@ import type {
 } from "atom.io"
 import { disposeState } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
-import type { Molecule, seekState } from "atom.io/immortal"
+import type {
+	MoleculeFamilyToken,
+	MoleculeToken,
+	seekState,
+} from "atom.io/immortal"
+import {
+	createMoleculeFamily,
+	makeMoleculeInStore,
+	Molecule,
+} from "atom.io/immortal"
 import type { Store } from "atom.io/internal"
 import {
 	createMutableAtomFamily,
@@ -21,6 +30,7 @@ import {
 	findInStore,
 	getFromStore,
 	getJsonFamily,
+	getJsonToken,
 	IMPLICIT,
 	initFamilyMember,
 	isChildStore,
@@ -192,6 +202,7 @@ 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),
 		}
 		this.retrieve = (
 			token: ReadableFamilyToken<any, any>,
@@ -388,6 +399,7 @@ export class Join<
 		}
 		let externalStore: ExternalStoreConfiguration<Content>
 		let contentAtoms: RegularAtomFamily<Content, string>
+		let contentMolecules: MoleculeFamilyToken<string, any, any>
 		if (defaultContent) {
 			contentAtoms = createRegularAtomFamily<Content, string>(
 				{
@@ -396,6 +408,21 @@ export class Join<
 				},
 				store,
 			)
+			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)
+							}
+						},
+				},
+				store,
+			)
 			const getContent: Read<(key: string) => Content | null> = ({ get }, key) =>
 				get(this.retrieve(contentAtoms, key))
 			const setContent: Write<(key: string, content: Content) => void> = (
@@ -443,6 +470,8 @@ export class Join<
 				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)
 				}
 				return compositeKey
 			},

package/dist/chunk-6MLFYN32.js

@@ -0,0 +1,18 @@
+// ../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 { isBoolean, isNull, isNumber, isPrimitive, isString };

package/dist/{chunk-JA4V7TJY.js → chunk-7DT3PVS3.js}

@@ -1,6 +1,7 @@
 import { Junction } from './chunk-FTONNX2R.js';
 import { disposeState } from 'atom.io';
-import { getFromStore, setIntoStore, findInStore, seekInStore, initFamilyMember, createMutableAtomFamily, createRegularAtomFamily, IMPLICIT, newest, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
+import { createMoleculeFamily, Molecule, makeMoleculeInStore } from 'atom.io/immortal';
+import { getFromStore, setIntoStore, findInStore, seekInStore, getJsonToken, initFamilyMember, createMutableAtomFamily, createRegularAtomFamily, newest, IMPLICIT, isChildStore, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
 
@@ -22,7 +23,8 @@ var Join = class _Join {
         setIntoStore(token, value, store);
       },
       find: (token, key) => findInStore(token, key, store),
-      seek: (token, key) => seekInStore(token, key, store)
+      seek: (token, key) => seekInStore(token, key, store),
+      json: (token) => getJsonToken(token, store)
     };
     this.retrieve = (token, key) => {
       const maybeToken = this.transactors.seek(token, key);
@@ -193,6 +195,7 @@ var Join = class _Join {
     };
     let externalStore;
     let contentAtoms;
+    let contentMolecules;
     if (defaultContent) {
       contentAtoms = createRegularAtomFamily(
         {
@@ -201,6 +204,17 @@ var Join = class _Join {
         },
         store
       );
+      contentMolecules = createMoleculeFamily(
+        {
+          key: `${options.key}/content-molecules`,
+          new: (s) => class ContentMolecule extends Molecule {
+            constructor(context, token) {
+              super(s, context, token);
+            }
+          }
+        },
+        store
+      );
       const getContent = ({ get }, key) => get(this.retrieve(contentAtoms, key));
       const setContent = ({ set }, key, content) => {
         set(this.retrieve(contentAtoms, key), content);
@@ -239,6 +253,8 @@ var Join = class _Join {
         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);
         }
         return compositeKey;
       }

package/dist/chunk-OAYGID5B.js

@@ -0,0 +1,27 @@
+// ../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: ``
+};
+
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, parseJson, stringSetJsonInterface, stringifyJson };

package/dist/index.cjs

@@ -29,17 +29,8 @@ function atom(options) {
 function atomFamily(options) {
   return Internal.createAtomFamily(options, Internal.IMPLICIT.STORE);
 }
-function disposeState(token, store = Internal__namespace.IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      Internal__namespace.disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      Internal__namespace.disposeSelector(token, store);
-      break;
-  }
+function disposeState(token) {
+  Internal__namespace.disposeFromStore(token, Internal__namespace.IMPLICIT.STORE);
 }
 function getState(token) {
   return Internal__namespace.getFromStore(token, Internal__namespace.IMPLICIT.STORE);

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-import * as Internal from 'atom.io/internal';
-import { Transceiver, Subject, Store, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineSelectorUpdate, TimelineTransactionUpdate } from 'atom.io/internal';
+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 { findState } from 'atom.io/ephemeral';
-import { 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 } from 'atom.io';
+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';
 
 type Effectors<T> = {
     setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
@@ -40,7 +40,7 @@ type RegularAtomFamilyTokenWithCall<T, K extends Json.Serializable> = RegularAto
 };
 type RegularAtomFamily<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & {
     (key: K): RegularAtomToken<T>;
-    subject: Subject<RegularAtomToken<T>>;
+    subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
     install: (store: Store) => void;
 };
 type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = JsonInterface<T, J> & {
@@ -62,7 +62,7 @@ type MutableAtomFamilyTokenWithCall<T extends Transceiver<any>, J extends Json.S
 };
 type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
     (key: K): MutableAtomToken<T, J>;
-    subject: Subject<MutableAtomToken<T, J>>;
+    subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
     install: (store: Store) => void;
 };
 type AtomFamily<T, K extends Json.Serializable = Json.Serializable> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
@@ -70,20 +70,37 @@ type AtomFamilyToken<T, K extends Json.Serializable = Json.Serializable> = Mutab
 declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyTokenWithCall<T, J, K>;
 declare function atomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyTokenWithCall<T, K>;
 
-declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J> | undefined;
-declare function seekState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T> | undefined;
-declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T> | undefined;
-declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T> | undefined;
-declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T> | undefined;
-declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T> | undefined;
-
 type TransactionToken<F extends Func> = {
     key: string;
     type: `transaction`;
     __F?: F;
 };
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | TransactionUpdate<Func>;
+type StateCreation<Token extends ReadableToken<any>> = {
+    type: `state_creation`;
+    token: Token;
+};
+type StateDisposal<Token extends ReadableToken<any>> = {
+    type: `state_disposal`;
+    token: Token;
+    value?: TokenType<Token>;
+};
+type MoleculeCreation<Key extends Json.Serializable> = {
+    type: `molecule_creation`;
+    token: MoleculeToken<Key, any, any>;
+    family: MoleculeFamilyToken<Key, any, any>;
+    context: MoleculeToken<any, any, any>[];
+    params: any[];
+};
+type MoleculeDisposal<Key extends Json.Serializable> = {
+    type: `molecule_disposal`;
+    token: MoleculeToken<Key, any, any>;
+    family: MoleculeFamilyToken<any, any, any>;
+    context: MoleculeToken<any, any, any>[];
+    familyKeys: string[];
+};
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal<any> | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
 type TransactionUpdate<F extends Func> = {
+    type: `transaction_update`;
     key: string;
     id: string;
     epoch: number;
@@ -92,20 +109,24 @@ type TransactionUpdate<F extends Func> = {
     output: ReturnType<F>;
 };
 type Transactors = Readonly<{
-    get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
+    get: <S>(state: ReadableToken<S>) => S;
     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;
     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>;
+    make: typeof makeMolecule;
+    dispose: typeof disposeState;
     run: typeof runTransaction;
     env: () => EnvironmentData;
 }>;
-type ReadonlyTransactors = Pick<Transactors, `find` | `get` | `seek`>;
+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>;
@@ -149,7 +170,7 @@ type WritableSelectorFamilyTokenWithCall<T, K extends Json.Serializable> = Writa
 };
 type WritableSelectorFamily<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & {
     (key: K): WritableSelectorToken<T>;
-    subject: Subject<WritableSelectorToken<T>>;
+    subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
     install: (store: Store) => void;
 };
 type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
@@ -165,7 +186,7 @@ type ReadonlySelectorFamilyTokenWithCall<T, K extends Json.Serializable> = Reado
 type ReadonlySelectorFamily<T, K extends Json.Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
-    subject: Subject<ReadonlySelectorToken<T>>;
+    subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
     install: (store: Store) => void;
     __T?: T;
     __K?: K;
@@ -175,7 +196,7 @@ 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: ReadableToken<any>, store?: Internal.Store): void;
+declare function disposeState(token: MoleculeToken<any, any, any> | ReadableToken<any>): void;
 
 declare function getState<T>(token: ReadableToken<T>): T;
 
@@ -272,10 +293,11 @@ type StateUpdate<T> = {
     newValue: T;
     oldValue: T;
 };
-type KeyedStateUpdate<T> = StateUpdate<T> & {
+type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
     key: string;
+    type: `atom_update` | `selector_update`;
     family?: FamilyMetadata;
-};
+}>;
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
 type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
 declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string, store?: Store): () => void;
@@ -283,6 +305,7 @@ declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpd
 declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string, store?: Store): () => void;
 
 type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
 type TimelineToken<M> = {
     key: string;
     type: `timeline`;
@@ -290,10 +313,10 @@ type TimelineToken<M> = {
 };
 type TimelineOptions<ManagedAtom extends TimelineManageable> = {
     key: string;
-    atoms: ManagedAtom[];
+    scope: (ManagedAtom | MoleculeFamilyToken<any, any, any>)[];
     shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
 };
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineSelectorUpdate<ManagedAtom> | TimelineTransactionUpdate;
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation<any> | TimelineMoleculeDisposal<any> | 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;
@@ -313,6 +336,11 @@ declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(famil
 declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
 type Func = (...parameters: any[]) => any;
+type Flat<R extends {
+    [K in PropertyKey]: any;
+}> = {
+    [K in keyof R]: R[K];
+};
 type RegularAtomToken<T> = {
     key: string;
     type: `atom`;
@@ -351,4 +379,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomToken, type Effectors, type FamilyMetadata, type Func, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, 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 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 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 };

package/dist/index.js

@@ -9,17 +9,8 @@ function atom(options) {
 function atomFamily(options) {
   return createAtomFamily(options, IMPLICIT.STORE);
 }
-function disposeState(token, store = Internal.IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      Internal.disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      Internal.disposeSelector(token, store);
-      break;
-  }
+function disposeState(token) {
+  Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
 }
 
 // src/logger.ts

package/ephemeral/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
+import { Transceiver } from 'atom.io/internal';
+import { Json } from 'atom.io/json';
+
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+
+export { findState };

package/eslint-plugin/dist/index.cjs

@@ -205,7 +205,6 @@ var lifespan = {
                       {
                         for (const prop of getAndSetProps) {
                           if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
-                            console.log(prop.value);
                             storeProcedures.push(prop.value);
                           }
                         }

package/eslint-plugin/dist/index.d.ts

@@ -0,0 +1,73 @@
+import * as ESTree from 'estree';
+import * as eslint from 'eslint';
+import { Rule } from 'eslint';
+import { ESLintUtils } from '@typescript-eslint/utils';
+
+declare const explicitStateTypes: ESLintUtils.RuleModule<"noTypeArgument", [], ESLintUtils.RuleListener>;
+
+declare const lifespan: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+            category: string;
+            recommended: false;
+            url: string;
+        };
+        schema: {
+            type: "string";
+            enum: string[];
+            default: string;
+        }[];
+    };
+    create(context: Rule.RuleContext): {
+        ImportDeclaration(node: ESTree.ImportDeclaration & Rule.NodeParentExtension): void;
+        CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
+    };
+};
+
+declare const synchronousSelectorDependencies: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+            category: string;
+            recommended: false;
+            url: string;
+        };
+        schema: never[];
+    };
+    create(context: Rule.RuleContext): {
+        CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
+    };
+};
+
+declare const index_explicitStateTypes: typeof explicitStateTypes;
+declare const index_lifespan: typeof lifespan;
+declare const index_synchronousSelectorDependencies: typeof synchronousSelectorDependencies;
+declare namespace index {
+  export { index_explicitStateTypes as explicitStateTypes, index_lifespan as lifespan, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
+}
+
+declare const _default: {
+    rules: {
+        "explicit-state-types": any;
+        "synchronous-selector-dependencies": {
+            meta: {
+                type: "problem";
+                docs: {
+                    description: string;
+                    category: string;
+                    recommended: false;
+                    url: string;
+                };
+                schema: never[];
+            };
+            create(context: eslint.Rule.RuleContext): {
+                CallExpression(node: ESTree.CallExpression & eslint.Rule.NodeParentExtension): void;
+            };
+        };
+    };
+};
+
+export { index as Rules, _default as default };

package/eslint-plugin/dist/index.js

@@ -196,7 +196,6 @@ var lifespan = {
                       {
                         for (const prop of getAndSetProps) {
                           if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
-                            console.log(prop.value);
                             storeProcedures.push(prop.value);
                           }
                         }

package/eslint-plugin/src/rules/lifespan.ts

@@ -96,7 +96,6 @@ export const lifespan = {
 														prop.value.type === `FunctionExpression` ||
 														prop.value.type === `ArrowFunctionExpression`
 													) {
-														console.log(prop.value)
 														storeProcedures.push(prop.value)
 													}
 												}