atom.io 0.21.1 → 0.23.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-import * as Internal from 'atom.io/internal';
-import { Transceiver, Subject, Store, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineSelectorUpdate, TimelineTransactionUpdate } from 'atom.io/internal';
+import { Transceiver, Subject, Store, EnvironmentData, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
 import { Json, JsonInterface } from 'atom.io/json';
-import { 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 { findState } from 'atom.io/ephemeral';
+import { MoleculeToken, MoleculeFamilyToken, seekState, makeMolecule } from 'atom.io/immortal';
+import { ReadableFamilyToken as ReadableFamilyToken$1, ReadableToken as ReadableToken$1, RegularAtomToken as RegularAtomToken$1, MutableAtomToken as MutableAtomToken$1, WritableSelectorToken as WritableSelectorToken$1, ReadonlySelectorToken as ReadonlySelectorToken$1, WritableToken as WritableToken$1, RegularAtomFamilyToken as RegularAtomFamilyToken$1, MutableAtomFamilyToken as MutableAtomFamilyToken$1, WritableSelectorFamilyToken as WritableSelectorFamilyToken$1, ReadonlySelectorFamilyToken as ReadonlySelectorFamilyToken$1, WritableFamilyToken as WritableFamilyToken$1 } from 'atom.io';
 
 type Effectors<T> = {
     setSelf: <V extends T>(next: V | ((oldValue: T) => V)) => void;
@@ -33,10 +34,13 @@ type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
     __T?: T;
     __K?: K;
 };
-type RegularAtomFamilyTokenWithCall<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => RegularAtomToken<T>);
+type RegularAtomFamilyTokenWithCall<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): RegularAtomToken<T>;
+};
 type RegularAtomFamily<T, K extends Json.Serializable> = RegularAtomFamilyToken<T, K> & {
     (key: K): RegularAtomToken<T>;
-    subject: Subject<RegularAtomToken<T>>;
+    subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>;
     install: (store: Store) => void;
 };
 type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = JsonInterface<T, J> & {
@@ -52,10 +56,13 @@ type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializa
     __J?: J;
     __K?: K;
 };
-type MutableAtomFamilyTokenWithCall<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = MutableAtomFamilyToken<T, J, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => MutableAtomToken<T, J>);
+type MutableAtomFamilyTokenWithCall<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = MutableAtomFamilyToken<T, J, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): MutableAtomToken<T, J>;
+};
 type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
     (key: K): MutableAtomToken<T, J>;
-    subject: Subject<MutableAtomToken<T, J>>;
+    subject: Subject<StateCreation<MutableAtomToken<T, J>> | StateDisposal<MutableAtomToken<T, J>>>;
     install: (store: Store) => void;
 };
 type AtomFamily<T, K extends Json.Serializable = Json.Serializable> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
@@ -68,8 +75,32 @@ type TransactionToken<F extends Func> = {
     type: `transaction`;
     __F?: F;
 };
