atom.io 0.27.3 → 0.27.5

package/dist/index.d.ts

@@ -287,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;
@@ -355,9 +355,9 @@ type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
 }>;
 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;
-declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string, store?: Store): () => void;
-declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string, store?: Store): () => void;
+declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
+declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => 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;

package/dist/index.js

@@ -1,30 +1,26 @@
 import './chunk-XWL6SNVU.js';
 import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createMoleculeFamily, makeMoleculeInStore, Molecule, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, arbitrary, actUponStore } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 
 function atom(options) {
-  return createStandaloneAtom(options, IMPLICIT.STORE);
+  return createStandaloneAtom(IMPLICIT.STORE, options);
 }
 function atomFamily(options) {
-  return createAtomFamily(options, IMPLICIT.STORE);
+  return createAtomFamily(IMPLICIT.STORE, options);
 }
 function disposeState(token, key) {
   if (key) {
-    Internal.disposeFromStore(token, key, Internal.IMPLICIT.STORE);
+    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token, key);
   } else {
-    Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
+    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token);
   }
 }
-function getState(token, key) {
-  if (key) {
-    return Internal.getFromStore(
-      token,
-      key,
-      Internal.IMPLICIT.STORE
-    );
+function getState(...params) {
+  if (params.length === 2) {
+    return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
   }
-  return Internal.getFromStore(token, Internal.IMPLICIT.STORE);
+  return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
 }
 
 // src/logger.ts
@@ -63,7 +59,7 @@ var AtomIOLogger = class {
   };
 };
 function moleculeFamily(options) {
-  return createMoleculeFamily(options, IMPLICIT.STORE);
+  return createMoleculeFamily(IMPLICIT.STORE, options);
 }
 function makeMolecule(context, family, key, ...params) {
   return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
@@ -77,16 +73,16 @@ function makeRootMolecule(key, store = IMPLICIT.STORE) {
   };
 }
 function selector(options) {
-  return createStandaloneSelector(options, IMPLICIT.STORE);
+  return createStandaloneSelector(IMPLICIT.STORE, options);
 }
 function selectorFamily(options) {
-  return createSelectorFamily(options, IMPLICIT.STORE);
+  return createSelectorFamily(IMPLICIT.STORE, options);
 }
-function setState(token, p1, p2) {
-  if (p2) {
-    Internal.setIntoStore(token, p1, p2, Internal.IMPLICIT.STORE);
+function setState(...params) {
+  if (params.length === 2) {
+    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
   } else {
-    Internal.setIntoStore(token, p1, Internal.IMPLICIT.STORE);
+    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
   }
 }
 var Silo = class {
@@ -108,63 +104,47 @@ var Silo = class {
   makeMolecule;
   constructor(config, fromStore = null) {
     const s = new Store(config, fromStore);
-    function _atom(options) {
-      return createStandaloneAtom(options, s);
-    }
-    function _atomFamily(options) {
-      return createAtomFamily(options, s);
-    }
     this.store = s;
-    this.atom = _atom;
-    this.atomFamily = _atomFamily;
-    this.selector = (options) => createStandaloneSelector(options, s);
-    this.selectorFamily = (options) => createSelectorFamily(options, s);
+    this.atom = (options) => createStandaloneAtom(s, options);
+    this.atomFamily = (options) => createAtomFamily(s, options);
+    this.selector = (options) => createStandaloneSelector(s, options);
+    this.selectorFamily = (options) => createSelectorFamily(s, options);
     this.transaction = (options) => createTransaction(options, s);
     this.timeline = (options) => createTimeline(options, s);
-    this.findState = (token, key) => findInStore(token, key, s);
-    this.getState = (...params) => getFromStore(...params, s);
+    this.findState = (...params) => findInStore(s, ...params);
+    this.getState = (...params) => getFromStore(s, ...params);
     this.setState = (...params) => {
-      setIntoStore(...params, s);
+      setIntoStore(s, ...params);
     };
     this.disposeState = (...params) => {
-      disposeFromStore(...params, s);
+      disposeFromStore(s, ...params);
     };
-    this.subscribe = (token, handler, key) => subscribe(token, handler, key, s);
+    this.subscribe = (...params) => subscribeInStore(s, ...params);
     this.undo = (token) => {
-      timeTravel(`undo`, token, s);
+      timeTravel(s, `undo`, token);
     };
     this.redo = (token) => {
-      timeTravel(`redo`, token, s);
+      timeTravel(s, `redo`, token);
     };
-    this.moleculeFamily = (...params) => {
-      return createMoleculeFamily(...params, s);
+    this.moleculeFamily = (options) => {
+      return createMoleculeFamily(s, options);
     };
     this.makeMolecule = (...params) => {
       return makeMoleculeInStore(s, ...params);
     };
   }
 };
-function subscribe(token, handleUpdate, key = arbitrary(), store = IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-    case `readonly_selector`:
-    case `selector`:
-      return subscribeToState(token, handleUpdate, key, store);
-    case `transaction`:
-      return subscribeToTransaction(token, handleUpdate, key, store);
-    case `timeline`:
-      return subscribeToTimeline(token, handleUpdate, key, store);
-  }
+function subscribe(token, handleUpdate, key = arbitrary()) {
+  return subscribeInStore(IMPLICIT.STORE, token, handleUpdate, key);
 }
 var timeline = (options) => {
   return createTimeline(options, IMPLICIT.STORE);
 };
 var redo = (tl) => {
-  timeTravel(`redo`, tl, IMPLICIT.STORE);
+  timeTravel(IMPLICIT.STORE, `redo`, tl);
 };
 var undo = (tl) => {
-  timeTravel(`undo`, tl, IMPLICIT.STORE);
+  timeTravel(IMPLICIT.STORE, `undo`, tl);
 };
 function transaction(options) {
   return createTransaction(options, IMPLICIT.STORE);

package/ephemeral/dist/index.js

@@ -2,7 +2,7 @@ import '../../dist/chunk-XWL6SNVU.js';
 import { findInStore, IMPLICIT } from 'atom.io/internal';
 
 function findState(token, key) {
-  const state = findInStore(token, key, IMPLICIT.STORE);
+  const state = findInStore(IMPLICIT.STORE, token, key);
   return state;
 }
 

package/ephemeral/src/find-state.ts

@@ -92,6 +92,6 @@ export function findState(
 	token: ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
 ): ReadableToken<any> {
-	const state = findInStore(token, key, IMPLICIT.STORE)
+	const state = findInStore(IMPLICIT.STORE, token, key)
 	return state
 }

package/immortal/dist/index.js

@@ -3,9 +3,9 @@ import { seekInStore, IMPLICIT } from 'atom.io/internal';
 
 function seekState(token, key) {
   if (token.type === `molecule_family`) {
-    return seekInStore(token, key, IMPLICIT.STORE);
+    return seekInStore(IMPLICIT.STORE, token, key);
   }
-  const state = seekInStore(token, key, IMPLICIT.STORE);
+  const state = seekInStore(IMPLICIT.STORE, token, key);
   return state;
 }
 

package/immortal/src/seek-state.ts

@@ -65,8 +65,8 @@ export function seekState(
 	key: Canonical,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	if (token.type === `molecule_family`) {
-		return seekInStore(token, key, IMPLICIT.STORE)
+		return seekInStore(IMPLICIT.STORE, token, key)
 	}
-	const state = seekInStore(token, key, IMPLICIT.STORE)
+	const state = seekInStore(IMPLICIT.STORE, token, key)
 	return state
 }

package/internal/dist/index.d.ts

@@ -1,7 +1,8 @@
 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, 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 { TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, RegularAtomToken, MutableAtomToken, AtomToken, WritableSelectorToken, ReadonlySelectorToken, SelectorToken, WritableToken, ReadableToken, RegularAtomFamilyToken, MutableAtomFamilyToken, AtomFamilyToken, WritableSelectorFamilyToken, ReadonlySelectorFamilyToken, SelectorFamilyToken, WritableFamilyToken, ReadableFamilyToken, MoleculeConstructor, MoleculeFamily, MoleculeFamilyToken, MoleculeToken, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, StateCreation, StateDisposal, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, 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';
+import { Store as Store$1, Func as Func$1 } from 'atom.io/internal';
 
 type primitive = boolean | number | string | null;
 
@@ -156,14 +157,19 @@ 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<T extends Func>(state: Transaction<T>): TransactionToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
+declare function deposit<T, K extends Canonical>(state: RegularAtomFamily<T, K>): RegularAtomFamilyToken<T, K>;
+declare function deposit<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>;
+declare function deposit<T>(state: WritableSelectorFamily<T, any>): WritableSelectorFamilyToken<T, any>;
+declare function deposit<T>(state: ReadonlySelectorFamily<T, any>): ReadonlySelectorFamilyToken<T, any>;
+declare function deposit<T>(state: SelectorFamily<T, any>): SelectorFamilyToken<T, any>;
+declare function deposit<T>(state: WritableFamily<T, any>): WritableFamilyToken<T, any>;
+declare function deposit<T>(state: ReadableFamily<T, any>): ReadableFamilyToken<T, 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(state: Molecule<any> | ReadableState<any>): MoleculeToken<any> | ReadableToken<any>;
 
 interface Lineage {
     parent: typeof this | null;
@@ -230,12 +236,13 @@ type Timeline<ManagedAtom extends TimelineManageable> = {
 };
 declare function createTimeline<ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>, store: Store, data?: Timeline<ManagedAtom>): TimelineToken<ManagedAtom>;
 
-declare const timeTravel: (action: `redo` | `undo`, token: TimelineToken<any>, store: Store) => void;
+declare const timeTravel: (store: Store, action: `redo` | `undo`, token: TimelineToken<any>) => void;
 
 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>>;
@@ -320,13 +327,13 @@ declare function isTransceiver(value: unknown): value is Transceiver<Json.Serial
 type TransceiverMode = `playback` | `record` | `transaction`;
 type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S : never;
 
-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 createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
 
-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 function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, 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 getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => 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>;
 
@@ -359,10 +366,10 @@ declare class FamilyTracker<Core extends Transceiver<any>, FamilyMemberKey exten
 
 declare function arbitrary(random?: () => number): string;
 
-declare function createRegularAtom<T>(options: RegularAtomOptions<T>, family: FamilyMetadata | undefined, store: Store): RegularAtomToken<T>;
+declare function createRegularAtom<T>(store: Store, options: RegularAtomOptions<T>, family: FamilyMetadata | undefined): RegularAtomToken<T>;
 
-declare function createStandaloneAtom<T>(options: RegularAtomOptions<T>, store: Store): RegularAtomToken<T>;
-declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>;
+declare function createStandaloneAtom<T>(store: Store, options: RegularAtomOptions<T>): RegularAtomToken<T>;
+declare function createStandaloneAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>;
 
 declare function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void;
 
@@ -394,57 +401,59 @@ 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): 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, internalRoles?: string[]): ReadonlySelectorFamilyToken<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): 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;
-declare function disposeFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): void;
-
-declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function findInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T>;
-
-declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key, store: Store): MutableAtomToken<T, J> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key, store: Store): RegularAtomToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key, store: Store): AtomToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key, store: Store): WritableSelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key, store: Store): ReadonlySelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key, store: Store): SelectorToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key, store: Store): WritableToken<T> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key, store: Store): ReadableToken<T> | undefined;
-declare function seekInStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): MoleculeKey<M> | undefined;
+declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function createAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
+
+declare function createReadonlySelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
+
+declare function createRegularAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>, internalRoles?: string[]): RegularAtomFamilyToken<T, K>;
+
+declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
+
+declare function disposeFromStore(store: Store, token: MoleculeToken<any> | ReadableToken<any>): void;
+declare function disposeFromStore<K extends Canonical>(store: Store, token: ReadableFamilyToken<any, K>, key: K): void;
+declare function disposeFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
+
+declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+
+declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+
+declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
+declare function seekInStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M> | undefined;
 
 type EnvironmentData = {
     store: Store;
 };
 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, K extends Canonical>(token: ReadableFamilyToken<T, K>, key: K, store: Store): T;
