atom.io 0.38.2 → 0.39.1

package/src/internal/overlays/set-overlay.ts

@@ -0,0 +1,55 @@
+export class SetOverlay<T> extends Set<T> {
+	public deleted: Set<T> = new Set()
+	public source: Set<T>
+
+	public constructor(source: Set<T>) {
+		super()
+		this.source = source
+	}
+
+	public add(value: T): this {
+		if (this.source.has(value)) {
+			this.deleted.delete(value)
+			return this
+		}
+		return super.add(value)
+	}
+
+	public hasOwn(member: T): boolean {
+		return super.has(member)
+	}
+
+	public has(key: T): boolean {
+		return !this.deleted.has(key) && (super.has(key) || this.source.has(key))
+	}
+
+	public delete(key: T): boolean {
+		if (this.source.has(key)) {
+			this.deleted.add(key)
+			return true
+		}
+		return super.delete(key)
+	}
+
+	public clear(): void {
+		this.deleted = new Set(this.source)
+		super.clear()
+	}
+
+	public *[Symbol.iterator](): SetIterator<T> {
+		yield* super[Symbol.iterator]()
+		for (const value of this.source) {
+			if (!this.deleted.has(value)) {
+				yield value
+			}
+		}
+	}
+
+	public *iterateOwn(): SetIterator<T> {
+		yield* super[Symbol.iterator]()
+	}
+
+	public get size(): number {
+		return super.size + this.source.size - this.deleted.size
+	}
+}

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

