atom.io 0.33.1 → 0.33.3

package/dist/data/index.d.ts

@@ -5,7 +5,7 @@ import * as AtomIO$1 from "atom.io";
 import * as AtomIO from "atom.io";
 
 //#region src/data/dict.d.ts
-declare function dict<State, Key extends Canonical>(family: AtomIO$2.ReadonlySelectorFamilyToken<State, Key> | AtomIO$2.RegularAtomFamilyToken<State, Key> | AtomIO$2.WritableSelectorFamilyToken<State, Key>, index: AtomIO$2.ReadonlySelectorToken<Key[]> | AtomIO$2.RegularAtomToken<Key[]> | AtomIO$2.WritableSelectorToken<Key[]>, store?: Store): AtomIO$2.ReadonlySelectorToken<{ [K in stringified<Key>]: State }>;
+declare function dict<State, Key extends Canonical>(family: AtomIO$2.ReadonlyPureSelectorFamilyToken<State, Key> | AtomIO$2.RegularAtomFamilyToken<State, Key> | AtomIO$2.WritablePureSelectorFamilyToken<State, Key>, index: AtomIO$2.ReadonlyPureSelectorToken<Key[]> | AtomIO$2.RegularAtomToken<Key[]> | AtomIO$2.WritablePureSelectorToken<Key[]>, store?: Store): AtomIO$2.ReadonlyPureSelectorToken<{ [K in stringified<Key>]: State }>;
 
 //#endregion
 //#region src/data/struct.d.ts
@@ -14,14 +14,14 @@ declare function struct<Struct extends {
 }, Key extends string>(options: {
   key: Key;
   default: Struct;
-}, store?: Store): [{ [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: AtomIO$1.RegularAtomToken<Struct[K]> }, AtomIO$1.ReadonlySelectorToken<Struct>];
+}, store?: Store): [{ [K in keyof Struct as `${Key}${Capitalize<K & string>}State`]: AtomIO$1.RegularAtomToken<Struct[K]> }, AtomIO$1.ReadonlyPureSelectorToken<Struct>];
 
 //#endregion
 //#region src/data/struct-family.d.ts
 declare function structFamily<Struct extends object, Key extends string>(options: {
   key: Key;
   default: Struct;
-}): [{ [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string> }, AtomIO.ReadonlySelectorFamilyToken<Struct, string>];
+}): [{ [K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<K & string>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string> }, AtomIO.ReadonlyPureSelectorFamilyToken<Struct, string>];
 
 //#endregion
 export { dict, struct, structFamily };

package/dist/data/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["family:\n\t\t| AtomIO.ReadonlySelectorFamilyToken<State, Key>\n\t\t| AtomIO.RegularAtomFamilyToken<State, Key>\n\t\t| AtomIO.WritableSelectorFamilyToken<State, Key>","index:\n\t\t| AtomIO.ReadonlySelectorToken<Key[]>\n\t\t| AtomIO.RegularAtomToken<Key[]>\n\t\t| AtomIO.WritableSelectorToken<Key[]>","store: Store","options: {\n\t\tkey: Key\n\t\tdefault: Struct\n\t}","store: Store","options: {\n\tkey: Key\n\tdefault: Struct\n}"],"sources":["../../src/data/dict.ts","../../src/data/struct.ts","../../src/data/struct-family.ts"],"sourcesContent":null,"mappings":";;;;;;;iBASgB,wBAAwB,mBAEpC,QAAA,CAAO,4BAA4B,OAAO,OAC1C,QAAA,CAAO,uBAAuB,OAAO,OACrC,QAAA,CAAO,4BAA4B,OAAO,aAE1C,QAAA,CAAO,sBAAsB,SAC7B,QAAA,CAAO,iBAAiB,SACxB,QAAA,CAAO,sBAAsB,gBACzB,QACL,QAAA,CAAO,8BAA8B,YAAY,OAAO;;;;iBCV3C;;sBDAhB,CAAA,OAAgB,EAAA;EAAA,GAAA,ECKT,GDLS;EAAA,OAAwB,ECM7B,MDN6B;CAAA,EAAA,KAED,CAAA,ECM/B,KDN+B,CAAA,EAAA,CAAA,QAAA,MCSzB,MDTyB,IAAA,GCSZ,GDTY,GCSN,UDTM,CCUpC,CDVoC,GAAA,MAAA,CAAA,OAAA,GCW1B,QAAA,CAAO,gBDXmB,CCWF,MDXE,CCWK,CDXL,CAAA,CAAA,EAAA,ECatC,QAAA,CAAO,qBDb+B,CCaT,MDbS,CAAA,CAAA;;;;iBEAvB;OAIV;WACI;AFPV,CAAA,CAAA,EAAgB,CAAA,QAAA,MEUF,MFVE,IAAA,OEUe,UFVf,CEU0B,GFV1B,GAAA,MAAA,CAAA,GEU0C,UFV1C,CEWb,CFXa,GAAA,MAAA,CAAA,OAAA,GEYH,MAAA,CAAO,sBFZJ,CEY2B,MFZ3B,CEYkC,CFZlC,CAAA,EAAA,MAAA,CAAA,EAAA,EEcf,MAAA,CAAO,2BFdQ,CEcoB,MFdpB,EAAA,MAAA,CAAA,CAAA"}
+{"version":3,"file":"index.d.ts","names":["family:\n\t\t| AtomIO.ReadonlyPureSelectorFamilyToken<State, Key>\n\t\t| AtomIO.RegularAtomFamilyToken<State, Key>\n\t\t| AtomIO.WritablePureSelectorFamilyToken<State, Key>","index:\n\t\t| AtomIO.ReadonlyPureSelectorToken<Key[]>\n\t\t| AtomIO.RegularAtomToken<Key[]>\n\t\t| AtomIO.WritablePureSelectorToken<Key[]>","store: Store","options: {\n\t\tkey: Key\n\t\tdefault: Struct\n\t}","store: Store","options: {\n\tkey: Key\n\tdefault: Struct\n}"],"sources":["../../src/data/dict.ts","../../src/data/struct.ts","../../src/data/struct-family.ts"],"sourcesContent":[],"mappings":";;;;;;;iBASgB,wBAAwB,mBAEpC,QAAA,CAAO,gCAAgC,OAAO,OAC9C,QAAA,CAAO,uBAAuB,OAAO,OACrC,QAAA,CAAO,gCAAgC,OAAO,aAE9C,QAAA,CAAO,0BAA0B,SACjC,QAAA,CAAO,iBAAiB,SACxB,QAAA,CAAO,0BAA0B,gBAC7B,QACL,QAAA,CAAO,kCAAkC,YAAY,OAAO;;;;iBCV/C;;sBDAhB,CAAA,OAAgB,EAAA;EAAA,GAAA,ECKT,GDLS;EAAA,OAAwB,ECM7B,MDN6B;CAAA,EAAA,KAEG,CAAA,ECMnC,KDNmC,CAAA,EAAA,CAAA,QAAA,MCS7B,MDT6B,IAAA,GCShB,GDTgB,GCSV,UDTU,CCUxC,CDVwC,GAAA,MAAA,CAAA,OAAA,GCW9B,QAAA,CAAO,gBDXuB,CCWN,MDXM,CCWC,CDXD,CAAA,CAAA,EAAA,ECa1C,QAAA,CAAO,yBDbmC,CCaT,MDbS,CAAA,CAAA;;;;iBEA3B;OAIV;WACI;AFPV,CAAA,CAAA,EAAgB,CAAA,QAAA,MEUF,MFVE,IAAA,OEUe,UFVf,CEU0B,GFV1B,GAAA,MAAA,CAAA,GEU0C,UFV1C,CEWb,CFXa,GAAA,MAAA,CAAA,OAAA,GEYH,MAAA,CAAO,sBFZJ,CEY2B,MFZ3B,CEYkC,CFZlC,CAAA,EAAA,MAAA,CAAA,EAAA,EEcf,MAAA,CAAO,+BFdQ,CEcwB,MFdxB,EAAA,MAAA,CAAA,CAAA"}

