atom.io 0.31.1 → 0.32.1

package/dist/chunk-X7SD2NXU.js

@@ -0,0 +1,108 @@
+import { atom, SetRTX, join, selectorFamily, getInternalRelations, assignTransactionToContinuity, IMPLICIT, setEpochNumberOfContinuity } from './chunk-UQEYZ3OI.js';
+
+// realtime/src/realtime-continuity.ts
+var InvariantMap = class extends Map {
+  set(key, value) {
+    if (this.has(key)) {
+      console.warn(`Tried to set a key that already exists in an InvariantMap`, {
+        key,
+        value
+      });
+      return this;
+    }
+    return super.set(key, value);
+  }
+  clear() {
+    throw new Error(`Cannot clear an InvariantMap`);
+  }
+};
+var SyncGroup = class _SyncGroup {
+  constructor(key) {
+    this.key = key;
+  }
+  type = `continuity`;
+  globals = [];
+  actions = [];
+  perspectives = [];
+  static existing = new InvariantMap();
+  static create(key, builder) {
+    const group = new _SyncGroup(key);
+    const { type, globals, actions, perspectives } = builder(group);
+    const token = { type, key, globals, actions, perspectives };
+    _SyncGroup.existing.set(key, token);
+    return token;
+  }
+  add(...args) {
+    const zeroth = args[0];
+    switch (zeroth.type) {
+      case `atom`:
+      case `mutable_atom`:
+        this.globals.push(...args);
+        break;
+      case `transaction`:
+        this.actions.push(...args);
+        break;
+      case `atom_family`:
+      case `mutable_atom_family`:
+        {
+          const [family, index] = args;
+          this.perspectives.push({
+            type: `realtime_perspective`,
+            resourceAtoms: family,
+            viewAtoms: index
+          });
+        }
+        break;
+    }
+    return this;
+  }
+};
+function continuity(options) {
+  const { key, config } = options;
+  const token = SyncGroup.create(key, config);
+  const { actions } = token;
+  for (const action of actions) {
+    assignTransactionToContinuity(IMPLICIT.STORE, key, action.key);
+  }
+  setEpochNumberOfContinuity(IMPLICIT.STORE, key, -1);
+  return token;
+}
+
+// realtime/src/shared-room-store.ts
+var usersInThisRoomIndex = atom({
+  key: `usersInRoomIndex`,
+  mutable: true,
+  default: () => new SetRTX(),
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => SetRTX.fromJSON(json)
+});
+var roomIndex = atom({
+  key: `roomIndex`,
+  default: () => new SetRTX(),
+  mutable: true,
+  toJson: (set) => set.toJSON(),
+  fromJson: (json) => SetRTX.fromJSON(json)
+});
+var DEFAULT_USER_IN_ROOM_META = {
+  enteredAtEpoch: 0
+};
+var usersInRooms = join(
+  {
+    key: `usersInRooms`,
+    between: [`room`, `user`],
+    cardinality: `1:n`,
+    isAType: (input) => typeof input === `string`,
+    isBType: (input) => typeof input === `string`
+  },
+  DEFAULT_USER_IN_ROOM_META
+);
+var usersInMyRoomView = selectorFamily({
+  key: `usersInMyRoomView`,
+  get: (myUsername) => ({ find }) => {
+    const usersInRoomsAtoms = getInternalRelations(usersInRooms);
+    const myRoomIndex = find(usersInRoomsAtoms, myUsername);
+    return [myRoomIndex];
+  }
+});
+
+export { DEFAULT_USER_IN_ROOM_META, InvariantMap, SyncGroup, continuity, roomIndex, usersInMyRoomView, usersInRooms, usersInThisRoomIndex };

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { Transceiver, Func, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Store, Each, Flat } from 'atom.io/internal';
-import { Json, JsonInterface, Canonical, stringified } from 'atom.io/json';
-import { getState as getState$1, setState as setState$1, ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, RegularAtomToken as RegularAtomToken$1, MutableAtomToken as MutableAtomToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableToken as WritableToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, WritableFamilyToken as WritableFamilyToken$1 } from 'atom.io';
-import { findState } from 'atom.io/ephemeral';
-import { seekState } from 'atom.io/immortal';
+import { Transceiver, Func, EnvironmentData, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Timeline, JunctionSchemaBase, JunctionEntriesBase, Refinement, Store, Junction, Each, Flat } from 'atom.io/internal';
+import { Canonical, Json, JsonInterface, stringified } from 'atom.io/json';
+import { getState as getState$1, setState as setState$1, findState as findState$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 } from 'atom.io';
+import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
 /**
  * @public
@@ -139,19 +138,17 @@ type TransactionUpdate<F extends Func> = {
     params: Parameters<F>;
     output: ReturnType<F>;
 };
-type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json` | `seek`>;
+type GetterToolkit = Pick<SetterToolkit, `find` | `get` | `json`>;
 type SetterToolkit = Readonly<{
     get: typeof getState$1;
     set: typeof setState$1;
-    find: typeof findState;
-    seek: typeof seekState;
+    find: typeof findState$1;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
 }>;
 type ActorToolkit = Readonly<{
     get: typeof getState$1;
     set: typeof setState$1;
-    find: typeof findState;
-    seek: typeof seekState;
+    find: typeof findState$1;
     json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
     dispose: typeof disposeState;
     run: typeof runTransaction;
@@ -255,6 +252,68 @@ declare function disposeState(token: ReadableToken<any>): void;
  */
 declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
 