-type TransactionUpdateContent = KeyedStateUpdate<unknown> | TransactionUpdate<Func>;
+type StateCreation<Token extends ReadableToken<any>> = {
+    type: `state_creation`;
+    token: Token;
+};
+type StateDisposal<Token extends ReadableToken<any>> = {
+    type: `state_disposal`;
+    token: Token;
+    value?: TokenType<Token>;
+};
+type MoleculeCreation<Key extends Json.Serializable> = {
+    type: `molecule_creation`;
+    token: MoleculeToken<Key, any, any>;
+    family: MoleculeFamilyToken<Key, any, any>;
+    context: MoleculeToken<any, any, any>[];
+    params: any[];
+};
+type MoleculeDisposal<Key extends Json.Serializable> = {
+    type: `molecule_disposal`;
+    token: MoleculeToken<Key, any, any>;
+    family: MoleculeFamilyToken<any, any, any>;
+    context: MoleculeToken<any, any, any>[];
+    familyKeys: string[];
+};
+type TransactionUpdateContent = KeyedStateUpdate<unknown> | MoleculeCreation<any> | MoleculeDisposal<any> | StateCreation<ReadableToken<unknown>> | StateDisposal<ReadableToken<unknown>> | TransactionUpdate<Func>;
 type TransactionUpdate<F extends Func> = {
+    type: `transaction_update`;
     key: string;
     id: string;
     epoch: number;
@@ -78,18 +109,24 @@ type TransactionUpdate<F extends Func> = {
     output: ReturnType<F>;
 };
 type Transactors = Readonly<{
-    get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
+    get: <S>(state: ReadableToken<S>) => S;
     set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
     find: typeof findState;
+    seek: typeof seekState;
+    json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
 }>;
 type TransactorsWithRunAndEnv = Readonly<{
     get: <S>(state: ReadonlySelectorToken<S> | WritableToken<S>) => S;
     set: <S, New extends S>(state: WritableToken<S>, newValue: New | ((oldValue: S) => New)) => void;
     find: typeof findState;
+    seek: typeof seekState;
+    json: <T extends Transceiver<any>, J extends Json.Serializable>(state: MutableAtomToken<T, J>) => WritableSelectorToken<J>;
+    make: typeof makeMolecule;
+    dispose: typeof disposeState;
     run: typeof runTransaction;
     env: () => EnvironmentData;
 }>;
-type ReadonlyTransactors = Pick<Transactors, `find` | `get`>;
+type ReadonlyTransactors = Pick<Transactors, `find` | `get` | `json` | `seek`>;
 type Read<F extends Func> = (transactors: ReadonlyTransactors, ...parameters: Parameters<F>) => ReturnType<F>;
 type Write<F extends Func> = (transactors: Transactors, ...parameters: Parameters<F>) => ReturnType<F>;
 type Transact<F extends Func> = (transactors: TransactorsWithRunAndEnv, ...parameters: Parameters<F>) => ReturnType<F>;
@@ -127,10 +164,13 @@ type WritableSelectorFamilyToken<T, K extends Json.Serializable> = {
     __T?: T;
     __K?: K;
 };
-type WritableSelectorFamilyTokenWithCall<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => WritableSelectorToken<T>);
+type WritableSelectorFamilyTokenWithCall<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): WritableSelectorToken<T>;
+};
 type WritableSelectorFamily<T, K extends Json.Serializable> = WritableSelectorFamilyToken<T, K> & {
     (key: K): WritableSelectorToken<T>;
-    subject: Subject<WritableSelectorToken<T>>;
+    subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
     install: (store: Store) => void;
 };
 type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
@@ -139,11 +179,14 @@ type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
     __T?: T;
     __K?: K;
 };
-type ReadonlySelectorFamilyTokenWithCall<T, K extends Json.Serializable> = ReadonlySelectorFamilyToken<T, K> & /** @deprecated Prefer the `findState`, `findInStore`, or `find` functions. */ ((key: K) => ReadonlySelectorToken<T>);
+type ReadonlySelectorFamilyTokenWithCall<T, K extends Json.Serializable> = ReadonlySelectorFamilyToken<T, K> & {
+    /** @deprecated In ephemeral stores, prefer the `findState`, `findInStore`, or `find` functions. In immortal stores, prefer the `seekState`, `seekInStore`, or `seek` functions. */
+    (key: K): ReadonlySelectorToken<T>;
+};
 type ReadonlySelectorFamily<T, K extends Json.Serializable> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
-    subject: Subject<ReadonlySelectorToken<T>>;
+    subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
     install: (store: Store) => void;
     __T?: T;
     __K?: K;
@@ -153,14 +196,7 @@ type SelectorFamilyToken<T, K extends Json.Serializable> = ReadonlySelectorFamil
 declare function selectorFamily<T, K extends Json.Serializable>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyTokenWithCall<T, K>;
 declare function selectorFamily<T, K extends Json.Serializable>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyTokenWithCall<T, K>;
 
-declare function disposeState(token: ReadableToken<any>, store?: Internal.Store): void;
-
-declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken$1<T, J, K>, key: Key): MutableAtomToken$1<T, J>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken$1<T, K>, key: Key): RegularAtomToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken$1<T, K>, key: Key): WritableSelectorToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken$1<T, K>, key: Key): ReadonlySelectorToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken$1<T, K>, key: Key): WritableToken$1<T>;
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken$1<T, K>, key: Key): ReadableToken$1<T>;
+declare function disposeState(token: MoleculeToken<any, any, any> | ReadableToken<any>): void;
 
 declare function getState<T>(token: ReadableToken<T>): T;
 
@@ -250,17 +286,18 @@ declare class Silo {
     subscribe: typeof subscribe;
     undo: typeof undo;
     redo: typeof redo;
-    constructor(name: string, fromStore?: Store | null);
+    constructor(config: Store[`config`], fromStore?: Store | null);
 }
 
 type StateUpdate<T> = {
     newValue: T;
     oldValue: T;
 };
