atom.io 0.25.6 → 0.27.0

package/data/dist/index.d.ts

@@ -1,12 +1,12 @@
 import * as AtomIO from 'atom.io';
 import { ReadonlySelectorFamily, MutableAtomFamily, SetterToolkit, disposeState, ReadonlySelectorToken, MutableAtomFamilyToken } from 'atom.io';
 import { Store, Molecule } from 'atom.io/internal';
-import { Json, Stringified } from 'atom.io/json';
+import { Canonical, stringified, Json } from 'atom.io/json';
 import { findState } from 'atom.io/ephemeral';
 import { SetRTX, SetRTXJson } from 'atom.io/transceivers/set-rtx';
 
-declare function dict<State, Key extends Json.Serializable>(findState: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamily<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
-    [K in Stringified<Key>]: State;
+declare function dict<State, Key extends Canonical>(findState: AtomIO.ReadonlySelectorFamilyToken<State, Key> | AtomIO.RegularAtomFamilyToken<State, Key> | AtomIO.WritableSelectorFamily<State, Key>, index: AtomIO.ReadonlySelectorToken<Key[]> | AtomIO.RegularAtomToken<Key[]> | AtomIO.WritableSelectorToken<Key[]>, store?: Store): AtomIO.ReadonlySelectorToken<{
+    [K in stringified<Key>]: State;
 }>;
 
 type primitive = boolean | number | string | null;

package/data/dist/index.js

@@ -1,5 +1,5 @@
-import { Junction } from '../../dist/chunk-HYXKCFVY.js';
-import '../../dist/chunk-S4N6XNPH.js';
+import { Junction } from '../../dist/chunk-IBTHB2PI.js';
+import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, findInStore, IMPLICIT, getFromStore, setIntoStore, seekInStore, getJsonToken, disposeFromStore, withdraw, growMoleculeInStore, NotFoundError, initFamilyMemberInStore, createMutableAtomFamily, createRegularAtomFamily, createMoleculeFamily, newest, makeMoleculeInStore, isChildStore, createRegularAtom, createSelectorFamily, getJsonFamily } from 'atom.io/internal';
 import { stringifyJson } from 'atom.io/json';
 import { SetRTX } from 'atom.io/transceivers/set-rtx';
@@ -23,8 +23,37 @@ function capitalize(string) {
   return string[0].toUpperCase() + string.slice(1);
 }
 var Join = class _Join {
+  options;
+  defaultContent;
+  toolkit;
+  retrieve;
+  molecules = /* @__PURE__ */ new Map();
+  relations;
+  states;
+  core;
+  transact(toolkit, run) {
+    const originalToolkit = this.toolkit;
+    this.toolkit = toolkit;
+    run(this);
+    this.toolkit = originalToolkit;
+  }
+  store;
+  alternates;
+  [Symbol.dispose]() {
+    this.alternates.delete(this.store.config.name);
+  }
+  in(store) {
+    const key = store.config.name;
+    const alternate = this.alternates.get(key);
+    if (alternate) {
+      return alternate;
+    }
+    const join2 = new _Join(this.options, this.defaultContent, store);
+    this.alternates.set(key, join2);
+    join2.alternates = this.alternates;
+    return join2;
+  }
   constructor(options, defaultContent, store = IMPLICIT.STORE) {
-    this.molecules = /* @__PURE__ */ new Map();
     this.store = store;
     this.options = options;
     this.defaultContent = defaultContent;
@@ -424,26 +453,6 @@ var Join = class _Join {
       }
     }
   }