+/**
+ * @public
+ * Finds a {@link MutableAtomToken} in the store
+ * @param token - A {@link MutableAtomFamilyToken}
+ * @param key - The key of the state
+ * @returns
+ * The current value of the state
+ * @overload Mutable Atom
+ */
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J, K>;
+/**
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
+ * @returns
+ * The current value of the state
+ * @overload Regular Atom
+ */
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T, K>;
+/**
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
+ * @returns
+ * The current value of the state
+ * @overload Writable Selector
+ */
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T, K>;
+/**
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
+ * @returns
+ * The current value of the state
+ * @overload Readonly Selector
+ */
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T, K>;
+/**
+ * @public
+ * Finds a state in the store
+ * @param token - The token of the state family
+ * @param key - The key of the state
+ * @returns
+ * The current value of the state
+ * @overload Writable State
+ */
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T, K>;
+/**
+ * @public
+ * Finds a {@link ReadableToken} in the store
+ * @param token - A {@link ReadableFamilyToken}
+ * @param key - The key of the state
+ * @returns
+ * The current value of the state
+ * @overload Unknown
+ * @default
+ */
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T, K>;
+
 /**
  * @public
  * Get the current value of a state
@@ -274,6 +333,71 @@ declare function getState<T>(token: ReadableToken<T>): T;
  */
 declare function getState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): T;
 