-type KeyedStateUpdate<T> = StateUpdate<T> & {
+type KeyedStateUpdate<T> = Flat<StateUpdate<T> & {
     key: string;
+    type: `atom_update` | `selector_update`;
     family?: FamilyMetadata;
-};
+}>;
 type UpdateHandler<T> = (update: StateUpdate<T>) => void;
 type TransactionUpdateHandler<F extends Func> = (data: TransactionUpdate<F>) => void;
 declare function subscribe<T>(token: ReadableToken<T>, handleUpdate: UpdateHandler<T>, key?: string, store?: Store): () => void;
@@ -268,6 +305,7 @@ declare function subscribe<F extends Func>(token: TransactionToken<F>, handleUpd
 declare function subscribe<M extends TimelineManageable>(token: TimelineToken<M>, handleUpdate: (update: TimelineUpdate<M> | `redo` | `undo`) => void, key?: string, store?: Store): () => void;
 
 type TimelineManageable = AtomFamilyToken<any, any> | AtomToken<any>;
+type AtomOnly<M extends TimelineManageable> = M extends AtomFamilyToken<any, any> ? AtomToken<any> : M extends AtomToken<any> ? M : never;
 type TimelineToken<M> = {
     key: string;
     type: `timeline`;
@@ -275,10 +313,10 @@ type TimelineToken<M> = {
 };
 type TimelineOptions<ManagedAtom extends TimelineManageable> = {
     key: string;
-    atoms: ManagedAtom[];
+    scope: (ManagedAtom | MoleculeFamilyToken<any, any, any>)[];
     shouldCapture?: (update: TimelineUpdate<ManagedAtom>, timeline: Timeline<TimelineManageable>) => boolean;
 };
-type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineSelectorUpdate<ManagedAtom> | TimelineTransactionUpdate;
+type TimelineUpdate<ManagedAtom extends TimelineManageable> = TimelineAtomUpdate<ManagedAtom> | TimelineMoleculeCreation<any> | TimelineMoleculeDisposal<any> | TimelineSelectorUpdate<ManagedAtom> | TimelineStateCreation<AtomOnly<ManagedAtom>> | TimelineStateDisposal<AtomOnly<ManagedAtom>> | TimelineTransactionUpdate;
 declare const timeline: <ManagedAtom extends TimelineManageable>(options: TimelineOptions<ManagedAtom>) => TimelineToken<ManagedAtom>;
 declare const redo: (tl: TimelineToken<any>) => void;
 declare const undo: (tl: TimelineToken<any>) => void;
@@ -298,6 +336,11 @@ declare function belongsTo<Family extends WritableFamilyToken$1<any, any>>(famil
 declare function belongsTo<Family extends ReadableFamilyToken$1<any, any>>(family: Family, unknownToken: ReadableToken$1<any>): unknownToken is ReadableToken$1<TokenType<Family>>;
 
 type Func = (...parameters: any[]) => any;
+type Flat<R extends {
+    [K in PropertyKey]: any;
+}> = {
+    [K in keyof R]: R[K];
+};
 type RegularAtomToken<T> = {
     key: string;
     type: `atom`;
@@ -336,4 +379,4 @@ type FamilyMetadata = {
     subKey: string;
 };
 
-export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomToken, type Effectors, type FamilyMetadata, type Func, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type ReadonlyTransactors, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, Silo, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type Transactors, type TransactorsWithRunAndEnv, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, findState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type Effectors, type FamilyMetadata, type Flat, type Func, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeCreation, type MoleculeDisposal, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomFamilyTokenWithCall, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorFamilyTokenWithCall, type ReadonlySelectorOptions, type ReadonlySelectorToken, type ReadonlyTransactors, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, Silo, type StateCreation, type StateDisposal, type StateUpdate, type TimelineManageable, type TimelineOptions, type TimelineToken, type TimelineUpdate, type TokenDenomination, type TokenType, type Transact, type TransactionIO, type TransactionOptions, type TransactionToken, type TransactionUpdate, type TransactionUpdateContent, type TransactionUpdateHandler, type Transactors, type TransactorsWithRunAndEnv, type UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorFamilyTokenWithCall, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/dist/index.js

@@ -1,7 +1,7 @@
 export { getState } from './chunk-PNIHPILQ.js';
 import './chunk-F2X4B4VY.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';
+import { createStandaloneAtom, IMPLICIT, createAtomFamily, createStandaloneSelector, createSelectorFamily, Store, createTransaction, createTimeline, findInStore, getFromStore, setIntoStore, timeTravel, subscribeToTimeline, subscribeToTransaction, subscribeToState, arbitrary, actUponStore } from 'atom.io/internal';
 
 function atom(options) {
   return createStandaloneAtom(options, IMPLICIT.STORE);
@@ -9,21 +9,8 @@ function atom(options) {
 function atomFamily(options) {
   return createAtomFamily(options, IMPLICIT.STORE);
 }
-function disposeState(token, store = Internal.IMPLICIT.STORE) {
-  switch (token.type) {
-    case `atom`:
-    case `mutable_atom`:
-      Internal.disposeAtom(token, store);
-      break;
-    case `selector`:
-    case `readonly_selector`:
-      Internal.disposeSelector(token, store);
-      break;
-  }
-}
-function findState(token, key) {
-  const state = findInStore(token, key, IMPLICIT.STORE);
-  return state;
+function disposeState(token) {
+  Internal.disposeFromStore(token, Internal.IMPLICIT.STORE);
 }
 
 // src/logger.ts
@@ -74,8 +61,8 @@ function setState(token, value) {
   Internal.setIntoStore(token, value, Internal.IMPLICIT.STORE);
 }
 var Silo = class {
-  constructor(name, fromStore = null) {
-    const s = new Store(name, fromStore);
+  constructor(config, fromStore = null) {
+    const s = new Store(config, fromStore);
     function _atom(options) {
       return createStandaloneAtom(options, s);
     }
@@ -141,4 +128,4 @@ function belongsTo(family, unknownToken) {
   return family.key === ((_a = unknownToken.family) == null ? void 0 : _a.key);
 }
 
-export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, findState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { AtomIOLogger, LOG_LEVELS, Silo, atom, atomFamily, belongsTo, disposeState, isToken, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };

package/ephemeral/dist/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var internal = require('atom.io/internal');
+
+// ephemeral/src/find-state.ts
+function findState(token, key) {
+  const state = internal.findInStore(token, key, internal.IMPLICIT.STORE);
+  return state;
+}
+
+exports.findState = findState;

package/ephemeral/dist/index.js

@@ -0,0 +1,9 @@
+import '../../dist/chunk-F2X4B4VY.js';
+import { findInStore, IMPLICIT } from 'atom.io/internal';
+
+function findState(token, key) {
+  const state = findInStore(token, key, IMPLICIT.STORE);
+  return state;
+}
+
+export { findState };

package/ephemeral/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "atom.io-ephemeral",
+	"type": "module",
+	"private": true,
+	"main": "dist/index.cjs",
+	"module": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"browser": "./dist/index.js",
+			"require": "./dist/index.cjs",
+			"types": "./dist/index.d.ts"
+		}
+	}
+}

package/ephemeral/src/index.ts

@@ -0,0 +1 @@
+export * from "./find-state"

package/eslint-plugin/dist/index.cjs

@@ -14,6 +14,7 @@ var __export = (target, all) => {
 var rules_exports = {};
 __export(rules_exports, {
   explicitStateTypes: () => explicitStateTypes,
+  lifespan: () => lifespan,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
 var createRule = utils.ESLintUtils.RuleCreator(
@@ -66,7 +67,7 @@ var explicitStateTypes = createRule({
   }
 });
 
-// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
+// eslint-plugin/src/walk.ts
 function walk(node, callback, depth = 0) {
   callback(node, depth);
   switch (node.type) {
@@ -125,8 +126,161 @@ function walk(node, callback, depth = 0) {
       walk(node.object, callback, depth);
       walk(node.property, callback, depth);
       break;
+    case `CallExpression`:
+      walk(node.callee, callback, depth);
+      for (const argument of node.arguments) {
+        walk(argument, callback, depth);
+      }
+      break;
   }
 }
+
+// eslint-plugin/src/rules/lifespan.ts
+var lifespan = {
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
+      category: `Possible Errors`,
+      recommended: false,
+      url: ``
+      // URL to documentation page for this rule
+    },
+    schema: [
+      {
+        type: `string`,
+        enum: [`ephemeral`, `immortal`],
+        default: `ephemeral`
+      }
+    ]
+  },
+  create(context) {
+    var _a;
+    const storeLifespan = (_a = context.options[0]) != null ? _a : `ephemeral`;
+    return {
+      ImportDeclaration(node) {
+        const importSource = node.source.value;
+        if (!importSource.startsWith(`atom.io/`)) {
+          return;
+        }
+        const [_, subPackageName] = importSource.split(`/`);
+        if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
+          context.report({
+            node,
+            message: `do not import from "${importSource}" in an ${storeLifespan} store`
+          });
+        }
+      },
+      CallExpression(node) {
+        if (storeLifespan === `ephemeral`) {
+          return;
+        }
+        const functionCallee = node.callee.type === `Identifier` ? node.callee : void 0;
+        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
+        const callee = functionCallee != null ? functionCallee : methodCallee;
+        if (callee === void 0) {
+          return;
+        }
+        if (callee.name === `findState`) {
+          context.report({
+            node,
+            message: `do not use findState in an ${storeLifespan} store`
+          });
+        }
+        const storeProcedures = [];
+        if (callee.name === `selector` || callee.name === `selectorFamily` || callee.name === `transaction`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const argProperties = node.arguments[0].properties;
+            switch (callee.name) {
+              case `selector`:
+              case `selectorFamily`:
+                {
+                  const getAndSetProps = argProperties.filter(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && (prop.key.name === `get` || prop.key.name === `set`);
+                    }
+                  );
+                  switch (callee.name) {
+                    case `selector`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
+                            storeProcedures.push(prop.value);
+                          }
+                        }
+                      }
+                      break;
+                    case `selectorFamily`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          const { value } = prop;
+                          if (value.type === `FunctionExpression` || value.type === `ArrowFunctionExpression`) {
+                            if (value.body.type === `BlockStatement`) {
+                              for (const statement of value.body.body) {
+                                if (statement.type === `ReturnStatement` && statement.argument && (statement.argument.type === `FunctionExpression` || statement.argument.type === `ArrowFunctionExpression`)) {
+                                  storeProcedures.push(statement.argument);
+                                }
+                              }
+                            } else if (value.body.type === `FunctionExpression` || value.body.type === `ArrowFunctionExpression`) {
+                              storeProcedures.push(value.body);
+                            }
+                          }
+                        }
+                      }
+                      break;
+                  }
+                }
+                break;
+              case `transaction`:
+                {
+                  const doProp = argProperties.find(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && prop.key.name === `do`;
+                    }
+                  );
+                  if (doProp) {
+                    if (doProp.value.type === `FunctionExpression` || doProp.value.type === `ArrowFunctionExpression`) {
+                      storeProcedures.push(doProp.value);
+                    }
+                  }
+                }
+                break;
+            }
+          }
+        }
+        for (const storeProcedure of storeProcedures) {
+          const transactorsParam = storeProcedure.params[0];
+          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : void 0;
+          walk(storeProcedure.body, (n) => {
+            if (n.type === `CallExpression`) {
+              let willReport = false;
+              switch (n.callee.type) {
+                case `MemberExpression`:
+                  if (n.callee.object.type === `Identifier` && n.callee.object.name === nonDestructuredTransactorsName && n.callee.property.type === `Identifier` && n.callee.property.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+                case `Identifier`:
+                  if (n.callee.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+              }
+              if (willReport) {
+                context.report({
+                  node: n,
+                  message: `Using find in a transactor is not allowed in an immortal store.`
+                });
+              }
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 var synchronousSelectorDependencies = {
   meta: {
     type: `problem`,

package/eslint-plugin/dist/index.js

@@ -5,6 +5,7 @@ import { ESLintUtils } from '@typescript-eslint/utils';
 var rules_exports = {};
 __export(rules_exports, {
   explicitStateTypes: () => explicitStateTypes,
+  lifespan: () => lifespan,
   synchronousSelectorDependencies: () => synchronousSelectorDependencies
 });
 var createRule = ESLintUtils.RuleCreator(
@@ -57,7 +58,7 @@ var explicitStateTypes = createRule({
   }
 });
 
-// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
+// eslint-plugin/src/walk.ts
 function walk(node, callback, depth = 0) {
   callback(node, depth);
   switch (node.type) {
@@ -116,8 +117,161 @@ function walk(node, callback, depth = 0) {
       walk(node.object, callback, depth);
       walk(node.property, callback, depth);
       break;
+    case `CallExpression`:
+      walk(node.callee, callback, depth);
+      for (const argument of node.arguments) {
+        walk(argument, callback, depth);
+      }
+      break;
   }
 }
+
+// eslint-plugin/src/rules/lifespan.ts
+var lifespan = {
+  meta: {
+    type: `problem`,
+    docs: {
+      description: `atom.io provides tools for short-lived (ephemeral) and long-lived (immortal) stores. This rule allows you to guard against unsafe usage of tools for the other type of store.`,
+      category: `Possible Errors`,
+      recommended: false,
+      url: ``
+      // URL to documentation page for this rule
+    },
+    schema: [
+      {
+        type: `string`,
+        enum: [`ephemeral`, `immortal`],
+        default: `ephemeral`
+      }
+    ]
+  },
+  create(context) {
+    var _a;
+    const storeLifespan = (_a = context.options[0]) != null ? _a : `ephemeral`;
+    return {
+      ImportDeclaration(node) {
+        const importSource = node.source.value;
+        if (!importSource.startsWith(`atom.io/`)) {
+          return;
+        }
+        const [_, subPackageName] = importSource.split(`/`);
+        if (storeLifespan === `immortal` && subPackageName === `ephemeral`) {
+          context.report({
+            node,
+            message: `do not import from "${importSource}" in an ${storeLifespan} store`
+          });
+        }
+      },
+      CallExpression(node) {
+        if (storeLifespan === `ephemeral`) {
+          return;
+        }
+        const functionCallee = node.callee.type === `Identifier` ? node.callee : void 0;
+        const methodCallee = node.callee.type === `MemberExpression` && node.callee.property.type === `Identifier` ? node.callee.property : void 0;
+        const callee = functionCallee != null ? functionCallee : methodCallee;
+        if (callee === void 0) {
+          return;
+        }
+        if (callee.name === `findState`) {
+          context.report({
+            node,
+            message: `do not use findState in an ${storeLifespan} store`
+          });
+        }
+        const storeProcedures = [];
+        if (callee.name === `selector` || callee.name === `selectorFamily` || callee.name === `transaction`) {
+          if (node.arguments[0].type === `ObjectExpression`) {
+            const argProperties = node.arguments[0].properties;
+            switch (callee.name) {
+              case `selector`:
+              case `selectorFamily`:
+                {
+                  const getAndSetProps = argProperties.filter(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && (prop.key.name === `get` || prop.key.name === `set`);
+                    }
+                  );
+                  switch (callee.name) {
+                    case `selector`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          if (prop.value.type === `FunctionExpression` || prop.value.type === `ArrowFunctionExpression`) {
+                            storeProcedures.push(prop.value);
+                          }
+                        }
+                      }
+                      break;
+                    case `selectorFamily`:
+                      {
+                        for (const prop of getAndSetProps) {
+                          const { value } = prop;
+                          if (value.type === `FunctionExpression` || value.type === `ArrowFunctionExpression`) {
+                            if (value.body.type === `BlockStatement`) {
+                              for (const statement of value.body.body) {
+                                if (statement.type === `ReturnStatement` && statement.argument && (statement.argument.type === `FunctionExpression` || statement.argument.type === `ArrowFunctionExpression`)) {
+                                  storeProcedures.push(statement.argument);
+                                }
+                              }
+                            } else if (value.body.type === `FunctionExpression` || value.body.type === `ArrowFunctionExpression`) {
+                              storeProcedures.push(value.body);
+                            }
+                          }
+                        }
+                      }
+                      break;
+                  }
+                }
+                break;
+              case `transaction`:
+                {
+                  const doProp = argProperties.find(
+                    (prop) => {
+                      return `key` in prop && `name` in prop.key && prop.key.name === `do`;
+                    }
+                  );
+                  if (doProp) {
+                    if (doProp.value.type === `FunctionExpression` || doProp.value.type === `ArrowFunctionExpression`) {
+                      storeProcedures.push(doProp.value);
+                    }
+                  }
+                }
+                break;
+            }
+          }
+        }
+        for (const storeProcedure of storeProcedures) {
+          const transactorsParam = storeProcedure.params[0];
+          const nonDestructuredTransactorsName = transactorsParam && `name` in transactorsParam ? transactorsParam.name : void 0;
+          walk(storeProcedure.body, (n) => {
+            if (n.type === `CallExpression`) {
+              let willReport = false;
+              switch (n.callee.type) {
+                case `MemberExpression`:
+                  if (n.callee.object.type === `Identifier` && n.callee.object.name === nonDestructuredTransactorsName && n.callee.property.type === `Identifier` && n.callee.property.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+                case `Identifier`:
+                  if (n.callee.name === `find`) {
+                    willReport = true;
+                  }
+                  break;
+              }
+              if (willReport) {
+                context.report({
+                  node: n,
+                  message: `Using find in a transactor is not allowed in an immortal store.`
+                });
+              }
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
+// eslint-plugin/src/rules/synchronous-selector-dependencies.ts
 var synchronousSelectorDependencies = {
   meta: {
     type: `problem`,