package/dist/data/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":["family:\n\t\t| AtomIO.ReadonlySelectorFamilyToken<State, Key>\n\t\t| AtomIO.RegularAtomFamilyToken<State, Key>\n\t\t| AtomIO.WritableSelectorFamilyToken<State, Key>","index:\n\t\t| AtomIO.ReadonlySelectorToken<Key[]>\n\t\t| AtomIO.RegularAtomToken<Key[]>\n\t\t| AtomIO.WritableSelectorToken<Key[]>","store: Store","options: {\n\t\tkey: Key\n\t\tdefault: Struct\n\t}","store: Store","atoms: {\n\t\t[K in keyof Struct as `${Key}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomToken<Struct[K]>\n\t}","topKey: string","subKey: string","options: {\n\tkey: Key\n\tdefault: Struct\n}","atoms: {\n\t\t[K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>\n\t}","findStructState: AtomIO.ReadonlySelectorFamilyToken<Struct, string>"],"sources":["../../src/data/dict.ts","../../src/data/struct.ts","../../src/data/struct-family.ts"],"sourcesContent":["import type * as AtomIO from \"atom.io\"\nimport type { Store } from \"atom.io/internal\"\nimport {\n\tcreateStandaloneSelector,\n\tfindInStore,\n\tIMPLICIT,\n} from \"atom.io/internal\"\nimport type { Canonical, stringified } from \"atom.io/json\"\n\nexport function dict<State, Key extends Canonical>(\n\tfamily:\n\t\t| AtomIO.ReadonlySelectorFamilyToken<State, Key>\n\t\t| AtomIO.RegularAtomFamilyToken<State, Key>\n\t\t| AtomIO.WritableSelectorFamilyToken<State, Key>,\n\tindex:\n\t\t| AtomIO.ReadonlySelectorToken<Key[]>\n\t\t| AtomIO.RegularAtomToken<Key[]>\n\t\t| AtomIO.WritableSelectorToken<Key[]>,\n\tstore: Store = IMPLICIT.STORE,\n): AtomIO.ReadonlySelectorToken<{ [K in stringified<Key>]: State }> {\n\treturn createStandaloneSelector(store, {\n\t\tkey: `${family.key}Dict`,\n\t\tget: ({ get }) => {\n\t\t\tconst keys = get(index)\n\t\t\treturn keys.reduce((acc, key) => {\n\t\t\t\tacc[key] = get(findInStore(store, family, key))\n\t\t\t\treturn acc\n\t\t\t}, {} as any)\n\t\t},\n\t})\n}\n","import type * as AtomIO from \"atom.io\"\nimport type { Store } from \"atom.io/internal\"\nimport {\n\tcapitalize,\n\tcreateRegularAtom,\n\tcreateStandaloneSelector,\n\tIMPLICIT,\n} from \"atom.io/internal\"\n\nexport function struct<\n\tStruct extends { [key: string]: unknown },\n\tKey extends string,\n>(\n\toptions: {\n\t\tkey: Key\n\t\tdefault: Struct\n\t},\n\tstore: Store = IMPLICIT.STORE,\n): [\n\t{\n\t\t[K in keyof Struct as `${Key}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomToken<Struct[K]>\n\t},\n\tAtomIO.ReadonlySelectorToken<Struct>,\n] {\n\tconst atoms: {\n\t\t[K in keyof Struct as `${Key}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomToken<Struct[K]>\n\t} = Object.keys(options.default).reduce((acc, key) => {\n\t\tconst atomName = options.key + capitalize(key) + `State`\n\t\tacc[atomName] = createRegularAtom(\n\t\t\tstore,\n\t\t\t{\n\t\t\t\tkey: `${options.key}.${key}`,\n\t\t\t\tdefault: options.default[key],\n\t\t\t},\n\t\t\tundefined,\n\t\t)\n\t\treturn acc\n\t}, {} as any)\n\tconst structState = createStandaloneSelector(store, {\n\t\tkey: options.key,\n\t\tget: ({ get }) => {\n\t\t\treturn Object.keys(options.default).reduce((acc, key) => {\n\t\t\t\t// @ts-expect-error finicky\n\t\t\t\tacc[key] = get(atoms[options.key + capitalize(key) + `State`])\n\t\t\t\treturn acc\n\t\t\t}, {} as any)\n\t\t},\n\t})\n\treturn [atoms, structState]\n}\n","import type * as AtomIO from \"atom.io\"\nimport {\n\tcapitalize,\n\tcreateRegularAtomFamily,\n\tcreateSelectorFamily,\n\tIMPLICIT,\n} from \"atom.io/internal\"\n\nconst nameFamily = (topKey: string, subKey: string) =>\n\t`find` + capitalize(topKey) + capitalize(subKey) + `State`\n\nexport function structFamily<\n\tStruct extends object,\n\tKey extends string,\n>(options: {\n\tkey: Key\n\tdefault: Struct\n}): [\n\t{\n\t\t[K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>\n\t},\n\tAtomIO.ReadonlySelectorFamilyToken<Struct, string>,\n] {\n\tconst atoms: {\n\t\t[K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>\n\t} = Object.keys(options.default).reduce((acc, subKey) => {\n\t\tconst atomFamilyName = nameFamily(options.key, subKey)\n\t\tacc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {\n\t\t\tkey: `${options.key}.${subKey}`,\n\t\t\tdefault: (options.default as any)[subKey],\n\t\t})\n\t\treturn acc\n\t}, {} as any)\n\tconst findStructState: AtomIO.ReadonlySelectorFamilyToken<Struct, string> =\n\t\tcreateSelectorFamily(IMPLICIT.STORE, {\n\t\t\tkey: options.key,\n\t\t\tget:\n\t\t\t\t(id) =>\n\t\t\t\t({ find, get }) => {\n\t\t\t\t\treturn Object.keys(options.default).reduce((acc, subKey) => {\n\t\t\t\t\t\tacc[subKey] = get(\n\t\t\t\t\t\t\tfind((atoms as any)[nameFamily(options.key, subKey)], id),\n\t\t\t\t\t\t)\n\t\t\t\t\t\treturn acc\n\t\t\t\t\t}, {} as any)\n\t\t\t\t},\n\t\t})\n\treturn [atoms, findStructState]\n}\n"],"mappings":";;;AASA,SAAgB,KACfA,QAIAC,OAIAC,QAAe,SAAS,OAC2C;AACnE,QAAO,yBAAyB,OAAO;EACtC,MAAM,EAAE,OAAO,IAAI;EACnB,KAAK,CAAC,EAAE,KAAK,KAAK;GACjB,MAAM,OAAO,IAAI,MAAM;AACvB,UAAO,KAAK,OAAO,CAAC,KAAK,QAAQ;AAChC,QAAI,OAAO,IAAI,YAAY,OAAO,QAAQ,IAAI,CAAC;AAC/C,WAAO;GACP,GAAE,CAAE,EAAQ;EACb;CACD,EAAC;AACF;;;;ACrBD,SAAgB,OAIfC,SAIAC,QAAe,SAAS,OAQvB;CACD,MAAMC,QAIF,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,QAAQ;EACrD,MAAM,WAAW,QAAQ,MAAM,WAAW,IAAI,IAAI;AAClD,MAAI,YAAY,kBACf,OACA;GACC,MAAM,EAAE,QAAQ,IAAI,GAAG,IAAI;GAC3B,SAAS,QAAQ,QAAQ;EACzB,UAED;AACD,SAAO;CACP,GAAE,CAAE,EAAQ;CACb,MAAM,cAAc,yBAAyB,OAAO;EACnD,KAAK,QAAQ;EACb,KAAK,CAAC,EAAE,KAAK,KAAK;AACjB,UAAO,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,QAAQ;AAExD,QAAI,OAAO,IAAI,MAAM,QAAQ,MAAM,WAAW,IAAI,IAAI,QAAQ;AAC9D,WAAO;GACP,GAAE,CAAE,EAAQ;EACb;CACD,EAAC;AACF,QAAO,CAAC,OAAO,WAAY;AAC3B;;;;AC7CD,MAAM,aAAa,CAACC,QAAgBC,YAClC,QAAQ,WAAW,OAAO,GAAG,WAAW,OAAO,IAAI;AAErD,SAAgB,aAGdC,SAUA;CACD,MAAMC,QAIF,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,WAAW;EACxD,MAAM,iBAAiB,WAAW,QAAQ,KAAK,OAAO;AACtD,MAAI,kBAAkB,wBAAwB,SAAS,OAAO;GAC7D,MAAM,EAAE,QAAQ,IAAI,GAAG,OAAO;GAC9B,SAAU,QAAQ,QAAgB;EAClC,EAAC;AACF,SAAO;CACP,GAAE,CAAE,EAAQ;CACb,MAAMC,kBACL,qBAAqB,SAAS,OAAO;EACpC,KAAK,QAAQ;EACb,KACC,CAAC,OACD,CAAC,EAAE,MAAM,KAAK,KAAK;AAClB,UAAO,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,WAAW;AAC3D,QAAI,UAAU,IACb,KAAM,MAAc,WAAW,QAAQ,KAAK,OAAO,GAAG,GAAG,CACzD;AACD,WAAO;GACP,GAAE,CAAE,EAAQ;EACb;CACF,EAAC;AACH,QAAO,CAAC,OAAO,eAAgB;AAC/B"}
+{"version":3,"file":"index.js","names":["family:\n\t\t| AtomIO.ReadonlyPureSelectorFamilyToken<State, Key>\n\t\t| AtomIO.RegularAtomFamilyToken<State, Key>\n\t\t| AtomIO.WritablePureSelectorFamilyToken<State, Key>","index:\n\t\t| AtomIO.ReadonlyPureSelectorToken<Key[]>\n\t\t| AtomIO.RegularAtomToken<Key[]>\n\t\t| AtomIO.WritablePureSelectorToken<Key[]>","store: Store","options: {\n\t\tkey: Key\n\t\tdefault: Struct\n\t}","store: Store","atoms: {\n\t\t[K in keyof Struct as `${Key}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomToken<Struct[K]>\n\t}","topKey: string","subKey: string","options: {\n\tkey: Key\n\tdefault: Struct\n}","atoms: {\n\t\t[K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>\n\t}","findStructState: AtomIO.ReadonlyPureSelectorFamilyToken<Struct, string>"],"sources":["../../src/data/dict.ts","../../src/data/struct.ts","../../src/data/struct-family.ts"],"sourcesContent":["import type * as AtomIO from \"atom.io\"\nimport type { Store } from \"atom.io/internal\"\nimport {\n\tcreateStandaloneSelector,\n\tfindInStore,\n\tIMPLICIT,\n} from \"atom.io/internal\"\nimport type { Canonical, stringified } from \"atom.io/json\"\n\nexport function dict<State, Key extends Canonical>(\n\tfamily:\n\t\t| AtomIO.ReadonlyPureSelectorFamilyToken<State, Key>\n\t\t| AtomIO.RegularAtomFamilyToken<State, Key>\n\t\t| AtomIO.WritablePureSelectorFamilyToken<State, Key>,\n\tindex:\n\t\t| AtomIO.ReadonlyPureSelectorToken<Key[]>\n\t\t| AtomIO.RegularAtomToken<Key[]>\n\t\t| AtomIO.WritablePureSelectorToken<Key[]>,\n\tstore: Store = IMPLICIT.STORE,\n): AtomIO.ReadonlyPureSelectorToken<{ [K in stringified<Key>]: State }> {\n\treturn createStandaloneSelector(store, {\n\t\tkey: `${family.key}Dict`,\n\t\tget: ({ get }) => {\n\t\t\tconst keys = get(index)\n\t\t\treturn keys.reduce((acc, key) => {\n\t\t\t\tacc[key] = get(findInStore(store, family, key))\n\t\t\t\treturn acc\n\t\t\t}, {} as any)\n\t\t},\n\t})\n}\n","import type * as AtomIO from \"atom.io\"\nimport type { Store } from \"atom.io/internal\"\nimport {\n\tcapitalize,\n\tcreateRegularAtom,\n\tcreateStandaloneSelector,\n\tIMPLICIT,\n} from \"atom.io/internal\"\n\nexport function struct<\n\tStruct extends { [key: string]: unknown },\n\tKey extends string,\n>(\n\toptions: {\n\t\tkey: Key\n\t\tdefault: Struct\n\t},\n\tstore: Store = IMPLICIT.STORE,\n): [\n\t{\n\t\t[K in keyof Struct as `${Key}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomToken<Struct[K]>\n\t},\n\tAtomIO.ReadonlyPureSelectorToken<Struct>,\n] {\n\tconst atoms: {\n\t\t[K in keyof Struct as `${Key}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomToken<Struct[K]>\n\t} = Object.keys(options.default).reduce((acc, key) => {\n\t\tconst atomName = options.key + capitalize(key) + `State`\n\t\tacc[atomName] = createRegularAtom(\n\t\t\tstore,\n\t\t\t{\n\t\t\t\tkey: `${options.key}.${key}`,\n\t\t\t\tdefault: options.default[key],\n\t\t\t},\n\t\t\tundefined,\n\t\t)\n\t\treturn acc\n\t}, {} as any)\n\tconst structState = createStandaloneSelector(store, {\n\t\tkey: options.key,\n\t\tget: ({ get }) => {\n\t\t\treturn Object.keys(options.default).reduce((acc, key) => {\n\t\t\t\t// @ts-expect-error finicky\n\t\t\t\tacc[key] = get(atoms[options.key + capitalize(key) + `State`])\n\t\t\t\treturn acc\n\t\t\t}, {} as any)\n\t\t},\n\t})\n\treturn [atoms, structState]\n}\n","import type * as AtomIO from \"atom.io\"\nimport {\n\tcapitalize,\n\tcreateRegularAtomFamily,\n\tcreateSelectorFamily,\n\tIMPLICIT,\n} from \"atom.io/internal\"\n\nconst nameFamily = (topKey: string, subKey: string) =>\n\t`find` + capitalize(topKey) + capitalize(subKey) + `State`\n\nexport function structFamily<\n\tStruct extends object,\n\tKey extends string,\n>(options: {\n\tkey: Key\n\tdefault: Struct\n}): [\n\t{\n\t\t[K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>\n\t},\n\tAtomIO.ReadonlyPureSelectorFamilyToken<Struct, string>,\n] {\n\tconst atoms: {\n\t\t[K in keyof Struct as `find${Capitalize<Key & string>}${Capitalize<\n\t\t\tK & string\n\t\t>}State`]: AtomIO.RegularAtomFamilyToken<Struct[K], string>\n\t} = Object.keys(options.default).reduce((acc, subKey) => {\n\t\tconst atomFamilyName = nameFamily(options.key, subKey)\n\t\tacc[atomFamilyName] = createRegularAtomFamily(IMPLICIT.STORE, {\n\t\t\tkey: `${options.key}.${subKey}`,\n\t\t\tdefault: (options.default as any)[subKey],\n\t\t})\n\t\treturn acc\n\t}, {} as any)\n\tconst findStructState: AtomIO.ReadonlyPureSelectorFamilyToken<Struct, string> =\n\t\tcreateSelectorFamily(IMPLICIT.STORE, {\n\t\t\tkey: options.key,\n\t\t\tget:\n\t\t\t\t(id) =>\n\t\t\t\t({ find, get }) => {\n\t\t\t\t\treturn Object.keys(options.default).reduce((acc, subKey) => {\n\t\t\t\t\t\tacc[subKey] = get(\n\t\t\t\t\t\t\tfind((atoms as any)[nameFamily(options.key, subKey)], id),\n\t\t\t\t\t\t)\n\t\t\t\t\t\treturn acc\n\t\t\t\t\t}, {} as any)\n\t\t\t\t},\n\t\t})\n\treturn [atoms, findStructState]\n}\n"],"mappings":";;;AASA,SAAgB,KACfA,QAIAC,OAIAC,QAAe,SAAS,OAC+C;AACvE,QAAO,yBAAyB,OAAO;EACtC,MAAM,EAAE,OAAO,IAAI;EACnB,KAAK,CAAC,EAAE,KAAK,KAAK;GACjB,MAAM,OAAO,IAAI,MAAM;AACvB,UAAO,KAAK,OAAO,CAAC,KAAK,QAAQ;AAChC,QAAI,OAAO,IAAI,YAAY,OAAO,QAAQ,IAAI,CAAC;AAC/C,WAAO;GACP,GAAE,CAAE,EAAQ;EACb;CACD,EAAC;AACF;;;;ACrBD,SAAgB,OAIfC,SAIAC,QAAe,SAAS,OAQvB;CACD,MAAMC,QAIF,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,QAAQ;EACrD,MAAM,WAAW,QAAQ,MAAM,WAAW,IAAI,IAAI;AAClD,MAAI,YAAY,kBACf,OACA;GACC,MAAM,EAAE,QAAQ,IAAI,GAAG,IAAI;GAC3B,SAAS,QAAQ,QAAQ;EACzB,UAED;AACD,SAAO;CACP,GAAE,CAAE,EAAQ;CACb,MAAM,cAAc,yBAAyB,OAAO;EACnD,KAAK,QAAQ;EACb,KAAK,CAAC,EAAE,KAAK,KAAK;AACjB,UAAO,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,QAAQ;AAExD,QAAI,OAAO,IAAI,MAAM,QAAQ,MAAM,WAAW,IAAI,IAAI,QAAQ;AAC9D,WAAO;GACP,GAAE,CAAE,EAAQ;EACb;CACD,EAAC;AACF,QAAO,CAAC,OAAO,WAAY;AAC3B;;;;AC7CD,MAAM,aAAa,CAACC,QAAgBC,YAClC,QAAQ,WAAW,OAAO,GAAG,WAAW,OAAO,IAAI;AAErD,SAAgB,aAGdC,SAUA;CACD,MAAMC,QAIF,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,WAAW;EACxD,MAAM,iBAAiB,WAAW,QAAQ,KAAK,OAAO;AACtD,MAAI,kBAAkB,wBAAwB,SAAS,OAAO;GAC7D,MAAM,EAAE,QAAQ,IAAI,GAAG,OAAO;GAC9B,SAAU,QAAQ,QAAgB;EAClC,EAAC;AACF,SAAO;CACP,GAAE,CAAE,EAAQ;CACb,MAAMC,kBACL,qBAAqB,SAAS,OAAO;EACpC,KAAK,QAAQ;EACb,KACC,CAAC,OACD,CAAC,EAAE,MAAM,KAAK,KAAK;AAClB,UAAO,OAAO,KAAK,QAAQ,QAAQ,CAAC,OAAO,CAAC,KAAK,WAAW;AAC3D,QAAI,UAAU,IACb,KAAM,MAAc,WAAW,QAAQ,KAAK,OAAO,GAAG,GAAG,CACzD;AACD,WAAO;GACP,GAAE,CAAE,EAAQ;EACb;CACF,EAAC;AACH,QAAO,CAAC,OAAO,eAAgB;AAC/B"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["explicitStateTypes: ESLintUtils.RuleModule<\n\t`noTypeArgument`,\n\t[],\n\tunknown,\n\tESLintUtils.RuleListener\n>","synchronousSelectorDependencies: {\n\tmeta: {\n\t\ttype: RuleType\n\t\tdocs: {\n\t\t\tdescription: string\n\t\t\tcategory: string\n\t\t\trecommended: boolean\n\t\t\turl: string\n\t\t}\n\t\tschema: never[]\n\t}\n\tcreate(context: Rule.RuleContext): Rule.NodeListener\n}","context: Rule.RuleContext","plugin: ESLint.Plugin"],"sources":["../../src/eslint-plugin/rules/explicit-state-types.ts","../../src/eslint-plugin/rules/synchronous-selector-dependencies.ts","../../src/eslint-plugin/rules/index.ts","../../src/eslint-plugin/index.ts"],"sourcesContent":null,"mappings":";;;;;;cASaA,oBAAoB,WAAA,CAAY,0CAI5C,WAAA,CAAY;;;;cCNAC;;UAEL;;MDAR,WAAaD,EAAAA,MAAAA;MAIA,QAAA,EAAA,MAAA;MAAA,WAAZ,EAAA,OAAY;MAAA,GAAA,EAJoB,MAAA;IAAY,CAAA;;;kBCS5B,IAAA,CAAK,cAAc,IAAA,CAAK;AAXzC,CAAA;;;;;;;;;cEDMG,QAAQ,MAAA,CAAO"}
+{"version":3,"file":"index.d.ts","names":["explicitStateTypes: ESLintUtils.RuleModule<\n\t`noTypeArgument`,\n\t[],\n\tunknown,\n\tESLintUtils.RuleListener\n>","synchronousSelectorDependencies: {\n\tmeta: {\n\t\ttype: RuleType\n\t\tdocs: {\n\t\t\tdescription: string\n\t\t\tcategory: string\n\t\t\trecommended: boolean\n\t\t\turl: string\n\t\t}\n\t\tschema: never[]\n\t}\n\tcreate(context: Rule.RuleContext): Rule.NodeListener\n}","context: Rule.RuleContext","plugin: ESLint.Plugin"],"sources":["../../src/eslint-plugin/rules/explicit-state-types.ts","../../src/eslint-plugin/rules/synchronous-selector-dependencies.ts","../../src/eslint-plugin/rules/index.ts","../../src/eslint-plugin/index.ts"],"sourcesContent":[],"mappings":";;;;;;cASaA,oBAAoB,WAAA,CAAY,0CAI5C,WAAA,CAAY;;;;cCNAC;;UAEL;;MDAR,WAAaD,EAAAA,MAAAA;MAIA,QAAA,EAAA,MAAA;MAAA,WAAZ,EAAA,OAAY;MAAA,GAAA,EAJoB,MAAA;IAAY,CAAA;;;kBCS5B,IAAA,CAAK,cAAc,IAAA,CAAK;AAXzC,CAAA;;;;;;;;;cEDMG,QAAQ,MAAA,CAAO"}

package/dist/internal/index.d.ts

@@ -1,6 +1,6 @@
 import { Func as Func$1, Store as Store$1 } from "atom.io/internal";
 import { Canonical, Json, JsonInterface, stringified } from "atom.io/json";
-import { Above, ActorToolkit, Anarchy, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomToken, Claim, CompoundFrom, CompoundTypedKey, FamilyMetadata, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, Logger, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, ReadableFamilyToken, ReadableToken, ReadonlySelectorFamilyOptions, ReadonlySelectorFamilyToken, ReadonlySelectorOptions, ReadonlySelectorToken, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorFamilyToken, SelectorToken, SetterToolkit, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenType, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, UpdateHandler, Vassal, WritableFamilyToken, WritableSelectorFamilyOptions, WritableSelectorFamilyToken, WritableSelectorOptions, WritableSelectorToken, WritableToken } from "atom.io";
+import { Above, ActorToolkit, Anarchy, AtomFamilyToken, AtomIOLogger, AtomIOToken, AtomToken, Claim, CompoundFrom, CompoundTypedKey, FamilyMetadata, HeldSelectorFamilyToken, HeldSelectorToken, Hierarchy, JoinOptions, JoinStates, JoinToken, KeyedStateUpdate, Logger, MoleculeCreation, MoleculeDisposal, MoleculeTransfer, MutableAtomFamilyOptions, MutableAtomFamilyToken, MutableAtomOptions, MutableAtomToken, PureSelectorFamilyToken, PureSelectorToken, ReadableFamilyToken, ReadableToken, ReadonlyHeldSelectorFamilyOptions, ReadonlyHeldSelectorFamilyToken, ReadonlyHeldSelectorOptions, ReadonlyHeldSelectorToken, ReadonlyPureSelectorFamilyOptions, ReadonlyPureSelectorFamilyToken, ReadonlyPureSelectorOptions, ReadonlyPureSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, RegularAtomFamilyOptions, RegularAtomFamilyToken, RegularAtomOptions, RegularAtomToken, SelectorFamilyToken, SelectorToken, SetterToolkit, SingularTypedKey, StateCreation, StateDisposal, StateUpdate, TimelineManageable, TimelineOptions, TimelineToken, TimelineUpdate, TokenType, TransactionOptions, TransactionToken, TransactionUpdate, TransactionUpdateHandler, UpdateHandler, Vassal, WritableFamilyToken, WritableHeldSelectorFamilyOptions, WritableHeldSelectorFamilyToken, WritableHeldSelectorOptions, WritableHeldSelectorToken, WritablePureSelectorFamilyOptions, WritablePureSelectorFamilyToken, WritablePureSelectorOptions, WritablePureSelectorToken, WritableSelectorFamilyToken, WritableSelectorToken, WritableToken } from "atom.io";
 import { SetRTX, SetRTXJson } from "atom.io/transceivers/set-rtx";
 
 //#region src/internal/store/circular-buffer.d.ts
@@ -19,16 +19,18 @@ declare class CircularBuffer<T> {
 //#region src/internal/store/counterfeit.d.ts
 declare const FAMILY_MEMBER_TOKEN_TYPES: {
   readonly atom_family: "atom";
-  readonly mutable_atom_family: "mutable_atom";
-  readonly selector_family: "selector";
-  readonly readonly_selector_family: "readonly_selector";
   readonly molecule_family: "molecule";
+  readonly mutable_atom_family: "mutable_atom";
+  readonly readonly_held_selector_family: "readonly_held_selector";
+  readonly readonly_pure_selector_family: "readonly_pure_selector";
+  readonly writable_held_selector_family: "writable_held_selector";
+  readonly writable_pure_selector_family: "writable_pure_selector";
 };
 declare function counterfeit<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: AtomFamilyToken<T, K>, key: Key): AtomToken<T>;
-declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T>;
-declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T>;
+declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadonlyPureSelectorFamilyToken<T, K>, key: Key): ReadonlyPureSelectorToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: WritableFamilyToken<T, K>, key: Key): WritableToken<T>;
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
@@ -77,7 +79,7 @@ type JunctionAdvancedConfiguration<AType extends string, BType extends string, C
   makeContentKey?: (a: AType, b: BType) => string;
 };
 type JunctionJSON<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null = null> {
+declare class Junction<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Content extends Json.Object | null = null> {
   readonly a: ASide;
   readonly b: BSide;
   readonly cardinality: `1:1` | `1:n` | `n:n`;
@@ -213,16 +215,16 @@ type TransactionEpoch = {
 declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
 declare function deposit<T extends Transceiver<any>>(state: MutableAtom<T, any>): MutableAtomToken<T, any>;
 declare function deposit<T>(state: Atom<T>): AtomToken<T>;
-declare function deposit<T>(state: WritableSelector<T>): WritableSelectorToken<T>;
-declare function deposit<T>(state: ReadonlySelector<T>): ReadonlySelectorToken<T>;
+declare function deposit<T>(state: WritablePureSelector<T>): WritablePureSelectorToken<T>;
+declare function deposit<T>(state: ReadonlyPureSelector<T>): ReadonlyPureSelectorToken<T>;
 declare function deposit<T>(state: Selector<T>): SelectorToken<T>;
 declare function deposit<T>(state: WritableState<T>): WritableToken<T>;
 declare function deposit<T>(state: ReadableState<T>): ReadableToken<T>;
 declare function deposit<T, K extends Canonical>(state: RegularAtomFamily<T, K>): RegularAtomFamilyToken<T, K>;
 declare function deposit<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(state: MutableAtomFamily<T, J, K>): MutableAtomFamilyToken<T, J, K>;
 declare function deposit<T>(state: AtomFamily<T, any>): AtomFamilyToken<T, any>;
-declare function deposit<T>(state: WritableSelectorFamily<T, any>): WritableSelectorFamilyToken<T, any>;
-declare function deposit<T>(state: ReadonlySelectorFamily<T, any>): ReadonlySelectorFamilyToken<T, any>;
+declare function deposit<T>(state: WritablePureSelectorFamily<T, any>): WritablePureSelectorFamilyToken<T, any>;
+declare function deposit<T>(state: ReadonlyPureSelectorFamily<T, any>): ReadonlyPureSelectorFamilyToken<T, any>;
 declare function deposit<T>(state: SelectorFamily<T, any>): SelectorFamilyToken<T, any>;
 declare function deposit<T>(state: WritableFamily<T, any>): WritableFamilyToken<T, any>;
 declare function deposit<T>(state: ReadableFamily<T, any>): ReadableFamilyToken<T, any>;
@@ -257,8 +259,8 @@ declare function claimWithinStore<H extends Hierarchy, V extends Exclude<Vassal<
 
 //#endregion
 //#region src/internal/join/join-internal.d.ts
-type JoinStateFamilies<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlySelectorFamilyToken<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlySelectorFamilyToken<BType[], AType> } : never;
-declare class Join<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null = null, ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
+type JoinStateFamilies<ASide extends string, AType extends string, BSide extends string, BType extends string, Cardinality extends `1:1` | `1:n` | `n:n`, Content extends Json.Object | null> = Cardinality extends `1:1` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntryOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<[BType, Content] | null, AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeyOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<BType | null, AType> } : Cardinality extends `1:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntryOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<[AType, Content] | null, BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeyOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<AType | null, BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<BType[], AType> } : Cardinality extends `n:n` ? (Content extends Json.Object ? { readonly [A in ASide as `${A}EntriesOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<[AType, Content][], BType> } & { readonly [B in BSide as `${B}EntriesOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<[BType, Content][], AType> } : {}) & { readonly [A in ASide as `${A}KeysOf${Capitalize<BSide>}`]: ReadonlyPureSelectorFamilyToken<AType[], BType> } & { readonly [B in BSide as `${B}KeysOf${Capitalize<ASide>}`]: ReadonlyPureSelectorFamilyToken<BType[], AType> } : never;
+declare class Join<const ASide extends string, const AType extends string, const BSide extends string, const BType extends string, const Cardinality extends `1:1` | `1:n` | `n:n`, const Content extends Json.Object | null = null, const ContentKey extends CompoundTypedKey<`content`, ASide, BSide> = CompoundTypedKey<`content`, ASide, BSide>> {
   private toolkit;
   options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>;
   defaultContent: Content | undefined;
@@ -361,7 +363,7 @@ declare class Store implements Lineage {
   valueMap: Map<string, any>;
   defaults: Map<string, any>;
   atoms: Map<string, Atom<any>>;
-  selectors: Map<string, WritableSelector<any>>;
+  writableSelectors: Map<string, WritableSelector<any>>;
   readonlySelectors: Map<string, ReadonlySelector<any>>;
   atomsThatAreDefault: Set<string>;
   selectorAtoms: Junction<`selectorKey`, string, `atomKey`, string>;
@@ -369,7 +371,7 @@ declare class Store implements Lineage {
     source: string;
   }>;
   trackers: Map<string, Tracker<Transceiver<any>>>;
-  families: Map<string, MutableAtomFamily<any, any, any> | ReadonlySelectorFamily<any, any> | RegularAtomFamily<any, any> | WritableSelectorFamily<any, any>>;
+  families: Map<string, HeldSelectorFamily<any, any> | MutableAtomFamily<any, any, any> | PureSelectorFamily<any, any> | RegularAtomFamily<any, any>>;
   joins: Map<string, Join<any, any, any, any, any, any>>;
   transactions: Map<string, Transaction<Func>>;
   transactionMeta: TransactionEpoch | TransactionProgress<Func>;
@@ -401,8 +403,8 @@ declare class Store implements Lineage {
 type StoreEventCarrier = {
   atomCreation: Subject<AtomToken<unknown>>;
   atomDisposal: Subject<AtomToken<unknown>>;
-  selectorCreation: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
-  selectorDisposal: Subject<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
+  selectorCreation: Subject<SelectorToken<unknown>>;
+  selectorDisposal: Subject<SelectorToken<unknown>>;
   timelineCreation: Subject<TimelineToken<unknown>>;
   transactionCreation: Subject<TransactionToken<Func>>;
   transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
@@ -423,16 +425,28 @@ declare const clearStore: (store: Store) => void;
 declare function withdraw<T>(store: Store, token: RegularAtomToken<T>): RegularAtom<T>;
 declare function withdraw<T extends Transceiver<any>>(store: Store, token: MutableAtomToken<T, any>): MutableAtom<T, any>;
 declare function withdraw<T>(store: Store, token: AtomToken<T>): Atom<T>;
-declare function withdraw<T>(store: Store, token: WritableSelectorToken<T>): WritableSelector<T>;
+declare function withdraw<T>(store: Store, token: WritableHeldSelectorToken<T>): WritableHeldSelector<T>;
+declare function withdraw<T>(store: Store, token: ReadonlyHeldSelectorToken<T>): ReadonlyHeldSelector<T>;
+declare function withdraw<T>(store: Store, token: WritablePureSelectorToken<T>): WritablePureSelector<T>;
+declare function withdraw<T>(store: Store, token: ReadonlyPureSelectorToken<T>): ReadonlyPureSelector<T>;
 declare function withdraw<T>(store: Store, token: ReadonlySelectorToken<T>): ReadonlySelector<T>;
+declare function withdraw<T>(store: Store, token: WritableSelectorToken<T>): WritableSelector<T>;
+declare function withdraw<T>(store: Store, token: HeldSelectorToken<T>): HeldSelector<T>;
+declare function withdraw<T>(store: Store, token: PureSelectorToken<T>): PureSelector<T>;
 declare function withdraw<T>(store: Store, token: SelectorToken<T>): Selector<T>;
 declare function withdraw<T>(store: Store, token: WritableToken<T>): WritableState<T>;
 declare function withdraw<T>(store: Store, token: ReadableToken<T>): ReadableState<T>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: RegularAtomFamilyToken<T, K>): RegularAtomFamily<T, K>;
 declare function withdraw<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, token: MutableAtomFamilyToken<T, J, K>): MutableAtomFamily<T, J, K>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: AtomFamilyToken<T>): AtomFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlyHeldSelectorFamilyToken<T, K>): ReadonlyHeldSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: WritableHeldSelectorFamilyToken<T, K>): WritableHeldSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K>): ReadonlyPureSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: WritablePureSelectorFamilyToken<T, K>): WritablePureSelectorFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: WritableSelectorFamilyToken<T, K>): WritableSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: HeldSelectorFamilyToken<T, K>): HeldSelectorFamily<T, any>;
+declare function withdraw<T, K extends Canonical>(store: Store, token: PureSelectorFamilyToken<T, K>): PureSelectorFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: SelectorFamilyToken<T, K>): SelectorFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: ReadableFamilyToken<T, K>): ReadableFamily<T, any>;
 declare function withdraw<T, K extends Canonical>(store: Store, token: WritableFamilyToken<T, K>): WritableFamily<T, any>;
@@ -465,11 +479,11 @@ declare function createMutableAtomFamily<T extends Transceiver<any>, J extends J
 
 //#endregion
 //#region src/internal/mutable/get-json-family.d.ts
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
+declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritablePureSelectorFamily<SerializableCore, Key>;
 
 //#endregion
 //#region src/internal/mutable/get-json-token.d.ts
-declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
+declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritablePureSelectorToken<SerializableCore>;
 
 //#endregion
 //#region src/internal/mutable/get-update-family.d.ts
@@ -569,8 +583,8 @@ declare function createAtomFamily<T extends Transceiver<any>, J extends Json.Ser
 declare function createAtomFamily<T, K extends Canonical>(store: Store, options: RegularAtomFamilyOptions<T, K>): RegularAtomFamilyToken<T, K>;
 
 //#endregion
-//#region src/internal/families/create-readonly-selector-family.d.ts
-declare function createReadonlySelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlySelectorFamilyToken<T, K>;
+//#region src/internal/families/create-readonly-pure-selector-family.d.ts
+declare function createReadonlyPureSelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlyPureSelectorFamilyOptions<T, K>, internalRoles?: string[]): ReadonlyPureSelectorFamilyToken<T, K>;
 
 //#endregion
 //#region src/internal/families/create-regular-atom-family.d.ts
@@ -578,12 +592,14 @@ declare function createRegularAtomFamily<T, K extends Canonical>(store: Store, o
 
 //#endregion
 //#region src/internal/families/create-selector-family.d.ts
-declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: WritableSelectorFamilyOptions<T, K>): WritableSelectorFamilyToken<T, K>;
-declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlySelectorFamilyOptions<T, K>): ReadonlySelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T extends object, K extends Canonical>(store: Store, options: WritableHeldSelectorFamilyOptions<T, K>): WritableHeldSelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T extends object, K extends Canonical>(store: Store, options: ReadonlyHeldSelectorFamilyOptions<T, K>): ReadonlyHeldSelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: WritablePureSelectorFamilyOptions<T, K>): WritablePureSelectorFamilyToken<T, K>;
+declare function createSelectorFamily<T, K extends Canonical>(store: Store, options: ReadonlyPureSelectorFamilyOptions<T, K>): ReadonlyPureSelectorFamilyToken<T, K>;
 
 //#endregion
-//#region src/internal/families/create-writable-selector-family.d.ts
-declare function createWritableSelectorFamily<T, K extends Canonical>(store: Store, options: WritableSelectorFamilyOptions<T, K>, internalRoles?: string[]): WritableSelectorFamilyToken<T, K>;
+//#region src/internal/families/create-writable-pure-selector-family.d.ts
+declare function createWritablePureSelectorFamily<T, K extends Canonical>(store: Store, options: WritablePureSelectorFamilyOptions<T, K>, internalRoles?: string[]): WritablePureSelectorFamilyToken<T, K>;
 
 //#endregion
 //#region src/internal/families/dispose-from-store.d.ts
@@ -595,8 +611,8 @@ declare function disposeFromStore<K extends Canonical>(store: Store, token: Read
 declare function findInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
-declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K>;
+declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K>, key: Key): ReadonlyPureSelectorToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
 declare function findInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
@@ -606,8 +622,8 @@ declare function findInStore<T, K extends Canonical, Key extends K>(store: Store
 declare function initFamilyMemberInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K>;
-declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K>;
+declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K>, key: Key): ReadonlyPureSelectorToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K>;
 declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K>;
@@ -617,8 +633,8 @@ declare function initFamilyMemberInStore<T, K extends Canonical, Key extends K>(
 declare function seekInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical, Key extends K>(store: Store, token: MutableAtomFamilyToken<T, J, K>, key: Key): MutableAtomToken<T, J, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: RegularAtomFamilyToken<T, K>, key: Key): RegularAtomToken<T, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: AtomFamilyToken<T, K>, key: Key): AtomToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableSelectorFamilyToken<T, K>, key: Key): WritableSelectorToken<T, K> | undefined;
-declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlySelectorFamilyToken<T, K>, key: Key): ReadonlySelectorToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritablePureSelectorFamilyToken<T, K>, key: Key): WritablePureSelectorToken<T, K> | undefined;
+declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadonlyPureSelectorFamilyToken<T, K>, key: Key): ReadonlyPureSelectorToken<T, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: SelectorFamilyToken<T, K>, key: Key): SelectorToken<T, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: WritableFamilyToken<T, K>, key: Key): WritableToken<T, K> | undefined;
 declare function seekInStore<T, K extends Canonical, Key extends K>(store: Store, token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T, K> | undefined;
@@ -724,17 +740,27 @@ type ReservedIntrospectionKey = `🔍 ${string}`;
 declare function isReservedIntrospectionKey(value: string): value is ReservedIntrospectionKey;
 
 //#endregion
-//#region src/internal/selector/create-readonly-selector.d.ts
-declare const createReadonlySelector: <T>(store: Store, options: ReadonlySelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlySelectorToken<T>;
+//#region src/internal/selector/create-readonly-held-selector.d.ts
+declare const createReadonlyHeldSelector: <T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlyHeldSelectorToken<T>;
+
+//#endregion
+//#region src/internal/selector/create-readonly-pure-selector.d.ts
+declare const createReadonlyPureSelector: <T>(store: Store, options: ReadonlyPureSelectorOptions<T>, family: FamilyMetadata | undefined) => ReadonlyPureSelectorToken<T>;
 
 //#endregion
 //#region src/internal/selector/create-standalone-selector.d.ts
-declare function createStandaloneSelector<T>(store: Store, options: WritableSelectorOptions<T>): WritableSelectorToken<T>;
-declare function createStandaloneSelector<T>(store: Store, options: ReadonlySelectorOptions<T>): ReadonlySelectorToken<T>;
+declare function createStandaloneSelector<T extends object>(store: Store, options: WritableHeldSelectorOptions<T>): WritableHeldSelectorToken<T>;
+declare function createStandaloneSelector<T extends object>(store: Store, options: ReadonlyHeldSelectorOptions<T>): ReadonlyHeldSelectorToken<T>;
+declare function createStandaloneSelector<T>(store: Store, options: WritablePureSelectorOptions<T>): WritablePureSelectorToken<T>;
+declare function createStandaloneSelector<T>(store: Store, options: ReadonlyPureSelectorOptions<T>): ReadonlyPureSelectorToken<T>;
 
 //#endregion
-//#region src/internal/selector/create-writable-selector.d.ts
-declare const createWritableSelector: <T>(store: Store, options: WritableSelectorOptions<T>, family: FamilyMetadata | undefined) => WritableSelectorToken<T>;
+//#region src/internal/selector/create-writable-held-selector.d.ts
+declare const createWritableHeldSelector: <T extends object>(store: Store, options: WritableHeldSelectorOptions<T>, family: FamilyMetadata | undefined) => WritableHeldSelectorToken<T>;
+
+//#endregion
+//#region src/internal/selector/create-writable-pure-selector.d.ts
+declare const createWritablePureSelector: <T>(store: Store, options: WritablePureSelectorOptions<T>, family: FamilyMetadata | undefined) => WritablePureSelectorToken<T>;
 
 //#endregion
 //#region src/internal/selector/dispose-selector.d.ts
@@ -742,20 +768,20 @@ declare function disposeSelector(store: Store, selectorToken: SelectorToken<unkn
 
 //#endregion
 //#region src/internal/selector/get-selector-dependency-keys.d.ts
-declare const getSelectorDependencyKeys: (key: string, store: Store) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
+declare const getSelectorDependencyKeys: (store: Store, key: string) => (AtomKey<unknown> | ReadonlySelectorKey<unknown> | SelectorKey<unknown>)[];
 
 //#endregion
 //#region src/internal/selector/register-selector.d.ts
-declare const registerSelector: (selectorKey: string, covered: Set<string>, store: Store) => SetterToolkit;
+declare const registerSelector: (store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, covered: Set<string>) => SetterToolkit;
 
 //#endregion
 //#region src/internal/selector/trace-selector-atoms.d.ts
-declare const traceSelectorAtoms: (directDependencyKey: StateKey<unknown>, covered: Set<string>, store: Store) => AtomKey<unknown>[];
+declare const traceSelectorAtoms: (store: Store, directDependencyKey: StateKey<unknown>, covered: Set<string>) => AtomKey<unknown>[];
 declare const traceAllSelectorAtoms: (selector: Selector<any>, store: Store) => AtomKey<unknown>[];
 
 //#endregion
 //#region src/internal/selector/update-selector-atoms.d.ts
-declare const updateSelectorAtoms: (selectorKey: string, dependency: ReadonlySelectorToken<unknown> | WritableToken<unknown>, covered: Set<string>, store: Store) => void;
+declare const updateSelectorAtoms: (store: Store, selectorType: `readonly_held_selector` | `readonly_pure_selector` | `writable_held_selector` | `writable_pure_selector`, selectorKey: string, dependency: ReadonlyPureSelectorToken<unknown> | WritableToken<unknown>, covered: Set<string>) => void;
 
 //#endregion
 //#region src/internal/set-state/become.d.ts
@@ -820,16 +846,31 @@ type MutableAtom<T extends Transceiver<any>, J extends Json.Serializable> = Atom
   cleanup?: () => void;
 };
 type Atom<T> = RegularAtom<T> | (T extends Transceiver<any> ? MutableAtom<T, any> : never);
-type WritableSelector<T> = AtomIOState & {
-  type: `selector`;
+type WritableHeldSelector<T> = AtomIOState & {
+  type: `writable_held_selector`;
+  const: T;
   get: () => T;
   set: (newValue: T | ((oldValue: T) => T)) => void;
 };
-type ReadonlySelector<T> = AtomIOState & {
-  type: `readonly_selector`;
+type ReadonlyHeldSelector<T> = AtomIOState & {
+  type: `readonly_held_selector`;
+  const: T;
   get: () => T;
 };
-type Selector<T> = ReadonlySelector<T> | WritableSelector<T>;
+type WritablePureSelector<T> = AtomIOState & {
+  type: `writable_pure_selector`;
+  get: () => T;
+  set: (newValue: T | ((oldValue: T) => T)) => void;
+};
+type ReadonlyPureSelector<T> = AtomIOState & {
+  type: `readonly_pure_selector`;
+  get: () => T;
+};
+type ReadonlySelector<T> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T>;
+type WritableSelector<T> = WritableHeldSelector<T> | WritablePureSelector<T>;
+type HeldSelector<T> = ReadonlyHeldSelector<T> | WritableHeldSelector<T>;
+type PureSelector<T> = ReadonlyPureSelector<T> | WritablePureSelector<T>;
+type Selector<T> = ReadonlyHeldSelector<T> | ReadonlyPureSelector<T> | WritableHeldSelector<T> | WritablePureSelector<T>;
 type WritableState<T> = Atom<T> | WritableSelector<T>;
 type ReadableState<T> = Atom<T> | Selector<T>;
 type RegularAtomFamily<T, K extends Canonical> = RegularAtomFamilyToken<T, K> & {
@@ -845,23 +886,39 @@ type MutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable,
   internalRoles: string[] | undefined;
 };
 type AtomFamily<T, K extends Canonical = Canonical> = MutableAtomFamily<T extends Transceiver<any> ? T : never, any, K> | RegularAtomFamily<T, K>;
-type WritableSelectorFamily<T, K extends Canonical> = WritableSelectorFamilyToken<T, K> & ((key: K) => WritableSelectorToken<T>) & {
+type WritablePureSelectorFamily<T, K extends Canonical> = WritablePureSelectorFamilyToken<T, K> & ((key: K) => WritablePureSelectorToken<T>) & {
+  default: (key: K) => T;
+  subject: Subject<StateCreation<WritablePureSelectorToken<T>> | StateDisposal<WritablePureSelectorToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
+};
+type WritableHeldSelectorFamily<T, K extends Canonical> = WritableHeldSelectorFamilyToken<T, K> & ((key: K) => WritableHeldSelectorToken<T>) & {
+  default: (key: K) => T;
+  subject: Subject<StateCreation<WritableHeldSelectorToken<T>> | StateDisposal<WritableHeldSelectorToken<T>>>;
+  install: (store: Store) => void;
+  internalRoles: string[] | undefined;
+};
+type ReadonlyPureSelectorFamily<T, K extends Canonical> = ReadonlyPureSelectorFamilyToken<T, K> & ((key: K) => ReadonlyPureSelectorToken<T>) & {
   default: (key: K) => T;
-  subject: Subject<StateCreation<WritableSelectorToken<T>> | StateDisposal<WritableSelectorToken<T>>>;
+  subject: Subject<StateCreation<ReadonlyPureSelectorToken<T>> | StateDisposal<ReadonlyPureSelectorToken<T>>>;
   install: (store: Store) => void;
   internalRoles: string[] | undefined;
 };
-type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlySelectorFamilyToken<T, K> & ((key: K) => ReadonlySelectorToken<T>) & {
+type ReadonlyHeldSelectorFamily<T, K extends Canonical> = ReadonlyHeldSelectorFamilyToken<T, K> & ((key: K) => ReadonlyHeldSelectorToken<T>) & {
   default: (key: K) => T;
-  subject: Subject<StateCreation<ReadonlySelectorToken<T>> | StateDisposal<ReadonlySelectorToken<T>>>;
+  subject: Subject<StateCreation<ReadonlyHeldSelectorToken<T>> | StateDisposal<ReadonlyHeldSelectorToken<T>>>;
   install: (store: Store) => void;
   internalRoles: string[] | undefined;
 };
-type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | WritableSelectorFamily<T, K>;
-type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
+type PureSelectorFamily<T, K extends Canonical> = ReadonlyPureSelectorFamily<T, K> | WritablePureSelectorFamily<T, K>;
+type HeldSelectorFamily<T, K extends Canonical> = ReadonlyHeldSelectorFamily<T, K> | WritableHeldSelectorFamily<T, K>;
+type ReadonlySelectorFamily<T, K extends Canonical> = ReadonlyHeldSelectorFamily<T, K> | ReadonlyPureSelectorFamily<T, K>;
+type WritableSelectorFamily<T, K extends Canonical> = WritableHeldSelectorFamily<T, K> | WritablePureSelectorFamily<T, K>;
+type SelectorFamily<T, K extends Canonical> = HeldSelectorFamily<T, K> | PureSelectorFamily<T, K>;
+type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritablePureSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 type AtomIOInternalResource = ReadableFamily<any, any> | ReadableState<any> | Timeline<any> | Transaction<any>;
 
 //#endregion
-export { Atom, AtomFamily, AtomIOInternalResource, AtomIOState, AtomKey, BaseExternalStoreConfiguration, ChildStore, CircularBuffer, Count, Each, Empty, EnvironmentData, ExternalStoreConfiguration, ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Flat, Func, Future, IMPLICIT, Join, JoinStateFamilies, Junction, JunctionAdvancedConfiguration, JunctionEntries, JunctionEntriesBase, JunctionJSON, JunctionSchema, JunctionSchemaBase, LazyMap, Lineage, Modify, Molecule, MutableAtom, MutableAtomFamily, NotFoundError, OperationProgress, ReadableFamily, ReadableState, ReadonlySelector, ReadonlySelectorFamily, ReadonlySelectorKey, Refinement, RegularAtom, RegularAtomFamily, ReservedIntrospectionKey, RootStore, Selector, SelectorFamily, SelectorKey, Signal$1 as Signal, StateKey, StatefulSubject, Store, StoreEventCarrier, Subject, TRANSACTION_PHASES, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Tracker, Transaction, TransactionEpoch, TransactionPhase, TransactionProgress, Transceiver, TransceiverMode, WritableFamily, WritableSelector, WritableSelectorFamily, WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, createWritableSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { Atom, AtomFamily, AtomIOInternalResource, AtomIOState, AtomKey, BaseExternalStoreConfiguration, ChildStore, CircularBuffer, Count, Each, Empty, EnvironmentData, ExternalStoreConfiguration, ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Flat, Func, Future, HeldSelector, HeldSelectorFamily, IMPLICIT, Join, JoinStateFamilies, Junction, JunctionAdvancedConfiguration, JunctionEntries, JunctionEntriesBase, JunctionJSON, JunctionSchema, JunctionSchemaBase, LazyMap, Lineage, Modify, Molecule, MutableAtom, MutableAtomFamily, NotFoundError, OperationProgress, PureSelector, PureSelectorFamily, ReadableFamily, ReadableState, ReadonlyHeldSelector, ReadonlyHeldSelectorFamily, ReadonlyPureSelector, ReadonlyPureSelectorFamily, ReadonlySelector, ReadonlySelectorFamily, ReadonlySelectorKey, Refinement, RegularAtom, RegularAtomFamily, ReservedIntrospectionKey, RootStore, Selector, SelectorFamily, SelectorKey, Signal$1 as Signal, StateKey, StatefulSubject, Store, StoreEventCarrier, Subject, TRANSACTION_PHASES, Timeline, TimelineAtomUpdate, TimelineMoleculeCreation, TimelineMoleculeDisposal, TimelineSelectorUpdate, TimelineStateCreation, TimelineStateDisposal, TimelineTransactionUpdate, Tracker, Transaction, TransactionEpoch, TransactionPhase, TransactionProgress, Transceiver, TransceiverMode, WritableFamily, WritableHeldSelector, WritableHeldSelectorFamily, WritablePureSelector, WritablePureSelectorFamily, WritableSelector, WritableSelectorFamily, WritableState, abortTransaction, actUponStore, allocateIntoStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, capitalize, claimWithinStore, clearStore, closeOperation, counterfeit, createAtomFamily, createMutableAtom, createMutableAtomFamily, createReadonlyHeldSelector, createReadonlyPureSelector, createReadonlyPureSelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableHeldSelector, createWritablePureSelector, createWritablePureSelectorFamily, deallocateFromStore, deposit, disposeAtom, disposeFromStore, disposeSelector, editRelationsInStore, evictCachedValue, findInStore, findRelationsInStore, fuseWithinStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getInternalRelationsFromStore, getJoin, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getTrace, getUpdateFamily, getUpdateToken, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestMoleculeTransferEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, installIntoStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isReservedIntrospectionKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeRootMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
 //# sourceMappingURL=index.d.ts.map