atom.io 0.40.5 → 0.40.7

package/dist/web/index.js

@@ -1,5 +1,6 @@
-//#region src/web/persist-sync.ts
-const persistSync = (storage, { stringify, parse }, key) => ({ setSelf, onSet }) => {
+//#region src/web/storage-sync.ts
+const storageSync = (storage, { stringify, parse }, key) => ({ setSelf, onSet }) => {
+	if (!storage) return;
 	const savedValue = storage.getItem(key);
 	if (savedValue != null) setSelf(parse(savedValue));
 	onSet(({ newValue }) => {
@@ -12,5 +13,5 @@ const persistSync = (storage, { stringify, parse }, key) => ({ setSelf, onSet })
 };
 
 //#endregion
-export { persistSync };
+export { storageSync };
 //# sourceMappingURL=index.js.map

package/dist/web/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/web/persist-sync.ts"],"sourcesContent":["import type { AtomEffect, ViewOf } from \"atom.io\"\n\nexport type StringInterface<T> = {\n\tstringify: (t: ViewOf<T>) => string\n\tparse: (s: string) => T\n}\n\nexport const persistSync =\n\t<T>(\n\t\tstorage: Storage,\n\t\t{ stringify, parse }: StringInterface<T>,\n\t\tkey: string,\n\t): AtomEffect<T> =>\n\t({ setSelf, onSet }) => {\n\t\tconst savedValue = storage.getItem(key)\n\t\tif (savedValue != null) setSelf(parse(savedValue))\n\n\t\tonSet(({ newValue }) => {\n\t\t\tif (newValue == null) {\n\t\t\t\tstorage.removeItem(key)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tstorage.setItem(key, stringify(newValue))\n\t\t})\n\t}\n"],"mappings":";AAOA,MAAa,eAEX,SACA,EAAE,WAAW,SACb,SAEA,EAAE,SAAS,YAAY;CACvB,MAAM,aAAa,QAAQ,QAAQ;AACnC,KAAI,cAAc,KAAM,SAAQ,MAAM;AAEtC,QAAO,EAAE,eAAe;AACvB,MAAI,YAAY,MAAM;AACrB,WAAQ,WAAW;AACnB;;AAED,UAAQ,QAAQ,KAAK,UAAU"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/web/storage-sync.ts"],"sourcesContent":["import type { AtomEffect, ViewOf } from \"atom.io\"\n\nexport type StringInterface<T> = {\n\tstringify: (t: ViewOf<T>) => string\n\tparse: (s: string) => T\n}\n\nexport const storageSync =\n\t<T>(\n\t\tstorage: Storage | undefined,\n\t\t{ stringify, parse }: StringInterface<T>,\n\t\tkey: string,\n\t): AtomEffect<T> =>\n\t({ setSelf, onSet }) => {\n\t\tif (!storage) {\n\t\t\treturn\n\t\t}\n\t\tconst savedValue = storage.getItem(key)\n\t\tif (savedValue != null) setSelf(parse(savedValue))\n\n\t\tonSet(({ newValue }) => {\n\t\t\tif (newValue == null) {\n\t\t\t\tstorage.removeItem(key)\n\t\t\t\treturn\n\t\t\t}\n\t\t\tstorage.setItem(key, stringify(newValue))\n\t\t})\n\t}\n"],"mappings":";AAOA,MAAa,eAEX,SACA,EAAE,WAAW,SACb,SAEA,EAAE,SAAS,YAAY;AACvB,KAAI,CAAC,QACJ;CAED,MAAM,aAAa,QAAQ,QAAQ;AACnC,KAAI,cAAc,KAAM,SAAQ,MAAM;AAEtC,QAAO,EAAE,eAAe;AACvB,MAAI,YAAY,MAAM;AACrB,WAAQ,WAAW;AACnB;;AAED,UAAQ,QAAQ,KAAK,UAAU"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.40.5",
+  "version": "0.40.7",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -61,9 +61,9 @@
   },
   "devDependencies": {
     "@eslint/core": "0.15.2",
-    "@storybook/addon-docs": "9.1.3",
-    "@storybook/addon-onboarding": "9.1.3",
-    "@storybook/react-vite": "9.1.3",
+    "@storybook/addon-docs": "9.1.4",
+    "@storybook/addon-onboarding": "9.1.4",
+    "@storybook/react-vite": "9.1.4",
     "@testing-library/react": "16.3.0",
     "@types/bun": "npm:bun-types@1.2.21",
     "@types/eslint": "9.6.1",
@@ -72,15 +72,15 @@
     "@types/npmlog": "7.0.0",
     "@types/react": "19.1.12",
     "@types/tmp": "0.2.6",
-    "@typescript-eslint/parser": "8.41.0",
-    "@typescript-eslint/rule-tester": "8.41.0",
-    "@typescript-eslint/utils": "8.41.0",
+    "@typescript-eslint/parser": "8.42.0",
+    "@typescript-eslint/rule-tester": "8.42.0",
+    "@typescript-eslint/utils": "8.42.0",
     "@vitest/coverage-v8": "3.2.4",
     "@vitest/ui": "3.2.4",
     "concurrently": "9.2.1",
     "drizzle-kit": "0.31.4",
     "drizzle-orm": "0.44.5",
-    "eslint": "9.34.0",
+    "eslint": "9.35.0",
     "happy-dom": "18.0.1",
     "http-proxy": "1.18.1",
     "motion": "12.23.12",
@@ -94,15 +94,15 @@
     "recoverage": "0.1.11",
     "socket.io": "4.8.1",
     "socket.io-client": "4.8.1",
-    "storybook": "9.1.3",
+    "storybook": "9.1.4",
     "tmp": "0.2.5",
     "tsdown": "0.14.2",
     "typescript": "5.9.2",
-    "vite": "7.1.3",
+    "vite": "7.1.4",
     "vite-tsconfig-paths": "5.1.4",
     "vitest": "3.2.4",
     "zod": "3.25.76",
-    "break-check": "0.6.14"
+    "break-check": "0.6.15"
   },
   "main": "./dist/main/index.js",
   "files": [
@@ -177,7 +177,7 @@
   },
   "scripts": {
     "manifest": "./__scripts__/manifest-build.node.ts",
-    "build": "tsdown && bun ./__scripts__/build-sort.bun.ts",
+    "build": "tsdown",
     "lint:biome": "biome check -- .",
     "lint:eslint": "eslint -- .",
     "lint:types": "tsgo --noEmit",

package/src/internal/atom/create-regular-atom.ts

@@ -6,20 +6,21 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
-import type { RegularAtom, RootStore } from ".."
-import { resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
+import { resetInStore, setIntoStore } from "../set-state"
+import type { RegularAtom } from "../state-types"
 import type { Store } from "../store"
 import { deposit } from "../store"
 import { Subject } from "../subject"
 import { subscribeToState } from "../subscribe"
-import type { internalRole } from "./has-role"
+import type { RootStore } from "../transaction"
+import type { InternalRole } from "./has-role"
 
 export function createRegularAtom<T, K extends Canonical, E>(
 	store: Store,
 	options: RegularAtomOptions<T, E>,
 	family: FamilyMetadata<K> | undefined,
-	internalRoles?: internalRole[],
+	internalRoles?: InternalRole[],
 ): RegularAtomToken<T, K, E> {
 	const type = `atom`
 	const { key } = options

package/src/internal/atom/dispose-atom.ts

@@ -1,8 +1,13 @@
 import type { AtomDisposalEvent, AtomToken, StateLifecycleEvent } from "atom.io"
 
-import type { Store, Subject } from ".."
-import { getUpdateToken, hasRole, isChildStore, newest, withdraw } from ".."
 import { getFamilyOfToken } from "../families/get-family-of-token"
+import { newest } from "../lineage"
+import { getUpdateToken } from "../mutable"
+import type { Store } from "../store"
+import { withdraw } from "../store"
+import type { Subject } from "../subject"
+import { isChildStore } from "../transaction"
+import { hasRole } from "./has-role"
 
 export function disposeAtom(
 	store: Store,

package/src/internal/atom/has-role.ts

@@ -1,9 +1,9 @@
-import type { Atom } from ".."
+import type { Atom } from "../state-types"
 
 export const INTERNAL_ROLES = [`tracker:signal`] as const
-export type internalRole = (typeof INTERNAL_ROLES)[number]
+export type InternalRole = (typeof INTERNAL_ROLES)[number]
 
-export function hasRole(atom: Atom<any, any>, role: internalRole): boolean {
+export function hasRole(atom: Atom<any, any>, role: InternalRole): boolean {
 	if (`internalRoles` in atom === false) {
 		return false
 	}

package/src/internal/caching.ts

@@ -1,11 +1,13 @@
-import type { ReadableState, Transceiver } from "."
-import { closeOperation, isChildStore, openOperation, Tracker } from "."
 import { Future } from "./future"
+import { Tracker, type Transceiver } from "./mutable"
+import { closeOperation, openOperation } from "./operation"
 import {
 	evictDownstreamFromAtom,
 	evictDownstreamFromSelector,
 } from "./set-state/evict-downstream"
+import type { ReadableState } from "./state-types"
 import type { Store } from "./store"
+import { isChildStore } from "./transaction"
 
 export function writeToCache<T, E>(
 	target: Store,

package/src/internal/families/create-readonly-held-selector-family.ts

@@ -9,10 +9,11 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { ReadonlyHeldSelectorFamily, RootStore } from ".."
 import { newest } from "../lineage"
 import { createReadonlyHeldSelector } from "../selector"
+import type { ReadonlyHeldSelectorFamily } from "../state-types"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 
 export function createReadonlyHeldSelectorFamily<
 	T extends object,

package/src/internal/families/create-readonly-pure-selector-family.ts

@@ -12,11 +12,14 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { ReadonlyPureSelectorFamily, RootStore } from ".."
-import { findInStore, getFromStore, getJsonToken } from ".."
+import { getFromStore } from "../get-state"
 import { newest } from "../lineage"
+import { getJsonToken } from "../mutable"
 import { createReadonlyPureSelector } from "../selector"
+import type { ReadonlyPureSelectorFamily } from "../state-types"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
+import { findInStore } from "./find-in-store"
 
 export function createReadonlyPureSelectorFamily<T, K extends Canonical, E>(
 	store: RootStore,

package/src/internal/families/create-regular-atom-family.ts

@@ -10,11 +10,12 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { RegularAtomFamily, RootStore } from ".."
 import { createRegularAtom } from "../atom"
 import { isFn } from "../is-fn"
 import { newest } from "../lineage"
+import type { RegularAtomFamily } from "../state-types"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 
 export function createRegularAtomFamily<T, K extends Canonical, E>(
 	store: RootStore,

package/src/internal/families/create-writable-held-selector-family.ts

@@ -9,11 +9,12 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { RootStore, WritableHeldSelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createWritableHeldSelector } from "../selector"
+import type { WritableHeldSelectorFamily } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
 
 export function createWritableHeldSelectorFamily<
 	T extends object,

package/src/internal/families/create-writable-pure-selector-family.ts

@@ -12,12 +12,15 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { RootStore, WritablePureSelectorFamily } from ".."
-import { findInStore, getFromStore, getJsonToken } from ".."
+import { getFromStore } from "../get-state"
 import { newest } from "../lineage"
+import { getJsonToken } from "../mutable"
 import { createWritablePureSelector } from "../selector"
+import type { WritablePureSelectorFamily } from "../state-types"
 import type { Store } from "../store"
 import { Subject } from "../subject"
+import type { RootStore } from "../transaction"
+import { findInStore } from "./find-in-store"
 
 export function createWritablePureSelectorFamily<T, K extends Canonical, E>(
 	store: Store,

package/src/internal/families/dispose-from-store.ts

@@ -11,16 +11,16 @@ export function disposeFromStore(
 	token: ReadableToken<any, any, any>,
 ): void
 
-export function disposeFromStore<K extends Canonical, Key extends K>(
+export function disposeFromStore<K extends Canonical>(
 	store: Store,
 	token: ReadableFamilyToken<any, K, any>,
-	key: Key,
+	key: NoInfer<K>,
 ): void
 
-export function disposeFromStore<K extends Canonical, Key extends K>(
+export function disposeFromStore<K extends Canonical>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<any, K, any>, key: Key]
+		| [token: ReadableFamilyToken<any, K, any>, key: NoInfer<K>]
 		| [token: ReadableToken<any, any, any>]
 ): void
 

package/src/internal/families/find-in-store.ts

@@ -20,7 +20,7 @@ import type { Canonical } from "atom.io/json"
 
 import type { Transceiver } from "../mutable"
 import { type Store, withdraw } from "../store"
-import { mintInStore } from "./mint-in-store"
+import { DO_NOT_CREATE, mintInStore } from "./mint-in-store"
 import { seekInStore } from "./seek-in-store"
 
 // seek [token 🟧] [inits ⬛]
@@ -36,49 +36,49 @@ export function findInStore<
 	store: Store,
 	familyToken: MutableAtomFamilyToken<T, K>,
 	key: Key,
-): MutableAtomToken<T, K>
+): MutableAtomToken<T, Key>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: RegularAtomFamilyToken<T, K, E>,
 	key: Key,
-): RegularAtomToken<T, K, E>
+): RegularAtomToken<T, Key, E>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: AtomFamilyToken<T, K, E>,
 	key: Key,
-): AtomToken<T, K, E>
+): AtomToken<T, Key, E>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: WritablePureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): WritablePureSelectorToken<T, K, E>
+): WritablePureSelectorToken<T, Key, E>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: ReadonlyPureSelectorFamilyToken<T, K, E>,
 	key: Key,
-): ReadonlyPureSelectorToken<T, K, E>
+): ReadonlyPureSelectorToken<T, Key, E>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: SelectorFamilyToken<T, K, E>,
 	key: Key,
-): SelectorToken<T, K, E>
+): SelectorToken<T, Key, E>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: WritableFamilyToken<T, K, E>,
 	key: Key,
-): WritableToken<T, K, E>
+): WritableToken<T, Key, E>
 
 export function findInStore<T, K extends Canonical, Key extends K, E>(
 	store: Store,
 	familyToken: ReadableFamilyToken<T, K, E>,
 	key: Key,
-): ReadableToken<T, K, E>
+): ReadableToken<T, Key, E>
 
 export function findInStore(
 	store: Store,
@@ -90,6 +90,6 @@ export function findInStore(
 	if (existingStateToken) {
 		return existingStateToken
 	}
-	const newStateToken = mintInStore(store, family, key)
+	const newStateToken = mintInStore(DO_NOT_CREATE, store, family, key)
 	return newStateToken
 }

package/src/internal/families/get-family-of-token.ts

@@ -8,6 +8,7 @@ import type {
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 
+import type { Transceiver } from "../mutable"
 import type {
 	MutableAtomFamily,
 	ReadableFamily,
@@ -15,8 +16,7 @@ import type {
 	RegularAtomFamily,
 	WritableFamily,
 	WritablePureSelectorFamily,
-} from ".."
-import type { Transceiver } from "../mutable"
+} from "../state-types"
 import { type Store, withdraw } from "../store"
 
 export function getFamilyOfToken<

package/src/internal/families/index.ts

@@ -5,4 +5,5 @@ export * from "./create-selector-family"
 export * from "./create-writable-pure-selector-family"
 export * from "./dispose-from-store"
 export * from "./find-in-store"
+export * from "./get-family-of-token"
 export * from "./seek-in-store"

package/src/internal/families/mint-in-store.ts

@@ -2,48 +2,71 @@ import type { ReadableToken, WritableToken } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { ReadableFamily } from ".."
+import type { ReadableFamily } from "../state-types"
 import type { Store } from "../store"
-import { COUNTERFEIT, mint } from "../store"
+
+export const FAMILY_MEMBER_TOKEN_TYPES = {
+	atom_family: `atom`,
+	molecule_family: `molecule`,
+	mutable_atom_family: `mutable_atom`,
+	readonly_held_selector_family: `readonly_held_selector`,
+	readonly_pure_selector_family: `readonly_pure_selector`,
+	writable_held_selector_family: `writable_held_selector`,
+	writable_pure_selector_family: `writable_pure_selector`,
+} as const
 
 export const MUST_CREATE: unique symbol = Symbol(`MUST_CREATE`)
+export const DO_NOT_CREATE: unique symbol = Symbol(`DO_NOT_CREATE`)
 
-export function mintInStore<T, K extends Canonical, Key extends K, E>(
+export function mintInStore<T, K extends Canonical, KK extends K, E>(
+	mustCreate: typeof DO_NOT_CREATE | typeof MUST_CREATE,
 	store: Store,
 	family: ReadableFamily<T, K, E>,
-	key: Key,
-	mustCreate?: typeof MUST_CREATE,
-): WritableToken<T, Key, E>
-export function mintInStore<T, K extends Canonical, Key extends K, E>(
+	key: KK,
+): WritableToken<T, KK, E>
+export function mintInStore<T, K extends Canonical, KK extends K, E>(
+	mustCreate: typeof DO_NOT_CREATE | typeof MUST_CREATE,
 	store: Store,
 	family: ReadableFamily<T, K, E>,
-	key: Key,
-	mustCreate?: typeof MUST_CREATE,
-): ReadableToken<T, Key, E>
-export function mintInStore<T, K extends Canonical, Key extends K, E>(
+	key: KK,
+): ReadableToken<T, KK, E>
+export function mintInStore<T, K extends Canonical, KK extends K, E>(
+	mustCreate: typeof DO_NOT_CREATE | typeof MUST_CREATE,
 	store: Store,
 	family: ReadableFamily<T, K, E>,
-	key: Key,
-	mustCreate?: typeof MUST_CREATE,
-): ReadableToken<T, Key, E> {
+	key: KK,
+): ReadableToken<T, KK, E> {
 	const stringKey = stringifyJson(key)
 	const molecule = store.molecules.get(stringKey)
 
 	const cannotCreate = !molecule && store.config.lifespan === `immortal`
 
 	if (cannotCreate) {
+		const { type: familyType, key: familyKey } = family
 		store.logger.warn(
 			`💣`,
 			`key`,
 			stringKey,
 			`was used to mint a counterfeit token for`,
-			family.type,
-			`"${family.key}"`,
+			familyType,
+			`"${familyKey}"`,
 		)
-		return mint(family, key, COUNTERFEIT)
+		const fullKey = `${familyKey}(${stringKey})`
+		const type = FAMILY_MEMBER_TOKEN_TYPES[familyType]
+		const stateToken: ReadableToken<T, KK, E> & { counterfeit: true } = {
+			counterfeit: true,
+			key: fullKey,
+			type,
+			family: {
+				key: familyKey,
+				subKey: stringKey,
+			},
+		}
+
+		return stateToken
 	}
 
-	let token: ReadableToken<T, Key, E>
+	let token: ReadableToken<T, KK, E>
 	if (mustCreate === MUST_CREATE) {
 		store.logger.info(
 			`👪`,
@@ -57,7 +80,19 @@ export function mintInStore<T, K extends Canonical, Key extends K, E>(
 			store.moleculeData.set(stringKey, family.key)
 		}
 	} else {
-		token = mint(family, key)
+		const { type: familyType, key: familyKey } = family
+		const fullKey = `${familyKey}(${stringKey})`
+		const type = FAMILY_MEMBER_TOKEN_TYPES[familyType]
+		const stateToken: ReadableToken<T, KK, E> = {
+			key: fullKey,
+			type,
+			family: {
+				key: familyKey,
+				subKey: stringKey,
+			},
+		}
+
+		return stateToken
 	}
 
 	return token

package/src/internal/families/seek-in-store.ts

@@ -19,9 +19,9 @@ import type {
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import type { ReadableState } from ".."
 import { newest } from "../lineage"
 import type { Transceiver } from "../mutable"
+import type { ReadableState } from "../state-types"
 import { deposit, type Store } from "../store"
 
 export function seekInStore<

package/src/internal/get-state/get-fallback.ts

@@ -1,14 +1,14 @@
 import type { ReadableToken, ViewOf } from "atom.io"
 import { type Canonical, stringifyJson } from "atom.io/json"
 
-import type { ReadableFamily } from ".."
+import type { ReadableFamily } from "../state-types"
 import type { Store } from "../store"
 
 export function getFallback<T, K extends Canonical, E>(
 	store: Store,
 	token: ReadableToken<T, K, E>,
 	family: ReadableFamily<T, K, E>,
-	subKey: K,
+	subKey: NoInfer<K>,
 ): ViewOf<E | T> {
 	const disposal = store.disposalTraces.buffer.find(
 		(item) => item?.key === stringifyJson(subKey),

package/src/internal/get-state/get-from-store.ts

@@ -16,20 +16,20 @@ export function getFromStore<T, E>(
 export function getFromStore<T, K extends Canonical, E>(
 	store: Store,
 	token: ReadableFamilyToken<T, K, E>,
-	key: K,
+	key: NoInfer<K>,
 ): ViewOf<E | T>
 
-export function getFromStore<T, K extends Canonical, Key extends K, E>(
+export function getFromStore<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, any, E>]
 ): ViewOf<E | T>
 
-export function getFromStore<T, K extends Canonical, Key extends K, E>(
+export function getFromStore<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: Key]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, any, E>]
 ): ViewOf<E | T> {
 	const { token, family, subKey } = reduceReference(store, ...params)

package/src/internal/get-state/read-or-compute-value.ts

@@ -1,8 +1,8 @@
 import type { ViewOf } from "atom.io"
 
-import type { ReadableState } from ".."
 import { readFromCache, writeToCache } from "../caching"
 import { safeCompute } from "../safe-compute"
+import type { ReadableState } from "../state-types"
 import type { Store } from "../store"
 
 export function readOrComputeValue<T, E>(

package/src/internal/get-state/reduce-reference.ts

@@ -5,23 +5,25 @@ import type {
 } from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
-import type { ReadableFamily, Subject } from ".."
-import { isChildStore, isRootStore, newest } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
+import { newest } from "../lineage"
+import type { ReadableFamily } from "../state-types"
 import type { Store } from "../store"
 import { withdraw } from "../store"
+import type { Subject } from "../subject"
+import { isChildStore, isRootStore } from "../transaction"
 
 export function reduceReference<T, K extends Canonical, E>(
 	store: Store,
 	...params:
-		| [token: ReadableFamilyToken<T, K, E>, key: K]
+		| [token: ReadableFamilyToken<T, K, E>, key: NoInfer<K>]
 		| [token: ReadableToken<T, K, E>]
 ): {
 	token: ReadableToken<T, K, E>
 	family: ReadableFamily<T, K, E> | undefined
-	subKey: K | undefined
+	subKey: NoInfer<K> | undefined
 	isNew: boolean
 } {
 	let existingToken: ReadableToken<T, K, E> | undefined
@@ -45,7 +47,7 @@ export function reduceReference<T, K extends Canonical, E>(
 				}
 			}
 			if (!existingToken) {
-				brandNewToken = mintInStore(store, familyToken, subKey, MUST_CREATE)
+				brandNewToken = mintInStore(MUST_CREATE, store, familyToken, subKey)
 				token = brandNewToken
 			} else {
 				token = existingToken
@@ -56,7 +58,7 @@ export function reduceReference<T, K extends Canonical, E>(
 		subKey = params[1]
 		existingToken = seekInStore(store, family, subKey)
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, subKey, MUST_CREATE)
+			brandNewToken = mintInStore(MUST_CREATE, store, family, subKey)
 			token = brandNewToken
 		} else {
 			token = existingToken