+interface JoinOptions<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> extends JunctionSchemaBase<ASide, BSide>, Partial<JunctionEntriesBase<AType, BType, Content>> {
+    readonly key: string;
+    readonly cardinality: Cardinality;
+    readonly isAType: Refinement<string, AType>;
+    readonly isBType: Refinement<string, BType>;
+}
+type JoinToken<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null> = {
+    key: string;
+    type: `join`;
+    cardinality: Cardinality;
+    a: ASide;
+    b: BSide;
+    __aType?: AType;
+    __bType?: BType;
+    __content?: Content;
+};
+declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, null>, defaultContent?: undefined, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, null>;
+declare function join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object>(options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>, defaultContent: Content, store?: Store): JoinToken<ASide, AType, BSide, BType, Cardinality, Content>;
+type JoinStates<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[
+        AType,
+        Content
+    ] | null, BType>;
+} & {
+    readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[
+        BType,
+        Content
+    ] | null, AType>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType | null, BType>;
+} & {
+    readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType | null, AType>;
+} : Cardinality extends `1:n` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[
+        AType,
+        Content
+    ] | null, BType>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[
+        BType,
+        Content
+    ][], AType>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType | null, BType>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType[], AType>;
+} : Cardinality extends `n:n` ? (Content extends Json.Object ? {
+    readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<[
+        AType,
+        Content
+    ][], BType>;
+} & {
+    readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<[
+        BType,
+        Content
+    ][], AType>;
+} : {}) & {
+    readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorToken$1<AType[], BType>;
+} & {
+    readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorToken$1<BType[], AType>;
+} : never;
+declare function findRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, key: AType | BType): JoinStates<ASide, AType, BSide, BType, Cardinality, Content>;
+declare function editRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>, change: (relations: Junction<ASide, AType, BSide, BType, Content>) => void): void;
+declare function getInternalRelations<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null>(token: JoinToken<ASide, AType, BSide, BType, Cardinality, Content>): MutableAtomFamilyToken$1<SetRTX<string>, SetRTXJson<string>, string>;
+
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
     readonly "\u23E9": "Timeline redo";
