atom.io 0.23.5 → 0.24.0

package/immortal/dist/index.cjs

@@ -1,272 +1,14 @@
 'use strict';
 
-var Internal = require('atom.io/internal');
-var json = require('atom.io/json');
-var data = require('atom.io/data');
+var internal = require('atom.io/internal');
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var Internal__namespace = /*#__PURE__*/_interopNamespace(Internal);
-
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var Molecule = class _Molecule {
-  constructor(store, above, token) {
-    this.store = store;
-    this.token = token;
-    this.type = `molecule`;
-    this.below = [];
-    this.tokens = [];
-    this.joins = [];
-    this.subject = new Internal.Subject();
-    this.dispose = this[Symbol.dispose];
-    if (above) {
-      if (Array.isArray(above)) {
-        this.above = above;
-        for (const parent of above) {
-          parent.below.push(this);
-        }
-      } else {
-        this.above = [above];
-        above.below.push(this);
-      }
-    } else {
-      this.above = [];
-    }
-  }
-  get key() {
-    return this.token.key;
-  }
-  bond(token) {
-    const state = Internal.initFamilyMember(token, this.token.key, this.store);
-    if (token.type === `mutable_atom_family`) {
-      const jsonFamily = Internal.getJsonFamily(token, this.store);
-      const jsonState = Internal.initFamilyMember(jsonFamily, this.token.key, this.store);
-      this.tokens.push(jsonState);
-    }
-    this.tokens.push(state);
-    this.subject.next({ type: `state_creation`, token: state });
-    return state;
-  }
-  spawn(key) {
-    const child = new _Molecule(this.store, this, { key, type: `molecule` });
-    return child;
-  }
-  with(molecule) {
-    return (key) => {
-      const child = new _Molecule(this.store, [this, molecule], {
-        key,
-        type: `molecule`
-      });
-      return child;
-    };
-  }
-  detach(child) {
-    const childIndex = this.below.indexOf(child);
-    if (childIndex !== -1) {
-      this.below.splice(childIndex, 1);
-    }
-    const parentIndex = child.above.indexOf(this);
-    if (parentIndex !== -1) {
-      child.above.splice(parentIndex, 1);
-    }
-  }
-  claim(child) {
-    if (child === this) {
-      return;
-    }
-    for (const parent of child.above) {
-      parent.detach(child);
-    }
-    this.below.push(child);
-    child.above.push(this);
-  }
-  clear() {
-    var _a;
-    while (this.below.length > 0) {
-      (_a = this.below.pop()) == null ? void 0 : _a.dispose();
-    }
-    while (this.tokens.length > 0) {
-      const token = this.tokens.pop();
-      if (token) {
-        Internal.disposeFromStore(token, this.store);
-      }
-    }
-    while (this.joins.length > 0) {
-      const join = this.joins.pop();
-      if (join) {
-        join.molecules.delete(json.stringifyJson(this.token.key));
-      }
-    }
-  }
-  join(token) {
-    const join = data.getJoin(token, this.store);
-    join.molecules.set(json.stringifyJson(this.token.key), this);
-    this.joins.push(join);
-  }
-  [Symbol.dispose]() {
-    this.clear();
-    const target = Internal.newest(this.store);
-    target.molecules.delete(json.stringifyJson(this.token.key));
-    for (const parent of this.above) {
-      parent.detach(this);
-    }
-  }
-};
-
-// immortal/src/make-molecule.ts
-function createMoleculeFamily(options, store) {
-  const subject = new Internal__namespace.Subject();
-  const token = {
-    key: options.key,
-    type: `molecule_family`
-  };
-  const family = Object.assign(options.new(store), __spreadProps(__spreadValues({}, token), { subject }));
-  store.moleculeFamilies.set(options.key, family);
-  return token;
-}
-function moleculeFamily(options) {
-  return createMoleculeFamily(options, Internal__namespace.IMPLICIT.STORE);
-}
-function makeMoleculeInStore(store, context, family, key, ...params) {
-  const target = Internal__namespace.newest(store);
-  const token = {
-    type: `molecule`,
-    key,
-    family
-  };
-  const contextArray = Array.isArray(context) ? context : [context];
-  const owners = contextArray.map((ctx) => {
-    if (ctx instanceof Molecule) {
-      return ctx;
-    }
-    const stringKey = json.stringifyJson(ctx.key);
-    const molecule2 = store.molecules.get(stringKey);
-    if (!molecule2) {
-      throw new Error(
-        `Molecule ${stringKey} not found in store "${store.config.name}"`
-      );
-    }
-    return molecule2;
-  });
-  const Formula = Internal__namespace.withdraw(family, store);
-  const molecule = new Formula(owners, token, ...params);
-  target.molecules.set(json.stringifyJson(key), molecule);
-  const update = {
-    type: `molecule_creation`,
-    token,
-    family,
-    context: contextArray,
-    params
-  };
-  const isTransaction = Internal__namespace.isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(update);
-  } else {
-    Formula.subject.next(update);
-  }
-  return token;
-}
-function makeMolecule(context, family, key, ...params) {
-  return makeMoleculeInStore(
-    Internal__namespace.IMPLICIT.STORE,
-    context,
-    family,
-    key,
-    ...params
-  );
-}
-function useMoleculeFromStore(token, store) {
-  const molecule = store.molecules.get(json.stringifyJson(token.key));
-  return molecule;
-}
-function useMolecule(token) {
-  return useMoleculeFromStore(token, Internal__namespace.IMPLICIT.STORE);
-}
-function disposeMolecule(token, store) {
-  const mole = useMoleculeFromStore(token, store);
-  if (!mole || !token.family) {
-    return;
-  }
-  const { family } = token;
-  const Formula = Internal__namespace.withdraw(family, store);
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    token,
-    family,
-    context: mole.above,
-    familyKeys: mole.tokens.map((t) => {
-      var _a;
-      return (_a = t.family) == null ? void 0 : _a.key;
-    }).filter((k) => typeof k === `string`)
-  };
-  if (token.family) {
-    disposalEvent.family = token.family;
-  }
-  const isTransaction = Internal__namespace.isChildStore(store) && store.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    store.transactionMeta.update.updates.push(disposalEvent);
-  } else {
-    Formula.subject.next(disposalEvent);
-  }
-  mole.dispose();
-}
-function makeRootMolecule(key, store = Internal__namespace.IMPLICIT.STORE) {
-  const molecule = new Molecule(store, void 0, { key, type: `molecule` });
-  store.molecules.set(json.stringifyJson(key), molecule);
-  return {
-    key,
-    type: `molecule`
-  };
-}
+// immortal/src/seek-state.ts
 function seekState(token, key) {
   if (token.type === `molecule_family`) {
-    return Internal.seekInStore(token, key, Internal.IMPLICIT.STORE);
+    return internal.seekInStore(token, key, internal.IMPLICIT.STORE);
   }
-  const state = Internal.seekInStore(token, key, Internal.IMPLICIT.STORE);
+  const state = internal.seekInStore(token, key, internal.IMPLICIT.STORE);
   return state;
 }
 
