atom.io 0.26.0 → 0.27.1

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/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/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 };

package/ephemeral/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken } from 'atom.io';
 import { Transceiver } from 'atom.io/internal';
-import { Json } from 'atom.io/json';
+import { Json, Canonical } from 'atom.io/json';
 
 /**
  * @overload Mutable Atom
@@ -10,7 +10,7 @@ import { Json } from 'atom.io/json';
  * @returns
  * The current value of the state.
  */
-declare function findState<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>;
+declare function findState<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -18,7 +18,7 @@ declare function findState<T extends Transceiver<any>, J extends Json.Serializab
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -26,7 +26,7 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -34,7 +34,7 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
 /**
  * Finds a state in the store.
  * @param token - The token of the state family.
@@ -42,7 +42,7 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * @returns
  * The current value of the state.
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
 /**
  * @public
  * Finds a {@link ReadableToken} in the store.
@@ -52,6 +52,6 @@ declare function findState<T, K extends Json.Serializable, Key extends K>(token:
  * The current value of the state.
  * @overload Unknown
  */
-declare function findState<T, K extends Json.Serializable, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
+declare function findState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 
 export { findState };

package/ephemeral/src/find-state.ts

@@ -14,7 +14,7 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { findInStore, IMPLICIT } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 /**
  * @overload Mutable Atom
@@ -27,7 +27,7 @@ import type { Json } from "atom.io/json"
 export function findState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>
 /**
@@ -37,7 +37,7 @@ export function findState<
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T>
@@ -48,7 +48,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T>
@@ -59,7 +59,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T>
@@ -70,7 +70,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * @returns
  * The current value of the state.
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T>
@@ -83,7 +83,7 @@ export function findState<T, K extends Json.Serializable, Key extends K>(
  * The current value of the state.
  * @overload Unknown
  */
-export function findState<T, K extends Json.Serializable, Key extends K>(
+export function findState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 ): ReadableToken<T>

package/immortal/dist/index.d.ts

@@ -1,13 +1,13 @@
 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 { Json, Canonical } from 'atom.io/json';
 
-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;
-declare function seekState<T, K extends Json.Serializable, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
-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<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T> | undefined;
+declare function seekState<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T> | undefined;
 declare function seekState<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeToken<M> | undefined;
 
 export { seekState };

package/immortal/src/seek-state.ts

@@ -18,39 +18,39 @@ import type {
 } from "atom.io"
 import type { Transceiver } from "atom.io/internal"
 import { IMPLICIT, seekInStore } from "atom.io/internal"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 export function seekState<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends Json.Serializable,
+	K extends Canonical,
 	Key extends K,
 >(
 	token: MutableAtomFamilyToken<T, J, K>,
 	key: Key,
 ): MutableAtomToken<T, J> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: RegularAtomFamilyToken<T, K>,
 	key: Key,
 ): RegularAtomToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: WritableSelectorFamilyToken<T, K>,
 	key: Key,
 ): WritableSelectorToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: ReadonlySelectorFamilyToken<T, K>,
 	key: Key,
 ): ReadonlySelectorToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: WritableFamilyToken<T, K>,
 	key: Key,
 ): WritableToken<T> | undefined
 
-export function seekState<T, K extends Json.Serializable, Key extends K>(
+export function seekState<T, K extends Canonical, Key extends K>(
 	token: ReadableFamilyToken<T, K>,
 	key: Key,
 ): ReadableToken<T> | undefined
@@ -62,7 +62,7 @@ export function seekState<M extends MoleculeConstructor>(
 
 export function seekState(
 	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
-	key: Json.Serializable,
+	key: Canonical,
 ): MoleculeToken<any> | ReadableToken<any> | undefined {
 	if (token.type === `molecule_family`) {
 		return seekInStore(token, key, IMPLICIT.STORE)