atom.io 0.18.1 → 0.18.3

package/data/dist/index.cjs

@@ -671,5 +671,3 @@ exports.join = join;
 exports.struct = struct;
 exports.structFamily = structFamily;
 exports.until = until;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/data/dist/index.js

@@ -1,5 +1,5 @@
-import { Junction } from '../../dist/chunk-NYTGCPHB.js';
-import '../../dist/chunk-PZLG2HP3.js';
+import { Junction } from '../../dist/chunk-WX2NCOZR.js';
+import '../../dist/chunk-U2IICNHQ.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, createMutableAtomFamily, createRegularAtomFamily, createRegularAtom, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
 import { dispose } from 'atom.io';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
@@ -405,5 +405,3 @@ function until(loadable, fallback) {
 }
 
 export { Join, dict, join, struct, structFamily, until };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/dist/{chunk-JDUNWJFB.js → chunk-BWWVY5O5.js}

@@ -11,8 +11,6 @@ var persistAtom = (storage) => ({ stringify, parse }) => (key) => ({ setSelf, on
     storage.setItem(key, stringify(newValue));
   });
 };
-var lazyLocalStorageEffect = persistAtom(localStorage)(JSON);
+var lazyLocalStorageEffect = persistAtom(window.localStorage)(JSON);
 
 export { lazyLocalStorageEffect };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-JDUNWJFB.js.map

package/dist/{chunk-NYCVSXQB.js → chunk-CVBEVTM5.js}

@@ -177,5 +177,3 @@ var delve = (obj, path) => {
 };
 
 export { addTo, become, comprises, delve, doNothing, doesExtend, entriesToRecord, fallback, hasExactProperties, ifDefined, isArray, isEmptyArray, isEmptyObject, isModifier, isOneOf, isPlainObject, isRecord, map, mapObject, pipe, raiseError, recordToEntries, sprawl, treeShake };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-NYCVSXQB.js.map

package/dist/chunk-O47EQUM6.js

@@ -0,0 +1,29 @@
+import { lazyLocalStorageEffect } from './chunk-BWWVY5O5.js';
+import * as AtomIO from 'atom.io';
+
+var myIdState__INTERNAL = AtomIO.atom({
+  key: `mySocketId__INTERNAL`,
+  default: void 0
+});
+var myIdState = AtomIO.selector({
+  key: `mySocketId`,
+  get: ({ get }) => get(myIdState__INTERNAL)
+});
+var usernameEffects = typeof window === `undefined` ? [] : [lazyLocalStorageEffect(`myUsername`)];
+var myUsernameState = AtomIO.atom({
+  key: `myUsername`,
+  default: null,
+  effects: usernameEffects
+});
+var optimisticUpdateQueue = AtomIO.atom({
+  key: `updateQueue`,
+  default: []
+});
+var confirmedUpdateQueue = AtomIO.atom(
+  {
+    key: `serverConfirmedUpdateQueue`,
+    default: []
+  }
+);
+
+export { confirmedUpdateQueue, myIdState, myIdState__INTERNAL, myUsernameState, optimisticUpdateQueue };

package/dist/{chunk-PZLG2HP3.js → chunk-U2IICNHQ.js}

@@ -32,5 +32,3 @@ var __objRest = (source, exclude) => {
 };
 
 export { __objRest, __restKey, __spreadProps, __spreadValues };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-PZLG2HP3.js.map

package/dist/{chunk-XACXFU3B.js → chunk-VAE5OCKN.js}

@@ -42,5 +42,3 @@ var isPrimitive = (input) => {
 };
 
 export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-XACXFU3B.js.map

package/dist/{chunk-NYTGCPHB.js → chunk-WX2NCOZR.js}

@@ -257,5 +257,3 @@ var Junction = class {
 };
 
 export { Junction };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-NYTGCPHB.js.map

package/dist/{chunk-IZHOMSXA.js → chunk-YDOGCZ53.js}

@@ -327,5 +327,3 @@ function syncContinuity(continuity, socket, store) {
 }
 
 export { syncContinuity };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=chunk-IZHOMSXA.js.map

package/dist/index.cjs

@@ -177,5 +177,3 @@ exports.subscribe = subscribe;
 exports.timeline = timeline;
 exports.transaction = transaction;
 exports.undo = undo;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map

package/dist/index.js

@@ -1,4 +1,4 @@
-import './chunk-PZLG2HP3.js';
+import './chunk-U2IICNHQ.js';
 import * as Internal from 'atom.io/internal';
 import { createStandaloneAtom, IMPLICIT, createAtomFamily, findInStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 
@@ -136,5 +136,3 @@ function belongsTo(family, unknownToken) {
 }
 
 export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, dispose, findState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.js.map

package/internal/dist/index.cjs

@@ -504,27 +504,37 @@ function withdraw(token, store) {
     }
     target = target.child;
   }