-declare function getFromStore<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>, store: Store): InstanceType<M>;
+declare function getFromStore<T>(store: Store, token: ReadableToken<T>): T;
+declare function getFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeToken<M>): InstanceType<M>;
+declare function getFromStore<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>, key: K): T;
+declare function getFromStore<M extends MoleculeConstructor>(store: Store, token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): InstanceType<M>;
+declare function getFromStore(store: Store, token: MoleculeToken<any> | ReadableToken<any>): any;
+declare function getFromStore(store: Store, token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>, key: Canonical): any;
 
 declare const readOrComputeValue: <T>(state: ReadableState<T>, target: Store) => T;
 
@@ -488,7 +497,7 @@ declare class LazyMap<K, V> extends Map<K, V> {
     delete(key: K): boolean;
 }
 
-declare function createMoleculeFamily<M extends MoleculeConstructor>(options: MoleculeFamilyOptions<M>, store: Store): MoleculeFamilyToken<M>;
+declare function createMoleculeFamily<M extends MoleculeConstructor>(store: Store, options: MoleculeFamilyOptions<M>): MoleculeFamilyToken<M>;
 
 declare function disposeMolecule<M extends MoleculeConstructor>(token: MoleculeToken<M>, store: Store): void;
 
@@ -525,12 +534,12 @@ declare class NotFoundError extends Error {
     constructor(familyToken: AtomIOToken, key: Json.Serializable, store: Store);
 }
 