@@ -21,6 +21,8 @@ export function createReadonlyHeldSelector<T extends object>(
 	const covered = new Set<string>()
 	const { key, const: constant } = options
 	const type = `readonly_held_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const { get, find, json } = registerSelector(target, type, key, covered)
 
 	const getFrom = (innerTarget: Store) => {
@@ -35,6 +37,7 @@ export function createReadonlyHeldSelector<T extends object>(
 		innerTarget.selectorAtoms.delete(key)
 		options.get({ get, find, json }, constant)
 		writeToCache(innerTarget, readonlySelector, constant)
+		store.logger.info(`✨`, type, key, `=`, constant)
 		covered.clear()
 		return constant
 	}
@@ -46,17 +49,11 @@ export function createReadonlyHeldSelector<T extends object>(
 		getFrom,
 		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
 	}
-	if (family) {
-		readonlySelector.family = family
-	}
+	if (family) readonlySelector.family = family
+
 	target.readonlySelectors.set(key, readonlySelector)
-	store.logger.info(`✨`, type, key, `=`, constant)
-	const token: ReadonlyHeldSelectorToken<T> = {
-		key,
-		type,
-	}
-	if (family) {
-		token.family = family
-	}
+	const token: ReadonlyHeldSelectorToken<T> = { key, type }
+	if (family) token.family = family
+
 	return token
 }

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

@@ -21,6 +21,8 @@ export function createReadonlyPureSelector<T>(
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `readonly_pure_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const { get, find, json } = registerSelector(target, type, key, covered)
 
 	const getFrom = () => {
@@ -48,16 +50,12 @@ export function createReadonlyPureSelector<T>(
 		getFrom,
 		install: (s: Store) => createReadonlyPureSelector(s, options, family),
 	}
-	if (family) {
-		readonlySelector.family = family
-	}
+	if (family) readonlySelector.family = family
+
 	target.readonlySelectors.set(key, readonlySelector)
-	const token: ReadonlyPureSelectorToken<T> = {
-		key,
-		type,
-	}
-	if (family) {
-		token.family = family
-	}
+
+	const token: ReadonlyPureSelectorToken<T> = { key, type }
+	if (family) token.family = family
+
 	return token
 }

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

@@ -21,6 +21,8 @@ export function createWritableHeldSelector<T extends object>(
 	const covered = new Set<string>()
 	const { key, const: constant } = options
 	const type = `writable_held_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const setterToolkit = registerSelector(target, type, key, covered)
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
@@ -54,14 +56,12 @@ export function createWritableHeldSelector<T extends object>(
 		setSelf,
 		install: (s: Store) => createWritableHeldSelector(s, options, family),
 	}
-	if (family) {
-		mySelector.family = family
-	}
+	if (family) mySelector.family = family
+
 	target.writableSelectors.set(key, mySelector)
 
 	const token: WritableHeldSelectorToken<T> = { key, type }
-	if (family) {
-		token.family = family
-	}
+	if (family) token.family = family
+
 	return token
 }

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

@@ -21,6 +21,8 @@ export function createWritablePureSelector<T>(
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `writable_pure_selector` as const
+	store.logger.info(`🔨`, type, key, `is being created`)
+
 	const setterToolkit = registerSelector(target, type, key, covered)
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
@@ -57,8 +59,6 @@ export function createWritablePureSelector<T>(
 	if (family) mySelector.family = family
 
 	target.writableSelectors.set(key, mySelector)
-	const initialValue = getFrom(target)
-	store.logger.info(`✨`, mySelector.type, mySelector.key, `=`, initialValue)
 
 	const token: WritablePureSelectorToken<T> = { key, type }
 	if (family) token.family = family

package/src/internal/selector/register-selector.ts

@@ -37,11 +37,10 @@ export function registerSelector(
 				| [ReadableToken<any>]
 		) => {
 			const target = newest(store)
-			const { token, familyToken, subKey } = reduceReference(store, ...params)
+			const { token, family, subKey } = reduceReference(store, ...params)
 			let dependencyValue: unknown
-			if (`counterfeit` in token && familyToken && subKey) {
-				const dependencyFamily = withdraw(store, familyToken)
-				dependencyValue = getFallback(store, token, dependencyFamily, subKey)
+			if (`counterfeit` in token && family && subKey) {
+				dependencyValue = getFallback(store, token, family, subKey)
 			} else {
 				const dependency = withdraw(store, token)
 				dependencyValue = readOrComputeValue(store, dependency)

package/src/internal/set-state/become.ts

@@ -1,8 +1,13 @@
+import { isFn } from "../is-fn"
+
 export type Modify<T> = (thing: T) => T
 
-export const become =
-	<T>(nextVersionOfThing: Modify<T> | T) =>
-	(originalThing: T): T =>
-		nextVersionOfThing instanceof Function
-			? nextVersionOfThing(originalThing)
-			: nextVersionOfThing
+export function become<T>(
+	nextVersionOfThing: Modify<T> | T,
+	originalThing: T,
+): T {
+	if (isFn(nextVersionOfThing)) {
+		return nextVersionOfThing(originalThing)
+	}
+	return nextVersionOfThing
+}

package/src/internal/set-state/dispatch-state-update.ts

@@ -1,11 +1,12 @@
-import type {
-	AtomToken,
-	AtomUpdateEvent,
-	StateUpdate,
-	WritableToken,
-} from "atom.io"
+import type { AtomUpdateEvent, StateCreationEvent, StateUpdate } from "atom.io"
 
-import type { MutableAtom, WritableState } from ".."
+import {
+	type MutableAtom,
+	newest,
+	type Subject,
+	type WritableFamily,
+	type WritableState,
+} from ".."
 import { hasRole } from "../atom"
 import { readOrComputeValue } from "../get-state"
 import type { Transceiver } from "../mutable"
@@ -14,13 +15,49 @@ import type { OpenOperation } from "../operation"
 import { deposit, type Store } from "../store"
 import { isChildStore, isRootStore } from "../transaction"
 import { evictDownstreamFromAtom } from "./evict-downstream"
+import type { ProtoUpdate } from "./operate-on-store"
 
 export function dispatchOrDeferStateUpdate<T>(
 	target: Store & { operation: OpenOperation<any> },
 	state: WritableState<T>,
-	[oldValue, newValue]: [T, T],
-	_stateIsNewlyCreated: boolean,
+	{ oldValue, newValue }: ProtoUpdate<T>,
+	stateIsNewlyCreated: boolean,
+	family?: WritableFamily<T, any>,
 ): void {
+	const token = deposit(state)
+	if (stateIsNewlyCreated && family) {
+		state.subject.next({ newValue })
+		const stateCreationEvent: StateCreationEvent<any> = {
+			type: `state_creation`,
+			subType: `writable`,
+			token,
+			timestamp: Date.now(),
+			value: newValue,
+		}
+		const familySubject = family.subject as Subject<StateCreationEvent<any>>
+		familySubject.next(stateCreationEvent)
+		const innerTarget = newest(target)
+		if (token.family) {
+			if (isRootStore(innerTarget)) {
+				switch (token.type) {
+					case `atom`:
+					case `mutable_atom`:
+						target.on.atomCreation.next(token)
+						break
+					case `writable_pure_selector`:
+					case `writable_held_selector`:
+						target.on.selectorCreation.next(token)
+						break
+				}
+			} else if (
+				isChildStore(innerTarget) &&
+				innerTarget.on.transactionApplying.state === null
+			) {
+				innerTarget.transactionMeta.update.subEvents.push(stateCreationEvent)
+			}
+		}
+		return /* bailing early here to avoid redundant update */
+	}
 	const { key, subject, type } = state
 
 	const update: StateUpdate<T> = {
@@ -61,13 +98,11 @@ export function dispatchOrDeferStateUpdate<T>(
 
 	if (isChildStore(target) && (type === `mutable_atom` || type === `atom`)) {
 		if (target.on.transactionApplying.state === null) {
-			const token: WritableToken<T> = deposit(state)
-
 			if (isTransceiver(newValue)) {
 				return
 			}
 			const { timestamp } = target.operation
-			const atomUpdate: AtomUpdateEvent<AtomToken<T>> = {
+			const atomUpdate: AtomUpdateEvent<any> = {
 				type: `atom_update`,
 				token,
 				timestamp,

package/src/internal/set-state/operate-on-store.ts

@@ -1,6 +1,7 @@
 import type { WritableFamilyToken, WritableToken } from "atom.io"
 import { type Canonical, parseJson } from "atom.io/json"
 
+import type { WritableFamily } from ".."
 import { seekInStore } from "../families"
 import { getFamilyOfToken } from "../families/get-family-of-token"
 import { mintInStore, MUST_CREATE } from "../families/mint-in-store"
@@ -12,6 +13,8 @@ import { resetAtomOrSelector } from "./reset-atom-or-selector"
 import { RESET_STATE } from "./reset-in-store"
 import { setAtomOrSelector } from "./set-atom-or-selector"
 
+export type ProtoUpdate<T> = { oldValue: T; newValue: T }
+
 export const OWN_OP: unique symbol = Symbol(`OWN_OP`)
 export const JOIN_OP: unique symbol = Symbol(`JOIN_OP`)
 
@@ -32,7 +35,7 @@ export function operateOnStore<T, New extends T>(
 	let existingToken: WritableToken<T> | undefined
 	let brandNewToken: WritableToken<T> | undefined
 	let token: WritableToken<T>
-	let family: WritableFamilyToken<T, Canonical> | null
+	let family: WritableFamily<T, Canonical> | undefined
 	let key: Canonical | null
 	let value: New | typeof RESET_STATE | ((oldValue: T) => New)
 	if (params.length === 2) {
@@ -43,20 +46,18 @@ export function operateOnStore<T, New extends T>(
 			key = parseJson(token.family.subKey)
 			existingToken = seekInStore(store, family, key)
 			if (!existingToken) {
-				brandNewToken = mintInStore(store, family, key, MUST_CREATE)
-				token = brandNewToken
+				token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
 			} else {
 				token = existingToken
 			}
 		}
 	} else {
-		family = params[0]
+		family = withdraw(store, params[0])
 		key = params[1]
 		value = params[2]
 		existingToken = seekInStore(store, family, key)
 		if (!existingToken) {
-			brandNewToken = mintInStore(store, family, key, MUST_CREATE)
-			token = brandNewToken
+			token = brandNewToken = mintInStore(store, family, key, MUST_CREATE)
 		} else {
 			token = existingToken
 		}
@@ -115,14 +116,15 @@ export function operateOnStore<T, New extends T>(
 	}
 
 	const state = withdraw(target, token)
-	let protoUpdate: [T, T]
+	let protoUpdate: ProtoUpdate<T>
 	if (value === RESET_STATE) {
 		protoUpdate = resetAtomOrSelector(target, state)
 	} else {
 		protoUpdate = setAtomOrSelector(target, state, value)
 	}
+
 	const isNewlyCreated = Boolean(brandNewToken)
-	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated)
+	dispatchOrDeferStateUpdate(target, state, protoUpdate, isNewlyCreated, family)
 
 	if (opMode === OWN_OP) {
 		closeOperation(target)

package/src/internal/set-state/reset-atom-or-selector.ts

@@ -1,20 +1,20 @@
 import type { Atom, OpenOperation, Store, WritableState } from ".."
 import { traceRootSelectorAtoms } from ".."
+import { isFn } from "../is-fn"
 import { dispatchOrDeferStateUpdate } from "./dispatch-state-update"
+import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
 
 function resetAtom<T>(
 	target: Store & { operation: OpenOperation },
 	atom: Atom<T>,
-): [oldValue: T, newValue: T] {
+): ProtoUpdate<T> {
 	switch (atom.type) {
 		case `mutable_atom`:
 			return setAtom(target, atom, new atom.class())
 		case `atom`: {
 			let def = atom.default
-			if (def instanceof Function) {
-				def = def()
-			}
+			if (isFn(def)) def = def()
 			return setAtom(target, atom, def)
 		}
 	}
@@ -23,8 +23,8 @@ function resetAtom<T>(
 export function resetAtomOrSelector<T>(
 	target: Store & { operation: OpenOperation },
 	state: WritableState<T>,
-): [oldValue: T, newValue: T] {
-	let protoUpdate: [T, T]
+): ProtoUpdate<T> {
+	let protoUpdate: ProtoUpdate<T>
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:
@@ -40,7 +40,7 @@ export function resetAtomOrSelector<T>(
 					dispatchOrDeferStateUpdate(target, state, rootProtoUpdate, false)
 				}
 				const newValue = state.getFrom(target)
-				protoUpdate = [oldValue, newValue]
+				protoUpdate = { oldValue, newValue }
 			}
 			break
 	}

package/src/internal/set-state/set-atom-or-selector.ts

@@ -1,6 +1,7 @@
 import type { WritableState } from ".."
 import type { OpenOperation } from "../operation"
 import type { Store } from "../store"
+import type { ProtoUpdate } from "./operate-on-store"
 import { setAtom } from "./set-atom"
 import { setSelector } from "./set-selector"
 
@@ -8,8 +9,8 @@ export const setAtomOrSelector = <T>(
 	target: Store & { operation: OpenOperation },
 	state: WritableState<T>,
 	value: T | ((oldValue: T) => T),
-): [oldValue: T, newValue: T] => {
-	let protoUpdate: [T, T]
+): ProtoUpdate<T> => {
+	let protoUpdate: ProtoUpdate<T>
 	switch (state.type) {
 		case `atom`:
 		case `mutable_atom`:

package/src/internal/set-state/set-atom.ts

@@ -4,17 +4,18 @@ import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { markDone } from "../operation"
 import { become } from "./become"
 import { evictDownstreamFromAtom } from "./evict-downstream"
+import type { ProtoUpdate } from "./operate-on-store"
 
 export const setAtom = <T>(
 	target: Store & { operation: OpenOperation<any> },
 	atom: Atom<T>,
 	next: T | ((oldValue: T) => T),
-): [oldValue: T, newValue: T] => {
+): ProtoUpdate<T> => {
 	const oldValue = readOrComputeValue(target, atom, `mut`)
-	let newValue = become(next)(oldValue)
-	target.logger.info(`📝`, `atom`, atom.key, `set to`, newValue)
+	let newValue = become(next, oldValue)
+	target.logger.info(`⭐`, `atom`, atom.key, `setting value`, newValue)
 	newValue = writeToCache(target, atom, newValue)
 	markDone(target, atom.key)
 	evictDownstreamFromAtom(target, atom)
-	return [oldValue, newValue]
+	return { oldValue, newValue }
 }

package/src/internal/set-state/set-selector.ts

@@ -1,14 +1,15 @@
-import type { WritableSelector } from ".."
+import { readOrComputeValue, type WritableSelector } from ".."
 import { writeToCache } from "../caching"
 import { markDone, type OpenOperation } from "../operation"
 import type { Store } from "../store"
 import { become } from "./become"
+import type { ProtoUpdate } from "./operate-on-store"
 
 export function setSelector<T>(
 	target: Store & { operation: OpenOperation<any> },
 	selector: WritableSelector<T>,
 	next: T | ((oldValue: T) => T),
-): [oldValue: T, newValue: T] {
+): ProtoUpdate<T> {
 	let oldValue: T
 	let newValue: T
 	let constant: T
@@ -17,19 +18,19 @@ export function setSelector<T>(
 
 	switch (selector.type) {
 		case `writable_pure_selector`:
-			oldValue = selector.getFrom(target)
-			newValue = become(next)(oldValue)
-			writeToCache(target, selector, newValue)
+			oldValue = readOrComputeValue(target, selector, `mut`)
+			newValue = become(next, oldValue)
+			newValue = writeToCache(target, selector, newValue)
 			break
 		case `writable_held_selector`:
 			constant = selector.const
-			become(next)(constant)
+			become(next, constant)
 			oldValue = constant
 			newValue = constant
 	}
 
-	target.logger.info(`📝`, type, key, `setting to`, newValue)
+	target.logger.info(`⭐`, type, key, `setting to`, newValue)
 	markDone(target, key)
 	selector.setSelf(newValue)
-	return [oldValue, newValue]
+	return { oldValue, newValue }
 }

package/src/internal/store/withdraw.ts

@@ -171,14 +171,14 @@ export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: SelectorFamilyToken<T, K>,
 ): SelectorFamily<T, K>
-export function withdraw<T, K extends Canonical>(
-	store: Store,
-	token: ReadableFamilyToken<T, K>,
-): ReadableFamily<T, K>
 export function withdraw<T, K extends Canonical>(
 	store: Store,
 	token: WritableFamilyToken<T, K>,
 ): WritableFamily<T, K>
+export function withdraw<T, K extends Canonical>(
+	store: Store,
+	token: ReadableFamilyToken<T, K>,
+): ReadableFamily<T, K>
 
 export function withdraw<T extends Fn>(
 	store: Store,

package/src/internal/timeline/time-travel.ts

@@ -1,12 +1,12 @@
 import type { TimelineToken } from "atom.io"
 
 import {
-	ingestAtomUpdate,
+	ingestAtomUpdateEvent,
 	ingestCreationEvent,
 	ingestDisposalEvent,
-	ingestSelectorUpdate,
-	ingestTransactionUpdate,
-} from "../ingest-updates"
+	ingestSelectorUpdateEvent,
+	ingestTransactionOutcomeEvent,
+} from "../events"
 import type { Store } from "../store"
 
 export const timeTravel = (
@@ -50,28 +50,28 @@ export const timeTravel = (
 		--timelineData.at
 	}
 
-	const update = timelineData.history[timelineData.at]
+	const event = timelineData.history[timelineData.at]
 	const applying = action === `redo` ? `newValue` : `oldValue`
 
-	switch (update.type) {
+	switch (event.type) {
 		case `atom_update`: {
-			ingestAtomUpdate(applying, update, store)
+			ingestAtomUpdateEvent(store, event, applying)
 			break
 		}
 		case `selector_update`: {
-			ingestSelectorUpdate(applying, update, store)
+			ingestSelectorUpdateEvent(store, event, applying)
 			break
 		}
 		case `transaction_outcome`: {
-			ingestTransactionUpdate(applying, update, store)
+			ingestTransactionOutcomeEvent(store, event, applying)
 			break
 		}
 		case `state_creation`: {
-			ingestCreationEvent(update, applying, store)
+			ingestCreationEvent(store, event, applying)
 			break
 		}
 		case `state_disposal`: {
-			ingestDisposalEvent(update, applying, store)
+			ingestDisposalEvent(store, event, applying)
 			break
 		}
 		case `molecule_creation`:

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

@@ -1,4 +1,4 @@
-import { ingestTransactionUpdate } from "../ingest-updates"
+import { ingestTransactionOutcomeEvent } from "../events"
 import { newest } from "../lineage"
 import type { Store } from "../store"
 import { withdraw } from "../store"
@@ -6,10 +6,10 @@ import type { Fn } from "../utility-types"
 import { isChildStore, isRootStore } from "./is-root-store"
 import { setEpochNumberOfAction } from "./set-epoch-number"
 
-export const applyTransaction = <F extends Fn>(
-	output: ReturnType<F>,
+export function applyTransaction<F extends Fn>(
 	store: Store,
-): void => {
+	output: ReturnType<F>,
+): void {
 	const child = newest(store)
 	const { parent } = child
 	if (
@@ -38,7 +38,7 @@ export const applyTransaction = <F extends Fn>(
 		updates,
 	)
 
-	ingestTransactionUpdate(`newValue`, child.transactionMeta.update, parent)
+	ingestTransactionOutcomeEvent(parent, child.transactionMeta.update, `newValue`)
 
 	if (isRootStore(parent)) {
 		setEpochNumberOfAction(

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

@@ -11,10 +11,9 @@ import { arbitrary } from "../arbitrary"
 import { disposeFromStore, findInStore } from "../families"
 import { getEnvironmentData } from "../get-environment-data"
 import { getFromStore } from "../get-state"
-import { Junction } from "../junction"
-import { LazyMap } from "../lazy-map"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
+import { MapOverlay } from "../overlays/map-overlay"
 import { resetInStore, setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import type { Fn } from "../utility-types"
@@ -36,35 +35,27 @@ export const buildTransaction = (
 		loggers: parent.loggers,
 		logger: parent.logger,
 		config: parent.config,
-		atoms: new LazyMap(parent.atoms),
+		atoms: new MapOverlay(parent.atoms),
 		atomsThatAreDefault: new Set(parent.atomsThatAreDefault),
-		families: new LazyMap(parent.families),
-		joins: new LazyMap(parent.joins),
+		families: new MapOverlay(parent.families),
+		joins: new MapOverlay(parent.joins),
 		operation: { open: false },
-		readonlySelectors: new LazyMap(parent.readonlySelectors),
-		timelines: new LazyMap(parent.timelines),
-		timelineTopics: new Junction(parent.timelineTopics.toJSON()),
+		readonlySelectors: new MapOverlay(parent.readonlySelectors),
+		timelines: new MapOverlay(parent.timelines),
+		timelineTopics: parent.timelineTopics.overlay(),
 		trackers: new Map(),
-		transactions: new LazyMap(parent.transactions),
-		selectorAtoms: new Junction(parent.selectorAtoms.toJSON()),
-		selectorGraph: new Junction(parent.selectorGraph.toJSON(), {
-			makeContentKey: (...keys) => keys.sort().join(`:`),
-		}),
-		writableSelectors: new LazyMap(parent.writableSelectors),
-		valueMap: new LazyMap(parent.valueMap),
+		transactions: new MapOverlay(parent.transactions),
+		selectorAtoms: parent.selectorAtoms.overlay(),
+		selectorGraph: parent.selectorGraph.overlay(),
+		writableSelectors: new MapOverlay(parent.writableSelectors),
+		valueMap: new MapOverlay(parent.valueMap),
 		defaults: parent.defaults,
 		disposalTraces: store.disposalTraces.copy(),
-		molecules: new LazyMap(parent.molecules),
-		moleculeGraph: new Junction(parent.moleculeGraph.toJSON(), {
-			makeContentKey: parent.moleculeGraph.makeContentKey,
-		}),
-		moleculeData: new Junction(parent.moleculeData.toJSON(), {
-			makeContentKey: parent.moleculeData.makeContentKey,
-		}),
-		moleculeJoins: new Junction(parent.moleculeJoins.toJSON(), {
-			makeContentKey: parent.moleculeJoins.makeContentKey,
-		}),
-		miscResources: new LazyMap(parent.miscResources),
+		molecules: new MapOverlay(parent.molecules),
+		moleculeGraph: parent.moleculeGraph.overlay(),
+		moleculeData: parent.moleculeData.overlay(),
+		moleculeJoins: parent.moleculeJoins.overlay(),
+		miscResources: new MapOverlay(parent.miscResources),
 	}
 	const epoch = getEpochNumberOfAction(store, token.key)
 	const transactionMeta: TransactionProgress<Fn> = {