+  throw new NotFoundError(token, store);
 }
 
 // internal/src/store/withdraw-new-family-member.ts
-function withdrawNewFamilyMember(token, store) {
-  if (token.family) {
-    store.logger.info(
-      `\u{1F46A}`,
-      token.type,
-      token.key,
-      `creating new family member in store "${store.config.name}"`
-    );
-    const target = newest(store);
-    const family = target.families.get(token.family.key);
-    if (family) {
-      const jsonSubKey = JSON.parse(token.family.subKey);
-      family(jsonSubKey);
-      const state = withdraw(token, store);
-      return state;
+function withdrawOrCreate(token, store) {
+  try {
+    const state = withdraw(token, store);
+    return state;
+  } catch (notFoundError) {
+    if (token.family) {
+      store.logger.info(
+        `\u{1F46A}`,
+        token.type,
+        token.key,
+        `creating new family member in store "${store.config.name}"`
+      );
+      const target = newest(store);
+      const family = target.families.get(token.family.key);
+      if (family) {
+        const jsonSubKey = JSON.parse(token.family.subKey);
+        family(jsonSubKey);
+        const state = withdraw(token, store);
+        return state;
+      }
+      throw new NotFoundError(
+        { key: token.family.key, type: `${token.type}_family` },
+        store
+      );
     }
+    throw notFoundError;
   }
-  return void 0;
 }
 
 // internal/src/future.ts
@@ -637,10 +647,11 @@ function createRegularAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `atom` }, store);
+      const target2 = newest(store);
+      const atomAlreadyCreated = target2.atoms.has(fullKey);
       let token;
-      if (existing) {
-        token = deposit(existing);
+      if (atomAlreadyCreated) {
+        token = { type: `atom`, key: fullKey, family };
       } else {
         const individualOptions = {
           key: fullKey,
@@ -998,15 +1009,11 @@ var setAtomOrSelector = (state, value, store) => {
 
 // internal/src/set-state/set-into-store.ts
 function setIntoStore(token, value, store) {
-  var _a;
   const rejection = openOperation(token, store);
   if (rejection) {
     return;
   }
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
-  if (state === void 0) {
-    throw new NotFoundError(token, store);
-  }
+  const state = withdrawOrCreate(token, store);
   setAtomOrSelector(state, value, store);
   closeOperation(store);
 }
@@ -1091,14 +1098,8 @@ var updateSelectorAtoms = (selectorKey, dependency, store) => {
 // internal/src/selector/register-selector.ts
 var registerSelector = (selectorKey, store) => ({
   get: (dependency) => {
-    var _a;
     const target = newest(store);
-    const dependencyState = (_a = withdraw(dependency, store)) != null ? _a : withdrawNewFamilyMember(dependency, store);
-    if (dependencyState === void 0) {
-      throw new Error(
-        `State "${dependency.key}" not found in store "${store.config.name}".`
-      );
-    }
+    const dependencyState = withdrawOrCreate(dependency, store);
     const dependencyValue = readOrComputeValue(dependencyState, store);
     store.logger.info(
       `\u{1F50C}`,
@@ -1121,12 +1122,7 @@ var registerSelector = (selectorKey, store) => ({
     return dependencyValue;
   },
   set: (WritableToken, newValue) => {
-    const state = withdraw(WritableToken, store);
-    if (state === void 0) {
-      throw new Error(
-        `State "${WritableToken.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
-      );
-    }
+    const state = withdrawOrCreate(WritableToken, store);
     setAtomOrSelector(state, newValue, store);
   },
   find: (token, key) => findInStore(token, key, store)
@@ -1314,8 +1310,7 @@ var subscribeToRootAtoms = (selector, store) => {
 
 // internal/src/subscribe/subscribe-to-state.ts
 function subscribeToState(token, handleUpdate, key, store) {
-  var _a;
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
+  const state = withdrawOrCreate(token, store);
   if (state === void 0) {
     throw new Error(
       `State "${token.key}" not found in this store. Did you forget to initialize with the "atom" or "selector" function?`
@@ -1350,11 +1345,6 @@ function subscribeToState(token, handleUpdate, key, store) {
 // internal/src/subscribe/subscribe-to-timeline.ts
 var subscribeToTimeline = (token, handleUpdate, key, store) => {
   const tl = withdraw(token, store);
-  if (tl === void 0) {
-    throw new Error(
-      `Cannot subscribe to timeline "${token.key}": timeline not found in store "${store.config.name}".`
-    );
-  }
   store.logger.info(`\u{1F440}`, `timeline`, token.key, `Adding subscription "${key}"`);
   const unsubscribe = tl.subject.subscribe(key, handleUpdate);
   return () => {
@@ -1371,11 +1361,6 @@ var subscribeToTimeline = (token, handleUpdate, key, store) => {
 // internal/src/subscribe/subscribe-to-transaction.ts
 var subscribeToTransaction = (token, handleUpdate, key, store) => {
   const tx = withdraw(token, store);
-  if (tx === void 0) {
-    throw new Error(
-      `Cannot subscribe to transaction "${token.key}": transaction not found in store "${store.config.name}".`
-    );
-  }
   store.logger.info(
     `\u{1F440}`,
     `transaction`,
@@ -1650,10 +1635,11 @@ function createMutableAtomFamily(options, store) {
       const subKey = json.stringifyJson(key);
       const family = { key: options.key, subKey };
       const fullKey = `${options.key}(${subKey})`;
-      const existing = withdraw({ key: fullKey, type: `mutable_atom` }, store);
+      const target2 = newest(store);
+      const atomAlreadyCreated = target2.atoms.has(fullKey);
       let token;
-      if (existing) {
-        token = deposit(existing);
+      if (atomAlreadyCreated) {
+        token = { type: `mutable_atom`, key: fullKey, family };
       } else {
         const individualOptions = {
           key: fullKey,
@@ -1876,11 +1862,7 @@ function getEnvironmentData(store) {
 
 // internal/src/get-state/get-from-store.ts
 function getFromStore(token, store) {
-  var _a;
-  const state = (_a = withdraw(token, store)) != null ? _a : withdrawNewFamilyMember(token, store);
-  if (state === void 0) {
-    throw new NotFoundError(token, store);
-  }
+  const state = withdrawOrCreate(token, store);
   return readOrComputeValue(state, store);
 }
 
@@ -1952,16 +1934,11 @@ var LazyMap = class extends Map {
 // internal/src/timeline/add-atom-to-timeline.ts
 var addAtomToTimeline = (atomToken, tl, store) => {
   let maybeAtom = withdraw(atomToken, store);
-  if ((maybeAtom == null ? void 0 : maybeAtom.type) === `mutable_atom`) {
+  if (maybeAtom.type === `mutable_atom`) {
     const updateToken = getUpdateToken(maybeAtom);
     maybeAtom = withdraw(updateToken, store);
   }
   const atom = maybeAtom;
-  if (atom === void 0) {
-    throw new Error(
-      `Cannot subscribe to atom "${atomToken.key}" because it has not been initialized in store "${store.config.name}"`
-    );
-  }
   store.timelineAtoms.set({ atomKey: atom.key, timelineKey: tl.key });
   atom.subject.subscribe(`timeline`, (update) => {
     var _a, _b, _c, _d, _e, _f;
@@ -1993,15 +1970,11 @@ var addAtomToTimeline = (atomToken, tl, store) => {
         }
       }
       if (currentTransactionKey) {
-        const currentTransaction = withdraw(
-          { key: currentTransactionKey, type: `transaction` },
-          store
-        );
-        if (currentTransaction === void 0) {
-          throw new Error(
-            `Transaction "${currentTransactionKey}" not found in store "${store.config.name}". This is surprising, because we are in the application phase of "${currentTransactionKey}".`
-          );
-        }
+        const txToken = {
+          key: currentTransactionKey,
+          type: `transaction`
+        };
+        const currentTransaction = withdraw(txToken, store);
         if (tl.transactionKey !== currentTransactionKey) {
           if (tl.transactionKey) {
             store.logger.error(
@@ -2173,15 +2146,6 @@ function createTimeline(options, store, data) {
     if (tokenOrFamily.type === `atom_family` || tokenOrFamily.type === `mutable_atom_family`) {
       const familyToken = tokenOrFamily;
       const family = withdraw(familyToken, store);
-      if (family === void 0) {
-        store.logger.error(
-          `\u274C`,
-          `timeline`,
-          options.key,
-          `Failed to add family "${familyToken.key}" because it does not exist in the store`
-        );
-        continue;
-      }
       const familyKey = family.key;
       target.timelineAtoms.set({ atomKey: familyKey, timelineKey });
       family.subject.subscribe(`timeline:${options.key}`, (token2) => {
@@ -2194,26 +2158,8 @@ function createTimeline(options, store, data) {
       }
     } else {
       let atom = withdraw(tokenOrFamily, store);
-      if (atom === void 0) {
-        store.logger.error(
-          `\u274C`,
-          `timeline`,
-          options.key,
-          `Failed to add atom "${atomKey}" because it does not exist in the store`
-        );
-        continue;
-      }
       if (isMutable(atom)) {
         const updateAtom = withdraw(getUpdateToken(atom), store);
-        if (updateAtom === void 0) {
-          store.logger.error(
-            `\u274C`,
-            `timeline`,
-            options.key,
-            `Failed to add update atom "${atomKey}" because it does not exist in the store`
-          );
-          continue;
-        }
         atom = updateAtom;
         atomKey = atom.key;
       }
@@ -2637,6 +2583,4 @@ exports.traceAllSelectorAtoms = traceAllSelectorAtoms;
 exports.traceSelectorAtoms = traceSelectorAtoms;
 exports.updateSelectorAtoms = updateSelectorAtoms;
 exports.withdraw = withdraw;
-exports.withdrawNewFamilyMember = withdrawNewFamilyMember;
-//# sourceMappingURL=out.js.map
-//# sourceMappingURL=index.cjs.map
+exports.withdrawOrCreate = withdrawOrCreate;

package/internal/dist/index.d.ts

@@ -243,28 +243,28 @@ declare const IMPLICIT: {
 declare const clearStore: (store: Store) => void;
 
 type Withdrawable = Atom<any> | AtomFamily<any, any> | MutableAtom<any, any> | MutableAtomFamily<any, any, any> | ReadableState<any> | ReadableState<any> | ReadonlySelector<any> | ReadonlySelectorFamily<any, any> | RegularAtom<any> | RegularAtomFamily<any, any> | Selector<any> | SelectorFamily<any, any> | Timeline<any> | Transaction<any> | WritableSelector<any> | WritableSelectorFamily<any, any> | WritableState<any>;
-declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T> | undefined;
-declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any> | undefined;
-declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T> | undefined;
-declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T> | undefined;
-declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
-declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K> | undefined;
-declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any> | undefined;
-declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any> | undefined;
-declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never> | undefined;
-declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never> | undefined;
-
-declare function withdrawNewFamilyMember<T>(token: RegularAtomToken<T>, store: Store): Atom<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: WritableToken<T>, store: Store): WritableState<T> | undefined;
-declare function withdrawNewFamilyMember<T>(token: ReadableToken<T>, store: Store): ReadableState<T> | undefined;
+declare function withdraw<T>(token: RegularAtomToken<T>, store: Store): RegularAtom<T>;
+declare function withdraw<T extends Transceiver<any>>(token: MutableAtomToken<T, any>, store: Store): MutableAtom<T, any>;
+declare function withdraw<T>(token: AtomToken<T>, store: Store): Atom<T>;
+declare function withdraw<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
+declare function withdraw<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdraw<T>(token: SelectorToken<T>, store: Store): Selector<T>;
+declare function withdraw<T>(token: WritableToken<T>, store: Store): WritableState<T>;
+declare function withdraw<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
+declare function withdraw<T, K extends Json.Serializable>(token: RegularAtomFamilyToken<T, K>, store: Store): RegularAtomFamily<T, K>;
+declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(token: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomFamily<T, J, K>;
+declare function withdraw<T, K extends Json.Serializable>(token: AtomFamilyToken<T>, store: Store): AtomFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>, store: Store): ReadonlySelectorFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>, store: Store): WritableSelectorFamily<T, any>;
+declare function withdraw<T, K extends Json.Serializable>(token: SelectorFamilyToken<T, K>, store: Store): SelectorFamily<T, any>;
+declare function withdraw<T>(token: TransactionToken<T>, store: Store): Transaction<T extends _n ? T : never>;
+declare function withdraw<T>(token: TimelineToken<T>, store: Store): Timeline<T extends TimelineManageable ? T : never>;
+
+declare function withdrawOrCreate<T>(token: RegularAtomToken<T>, store: Store): Atom<T>;
+declare function withdrawOrCreate<T>(token: WritableSelectorToken<T>, store: Store): WritableSelector<T>;
+declare function withdrawOrCreate<T>(token: ReadonlySelectorToken<T>, store: Store): ReadonlySelector<T>;
+declare function withdrawOrCreate<T>(token: WritableToken<T>, store: Store): WritableState<T>;
+declare function withdrawOrCreate<T>(token: ReadableToken<T>, store: Store): ReadableState<T>;
 
 interface Transceiver<Signal extends Json.Serializable> {
     do: (update: Signal) => number | `OUT_OF_RANGE` | null;
@@ -484,4 +484,4 @@ type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 
-export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, 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 TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawNewFamilyMember };
+export { type Atom, type AtomIOState, type AtomKey, type ChildStore, type EnvironmentData, FamilyTracker, Future, IMPLICIT, LazyMap, type Lineage, type Modify, type MutableAtom, NotFoundError, type OperationProgress, 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 TimelineSelectorUpdate, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableSelector, type WritableState, abortTransaction, actUponStore, addAtomToTimeline, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deleteAtom, deleteSelector, deposit, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateToken, ingestAtomUpdate, ingestSelectorUpdate, ingestTransactionUpdate, isAtomDefault, isAtomKey, isChildStore, isDone, isMutable, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, readCachedValue, readOrComputeValue, registerSelector, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw, withdrawOrCreate };