-exports.Molecule = Molecule;
-exports.createMoleculeFamily = createMoleculeFamily;
-exports.disposeMolecule = disposeMolecule;
-exports.makeMolecule = makeMolecule;
-exports.makeMoleculeInStore = makeMoleculeInStore;
-exports.makeRootMolecule = makeRootMolecule;
-exports.moleculeFamily = moleculeFamily;
 exports.seekState = seekState;
-exports.useMolecule = useMolecule;
-exports.useMoleculeFromStore = useMoleculeFromStore;

package/immortal/dist/index.d.ts

@@ -1,94 +1,6 @@
-import { ReadableToken, StateCreation, StateDisposal, MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, Flat, MoleculeCreation, MoleculeDisposal } from 'atom.io';
-import * as Internal from 'atom.io/internal';
-import { Store, Subject, Transceiver } from 'atom.io/internal';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, MoleculeToken } from 'atom.io';
+import { Transceiver } from 'atom.io/internal';
 import { Json } from 'atom.io/json';
-import { Join, JoinToken } from 'atom.io/data';
-
-declare class Molecule<Key extends Json.Serializable> {
-    readonly store: Store;
-    readonly token: MoleculeToken<Key, any, any>;
-    readonly type = "molecule";
-    get key(): Key;
-    readonly family?: MoleculeFamilyToken<Key, any, any>;
-    readonly above: Molecule<any>[];
-    readonly below: Molecule<any>[];
-    readonly tokens: ReadableToken<any>[];
-    readonly joins: Join<any, any, any, any>[];
-    readonly subject: Subject<StateCreation<any> | StateDisposal<any>>;
-    constructor(store: Store, above: Molecule<any> | Molecule<any>[] | undefined, token: MoleculeToken<Key, any, any>);
-    bond<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(token: MutableAtomFamilyToken<T, J, K>): MutableAtomToken<T, J>;
-    bond<T, K extends Key>(token: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>;
-    bond<T, K extends Json.Serializable>(token: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>;
-    bond<T, K extends Json.Serializable>(token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>;
-    bond<T, K extends Json.Serializable>(token: WritableFamilyToken<T, K>): WritableToken<T>;
-    bond<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>): ReadableToken<T>;
-    spawn<K extends Json.Serializable>(key: K): Molecule<K>;
-    with(molecule: Molecule<any>): (key: string) => Molecule<any>;
-    detach(child: Molecule<any>): void;
-    claim(child: Molecule<any>): void;
-    clear(): void;
-    join(token: JoinToken<any, any, any, any>): void;
-    protected [Symbol.dispose](): void;
-    dispose: () => void;
-}
-
-type MoleculeConstructor<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]> = new (context: Molecule<any>[], token: MoleculeToken<Key, Struct, Params>, ...params: Params) => Molecule<Key> & Struct;
-type MoleculeFamilyToken<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]> = {
-    key: string;
-    type: `molecule_family`;
-    __K?: Key;
-    __S?: Struct;
-    __P?: Params;
-};
-type MoleculeFamily<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]> = Flat<MoleculeFamilyToken<Key, Struct, Params> & {
-    subject: Internal.Subject<MoleculeCreation<Key> | MoleculeDisposal<Key>>;
-}> & MoleculeConstructor<Key, Struct, Params>;
-type MoleculeToken<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]> = {
-    key: Key;
-    type: `molecule`;
-    family?: MoleculeFamilyToken<Key, Struct, Params>;
-    __S?: Struct;
-    __P?: Params;
-};
-type MoleculeFamilyOptions<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]> = {
-    key: string;
-    new: (store: Internal.Store) => MoleculeConstructor<Key, Struct, Params>;
-};
-declare function createMoleculeFamily<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(options: MoleculeFamilyOptions<Key, Struct, Params>, store: Internal.Store): MoleculeFamilyToken<Key, Struct, Params>;
-declare function moleculeFamily<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(options: MoleculeFamilyOptions<Key, Struct, Params>): MoleculeFamilyToken<Key, Struct, Params>;
-declare function makeMoleculeInStore<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(store: Internal.Store, context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[], family: MoleculeFamilyToken<Key, Struct, Params>, key: Key, ...params: Params): MoleculeToken<Key, Struct, Params>;
-declare function makeMolecule<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(context: MoleculeToken<any, any, any> | MoleculeToken<any, any, any>[], family: MoleculeFamilyToken<Key, Struct, Params>, key: Key, ...params: Params): MoleculeToken<Key, Struct, Params>;
-declare function useMoleculeFromStore<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): (Molecule<Key> & Struct) | undefined;
-declare function useMolecule<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>): (Molecule<Key> & Struct) | undefined;
-declare function disposeMolecule<Key extends Json.Serializable, Struct extends {
-    [key: string]: any;
-}, Params extends any[]>(token: MoleculeToken<Key, Struct, Params>, store: Internal.Store): void;
-type MoleculeType<M extends MoleculeFamilyToken<any, any, any>> = M extends MoleculeFamilyToken<any, infer T, any> ? T : never;
-declare function makeRootMolecule(key: Json.Serializable, store?: Internal.Store): MoleculeToken<Json.Serializable, {
-    [key: string]: unknown;
-}, []>;
 
 declare function seekState<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
 declare function seekState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
