atom.io 0.27.2 → 0.27.4

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Transceiver, Subject, Store, Func, EnvironmentData, Flat, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
+import { Transceiver, Func, EnvironmentData, Flat, Subject, Store, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
 import { Json, JsonInterface, Canonical } 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, setState as setState$1, makeMolecule as makeMolecule$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';
@@ -51,11 +51,6 @@ type RegularAtomFamilyToken<T, K extends Canonical> = {
     __T?: T;
     __K?: K;
 };
-type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
-    (key: K): 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 Canonical> = JsonInterface<T, J> & {
     key: string;
     default: (key: K) => T;
@@ -69,12 +64,6 @@ type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializa
     __J?: J;
     __K?: K;
 };
-type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
-    (key: K): MutableAtomToken<T, J>;
-    subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
-    install: (store: Store) => void;
-};
-type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
 type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
 declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function atomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
@@ -173,26 +162,12 @@ type WritableSelectorFamilyToken<T, K extends Canonical> = {
     __T?: T;
     __K?: K;
 };
-type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & {
-    (key: K): WritableSelectorToken<T>;
-    subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
-    install: (store: Store) => void;
-};
 type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
     key: string;
     type: `readonly_selector_family`;
     __T?: T;
     __K?: K;
 };
-type ReadonlySelectorFamily<T, K extends Canonical> = ((key: K) => ReadonlySelectorToken<T>) & {
-    key: string;
-    type: `readonly_selector_family`;
-    subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
-    install: (store: Store) => void;
-    __T?: T;
-    __K?: K;
-};
-type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
 type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
 declare function selectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
 declare function selectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
@@ -312,7 +287,7 @@ declare const LoggerIconDictionary: {
     readonly "\uD83D\uDC41": "Determining perspective";
 };
 type LoggerIcon = keyof typeof LoggerIconDictionary;