-  transact(toolkit, run) {
-    const originalToolkit = this.toolkit;
-    this.toolkit = toolkit;
-    run(this);
-    this.toolkit = originalToolkit;
-  }
-  [Symbol.dispose]() {
-    this.alternates.delete(this.store.config.name);
-  }
-  in(store) {
-    const key = store.config.name;
-    const alternate = this.alternates.get(key);
-    if (alternate) {
-      return alternate;
-    }
-    const join2 = new _Join(this.options, this.defaultContent, store);
-    this.alternates.set(key, join2);
-    join2.alternates = this.alternates;
-    return join2;
-  }
 };
 function join(options, defaultContent, store = IMPLICIT.STORE) {
   const joins = getJoinMap(store);
@@ -466,12 +475,11 @@ function getJoinMap(store) {
   return joins;
 }
 function getJoin(token, store) {
-  var _a;
   const joinMap = getJoinMap(store);
   let myJoin = joinMap.get(token.key);
   if (myJoin === void 0) {
     const rootJoinMap = getJoinMap(IMPLICIT.STORE);
-    myJoin = (_a = rootJoinMap.get(token.key)) == null ? void 0 : _a.in(store);
+    myJoin = rootJoinMap.get(token.key)?.in(store);
     if (myJoin === void 0) {
       throw new Error(
         `Join "${token.key}" not found in store "${store.config.name}"`

package/data/package.json

@@ -2,14 +2,11 @@
 	"name": "atom.io-data",
 	"type": "module",
 	"private": true,
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
+	"main": "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/data/src/dict.ts

@@ -5,9 +5,9 @@ import {
 	findInStore,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Json, Stringified } from "atom.io/json"
+import type { Canonical, stringified } from "atom.io/json"
 
-export function dict<State, Key extends Json.Serializable>(
+export function dict<State, Key extends Canonical>(
 	findState:
 		| AtomIO.ReadonlySelectorFamilyToken<State, Key>
 		| AtomIO.RegularAtomFamilyToken<State, Key>
@@ -17,7 +17,7 @@ export function dict<State, Key extends Json.Serializable>(
 		| AtomIO.RegularAtomToken<Key[]>
 		| AtomIO.WritableSelectorToken<Key[]>,
 	store: Store = IMPLICIT.STORE,
-): AtomIO.ReadonlySelectorToken<{ [K in Stringified<Key>]: State }> {
+): AtomIO.ReadonlySelectorToken<{ [K in stringified<Key>]: State }> {
 	return createStandaloneSelector(
 		{
 			key: `${findState.key}Dict`,

package/dist/chunk-AK23DRMD.js

@@ -0,0 +1,21 @@
+// ../anvl/src/json/index.ts
+var parseJson = (str) => JSON.parse(str);
+var stringifyJson = (json) => JSON.stringify(json);
+var JSON_TYPE_NAMES = [
+  `array`,
+  `boolean`,
+  `null`,
+  `number`,
+  `object`,
+  `string`
+];
+var JSON_DEFAULTS = {
+  array: [],
+  boolean: false,
+  null: null,
+  number: 0,
+  object: {},
+  string: ``
+};
+
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, parseJson, stringifyJson };

package/dist/{chunk-HYXKCFVY.js → chunk-IBTHB2PI.js}

@@ -1,56 +1,12 @@
 // ../rel8/junction/src/junction.ts
 var Junction = class {
-  constructor(data, config) {
-    this.relations = /* @__PURE__ */ new Map();
-    this.contents = /* @__PURE__ */ new Map();
-    this.makeContentKey = (a, b) => `${a}:${b}`;
-    var _a, _b, _c, _d;
-    this.a = data.between[0];
-    this.b = data.between[1];
-    this.cardinality = data.cardinality;
-    if (!(config == null ? void 0 : config.externalStore)) {
-      this.relations = new Map((_a = data.relations) == null ? void 0 : _a.map(([a, b]) => [a, new Set(b)]));
-      this.contents = new Map(data.contents);
-    }
-    this.isContent = (_b = config == null ? void 0 : config.isContent) != null ? _b : null;
-    if (config == null ? void 0 : config.makeContentKey) {
-      this.makeContentKey = config.makeContentKey;
-    }
-    if (config == null ? void 0 : config.externalStore) {
-      const externalStore = config.externalStore;
-      this.has = (a, b) => externalStore.has(a, b);
-      this.addRelation = (a, b) => {
-        externalStore.addRelation(a, b);
-      };
-      this.deleteRelation = (a, b) => {
-        externalStore.deleteRelation(a, b);
-      };
-      this.replaceRelationsSafely = (a, bs) => {
-        externalStore.replaceRelationsSafely(a, bs);
-      };
-      this.replaceRelationsUnsafely = (a, bs) => {
-        externalStore.replaceRelationsUnsafely(a, bs);
-      };
-      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
-      if (externalStore.getContent) {
-        this.getContentInternal = (contentKey) => {
-          return externalStore.getContent(contentKey);
-        };
-        this.setContent = (contentKey, content) => {
-          externalStore.setContent(contentKey, content);
-        };
-        this.deleteContent = (contentKey) => {
-          externalStore.deleteContent(contentKey);
-        };
-      }
-      for (const [x, ys] of (_c = data.relations) != null ? _c : []) {
-        for (const y of ys) this.addRelation(x, y);
-      }
-      for (const [contentKey, content] of (_d = data.contents) != null ? _d : []) {
-        this.setContent(contentKey, content);
-      }
-    }
-  }
+  a;
+  b;
+  cardinality;
+  relations = /* @__PURE__ */ new Map();
+  contents = /* @__PURE__ */ new Map();
+  isContent;
+  makeContentKey = (a, b) => `${a}:${b}`;
   getRelatedKeys(key) {
     return this.relations.get(key);
   }
@@ -128,6 +84,53 @@ var Junction = class {
   deleteContent(contentKey) {
     this.contents.delete(contentKey);
   }
+  constructor(data, config) {
+    this.a = data.between[0];
+    this.b = data.between[1];
+    this.cardinality = data.cardinality;
+    if (!config?.externalStore) {
+      this.relations = new Map(data.relations?.map(([a, b]) => [a, new Set(b)]));
+      this.contents = new Map(data.contents);
+    }
+    this.isContent = config?.isContent ?? null;
+    if (config?.makeContentKey) {
+      this.makeContentKey = config.makeContentKey;
+    }
+    if (config?.externalStore) {
+      const externalStore = config.externalStore;
+      this.has = (a, b) => externalStore.has(a, b);
+      this.addRelation = (a, b) => {
+        externalStore.addRelation(a, b);
+      };
+      this.deleteRelation = (a, b) => {
+        externalStore.deleteRelation(a, b);
+      };
+      this.replaceRelationsSafely = (a, bs) => {
+        externalStore.replaceRelationsSafely(a, bs);
+      };
+      this.replaceRelationsUnsafely = (a, bs) => {
+        externalStore.replaceRelationsUnsafely(a, bs);
+      };
+      this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key);
+      if (externalStore.getContent) {
+        this.getContentInternal = (contentKey) => {
+          return externalStore.getContent(contentKey);
+        };
+        this.setContent = (contentKey, content) => {
+          externalStore.setContent(contentKey, content);
+        };
+        this.deleteContent = (contentKey) => {
+          externalStore.deleteContent(contentKey);
+        };
+      }
+      for (const [x, ys] of data.relations ?? []) {
+        for (const y of ys) this.addRelation(x, y);
+      }
+      for (const [contentKey, content] of data.contents ?? []) {
+        this.setContent(contentKey, content);
+      }
+    }
+  }
   toJSON() {
     return {
       between: [this.a, this.b],
@@ -137,9 +140,8 @@ var Junction = class {
     };
   }
   set(a, ...rest) {
-    var _a;
     const b = typeof rest[0] === `string` ? rest[0] : a[this.b];
-    const content = ((_a = rest[1]) != null ? _a : typeof rest[0] === `string`) ? void 0 : rest[0];
+    const content = rest[1] ?? typeof rest[0] === `string` ? void 0 : rest[0];
     a = typeof a === `string` ? a : a[this.a];
     switch (this.cardinality) {
       case `1:1`: {
@@ -202,7 +204,7 @@ var Junction = class {
   replaceRelations(a, relations, config) {
     const hasContent = !Array.isArray(relations);
     const bs = hasContent ? Object.keys(relations) : relations;
-    if (config == null ? void 0 : config.reckless) {
+    if (config?.reckless) {
       this.replaceRelationsUnsafely(a, bs);
     } else {
       this.replaceRelationsSafely(a, bs);
@@ -227,8 +229,7 @@ var Junction = class {
       const aRelations = this.getRelatedKeys(a);
       if (aRelations) {
         return [...aRelations].map((aRelation) => {
-          var _a;
-          return [aRelation, (_a = this.getContent(a, aRelation)) != null ? _a : null];
+          return [aRelation, this.getContent(a, aRelation) ?? null];
         });
       }
     }
@@ -236,18 +237,16 @@ var Junction = class {
       const bRelations = this.getRelatedKeys(b);
       if (bRelations) {
         return [...bRelations].map((bRelation) => {
-          var _a;
-          return [bRelation, (_a = this.getContent(bRelation, b)) != null ? _a : null];
+          return [bRelation, this.getContent(bRelation, b) ?? null];
         });
       }
     }
     return [];
   }
   has(a, b) {
-    var _a;
     if (b) {
       const setA = this.getRelatedKeys(a);
-      return (_a = setA == null ? void 0 : setA.has(b)) != null ? _a : false;
+      return setA?.has(b) ?? false;
     }
     return this.relations.has(a);
   }

package/dist/{chunk-MR5NETHW.js → chunk-IW6WYRS7.js}

@@ -55,7 +55,7 @@ var fallback = (fn, fallbackValue) => {
 // ../anvl/src/nullish/index.ts
 var isUndefined = (input) => input === void 0;
 var ifDefined = (validate) => (input) => isUndefined(input) || validate(input);
-var ifNullish = (alt) => (input) => input != null ? input : alt;
+var ifNullish = (alt) => (input) => input ?? alt;
 
 // ../anvl/src/object/access.ts
 var access = (k) => Object.assign((obj) => obj[k], {
@@ -110,20 +110,19 @@ var doesExtend = (isValue) => hasProperties(isValue, ALLOW_EXTENSION);
 // ../anvl/src/object/sprawl.ts
 var sprawl = (tree, inspector) => {
   const walk = (path, node) => {
-    var _a;
     const inspect = (p, n) => {
       const result2 = inspector(p, n);
       if (result2) return result2;
       return null;
     };
     const result = inspect(path, node);
-    if ((_a = result == null ? void 0 : result.jobComplete) != null ? _a : result == null ? void 0 : result.pathComplete) {
+    if (result?.jobComplete ?? result?.pathComplete) {
       return result;
     }
     const childEntries = Array.isArray(node) ? node.map((v, i) => [i, v]) : isPlainObject(node) ? Object.entries(node) : [];
     for (const [k, v] of childEntries) {
       const subResult = walk([...path, k], v);
-      if (subResult == null ? void 0 : subResult.jobComplete) {
+      if (subResult?.jobComplete) {
         return subResult;
       }
     }
@@ -134,7 +133,7 @@ var sprawl = (tree, inspector) => {
 
 // ../anvl/src/object/index.ts
 var delve = (obj, path) => {
-  const found = path.reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+  const found = path.reduce((acc, key) => acc?.[key], obj);
   return found === void 0 ? new Error(`Not found`) : { found };
 };
 

package/dist/chunk-XWL6SNVU.js

@@ -0,0 +1,7 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export { __export };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Transceiver, Subject, Store, Func, EnvironmentData, Flat, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate } from 'atom.io/internal';
-import { Json, JsonInterface } from 'atom.io/json';
+import { Json, JsonInterface, Canonical } from 'atom.io/json';
 import { MoleculeConstructor as MoleculeConstructor$1, MoleculeToken as MoleculeToken$1, MoleculeFamilyToken as MoleculeFamilyToken$1, MoleculeParams as MoleculeParams$1, getState as getState$1, setState as setState$1, makeMolecule as makeMolecule$1, ActorToolkit as ActorToolkit$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, MoleculeCreation as MoleculeCreation$1, MoleculeDisposal as MoleculeDisposal$1 } from 'atom.io';
 import { findState } from 'atom.io/ephemeral';
 import { seekState } from 'atom.io/immortal';
@@ -40,52 +40,44 @@ declare function atom<T extends Transceiver<any>, J extends Json.Serializable>(o
  * @overload Regular
  */
 declare function atom<T>(options: RegularAtomOptions<T>): RegularAtomToken<T>;
-type RegularAtomFamilyOptions<T, K extends Json.Serializable> = {
+type RegularAtomFamilyOptions<T, K extends Canonical> = {
     key: string;
     default: T | ((key: K) => T);
     effects?: (key: K) => AtomEffect<T>[];
 };
-type RegularAtomFamilyToken<T, K extends Json.Serializable> = {
+type RegularAtomFamilyToken<T, K extends Canonical> = {
     key: string;
     type: `atom_family`;
     __T?: T;
     __K?: K;
 };
-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> & {
+type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
     (key: K): 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> & {
+type MutableAtomFamilyOptions<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & {
     key: string;
     default: (key: K) => T;
     effects?: (key: K) => AtomEffect<T>[];
     mutable: true;
 };
-type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable> = {
+type MutableAtomFamilyToken<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = {
     key: string;
     type: `mutable_atom_family`;
     __T?: T;
     __J?: J;
     __K?: K;
 };
-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> & {
+type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical> = JsonInterface<T, J> & MutableAtomFamilyToken<T, J, K> & {
     (key: K): 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>;
-type AtomFamilyToken<T, K extends Json.Serializable = Json.Serializable> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
-declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Json.Serializable>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyTokenWithCall<T, J, K>;
-declare function atomFamily<T, K extends Json.Serializable>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyTokenWithCall<T, K>;
+type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
+type AtomFamilyToken<T, K extends Canonical = Canonical> = MutableAtomFamilyToken<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamilyToken<T, K>;
+declare function atomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(options: MutableAtomFamilyOptions<T, J, K>): MutableAtomFamilyToken<T, J, K>;
+declare function atomFamily<T, K extends Canonical>(options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
 
 type TransactionToken<F extends Func> = {
     key: string;
@@ -166,41 +158,33 @@ type ReadonlySelectorOptions<T> = {
 };
 declare function selector<T>(options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
 declare function selector<T>(options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
-type WritableSelectorFamilyOptions<T, K extends Json.Serializable> = {
+type WritableSelectorFamilyOptions<T, K extends Canonical> = {
     key: string;
     get: (key: K) => Read<() => T>;
     set: (key: K) => Write<(newValue: T) => void>;
 };
-type ReadonlySelectorFamilyOptions<T, K extends Json.Serializable> = {
+type ReadonlySelectorFamilyOptions<T, K extends Canonical> = {
     key: string;
     get: (key: K) => Read<() => T>;
 };
-type WritableSelectorFamilyToken<T, K extends Json.Serializable> = {
+type WritableSelectorFamilyToken<T, K extends Canonical> = {
     key: string;
     type: `selector_family`;
     __T?: T;
     __K?: K;
 };
-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> & {
+type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & {
     (key: K): WritableSelectorToken<T>;
     subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
     install: (store: Store) => void;
 };
-type ReadonlySelectorFamilyToken<T, K extends Json.Serializable> = {
+type ReadonlySelectorFamilyToken<T, K extends Canonical> = {
     key: string;
     type: `readonly_selector_family`;
     __T?: T;
     __K?: K;
 };
-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>) & {
+type ReadonlySelectorFamily<T, K extends Canonical> = ((key: K) => ReadonlySelectorToken<T>) & {
     key: string;
     type: `readonly_selector_family`;
     subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
@@ -208,12 +192,12 @@ type ReadonlySelectorFamily<T, K extends Json.Serializable> = ((key: K) => Reado
     __T?: T;
     __K?: K;
 };
-type SelectorFamily<T, K extends Json.Serializable> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
-type SelectorFamilyToken<T, K extends Json.Serializable> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
-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>;
+type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
+type SelectorFamilyToken<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+declare function selectorFamily<T, K extends Canonical>(options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
+declare function selectorFamily<T, K extends Canonical>(options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
 
-type CtorToolkit<K extends Json.Serializable> = Flat<Omit<ActorToolkit$1, `find`> & {
+type CtorToolkit<K extends Canonical> = Flat<Omit<ActorToolkit$1, `find`> & {
     bond<T extends Transceiver<any>, J extends Json.Serializable>(family: MutableAtomFamilyToken$1<T, J, K>): MutableAtomToken$1<T, J>;
     bond<T>(family: RegularAtomFamilyToken$1<T, K>): RegularAtomToken$1<T>;
     bond<T>(family: WritableSelectorFamilyToken$1<T, K>): WritableSelectorToken$1<T>;
@@ -234,7 +218,7 @@ type CtorToolkit<K extends Json.Serializable> = Flat<Omit<ActorToolkit$1, `find`
     claim(below: MoleculeToken<any>, options: {
         exclusive: boolean;
     }): void;
-    spawn<Key extends Json.Serializable, Ctor extends MoleculeConstructor>(family: MoleculeFamilyToken<Ctor>, key: Key, ...params: MoleculeParams<Ctor>): MoleculeToken<Ctor>;
+    spawn<Key extends Canonical, Ctor extends MoleculeConstructor>(family: MoleculeFamilyToken<Ctor>, key: Key, ...params: MoleculeParams<Ctor>): MoleculeToken<Ctor>;
 }>;
 type MoleculeConstructor = new (toolkit: CtorToolkit<any>, key: any, ...params: any) => any;
 type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[];
@@ -268,13 +252,13 @@ type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`];
 declare function makeRootMolecule(key: string, store?: Store): MoleculeToken<ObjectConstructor>;
 
 declare function disposeState(token: MoleculeToken<any> | ReadableToken<any>): void;
-declare function disposeState<K extends Json.Serializable>(token: ReadableFamilyToken<any, K>, key: K): void;
+declare function disposeState<K extends Canonical>(token: ReadableFamilyToken<any, K>, key: K): void;
 declare function disposeState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): void;
 
 declare function getState<T>(token: ReadableToken<T>): T;
 declare function getState<M extends MoleculeConstructor>(token: MoleculeToken<M>): InstanceType<M>;
-declare function getState<T, K extends Json.Serializable>(token: ReadableFamilyToken<T, K>, key: K): T;
-declare function getState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: Json.Serializable): InstanceType<M>;
+declare function getState<T, K extends Canonical>(token: ReadableFamilyToken<T, K>, key: K): T;
+declare function getState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: Canonical): InstanceType<M>;
 
 declare const LoggerIconDictionary: {
     readonly "\u231B": "Timeline event fully captured";
@@ -346,12 +330,6 @@ declare class AtomIOLogger implements Logger {
     warn: LogFn;
 }
 
-type primitive = boolean | number | string | null;
-
-type Serializable = primitive | Readonly<{
-    [key: string]: Serializable;
-}> | ReadonlyArray<Serializable>;
-
 /**
  * @public
  * Set the value of a state into the implicit store.
@@ -369,7 +347,7 @@ declare function setState<T, New extends T>(token: WritableToken<T>, value: New
  * @param value - The new value of the state.
  * @overload Streamlined
  */
-declare function setState<T, K extends Serializable, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
+declare function setState<T, K extends Canonical, New extends T>(token: WritableFamilyToken<T, K>, key: K, value: New | ((oldValue: T) => New)): void;
 
 declare class Silo {
     store: Store;
@@ -466,13 +444,13 @@ type ReadonlySelectorToken<T> = {
 type SelectorToken<T> = ReadonlySelectorToken<T> | WritableSelectorToken<T>;
 type WritableToken<T> = AtomToken<T> | WritableSelectorToken<T>;
 type ReadableToken<T> = AtomToken<T> | SelectorToken<T>;
-type WritableFamily<T, K extends Json.Serializable> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
-type ReadableFamily<T, K extends Json.Serializable> = AtomFamily<T, K> | SelectorFamily<T, K>;
-type WritableFamilyToken<T, K extends Json.Serializable> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
-type ReadableFamilyToken<T, K extends Json.Serializable> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
+type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
+type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
+type WritableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | WritableSelectorFamilyToken<T, K>;
+type ReadableFamilyToken<T, K extends Canonical> = AtomFamilyToken<T, K> | SelectorFamilyToken<T, K>;
 type FamilyMetadata = {
     key: string;
     subKey: string;
 };
 
-export { type ActorToolkit, type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, 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 RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomFamilyTokenWithCall, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, 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 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, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };
+export { type ActorToolkit, type AtomEffect, type AtomFamily, type AtomFamilyToken, AtomIOLogger, type AtomOnly, type AtomToken, type CtorToolkit, type Effectors, type FamilyMetadata, type GetterToolkit, type KeyedStateUpdate, LOG_LEVELS, type LogFilter, type LogFn, type LogLevel, type Logger, type LoggerIcon, type MoleculeConstructor, type MoleculeCreation, type MoleculeDisposal, type MoleculeFamily, type MoleculeFamilyOptions, type MoleculeFamilyToken, type MoleculeKey, type MoleculeParams, type MoleculeToken, type MoleculeType, type MutableAtomFamily, type MutableAtomFamilyOptions, type MutableAtomFamilyToken, type MutableAtomOptions, type MutableAtomToken, type Read, type ReadableFamily, type ReadableFamilyToken, type ReadableToken, type ReadonlySelectorFamily, type ReadonlySelectorFamilyOptions, type ReadonlySelectorFamilyToken, type ReadonlySelectorOptions, type ReadonlySelectorToken, type RegularAtomFamily, type RegularAtomFamilyOptions, type RegularAtomFamilyToken, type RegularAtomOptions, type RegularAtomToken, type SelectorFamily, type SelectorFamilyToken, type SelectorToken, type SetterToolkit, 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 UpdateHandler, type WritableFamily, type WritableFamilyToken, type WritableSelectorFamily, type WritableSelectorFamilyOptions, type WritableSelectorFamilyToken, type WritableSelectorOptions, type WritableSelectorToken, type WritableToken, type Write, atom, atomFamily, belongsTo, disposeState, getState, isToken, makeMolecule, makeRootMolecule, moleculeFamily, redo, runTransaction, selector, selectorFamily, setState, simpleLog, simpleLogger, subscribe, timeline, transaction, undo };