-declare const createReadonlySelector: <T>(options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => ReadonlySelectorToken<T>;
+declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
 
-declare function createStandaloneSelector<T>(options: WritableSelectorOptions<T>, store: Store): WritableSelectorToken<T>;
-declare function createStandaloneSelector<T>(options: ReadonlySelectorOptions<T>, store: Store): ReadonlySelectorToken<T>;
+declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
+declare function createStandaloneSelector<T>(store: Store, options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
 
-declare const createWritableSelector: <T>(options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined, store: Store) => WritableSelectorToken<T>;
+declare const createWritableSelector: <T>(store: Store, options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined) => WritableSelectorToken<T>;
 
 declare function disposeSelector(selectorToken: ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>, store: Store): void;
 
@@ -548,8 +557,15 @@ declare const become: <T>(nextVersionOfThing: Modify<T> | T) => (originalThing:
 
 declare const setAtomOrSelector: <T>(state: WritableState<T>, value: T | ((oldValue: T) => T), store: Store) => void;
 
-declare function setIntoStore<T, New extends T>(token: WritableToken<T>, value: New | ((oldValue: T) => New), store: Store): void;
-declare function setIntoStore<T, K extends Canonical, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New), store: Store): void;
+declare function setIntoStore<T, New extends T>(store: Store, token: WritableToken<T>, value: New | ((oldValue: T) => New)): void;
+declare function setIntoStore<T, K extends Canonical, New extends T>(store: Store, token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
+
+declare const recallState: <T>(state: ReadableState<T>, store: Store) => T;
+
+declare function subscribeInStore<T>(store: Store$1, token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string): () => void;
+declare function subscribeInStore<F extends Func$1>(store: Store$1, token: TransactionToken<F>, handleUpdate: TransactionUpdateHandler<F>, key?: string): () => void;
+declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string): () => void;
+declare function subscribeInStore<M extends TimelineManageable>(store: Store$1, token: ReadableToken<any> | TimelineToken<M> | TransactionToken<any>, handleUpdate: TransactionUpdateHandler<any> | UpdateHandler<any> | ((update: TimelineUpdate<M> | `redo` | `undo`) => void), key?: string): () => void;
 
 declare const subscribeToRootAtoms: <T>(selector: Selector<T>, store: Store) => (() => void)[];
 
@@ -604,15 +620,14 @@ type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable,
     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>;
+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> = ((key: K) => ReadonlySelectorToken<T>) & {
-    key: string;
-    type: `readonly_selector_family`;
+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;
@@ -621,4 +636,4 @@ type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | Wri
 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 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 };
+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, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -1,3 +1,3 @@
-export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, 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 } from '../../dist/chunk-ETCFHO7J.js';
+export { FamilyTracker, Future, IMPLICIT, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, 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, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-6ABWLAGY.js';
 import '../../dist/chunk-IBTHB2PI.js';
 import '../../dist/chunk-XWL6SNVU.js';

package/internal/src/atom/create-regular-atom.ts

@@ -15,9 +15,9 @@ import { subscribeToState } from "../subscribe"
 import { markAtomAsDefault } from "./is-default"
 
 export function createRegularAtom<T>(
+	store: Store,
 	options: RegularAtomOptions<T>,
 	family: FamilyMetadata | undefined,
-	store: Store,
 ): RegularAtomToken<T> {
 	store.logger.info(
 		`🔨`,
@@ -47,7 +47,7 @@ export function createRegularAtom<T>(
 				options.key,
 				`installing in store "${s.config.name}"`,
 			)
-			return createRegularAtom(options, family, s)
+			return createRegularAtom(s, options, family)
 		},
 		subject,
 	} as const
@@ -68,7 +68,7 @@ export function createRegularAtom<T>(
 		for (const effect of options.effects) {
 			const cleanup = effect({
 				setSelf: (next) => {
-					setIntoStore(token, next, store)
+					setIntoStore(store, token, next)
 				},
 				onSet: (handle: UpdateHandler<T>) =>
 					subscribeToState(token, handle, `effect[${effectIndex}]`, store),

package/internal/src/atom/create-standalone-atom.ts

@@ -13,25 +13,27 @@ import type { Store } from "../store"
 import { createRegularAtom } from "./create-regular-atom"
 
 export function createStandaloneAtom<T>(
-	options: RegularAtomOptions<T>,
 	store: Store,
+	options: RegularAtomOptions<T>,
 ): RegularAtomToken<T>
+
 export function createStandaloneAtom<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
->(options: MutableAtomOptions<T, J>, store: Store): MutableAtomToken<T, J>
+>(store: Store, options: MutableAtomOptions<T, J>): MutableAtomToken<T, J>
+
 export function createStandaloneAtom<T>(
-	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
 	store: Store,
+	options: MutableAtomOptions<any, any> | RegularAtomOptions<T>,
 ): AtomToken<T> {
 	const isMutable = `mutable` in options
 
 	if (isMutable) {
-		const state = createMutableAtom(options, undefined, store)
+		const state = createMutableAtom(store, options, undefined)
 		store.on.atomCreation.next(state)
 		return state
 	}
-	const state = createRegularAtom(options, undefined, store)
+	const state = createRegularAtom(store, options, undefined)
 	store.on.atomCreation.next(state)
 	return state
 }

package/internal/src/families/create-atom-family.ts

@@ -16,23 +16,23 @@ export function createAtomFamily<
 	J extends Json.Serializable,
 	K extends Canonical,
 >(
-	options: MutableAtomFamilyOptions<T, J, K>,
 	store: Store,
+	options: MutableAtomFamilyOptions<T, J, K>,
 ): MutableAtomFamilyToken<T, J, K>
 export function createAtomFamily<T, K extends Canonical>(
-	options: RegularAtomFamilyOptions<T, K>,
 	store: Store,
+	options: RegularAtomFamilyOptions<T, K>,
 ): RegularAtomFamilyToken<T, K>
 export function createAtomFamily<T, K extends Canonical>(
+	store: Store,
 	options:
 		| MutableAtomFamilyOptions<any, any, any>
 		| RegularAtomFamilyOptions<T, K>,
-	store: Store,
 ): AtomFamilyToken<any, any> {
 	const isMutable = `mutable` in options
 
 	if (isMutable) {
-		return createMutableAtomFamily(options, store)
+		return createMutableAtomFamily(store, options)
 	}
-	return createRegularAtomFamily<T, K>(options, store)
+	return createRegularAtomFamily<T, K>(store, options)
 }