@@ -438,7 +562,7 @@ declare class Silo {
     selectorFamily: typeof selectorFamily;
     transaction: typeof transaction;
     timeline: typeof timeline;
-    findState: typeof findState;
+    findState: typeof findState$1;
     getState: typeof getState;
     setState: typeof setState;
     disposeState: typeof disposeState;
@@ -572,5 +696,6 @@ type FamilyMetadata<K extends Canonical = any> = {
     /** The family member's unique identifier, in the form of a string. */
     subKey: stringified<K>;
 };
+type Loadable<T> = Promise<T> | T;
 
-export { $claim, type Above, type ActorToolkit, Anarchy, type AtomDisposal, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomIOToken, type AtomOnly, type AtomToken, type Below, type Claim, type CompoundFrom, type CompoundTypedKey, type Effectors, type FamilyMetadata, type GetterToolkit, type Hierarchy, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeCreation, type MoleculeDisposal, type MoleculeTransfer, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Mutuals, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, Realm, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorDisposal, type SelectorFamilyToken, type SelectorToken, type Setter, type SetterToolkit, Silo, type SingularTypedKey, type StateCreation, type StateDisposal, type StateUpdate, T$, 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 TypeTag, type TypedKey, type UpdateHandler, type Vassal, type WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { $claim, type Above, type ActorToolkit, Anarchy, type AtomDisposal, type AtomEffect, type AtomFamilyToken, AtomIOLogger, type AtomIOToken, type AtomOnly, type AtomToken, type Below, type Claim, type CompoundFrom, type CompoundTypedKey, type Effectors, type FamilyMetadata, type GetterToolkit, type Hierarchy, type JoinOptions, type JoinStates, type JoinToken, type KeyedStateUpdate, LOG_LEVELS, type Loadable, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeCreation, type MoleculeDisposal, type MoleculeTransfer, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Mutuals, type Read, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, Realm, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorDisposal, type SelectorFamilyToken, type SelectorToken, type Setter, type SetterToolkit, Silo, type SingularTypedKey, type StateCreation, type StateDisposal, type StateUpdate, T$, 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 TypeTag, type TypedKey, type UpdateHandler, type Vassal, type WritableFamilyToken, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,229 +1,2 @@
-import { newest, isChildStore, withdraw } from './chunk-Y5MBNTVU.js';
+export { $claim, Anarchy, AtomIOLogger, LOG_LEVELS, Realm, Silo, T$, atom, atomFamily, belongsTo, disposeState, editRelations, findRelations, findState, getInternalRelations, getState, isToken, join, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo } from './chunk-UQEYZ3OI.js';
 import './chunk-XWL6SNVU.js';
-import * as Internal from 'atom.io/internal';
-import { createStandaloneAtom, IMPLICIT, createAtomFamily, makeRootMoleculeInStore, allocateIntoStore, fuseWithinStore, deallocateFromStore, claimWithinStore, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, disposeFromStore, subscribeInStore, timeTravel, actUponStore, arbitrary } from 'atom.io/internal';
-
-function atom(options) {
-  return createStandaloneAtom(IMPLICIT.STORE, options);
-}
-function atomFamily(options) {
-  return createAtomFamily(IMPLICIT.STORE, options);
-}
-function disposeState(...[token, key]) {
-  if (key) {
-    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token, key);
-  } else {
-    Internal.disposeFromStore(Internal.IMPLICIT.STORE, token);
-  }
-}
-function getState(...params) {
-  if (params.length === 2) {
-    return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
-  }
-  return Internal.getFromStore(Internal.IMPLICIT.STORE, ...params);
-}
-
-// src/logger.ts
-var LOG_LEVELS = [`info`, `warn`, `error`];
-var simpleLog = (logLevel) => (icon, denomination, tokenKey, message, ...rest) => {
-  console[logLevel](
-    `${icon} ${denomination} "${tokenKey}" ${message}`,
-    ...rest
-  );
-};
-var simpleLogger = {
-  error: simpleLog(`error`),
-  info: simpleLog(`info`),
-  warn: simpleLog(`warn`)
-};
-var AtomIOLogger = class {
-  constructor(logLevel, filter, logger = simpleLogger) {
-    this.logLevel = logLevel;
-    this.filter = filter;
-    this.logger = logger;
-  }
-  error = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== null) {
-      this.logger.error(...args);
-    }
-  };
-  info = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel === `info`) {
-      this.logger.info(...args);
-    }
-  };
-  warn = (...args) => {
-    if ((this.filter?.(...args) ?? true) && this.logLevel !== `error` && this.logLevel !== null) {
-      this.logger.warn(...args);
-    }
-  };
-};
-var $claim = Symbol(`claim`);
-var Realm = class {
-  store;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    makeRootMoleculeInStore(`root`, store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    return allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  fuse(type, reagentA, reagentB) {
-    return fuseWithinStore(this.store, type, reagentA, reagentB);
-  }
-  deallocate(claim) {
-    deallocateFromStore(this.store, claim);
-  }
-  claim(newProvenance, claim, exclusive) {
-    return claimWithinStore(this.store, newProvenance, claim, exclusive);
-  }
-};
-var Anarchy = class {
-  store;
-  realm;
-  constructor(store = IMPLICIT.STORE) {
-    this.store = store;
-    this.realm = new Realm(store);
-  }
-  allocate(provenance, key, attachmentStyle) {
-    allocateIntoStore(
-      this.store,
-      provenance,
-      key,
-      attachmentStyle
-    );
-  }
-  deallocate(key) {
-    deallocateFromStore(this.store, key);
-  }
-  claim(newProvenance, key, exclusive) {
-    claimWithinStore(this.store, newProvenance, key, exclusive);
-  }
-};
-var T$ = `T$`;
-function selector(options) {
-  return createStandaloneSelector(IMPLICIT.STORE, options);
-}
-function selectorFamily(options) {
-  return createSelectorFamily(IMPLICIT.STORE, options);
-}
-function setState(...params) {
-  if (params.length === 2) {
-    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
-  } else {
-    Internal.setIntoStore(Internal.IMPLICIT.STORE, ...params);
-  }
-}
-
-// internal/src/install-into-store.ts
-function installIntoStore(tokens, target, source) {
-  const sourceNewest = newest(source);
-  if (isChildStore(sourceNewest)) {
-    source.logger.error(
-      `\u274C`,
-      `transaction`,
-      sourceNewest.transactionMeta.update.key,
-      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
-      tokens,
-      `${sourceNewest.config.name} is undergoing a transaction.`
-    );
-    return;
-  }
-  const targetNewest = newest(target);
-  if (isChildStore(targetNewest)) {
-    target.logger.error(
-      `\u274C`,
-      `transaction`,
-      targetNewest.transactionMeta.update.key,
-      `could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
-      tokens,
-      `${targetNewest.config.name} is undergoing a transaction.`
-    );
-    return;
-  }
-  for (const token of tokens) {
-    const resource = withdraw(token, source);
-    resource.install(target);
-  }
-}
-
-// src/silo.ts
-var Silo = class {
-  store;
-  atom;
-  atomFamily;
-  selector;
-  selectorFamily;
-  transaction;
-  timeline;
-  findState;
-  getState;
-  setState;
-  disposeState;
-  subscribe;
-  undo;
-  redo;
-  runTransaction;
-  install;
-  constructor(config, fromStore = null) {
-    const s = this.store = new Store(config, fromStore);
-    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 = (...params) => findInStore(s, ...params);
-    this.getState = (...params) => getFromStore(s, ...params);
-    this.setState = (...params) => {
-      setIntoStore(s, ...params);
-    };
-    this.disposeState = (...params) => {
-      disposeFromStore(s, ...params);
-    };
-    this.subscribe = (...params) => subscribeInStore(s, ...params);
-    this.undo = (token) => {
-      timeTravel(s, `undo`, token);
-    };
-    this.redo = (token) => {
-      timeTravel(s, `redo`, token);
-    };
-    this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s);
-    this.install = (tokens, source = IMPLICIT.STORE) => {
-      installIntoStore(tokens, s, source);
-    };
-  }
-};
-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(IMPLICIT.STORE, `redo`, tl);
-};
-var undo = (tl) => {
-  timeTravel(IMPLICIT.STORE, `undo`, tl);
-};
-function transaction(options) {
-  return createTransaction(options, IMPLICIT.STORE);
-}
-function runTransaction(token, id = arbitrary()) {
-  return actUponStore(token, id, IMPLICIT.STORE);
-}
-
-// src/validators.ts
-function isToken(knownToken, unknownToken) {
-  return knownToken.key === unknownToken.key;
-}
-function belongsTo(family, unknownToken) {
-  return family.key === unknownToken.family?.key;
-}
-
-export { $claim, Anarchy, AtomIOLogger, LOG_LEVELS, Realm, Silo, T$, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

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

@@ -6,33 +6,6 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 
 declare const explicitStateTypes: ESLintUtils.RuleModule<"noTypeArgument", [], unknown, ESLintUtils.RuleListener>;
 
-declare const lifespan: {
-    meta: {
-        type: "problem";
-        docs: {
-            description: string;
-            category: string;
-            recommended: false;
-            url: string;
-        };
-        schema: {
-            type: "string";
-            enum: string[];
-            default: string;
-        }[];
-    };
-    create(context: _eslint_core.RuleContext<{
-        LangOptions: eslint.Linter.LanguageOptions;
-        Code: eslint.SourceCode;
-        RuleOptions: any[];
-        Node: ESTree.Node;
-        MessageIds: string;
-    }>): {
-        ImportDeclaration(node: ESTree.ImportDeclaration & Rule.NodeParentExtension): void;
-        CallExpression(node: ESTree.CallExpression & Rule.NodeParentExtension): void;
-    };
-};
-
 declare const synchronousSelectorDependencies: {
     meta: {
         type: "problem";
@@ -56,16 +29,14 @@ declare const synchronousSelectorDependencies: {
 };
 
 declare const index_explicitStateTypes: typeof explicitStateTypes;
-declare const index_lifespan: typeof lifespan;
 declare const index_synchronousSelectorDependencies: typeof synchronousSelectorDependencies;
 declare namespace index {
-  export { index_explicitStateTypes as explicitStateTypes, index_lifespan as lifespan, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
+  export { index_explicitStateTypes as explicitStateTypes, index_synchronousSelectorDependencies as synchronousSelectorDependencies };
 }
 
 declare const _default: {
     rules: {
         "explicit-state-types": any;
-        lifespan: any;
         "synchronous-selector-dependencies": {
             meta: {
                 type: "problem";