@@ -96,8 +8,6 @@ declare function seekState<T, K extends Json.Serializable, Key extends K>(token:
 declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
 declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
 declare function seekState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
-declare function seekState<K extends Json.Serializable, S extends {
-    [key: string]: any;
-}>(token: MoleculeFamilyToken<K, S, any[]>, key: K): MoleculeToken<K, S, any[]> | undefined;
+declare function seekState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeToken<M> | undefined;
 
-export { Molecule, type MoleculeConstructor, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeToken, type MoleculeType, createMoleculeFamily, disposeMolecule, makeMolecule, makeMoleculeInStore, makeRootMolecule, moleculeFamily, seekState, useMolecule, useMoleculeFromStore };
+export { seekState };

package/immortal/dist/index.js

@@ -1,218 +1,6 @@
-import { __spreadProps, __spreadValues } from '../../dist/chunk-F2X4B4VY.js';
-import * as Internal from 'atom.io/internal';
-import { Subject, initFamilyMember, getJsonFamily, disposeFromStore, newest, seekInStore, IMPLICIT } from 'atom.io/internal';
-import { stringifyJson } from 'atom.io/json';
-import { getJoin } from 'atom.io/data';
+import '../../dist/chunk-F2X4B4VY.js';
+import { seekInStore, IMPLICIT } from 'atom.io/internal';
 
-var Molecule = class _Molecule {
-  constructor(store, above, token) {
-    this.store = store;
-    this.token = token;
-    this.type = `molecule`;
-    this.below = [];
-    this.tokens = [];
-    this.joins = [];
-    this.subject = new Subject();
-    this.dispose = this[Symbol.dispose];
-    if (above) {
-      if (Array.isArray(above)) {
-        this.above = above;
-        for (const parent of above) {
-          parent.below.push(this);
-        }
-      } else {
-        this.above = [above];
-        above.below.push(this);
-      }
-    } else {
-      this.above = [];
-    }
-  }
-  get key() {
-    return this.token.key;
-  }
-  bond(token) {
-    const state = initFamilyMember(token, this.token.key, this.store);
-    if (token.type === `mutable_atom_family`) {
-      const jsonFamily = getJsonFamily(token, this.store);
-      const jsonState = initFamilyMember(jsonFamily, this.token.key, this.store);
-      this.tokens.push(jsonState);
-    }
-    this.tokens.push(state);
-    this.subject.next({ type: `state_creation`, token: state });
-    return state;
-  }
-  spawn(key) {
-    const child = new _Molecule(this.store, this, { key, type: `molecule` });
-    return child;
-  }
-  with(molecule) {
-    return (key) => {
-      const child = new _Molecule(this.store, [this, molecule], {
-        key,
-        type: `molecule`
-      });
-      return child;
-    };
-  }
-  detach(child) {
-    const childIndex = this.below.indexOf(child);
-    if (childIndex !== -1) {
-      this.below.splice(childIndex, 1);
-    }
-    const parentIndex = child.above.indexOf(this);
-    if (parentIndex !== -1) {
-      child.above.splice(parentIndex, 1);
-    }
-  }
-  claim(child) {
-    if (child === this) {
-      return;
-    }
-    for (const parent of child.above) {
-      parent.detach(child);
-    }
-    this.below.push(child);
-    child.above.push(this);
-  }
-  clear() {
-    var _a;
-    while (this.below.length > 0) {
-      (_a = this.below.pop()) == null ? void 0 : _a.dispose();
-    }
-    while (this.tokens.length > 0) {
-      const token = this.tokens.pop();
-      if (token) {
-        disposeFromStore(token, this.store);
-      }
-    }
-    while (this.joins.length > 0) {
-      const join = this.joins.pop();
-      if (join) {
-        join.molecules.delete(stringifyJson(this.token.key));
-      }
-    }
-  }
-  join(token) {
-    const join = getJoin(token, this.store);
-    join.molecules.set(stringifyJson(this.token.key), this);
-    this.joins.push(join);
-  }
-  [Symbol.dispose]() {
-    this.clear();
-    const target = newest(this.store);
-    target.molecules.delete(stringifyJson(this.token.key));
-    for (const parent of this.above) {
-      parent.detach(this);
-    }
-  }
-};
-
-// immortal/src/make-molecule.ts
-function createMoleculeFamily(options, store) {
-  const subject = new Internal.Subject();
-  const token = {
-    key: options.key,
-    type: `molecule_family`
-  };
-  const family = Object.assign(options.new(store), __spreadProps(__spreadValues({}, token), { subject }));
-  store.moleculeFamilies.set(options.key, family);
-  return token;
-}
-function moleculeFamily(options) {
-  return createMoleculeFamily(options, Internal.IMPLICIT.STORE);
-}
-function makeMoleculeInStore(store, context, family, key, ...params) {
-  const target = Internal.newest(store);
-  const token = {
-    type: `molecule`,
-    key,
-    family
-  };
-  const contextArray = Array.isArray(context) ? context : [context];
-  const owners = contextArray.map((ctx) => {
-    if (ctx instanceof Molecule) {
-      return ctx;
-    }
-    const stringKey = stringifyJson(ctx.key);
-    const molecule2 = store.molecules.get(stringKey);
-    if (!molecule2) {
-      throw new Error(
-        `Molecule ${stringKey} not found in store "${store.config.name}"`
-      );
-    }
-    return molecule2;
-  });
-  const Formula = Internal.withdraw(family, store);
-  const molecule = new Formula(owners, token, ...params);
-  target.molecules.set(stringifyJson(key), molecule);
-  const update = {
-    type: `molecule_creation`,
-    token,
-    family,
-    context: contextArray,
-    params
-  };
-  const isTransaction = Internal.isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(update);
-  } else {
-    Formula.subject.next(update);
-  }
-  return token;
-}
-function makeMolecule(context, family, key, ...params) {
-  return makeMoleculeInStore(
-    Internal.IMPLICIT.STORE,
-    context,
-    family,
-    key,
-    ...params
-  );
-}
-function useMoleculeFromStore(token, store) {
-  const molecule = store.molecules.get(stringifyJson(token.key));
-  return molecule;
-}
-function useMolecule(token) {
-  return useMoleculeFromStore(token, Internal.IMPLICIT.STORE);
-}
-function disposeMolecule(token, store) {
-  const mole = useMoleculeFromStore(token, store);
-  if (!mole || !token.family) {
-    return;
-  }
-  const { family } = token;
-  const Formula = Internal.withdraw(family, store);
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    token,
-    family,
-    context: mole.above,
-    familyKeys: mole.tokens.map((t) => {
-      var _a;
-      return (_a = t.family) == null ? void 0 : _a.key;
-    }).filter((k) => typeof k === `string`)
-  };
-  if (token.family) {
-    disposalEvent.family = token.family;
-  }
-  const isTransaction = Internal.isChildStore(store) && store.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    store.transactionMeta.update.updates.push(disposalEvent);
-  } else {
-    Formula.subject.next(disposalEvent);
-  }
-  mole.dispose();
-}
-function makeRootMolecule(key, store = Internal.IMPLICIT.STORE) {
-  const molecule = new Molecule(store, void 0, { key, type: `molecule` });
-  store.molecules.set(stringifyJson(key), molecule);
-  return {
-    key,
-    type: `molecule`
-  };
-}
 function seekState(token, key) {
   if (token.type === `molecule_family`) {
     return seekInStore(token, key, IMPLICIT.STORE);
@@ -221,4 +9,4 @@ function seekState(token, key) {
   return state;
 }
 
-export { Molecule, createMoleculeFamily, disposeMolecule, makeMolecule, makeMoleculeInStore, makeRootMolecule, moleculeFamily, seekState, useMolecule, useMoleculeFromStore };
+export { seekState };

package/immortal/src/index.ts

@@ -1,3 +1 @@
-export * from "./make-molecule"
-export * from "./molecule"
 export * from "./seek-state"

package/immortal/src/seek-state.ts

@@ -1,4 +1,8 @@
 import type {
+	MoleculeConstructor,
+	MoleculeFamilyToken,
+	MoleculeKey,
+	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -16,8 +20,6 @@ import type { Transceiver } from "atom.io/internal"
 import { IMPLICIT, seekInStore } from "atom.io/internal"
 import type { Json } from "atom.io/json"
 
-import type { MoleculeFamilyToken, MoleculeToken } from "./make-molecule"
-
 export function seekState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
@@ -53,18 +55,15 @@ export function seekState<T, K extends Json.Serializable, Key extends K>(
 	key: Key,
 ): ReadableToken<T> | undefined
 
-export function seekState<
-	K extends Json.Serializable,
-	S extends { [key: string]: any },
->(
-	token: MoleculeFamilyToken<K, S, any[]>,
-	key: K,
-): MoleculeToken<K, S, any[]> | undefined
+export function seekState<M extends MoleculeConstructor>(
+	token: MoleculeFamilyToken<M>,
+	key: MoleculeKey<M>,
+): MoleculeToken<M> | undefined
 
 export function seekState(
-	token: MoleculeFamilyToken<any, any, any> | ReadableFamilyToken<any, any>,
+	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
 	key: Json.Serializable,
-): MoleculeToken<any, any, any> | ReadableToken<any> | undefined {
+): MoleculeToken<any> | ReadableToken<any> | undefined {
 	if (token.type === `molecule_family`) {
 		return seekInStore(token, key, IMPLICIT.STORE)
 	}