-type TokenDenomination = `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom` | `readonly_selector` | `selector` | `state` | `timeline` | `transaction` | `unknown`;
+type TokenDenomination = `atom_family` | `atom` | `continuity` | `molecule_family` | `molecule` | `mutable_atom_family` | `mutable_atom` | `readonly_selector_family` | `readonly_selector` | `selector_family` | `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;
@@ -444,8 +419,6 @@ type ReadonlySelectorToken<T> = {
 type SelectorToken<T> = ReadonlySelectorToken<T> | WritableSelectorToken<T>;
 type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>;
 type ReadableToken<T> = AtomToken<T> | SelectorToken<T>;
-type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
-type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
 type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
 type FamilyMetadata = {
@@ -453,4 +426,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type ActorToolkit, type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, 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 MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, 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 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 AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, 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 WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, 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/eslint-plugin/dist/index.js

@@ -62,6 +62,9 @@ var explicitStateTypes = createRule({
 function walk(node, callback, depth = 0) {
   callback(node, depth);
   switch (node.type) {
+    case `AwaitExpression`:
+      walk(node.argument, callback, depth + 1);
+      break;
     case `FunctionDeclaration`:
     case `FunctionExpression`:
     case `ArrowFunctionExpression`:
@@ -113,6 +116,11 @@ function walk(node, callback, depth = 0) {
       walk(node.left, callback, depth);
       walk(node.right, callback, depth);
       break;
+    case `ConditionalExpression`:
+      walk(node.test, callback, depth + 1);
+      walk(node.consequent, callback, depth + 1);
+      walk(node.alternate, callback, depth + 1);
+      break;
     case `MemberExpression`:
       walk(node.object, callback, depth);
       walk(node.property, callback, depth);

package/eslint-plugin/src/walk.ts

@@ -8,6 +8,9 @@ export function walk(
 	callback(node, depth)
 
 	switch (node.type) {
+		case `AwaitExpression`:
+			walk(node.argument, callback, depth + 1)
+			break
 		case `FunctionDeclaration`:
 		case `FunctionExpression`:
 		case `ArrowFunctionExpression`:
@@ -59,6 +62,11 @@ export function walk(
 			walk(node.left, callback, depth)
 			walk(node.right, callback, depth)
 			break
+		case `ConditionalExpression`:
+			walk(node.test, callback, depth + 1)
+			walk(node.consequent, callback, depth + 1)
+			walk(node.alternate, callback, depth + 1)
+			break
 		case `MemberExpression`:
 			walk(node.object, callback, depth)
 			walk(node.property, callback, depth)

package/internal/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeToken, MoleculeFamily, MoleculeFamilyToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeConstructor, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, WritableSelectorFamily, MutableAtomFamily, RegularAtomFamily, ReadonlySelectorFamily, AtomIOLogger, Logger, AtomFamily, ReadableFamily, SelectorFamily, WritableFamily, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, MoleculeConstructor, MoleculeFamily, MoleculeFamilyToken, MoleculeToken, ReadableToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, ReadonlySelectorFamilyToken, WritableSelectorFamilyToken, SelectorFamilyToken, ReadableFamilyToken, WritableFamilyToken, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, MoleculeKey, KeyedStateUpdate, MoleculeFamilyOptions, MoleculeParams, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Canonical, Json, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 
@@ -156,14 +156,11 @@ declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T
 declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
-declare function deposit<K extends Canonical, S extends {
-    [key: string]: any;
-}, P extends any[]>(state: Molecule<any>): MoleculeToken<any>;
-declare function deposit<K extends Canonical, S extends {
-    [key: string]: any;
-}, P extends any[]>(state: MoleculeFamily<any>): MoleculeFamilyToken<any>;
+declare function deposit<M extends MoleculeConstructor>(state: MoleculeFamily<M>): MoleculeFamilyToken<M>;
+declare function deposit<M extends MoleculeConstructor>(state: Molecule<M>): MoleculeToken<M>;
 declare function deposit<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
+declare function deposit(state: Molecule<any> | ReadableState<any>): MoleculeToken<any> | ReadableToken<any>;
 
 interface Lineage {
     parent: typeof this | null;
@@ -236,6 +233,7 @@ declare class Store implements Lineage {
     parent: Store | null;
     child: Store | null;
     valueMap: Map<string, any>;
+    defaults: Map<string, any>;
     atoms: Map<string, Atom<any>>;
     selectors: Map<string, WritableSelector<any>>;
     readonlySelectors: Map<string, ReadonlySelector<any>>;
@@ -245,7 +243,7 @@ declare class Store implements Lineage {
         source: string;
     }>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
-    families: Map<string, WritableSelectorFamily<any, any> | MutableAtomFamily<any, any, any> | RegularAtomFamily<any, any> | ReadonlySelectorFamily<any, any>>;
+    families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
     transactions: Map<string, Transaction<Func>>;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     timelines: Map<string, Timeline<any>>;
@@ -254,7 +252,7 @@ declare class Store implements Lineage {
     }>;
     molecules: Map<string, Molecule<any>>;
     moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
-        subject: Subject<atom_io.MoleculeDisposal | atom_io.MoleculeCreation<any>>;
+        subject: Subject<atom_io.MoleculeCreation<any> | atom_io.MoleculeDisposal>;
         dependsOn: `all` | `any`;
         new: any;
     }>>;
@@ -322,12 +320,14 @@ type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S
 
 declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined, store: Store): MutableAtomToken<T, J>;
 
-declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(options: MutableAtomFamilyOptions<T, J, K>, store: Store, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
 
 declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
 declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>, store: Store) => WritableSelectorToken<SerializableCore>;
 
+declare const getUpdateFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => AtomFamily<Signal<Core>, Key>;
+
 declare const getUpdateToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => RegularAtomToken<Signal<Core>>;
 
 /**
@@ -392,15 +392,15 @@ declare function cacheValue<T extends Promise<any>>(key: string, value: T, subje
 declare const readCachedValue: <T>(token: ReadableState<any>, target: Store) => T;
 declare const evictCachedValue: (key: string, target: Store) => void;
 
-declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
-declare function createAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>, store: Store): MutableAtomFamilyToken<T, J, K>;
+declare function createAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamilyToken<T, K>;
 
-declare function createReadonlySelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createReadonlySelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
 
-declare function createRegularAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function createRegularAtomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>, store: Store, internalRoles?: string[]): RegularAtomFamilyToken<T, K>;
 
-declare function createSelectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamily<T, K>;
-declare function createSelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamily<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>, store: Store): WritableSelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>, store: Store): ReadonlySelectorFamilyToken<T, K>;
 
 declare function disposeFromStore(token: MoleculeToken<any> | ReadableToken<any>, store: Store): void;
 declare function disposeFromStore<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K, store: Store): void;
@@ -504,18 +504,20 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
 
-declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamily<T, J, K>, store: Store): MutableAtomToken<T, J>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: RegularAtomFamily<T, K>, store: Store): RegularAtomToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: AtomFamily<T, K>, store: Store): AtomToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableSelectorFamily<T, K>, store: Store): WritableSelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadonlySelectorFamily<T, K>, store: Store): ReadonlySelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: SelectorFamily<T, K>, store: Store): SelectorToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableFamily<T, K>, store: Store): WritableToken<T>;
-declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadableFamily<T, K>, store: Store): ReadableToken<T>;
+declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomToken<T, J>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: AtomFamilyToken<T, K>, store: Store): AtomToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: SelectorFamilyToken<T, K>, store: Store): SelectorToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: WritableFamilyToken<T, K>, store: Store): WritableToken<T>;
+declare function growMoleculeInStore<T, K extends Canonical>(molecule: Molecule<any>, family: ReadableFamilyToken<T, K>, store: Store): ReadableToken<T>;
 
 declare function makeMoleculeInStore<M extends MoleculeConstructor>(store: Store, context: MoleculeToken<M> | MoleculeToken<M>[], familyToken: MoleculeFamilyToken<M>, key: MoleculeKey<M>, ...params: MoleculeParams<M>): MoleculeToken<M>;
 
 type AtomIOToken = MoleculeFamilyToken<any> | MoleculeToken<any> | ReadableFamilyToken<any, any> | ReadableToken<any> | TimelineToken<any> | TransactionToken<any>;
+declare function prettyPrintTokenType(token: AtomIOToken): string;
+
 declare class NotFoundError extends Error {
     constructor(token: AtomIOToken, store: Store);
     constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
@@ -587,5 +589,33 @@ type ReadonlySelector<T> = AtomIOState & {
 type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
+type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
+    (key: K): RegularAtomToken<T>;
+    subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
+    install: (store: Store) => void;
+    internalRoles: string[] | undefined;
+};
+type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
+    (key: K): MutableAtomToken<T, J>;
+    subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
+    install: (store: Store) => void;
+    internalRoles: string[] | undefined;
+};
+type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
+type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & ((key: K) => WritableSelectorToken<T>) & {
+    default: (key: K) => T;
+    subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
+    install: (store: Store) => void;
+    internalRoles: string[] | undefined;
+};
+type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> & ((key: K) => ReadonlySelectorToken<T>) & {
+    default: (key: K) => T;
+    subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
+    install: (store: Store) => void;
+    internalRoles: string[] | undefined;
+};
+type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
+type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
+type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, NotFoundError, type OperationProgress, type Range, type ReadableState, type ReadonlySelector, type ReadonlySelectorKey, type RegularAtom, type RootStore, type Selector, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, type Flat, type Func, Future, IMPLICIT, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };