atom.io 0.19.0 → 0.19.2

package/internal/src/timeline/add-atom-to-timeline.ts

@@ -1,4 +1,9 @@
-import type { AtomToken, TransactionToken, TransactionUpdate, ƒn } from "atom.io"
+import type {
+	AtomToken,
+	TransactionToken,
+	TransactionUpdate,
+	Func,
+} from "atom.io"
 import type { TimelineUpdate } from "atom.io"
 
 import { newest } from "../lineage"
@@ -51,8 +56,8 @@ export const addAtomToTimeline = (
 			currentTransactionKey
 				? `in transaction "${currentTransactionKey}"`
 				: currentSelectorKey
-				  ? `in selector "${currentSelectorKey}"`
-				  : ``,
+					? `in selector "${currentSelectorKey}"`
+					: ``,
 		)
 		if (tl.timeTraveling === null) {
 			if (tl.selectorTime && tl.selectorTime !== currentSelectorTime) {
@@ -82,7 +87,7 @@ export const addAtomToTimeline = (
 					tl.transactionKey = currentTransactionKey
 					const unsubscribe = currentTransaction.subject.subscribe(
 						`timeline:${tl.key}`,
-						(update) => {
+						(transactionUpdate) => {
 							unsubscribe()
 							if (tl.timeTraveling === null && currentTransactionInstanceId) {
 								if (tl.at !== tl.history.length) {
@@ -90,23 +95,23 @@ export const addAtomToTimeline = (
 								}
 
 								const filterUpdates = (
-									updates: TransactionUpdate<ƒn>[`updates`],
+									updates: TransactionUpdate<Func>[`updates`],
 								) =>
 									updates
 										.filter((updateFromTx) => {
-											const target = newest(store)
+											const newestStore = newest(store)
 											if (`updates` in updateFromTx) {
 												return true
 											}
 											const atomOrFamilyKeys =
-												target.timelineAtoms.getRelatedKeys(tl.key)
+												newestStore.timelineAtoms.getRelatedKeys(tl.key)
 
 											return atomOrFamilyKeys
 												? [...atomOrFamilyKeys].some(
 														(key) =>
 															key === updateFromTx.key ||
 															key === updateFromTx.family?.key,
-												  )
+													)
 												: false
 										})
 										.map((updateFromTx) => {
@@ -119,12 +124,12 @@ export const addAtomToTimeline = (
 											return updateFromTx
 										})
 
-								const updates = filterUpdates(update.updates)
+								const updates = filterUpdates(transactionUpdate.updates)
 
 								const timelineTransactionUpdate: TimelineTransactionUpdate = {
 									type: `transaction_update`,
 									timestamp: Date.now(),
-									...update,
+									...transactionUpdate,
 									updates,
 								}
 								const willCapture =
@@ -140,7 +145,7 @@ export const addAtomToTimeline = (
 								`⌛`,
 								`timeline`,
 								tl.key,
-								`got a transaction_update "${update.key}"`,
+								`got a transaction_update "${transactionUpdate.key}"`,
 							)
 						},
 					)

package/internal/src/timeline/create-timeline.ts

@@ -1,5 +1,4 @@
 import type {
-	AtomFamily,
 	AtomFamilyToken,
 	FamilyMetadata,
 	StateUpdate,
@@ -9,7 +8,7 @@ import type {
 	TimelineUpdate,
 	TokenType,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"
@@ -31,7 +30,7 @@ export type TimelineSelectorUpdate<ManagedAtom extends TimelineManageable> = {
 	timestamp: number
 	atomUpdates: Omit<TimelineAtomUpdate<ManagedAtom>, `timestamp`>[]
 }
-export type TimelineTransactionUpdate = TransactionUpdate<ƒn> & {
+export type TimelineTransactionUpdate = TransactionUpdate<Func> & {
 	key: string
 	type: `transaction_update`
 	timestamp: number
@@ -73,7 +72,7 @@ export function createTimeline<ManagedAtom extends TimelineManageable>(
 		transactionKey: null,
 		...data,
 		history: data?.history.map((update) => ({ ...update })) ?? [],
-		install: (store) => createTimeline(options, store, tl),
+		install: (s) => createTimeline(options, s, tl),
 		subject: new Subject(),
 	}
 	if (options.shouldCapture) {

package/internal/src/transaction/act-upon-store.ts

@@ -1,15 +1,15 @@
-import type { TransactionToken, ƒn } from "atom.io"
+import type { TransactionToken, Func } from "atom.io"
 
 import { NotFoundError } from "../not-found-error"
 import type { Store } from "../store"
 import { withdraw } from "../store"
 
-export function actUponStore<ƒ extends ƒn>(
-	token: TransactionToken<ƒ>,
+export function actUponStore<F extends Func>(
+	token: TransactionToken<F>,
 	id: string,
 	store: Store,
-): (...parameters: Parameters<ƒ>) => ReturnType<ƒ> {
-	return (...parameters: Parameters<ƒ>): ReturnType<ƒ> => {
+): (...parameters: Parameters<F>) => ReturnType<F> {
+	return (...parameters: Parameters<F>): ReturnType<F> => {
 		const tx = withdraw(token, store)
 		if (tx) {
 			return tx.run(parameters, id)

package/internal/src/transaction/apply-transaction.ts

@@ -1,4 +1,4 @@
-import type { ƒn } from "atom.io"
+import type { Func } from "atom.io"
 
 import { ingestTransactionUpdate } from "../ingest-updates"
 import { newest } from "../lineage"
@@ -7,8 +7,8 @@ import type { Store } from "../store"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
-export const applyTransaction = <ƒ extends ƒn>(
-	output: ReturnType<ƒ>,
+export const applyTransaction = <F extends Func>(
+	output: ReturnType<F>,
 	store: Store,
 ): void => {
 	const child = newest(store)
@@ -65,7 +65,7 @@ export const applyTransaction = <ƒ extends ƒn>(
 			child.transactionMeta.update.epoch,
 			parent,
 		)
-		const myTransaction = withdraw<ƒ>(
+		const myTransaction = withdraw<F>(
 			{ key: child.transactionMeta.update.key, type: `transaction` },
 			store,
 		)

package/internal/src/transaction/build-transaction.ts

@@ -1,4 +1,4 @@
-import type { findState, ƒn } from "atom.io"
+import type { findState, Func } from "atom.io"
 
 import { Junction } from "~/packages/rel8/junction/src"
 
@@ -45,21 +45,24 @@ export const buildTransaction = (
 		valueMap: new LazyMap(parent.valueMap),
 	}
 	const epoch = getEpochNumberOfAction(key, store)
-	const transactionMeta: TransactionProgress<ƒn> = {
-		phase: `building` as const,
+	const transactionMeta: TransactionProgress<Func> = {
+		phase: `building`,
 		update: {
 			key,
 			id,
-			epoch: epoch === undefined ? NaN : epoch + 1,
+			epoch: epoch === undefined ? Number.NaN : epoch + 1,
 			updates: [],
 			params,
 			output: undefined,
 		},
 		transactors: {
 			get: (token) => getFromStore(token, child),
-			set: (token, value) => setIntoStore(token, value, child),
-			run: (token, id = arbitrary()) => actUponStore(token, id, child),
-			find: ((token, key) => findInStore(token, key, child)) as typeof findState,
+			set: (token, value) => {
+				setIntoStore(token, value, child)
+			},
+			run: (token, identifier = arbitrary()) =>
+				actUponStore(token, identifier, child),
+			find: ((token, k) => findInStore(token, k, child)) as typeof findState,
 			env: () => getEnvironmentData(child),
 		},
 	}

package/internal/src/transaction/create-transaction.ts

@@ -2,7 +2,7 @@ import type {
 	TransactionOptions,
 	TransactionToken,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 
 import { newest } from "../lineage"
@@ -13,22 +13,22 @@ import { abortTransaction } from "./abort-transaction"
 import { applyTransaction } from "./apply-transaction"
 import { buildTransaction } from "./build-transaction"
 
-export type Transaction<ƒ extends ƒn> = {
+export type Transaction<F extends Func> = {
 	key: string
 	type: `transaction`
 	install: (store: Store) => void
-	subject: Subject<TransactionUpdate<ƒ>>
-	run: (parameters: Parameters<ƒ>, id?: string) => ReturnType<ƒ>
+	subject: Subject<TransactionUpdate<F>>
+	run: (parameters: Parameters<F>, id?: string) => ReturnType<F>
 }
 
-export function createTransaction<ƒ extends ƒn>(
-	options: TransactionOptions<ƒ>,
+export function createTransaction<F extends Func>(
+	options: TransactionOptions<F>,
 	store: Store,
-): TransactionToken<ƒ> {
-	const newTransaction: Transaction<ƒ> = {
+): TransactionToken<F> {
+	const newTransaction: Transaction<F> = {
 		key: options.key,
 		type: `transaction`,
-		run: (params: Parameters<ƒ>, id: string) => {
+		run: (params: Parameters<F>, id: string) => {
 			const childStore = buildTransaction(options.key, params, store, id)
 			try {
 				const target = newest(store)
@@ -42,7 +42,7 @@ export function createTransaction<ƒ extends ƒn>(
 				throw thrown
 			}
 		},
-		install: (store) => createTransaction(options, store),
+		install: (s) => createTransaction(options, s),
 		subject: new Subject(),
 	}
 	const target = newest(store)

package/internal/src/transaction/index.ts

@@ -1,4 +1,4 @@
-import type { TransactionUpdate, TransactorsWithRunAndEnv, ƒn } from "atom.io"
+import type { TransactionUpdate, TransactorsWithRunAndEnv, Func } from "atom.io"
 import type { Junction } from "rel8/junction"
 
 export * from "./abort-transaction"
@@ -14,9 +14,9 @@ export * from "./set-epoch-number"
 export const TRANSACTION_PHASES = [`idle`, `building`, `applying`] as const
 export type TransactionPhase = (typeof TRANSACTION_PHASES)[number]
 
-export type TransactionProgress<ƒ extends ƒn> = {
+export type TransactionProgress<F extends Func> = {
 	phase: `applying` | `building`
-	update: TransactionUpdate<ƒ>
+	update: TransactionUpdate<F>
 	transactors: TransactorsWithRunAndEnv
 }
 

package/internal/src/transaction/is-root-store.ts

@@ -1,4 +1,4 @@
-import type { ƒn } from "atom.io"
+import type { Func } from "atom.io"
 
 import type { TransactionEpoch, TransactionProgress } from "."
 import type { Store } from "../store"
@@ -9,7 +9,7 @@ export interface RootStore extends Store {
 	child: ChildStore | null
 }
 export interface ChildStore extends Store {
-	transactionMeta: TransactionProgress<ƒn>
+	transactionMeta: TransactionProgress<Func>
 	parent: ChildStore | RootStore
 	child: ChildStore | null
 }

package/introspection/dist/index.cjs

@@ -42,12 +42,13 @@ var __spreadValues = (a, b) => {
 };
 var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var attachAtomIndex = (store = Internal.IMPLICIT.STORE) => {
+  console.log(store.config);
   const atomTokenIndexState__INTERNAL = Internal.createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
-        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
-          acc[key] = { key, type: `atom` };
+        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key, atom]) => {
+          acc[key] = { key, type: atom.type };
           return acc;
         }, {});
         return defaultAtomIndex;

package/introspection/dist/index.d.ts

@@ -1,24 +1,24 @@
-import { RegularAtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, ƒn as _n, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
+import { AtomToken, ReadonlySelectorToken, WritableSelectorToken, TransactionToken, Func, ReadonlySelectorFamilyToken, TransactionUpdate, TimelineToken } from 'atom.io';
 import * as Internal from 'atom.io/internal';
 import { Timeline } from 'atom.io/internal';
 
-type AtomTokenIndex = WritableTokenIndex<RegularAtomToken<unknown>>;
+type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>;
 
 type SelectorTokenIndex = WritableTokenIndex<ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>>;
 
 declare const attachIntrospectionStates: (store?: Internal.Store) => {
     atomIndex: ReadonlySelectorToken<AtomTokenIndex>;
     selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>;
-    transactionIndex: ReadonlySelectorToken<TransactionToken<_n>[]>;
-    findTransactionLogState: ReadonlySelectorFamilyToken<TransactionUpdate<_n>[], string>;
+    transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>;
+    findTransactionLogState: ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string>;
     timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>;
     findTimelineState: ReadonlySelectorFamilyToken<Timeline<any>, string>;
 };
 
-type FamilyNode<Token extends ReadonlySelectorToken<unknown> | RegularAtomToken<unknown> | WritableSelectorToken<unknown>> = {
+type FamilyNode<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = {
     key: string;
     familyMembers: Record<string, Token>;
 };
-type WritableTokenIndex<Token extends ReadonlySelectorToken<unknown> | RegularAtomToken<unknown> | WritableSelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
+type WritableTokenIndex<Token extends AtomToken<unknown> | ReadonlySelectorToken<unknown> | WritableSelectorToken<unknown>> = Record<string, FamilyNode<Token> | Token>;
 
 export { type FamilyNode, type WritableTokenIndex, attachIntrospectionStates };

package/introspection/dist/index.js

@@ -3,12 +3,13 @@ import * as Internal from 'atom.io/internal';
 import { createRegularAtom, newest, createStandaloneSelector, IMPLICIT, createRegularAtomFamily, Subject, createSelectorFamily } from 'atom.io/internal';
 
 var attachAtomIndex = (store = IMPLICIT.STORE) => {
+  console.log(store.config);
   const atomTokenIndexState__INTERNAL = createRegularAtom(
     {
       key: `\u{1F441}\u200D\u{1F5E8} Atom Token Index (Internal)`,
       default: () => {
-        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key]) => {
-          acc[key] = { key, type: `atom` };
+        const defaultAtomIndex = [...store.atoms].filter(([key]) => !key.includes(`\u{1F441}\u200D\u{1F5E8}`)).reduce((acc, [key, atom]) => {
+          acc[key] = { key, type: atom.type };
           return acc;
         }, {});
         return defaultAtomIndex;

package/introspection/src/attach-atom-index.ts

@@ -1,4 +1,4 @@
-import type { ReadonlySelectorToken, RegularAtomToken } from "atom.io"
+import type { AtomToken, ReadonlySelectorToken } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
@@ -9,19 +9,20 @@ import {
 
 import type { WritableTokenIndex } from "."
 
-export type AtomTokenIndex = WritableTokenIndex<RegularAtomToken<unknown>>
+export type AtomTokenIndex = WritableTokenIndex<AtomToken<unknown>>
 
 export const attachAtomIndex = (
 	store: Store = IMPLICIT.STORE,
 ): ReadonlySelectorToken<AtomTokenIndex> => {
+	console.log(store.config)
 	const atomTokenIndexState__INTERNAL = createRegularAtom<AtomTokenIndex>(
 		{
 			key: `👁‍🗨 Atom Token Index (Internal)`,
 			default: () => {
 				const defaultAtomIndex = [...store.atoms]
 					.filter(([key]) => !key.includes(`👁‍🗨`))
-					.reduce<AtomTokenIndex>((acc, [key]) => {
-						acc[key] = { key, type: `atom` }
+					.reduce<AtomTokenIndex>((acc, [key, atom]) => {
+						acc[key] = { key, type: atom.type }
 						return acc
 					}, {})
 				return defaultAtomIndex

package/introspection/src/attach-introspection-states.ts

@@ -5,7 +5,7 @@ import type {
 	TimelineToken,
 	TransactionToken,
 	TransactionUpdate,
-	ƒn,
+	Func,
 } from "atom.io"
 import * as Internal from "atom.io/internal"
 import type { Timeline } from "atom.io/internal"
@@ -23,9 +23,9 @@ export const attachIntrospectionStates = (
 ): {
 	atomIndex: ReadonlySelectorToken<AtomTokenIndex>
 	selectorIndex: ReadonlySelectorToken<SelectorTokenIndex>
-	transactionIndex: ReadonlySelectorToken<TransactionToken<ƒn>[]>
+	transactionIndex: ReadonlySelectorToken<TransactionToken<Func>[]>
 	findTransactionLogState: ReadonlySelectorFamilyToken<
-		TransactionUpdate<ƒn>[],
+		TransactionUpdate<Func>[],
 		string
 	>
 	timelineIndex: ReadonlySelectorToken<TimelineToken<any>[]>

package/introspection/src/attach-transaction-index.ts

@@ -1,4 +1,4 @@
-import type { ReadonlySelectorToken, TransactionToken, ƒn } from "atom.io"
+import type { ReadonlySelectorToken, TransactionToken, Func } from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
@@ -8,14 +8,14 @@ import {
 
 export const attachTransactionIndex = (
 	store: Store = IMPLICIT.STORE,
-): ReadonlySelectorToken<TransactionToken<ƒn>[]> => {
+): ReadonlySelectorToken<TransactionToken<Func>[]> => {
 	const transactionTokenIndexState__INTERNAL = createRegularAtom<
-		TransactionToken<ƒn>[]
+		TransactionToken<Func>[]
 	>(
 		{
 			key: `👁‍🗨 Transaction Token Index (Internal)`,
 			default: () =>
-				[...store.transactions].map(([key]): TransactionToken<ƒn> => {
+				[...store.transactions].map(([key]): TransactionToken<Func> => {
 					return { key, type: `transaction` }
 				}),
 			effects: [

package/introspection/src/attach-transaction-logs.ts

@@ -1,4 +1,8 @@
-import type { ReadonlySelectorFamilyToken, TransactionUpdate, ƒn } from "atom.io"
+import type {
+	ReadonlySelectorFamilyToken,
+	TransactionUpdate,
+	Func,
+} from "atom.io"
 import type { Store } from "atom.io/internal"
 import {
 	IMPLICIT,
@@ -8,9 +12,9 @@ import {
 
 export const attachTransactionLogs = (
 	store: Store = IMPLICIT.STORE,
-): ReadonlySelectorFamilyToken<TransactionUpdate<ƒn>[], string> => {
+): ReadonlySelectorFamilyToken<TransactionUpdate<Func>[], string> => {
 	const findTransactionUpdateLog = createRegularAtomFamily<
-		TransactionUpdate<ƒn>[],
+		TransactionUpdate<Func>[],
 		string
 	>(
 		{
@@ -30,7 +34,7 @@ export const attachTransactionLogs = (
 		store,
 	)
 	const findTransactionUpdateLogState = createSelectorFamily<
-		TransactionUpdate<ƒn>[],
+		TransactionUpdate<Func>[],
 		string
 	>(
 		{

package/introspection/src/index.ts

@@ -1,6 +1,6 @@
 import type {
+	AtomToken,
 	ReadonlySelectorToken,
-	RegularAtomToken,
 	WritableSelectorToken,
 } from "atom.io"
 
@@ -8,8 +8,8 @@ export * from "./attach-introspection-states"
 
 export type FamilyNode<
 	Token extends
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>,
 > = {
 	key: string
@@ -18,7 +18,7 @@ export type FamilyNode<
 
 export type WritableTokenIndex<
 	Token extends
+		| AtomToken<unknown>
 		| ReadonlySelectorToken<unknown>
-		| RegularAtomToken<unknown>
 		| WritableSelectorToken<unknown>,
 > = Record<string, FamilyNode<Token> | Token>

package/json/dist/index.cjs

@@ -49,7 +49,9 @@ var selectJson = (atom, transform, store = internal.IMPLICIT.STORE) => {
     {
       key: `${atom.key}:JSON`,
       get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue))
+      set: ({ set }, newValue) => {
+        set(atom, transform.fromJson(newValue));
+      }
     },
     store
   );
@@ -59,7 +61,9 @@ function selectJsonFamily(atomFamily, transform, store = internal.IMPLICIT.STORE
     {
       key: `${atomFamily.key}:JSON`,
       get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
-      set: (key) => ({ set }, newValue) => set(atomFamily(key), transform.fromJson(newValue))
+      set: (key) => ({ set }, newValue) => {
+        set(atomFamily(key), transform.fromJson(newValue));
+      }
     },
     store
   );

package/json/dist/index.d.ts

@@ -26,7 +26,7 @@ declare namespace json {
   export type { json_Array as Array, Object$1 as Object, json_Serializable as Serializable };
 }
 
-declare const parseJson: <S extends Stringified<Serializable>>(str: string | S) => S extends Stringified<infer J extends Serializable> ? J : Serializable;
+declare const parseJson: <S extends Stringified<Serializable>>(str: S | string) => S extends Stringified<infer J extends Serializable> ? J : Serializable;
 type Stringified<J extends Serializable> = string & {
     __json: J;
 };

package/json/dist/index.js

@@ -1,5 +1,5 @@
-import { parseJson } from '../../dist/chunk-VAE5OCKN.js';
-export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-VAE5OCKN.js';
+import { parseJson } from '../../dist/chunk-BF4MVQF6.js';
+export { JSON_DEFAULTS, JSON_TYPE_NAMES, isBoolean, isNull, isNumber, isPrimitive, isString, parseJson, stringSetJsonInterface, stringifyJson } from '../../dist/chunk-BF4MVQF6.js';
 import '../../dist/chunk-U2IICNHQ.js';
 import { createStandaloneSelector, IMPLICIT, createSelectorFamily } from 'atom.io/internal';
 
@@ -8,7 +8,9 @@ var selectJson = (atom, transform, store = IMPLICIT.STORE) => {
     {
       key: `${atom.key}:JSON`,
       get: ({ get }) => transform.toJson(get(atom)),
-      set: ({ set }, newValue) => set(atom, transform.fromJson(newValue))
+      set: ({ set }, newValue) => {
+        set(atom, transform.fromJson(newValue));
+      }
     },
     store
   );
@@ -18,7 +20,9 @@ function selectJsonFamily(atomFamily, transform, store = IMPLICIT.STORE) {
     {
       key: `${atomFamily.key}:JSON`,
       get: (key) => ({ get }) => transform.toJson(get(atomFamily(key))),
-      set: (key) => ({ set }, newValue) => set(atomFamily(key), transform.fromJson(newValue))
+      set: (key) => ({ set }, newValue) => {
+        set(atomFamily(key), transform.fromJson(newValue));
+      }
     },
     store
   );

package/json/src/select-json-family.ts

@@ -43,8 +43,9 @@ export function selectJsonFamily<
 					transform.toJson(get(atomFamily(key))),
 			set:
 				(key) =>
-				({ set }, newValue) =>
-					set(atomFamily(key), transform.fromJson(newValue)),
+				({ set }, newValue) => {
+					set(atomFamily(key), transform.fromJson(newValue))
+				},
 		},
 		store,
 	)

package/json/src/select-json.ts

@@ -14,7 +14,9 @@ export const selectJson = <T, J extends Json.Serializable>(
 		{
 			key: `${atom.key}:JSON`,
 			get: ({ get }) => transform.toJson(get(atom)),
-			set: ({ set }, newValue) => set(atom, transform.fromJson(newValue)),
+			set: ({ set }, newValue) => {
+				set(atom, transform.fromJson(newValue))
+			},
 		},
 		store,
 	)