atom.io 0.36.2 → 0.37.0

package/src/internal/index.ts

@@ -9,9 +9,10 @@ import type {
 	ReadonlyPureSelectorToken,
 	RegularAtomFamilyToken,
 	RegularAtomToken,
-	StateCreation,
-	StateDisposal,
+	StateCreationEvent,
+	StateDisposalEvent,
 	StateLifecycleEvent,
+	StateUpdate,
 	WritableHeldSelectorFamilyToken,
 	WritableHeldSelectorToken,
 	WritablePureSelectorFamilyToken,
@@ -62,7 +63,7 @@ export type AtomIOState = {
 	key: string
 	family?: FamilyMetadata
 	install: (store: Store) => void
-	subject: Subject<{ newValue: any; oldValue: any }>
+	subject: Subject<StateUpdate<any>>
 }
 export type RegularAtom<T> = Flat<
 	AtomIOState & {
@@ -87,28 +88,28 @@ export type WritableHeldSelector<T> = Flat<
 	AtomIOState & {
 		type: `writable_held_selector`
 		const: T
-		get: () => T
-		set: (newValue: T | ((oldValue: T) => T)) => void
+		getFrom: (target: Store) => T
+		setSelf: (newValue: T) => void
 	}
 >
 export type ReadonlyHeldSelector<T> = Flat<
 	AtomIOState & {
 		type: `readonly_held_selector`
 		const: T
-		get: () => T
+		getFrom: (target: Store) => T
 	}
 >
 export type WritablePureSelector<T> = Flat<
 	AtomIOState & {
 		type: `writable_pure_selector`
-		get: () => T
-		set: (newValue: T | ((oldValue: T) => T)) => void
+		getFrom: (target: Store) => T
+		setSelf: (newValue: T) => void
 	}
 >
 export type ReadonlyPureSelector<T> = Flat<
 	AtomIOState & {
 		type: `readonly_pure_selector`
-		get: () => T
+		getFrom: (target: Store) => T
 	}
 >
 export type ReadonlySelector<T> =
@@ -135,7 +136,7 @@ export type RegularAtomFamily<T, K extends Canonical> =
 		(key: K): RegularAtomToken<T>
 		install: (store: Store) => void
 		internalRoles: string[] | undefined
-		subject: Subject<StateCreation<AtomToken<T>> | StateDisposal<AtomToken<T>>>
+		subject: Subject<StateCreationEvent<AtomToken<T>> | StateDisposalEvent<AtomToken<T>>>
 	}
 
 // biome-ignore format: intersection
@@ -167,8 +168,8 @@ export type WritablePureSelectorFamily<T, K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<WritablePureSelectorToken<T>>
-				| StateDisposal<WritablePureSelectorToken<T>>
+				| StateCreationEvent<WritablePureSelectorToken<T>>
+				| StateDisposalEvent<WritablePureSelectorToken<T>>
 			>
 		}
 	>
@@ -183,8 +184,8 @@ export type WritableHeldSelectorFamily<T , K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<WritableHeldSelectorToken<T>>
-				| StateDisposal<WritableHeldSelectorToken<T>>
+				| StateCreationEvent<WritableHeldSelectorToken<T>>
+				| StateDisposalEvent<WritableHeldSelectorToken<T>>
 			>
 		}
 	>
@@ -199,8 +200,8 @@ export type ReadonlyPureSelectorFamily<T, K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<ReadonlyPureSelectorToken<T>>
-				| StateDisposal<ReadonlyPureSelectorToken<T>>
+				| StateCreationEvent<ReadonlyPureSelectorToken<T>>
+				| StateDisposalEvent<ReadonlyPureSelectorToken<T>>
 			>
 		}
 	>
@@ -215,8 +216,8 @@ export type ReadonlyHeldSelectorFamily<T , K extends Canonical> =
 			install: (store: Store) => void
 			internalRoles: string[] | undefined
 			subject: Subject<
-				| StateCreation<ReadonlyHeldSelectorToken<T>>
-				| StateDisposal<ReadonlyHeldSelectorToken<T>>
+				| StateCreationEvent<ReadonlyHeldSelectorToken<T>>
+				| StateDisposalEvent<ReadonlyHeldSelectorToken<T>>
 			>
 		}
 	>

package/src/internal/ingest-updates/ingest-atom-update.ts

@@ -1,18 +1,18 @@
-import type { KeyedStateUpdate, RegularAtomToken } from "atom.io"
+import type { AtomUpdateEvent } from "atom.io"
 
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 
 export function ingestAtomUpdate(
 	applying: `newValue` | `oldValue`,
-	atomUpdate: KeyedStateUpdate<any>,
+	atomUpdate: AtomUpdateEvent<any>,
 	store: Store,
 ): void {
-	const { key, newValue, oldValue } = atomUpdate
+	const {
+		token,
+		update: { newValue, oldValue },
+	} = atomUpdate
 	const value = applying === `newValue` ? newValue : oldValue
-	const token: RegularAtomToken<unknown> = { key, type: `atom` }
-	if (atomUpdate.family) {
-		Object.assign(token, { family: atomUpdate.family })
-	}
+
 	setIntoStore(store, token, value)
 }

package/src/internal/ingest-updates/ingest-creation-disposal.ts

@@ -1,10 +1,10 @@
 import type {
-	MoleculeCreation,
-	MoleculeDisposal,
-	MoleculeTransfer,
+	MoleculeCreationEvent,
+	MoleculeDisposalEvent,
+	MoleculeTransferEvent,
 	ReadableToken,
-	StateCreation,
-	StateDisposal,
+	StateCreationEvent,
+	StateDisposalEvent,
 } from "atom.io"
 import { parseJson, stringifyJson } from "atom.io/json"
 
@@ -17,7 +17,7 @@ import {
 import type { Store } from "../store"
 
 export function ingestCreationEvent(
-	update: StateCreation<any>,
+	update: StateCreationEvent<any>,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
@@ -34,7 +34,7 @@ export function ingestCreationEvent(
 }
 
 export function ingestDisposalEvent(
-	update: StateDisposal<ReadableToken<any>>,
+	update: StateDisposalEvent<ReadableToken<any>>,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
@@ -54,7 +54,7 @@ export function ingestDisposalEvent(
 }
 
 function createInStore(
-	update: StateCreation<any> | StateDisposal<any>,
+	update: StateCreationEvent<any> | StateDisposalEvent<any>,
 	store: Store,
 ): void {
 	const { family: familyMeta } = update.token
@@ -67,7 +67,7 @@ function createInStore(
 }
 
 export function ingestMoleculeCreationEvent(
-	update: MoleculeCreation,
+	update: MoleculeCreationEvent,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
@@ -82,7 +82,7 @@ export function ingestMoleculeCreationEvent(
 	}
 }
 export function ingestMoleculeDisposalEvent(
-	update: MoleculeDisposal,
+	update: MoleculeDisposalEvent,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {
@@ -108,7 +108,7 @@ export function ingestMoleculeDisposalEvent(
 	}
 }
 export function ingestMoleculeTransferEvent(
-	update: MoleculeTransfer,
+	update: MoleculeTransferEvent,
 	applying: `newValue` | `oldValue`,
 	store: Store,
 ): void {

package/src/internal/ingest-updates/ingest-selector-update.ts

@@ -1,15 +1,19 @@
-import type { TimelineManageable } from "atom.io"
+import type {
+	AtomOnly,
+	AtomUpdateEvent,
+	TimelineManageable,
+	TimelineSelectorUpdateEvent,
+} from "atom.io"
 
 import type { Store } from "../store"
-import type { TimelineAtomUpdate, TimelineSelectorUpdate } from "../timeline"
 import { ingestAtomUpdate } from "./ingest-atom-update"
 
 export function ingestSelectorUpdate(
 	applying: `newValue` | `oldValue`,
-	selectorUpdate: TimelineSelectorUpdate<any>,
+	selectorUpdate: TimelineSelectorUpdateEvent<any>,
 	store: Store,
 ): void {
-	let updates: Omit<TimelineAtomUpdate<TimelineManageable>, `timestamp`>[]
+	let updates: AtomUpdateEvent<AtomOnly<TimelineManageable>>[]
 	if (applying === `newValue`) {
 		updates = selectorUpdate.atomUpdates
 	} else {

package/src/internal/ingest-updates/ingest-transaction-update.ts

@@ -1,4 +1,4 @@
-import type { TransactionUpdate } from "atom.io"
+import type { TransactionOutcomeEvent } from "atom.io"
 
 import type { Store } from "../store"
 import { ingestAtomUpdate } from "./ingest-atom-update"
@@ -12,17 +12,16 @@ import {
 
 export function ingestTransactionUpdate(
 	applying: `newValue` | `oldValue`,
-	transactionUpdate: TransactionUpdate<any>,
+	transactionUpdate: TransactionOutcomeEvent<any>,
 	store: Store,
 ): void {
 	const updates =
 		applying === `newValue`
-			? transactionUpdate.updates
-			: [...transactionUpdate.updates].reverse()
+			? transactionUpdate.subEvents
+			: [...transactionUpdate.subEvents].reverse()
 	for (const updateFromTransaction of updates) {
 		switch (updateFromTransaction.type) {
 			case `atom_update`:
-			case `selector_update`:
 				ingestAtomUpdate(applying, updateFromTransaction, store)
 				break
 			case `state_creation`:
@@ -40,7 +39,7 @@ export function ingestTransactionUpdate(
 			case `molecule_transfer`:
 				ingestMoleculeTransferEvent(updateFromTransaction, applying, store)
 				break
-			case `transaction_update`:
+			case `transaction_outcome`:
 				ingestTransactionUpdate(applying, updateFromTransaction, store)
 				break
 		}

package/src/internal/install-into-store.ts

@@ -22,7 +22,7 @@ export function installIntoStore(
 		source.logger.error(
 			`❌`,
 			`transaction`,
-			sourceNewest.transactionMeta.update.key,
+			sourceNewest.transactionMeta.update.token.key,
 			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
 			tokens,
 			`${sourceNewest.config.name} is undergoing a transaction.`,
@@ -34,7 +34,7 @@ export function installIntoStore(
 		target.logger.error(
 			`❌`,
 			`transaction`,
-			targetNewest.transactionMeta.update.key,
+			targetNewest.transactionMeta.update.token.key,
 			`could not install the following tokens into store "${target.config.name} from "${source.config.name}":`,
 			tokens,
 			`${targetNewest.config.name} is undergoing a transaction.`,

package/src/internal/join/join-internal.ts

@@ -8,6 +8,7 @@ import type {
 	ReadonlyPureSelectorFamilyToken,
 	RegularAtomFamilyToken,
 	setState,
+	ViewOf,
 	Write,
 	WriterToolkit,
 } from "atom.io"
@@ -29,7 +30,6 @@ import type {
 } from "../junction"
 import { Junction } from "../junction"
 import type { Molecule } from "../molecule"
-import type { ViewOf } from "../mutable"
 import { createMutableAtomFamily, getJsonFamily, getJsonToken } from "../mutable"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"

package/src/internal/molecule.ts

@@ -4,9 +4,9 @@ import type {
 	CompoundFrom,
 	CompoundTypedKey,
 	Hierarchy,
-	MoleculeCreation,
-	MoleculeDisposal,
-	MoleculeTransfer,
+	MoleculeCreationEvent,
+	MoleculeDisposalEvent,
+	MoleculeTransferEvent,
 	SingularTypedKey,
 	Vassal,
 } from "atom.io"
@@ -77,15 +77,16 @@ export function allocateIntoStore<
 		target.molecules.set(stringKey, { key, stringKey, dependsOn })
 	}
 
-	const creationEvent: MoleculeCreation = {
+	const creationEvent: MoleculeCreationEvent = {
 		type: `molecule_creation`,
 		key,
 		provenance: origin,
+		timestamp: Date.now(),
 	}
 	const isTransaction =
 		isChildStore(target) && target.transactionMeta.phase === `building`
 	if (isTransaction) {
-		target.transactionMeta.update.updates.push(creationEvent)
+		target.transactionMeta.update.subEvents.push(creationEvent)
 	} else {
 		target.on.moleculeCreation.next(creationEvent)
 	}
@@ -174,18 +175,19 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 	const provenance: stringified<Canonical>[] = []
 
 	const values: [string, any][] = []
-	const disposalEvent: MoleculeDisposal = {
+	const disposalEvent: MoleculeDisposalEvent = {
 		type: `molecule_disposal`,
 		key: molecule.key,
 		values,
 		provenance,
+		timestamp: Date.now(),
 	}
 	const target = newest(store)
 	target.molecules.delete(stringKey)
 	const isTransaction =
 		isChildStore(target) && target.transactionMeta.phase === `building`
 	if (isTransaction) {
-		target.transactionMeta.update.updates.push(disposalEvent)
+		target.transactionMeta.update.subEvents.push(disposalEvent)
 	}
 	const relatedMolecules = store.moleculeGraph.getRelationEntries({
 		downstreamMoleculeKey: molecule.stringKey,
@@ -290,17 +292,18 @@ export function claimWithinStore<
 			source: newProvenanceMolecule.stringKey,
 		},
 	)
-	const transferEvent: MoleculeTransfer = {
+	const transferEvent: MoleculeTransferEvent = {
 		type: `molecule_transfer`,
 		key: molecule.key,
 		exclusive: Boolean(exclusive),
 		from: priorProvenance,
 		to: [newProvenanceMolecule.key],
+		timestamp: Date.now(),
 	}
 	const isTransaction =
 		isChildStore(target) && target.transactionMeta.phase === `building`
 	if (isTransaction) {
-		target.transactionMeta.update.updates.push(transferEvent)
+		target.transactionMeta.update.subEvents.push(transferEvent)
 	}
 
 	return claim

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -4,8 +4,7 @@ import type {
 	MutableAtomFamilyToken,
 	MutableAtomOptions,
 	MutableAtomToken,
-	StateCreation,
-	StateDisposal,
+	StateLifecycleEvent,
 } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
@@ -48,9 +47,7 @@ export function createMutableAtomFamily<
 		)
 	}
 
-	const subject = new Subject<
-		StateCreation<MutableAtomToken<T>> | StateDisposal<MutableAtomToken<T>>
-	>()
+	const subject = new Subject<StateLifecycleEvent<MutableAtomToken<T>>>()
 
 	const familyFunction = (key: K): MutableAtomToken<T> => {
 		const subKey = stringifyJson(key)
@@ -68,7 +65,7 @@ export function createMutableAtomFamily<
 
 		const token = createMutableAtom(target, individualOptions, family)
 
-		subject.next({ type: `state_creation`, token })
+		subject.next({ type: `state_creation`, token, timestamp: Date.now() })
 		return token
 	}
 

package/src/internal/mutable/tracker.ts

@@ -58,7 +58,7 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 		const stateKey = mutableState.key
 		const storeName = target.config.name
 		const storeStatus = isChildStore(target)
-			? target.transactionMeta.update.key
+			? target.transactionMeta.update.token.key
 			: `main`
 		const subscriptionKey = `tracker:${storeName}:${storeStatus}:${stateKey}`
 		const trackerCapturesOutboundSignal = (update: SignalFrom<T>) => {
@@ -91,7 +91,7 @@ export class Tracker<T extends Transceiver<any, any, any>> {
 		target: Store,
 	): void {
 		const subscriptionKey = `tracker:${target.config.name}:${
-			isChildStore(target) ? target.transactionMeta.update.key : `main`
+			isChildStore(target) ? target.transactionMeta.update.token.key : `main`
 		}:${mutableState.key}`
 		subscribeToState(
 			target,

package/src/internal/mutable/transceiver.ts

@@ -5,12 +5,12 @@ export interface Transceiver<
 	S extends Json.Serializable,
 	J extends Json.Serializable,
 > {
+	READONLY_VIEW: V
 	do: (update: S) => number | `OUT_OF_RANGE` | null
 	undo: (update: S) => void
 	subscribe: (key: string, fn: (update: S) => void) => () => void
 	cacheUpdateNumber: number
 	getUpdateNumber: (update: S) => number
-	view: () => V
 	toJSON: () => J
 }
 
@@ -30,14 +30,16 @@ export function isTransceiver(
 		value !== null &&
 		`do` in value &&
 		`undo` in value &&
-		`subscribe` in value
+		`subscribe` in value &&
+		`cacheUpdateNumber` in value &&
+		`getUpdateNumber` in value &&
+		`READONLY_VIEW` in value &&
+		`toJSON` in value
 	)
 }
 
 export type TransceiverMode = `playback` | `record` | `transaction`
 
-export type ViewOf<T> = T extends Transceiver<infer V, any, any> ? V : T
-
 export type SignalFrom<T extends Transceiver<any, any, any>> =
 	T extends Transceiver<any, infer S, any> ? S : never
 

package/src/internal/operation.ts

@@ -4,21 +4,22 @@ import type { Store } from "./store"
 import { isChildStore } from "./transaction/is-root-store"
 
 export type OperationProgress =
+	| OpenOperation<any>
 	| {
 			open: false
 	  }
-	| {
-			open: true
-			done: Set<string>
-			prev: Map<string, any>
-			time: number
-			token: ReadableToken<any>
-	  }
+export type OpenOperation<R extends ReadableToken<any> = ReadableToken<any>> = {
+	open: true
+	token: R
+	done: Set<string>
+	prev: Map<string, any>
+	timestamp: number
+}
 
-export const openOperation = (
+export function openOperation(
 	store: Store,
 	token: ReadableToken<any>,
-): number | undefined => {
+): number | (Store & { operation: OpenOperation }) {
 	if (store.operation.open) {
 		const rejectionTime = performance.now()
 		store.logger.info(
@@ -33,7 +34,7 @@ export const openOperation = (
 		open: true,
 		done: new Set(),
 		prev: new Map(),
-		time: Date.now(),
+		timestamp: Date.now(),
 		token,
 	}
 	store.logger.info(
@@ -41,13 +42,15 @@ export const openOperation = (
 		token.type,
 		token.key,
 		`operation start in store "${store.config.name}"${
-			!isChildStore(store)
-				? ``
-				: ` ${store.transactionMeta.phase} "${store.transactionMeta.update.key}"`
+			isChildStore(store)
+				? ` ${store.transactionMeta.phase} "${store.transactionMeta.update.token.key}"`
+				: ``
 		}`,
 	)
+	return store as Store & { operation: OpenOperation }
 }
-export const closeOperation = (store: Store): void => {
+
+export function closeOperation(store: Store): void {
 	if (store.operation.open) {
 		store.logger.info(
 			`🔴`,

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

@@ -11,19 +11,19 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export const createReadonlyHeldSelector = <T extends object>(
+export function createReadonlyHeldSelector<T extends object>(
 	store: Store,
 	options: ReadonlyHeldSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-): ReadonlyHeldSelectorToken<T> => {
+): ReadonlyHeldSelectorToken<T> {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
 	const { key, const: constant } = options
 	const type = `readonly_held_selector` as const
 	const { get, find, json } = registerSelector(target, type, key, covered)
-	const getSelf = () => {
-		const innerTarget = newest(store)
+
+	const getFrom = (innerTarget: Store) => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
 			downstreamSelectorKey: key,
 		})
@@ -34,7 +34,7 @@ export const createReadonlyHeldSelector = <T extends object>(
 		}
 		innerTarget.selectorAtoms.delete(key)
 		options.get({ get, find, json }, constant)
-		writeToCache(newest(store), readonlySelector, constant)
+		writeToCache(innerTarget, readonlySelector, constant)
 		covered.clear()
 		return constant
 	}
@@ -43,9 +43,11 @@ export const createReadonlyHeldSelector = <T extends object>(
 		...options,
 		type,
 		subject,
+		getFrom,
 		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
-		get: getSelf,
-		...(family && { family }),
+	}
+	if (family) {
+		readonlySelector.family = family
 	}
 	target.readonlySelectors.set(key, readonlySelector)
 	store.logger.info(`✨`, type, key, `=`, constant)

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

@@ -11,18 +11,19 @@ import type { Store } from "../store"
 import { Subject } from "../subject"
 import { registerSelector } from "./register-selector"
 
-export const createReadonlyPureSelector = <T>(
+export function createReadonlyPureSelector<T>(
 	store: Store,
 	options: ReadonlyPureSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-): ReadonlyPureSelectorToken<T> => {
+): ReadonlyPureSelectorToken<T> {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
 	const key = options.key
 	const type = `readonly_pure_selector` as const
 	const { get, find, json } = registerSelector(target, type, key, covered)
-	const getSelf = () => {
+
+	const getFrom = () => {
 		const innerTarget = newest(store)
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
 			downstreamSelectorKey: key,
@@ -44,9 +45,11 @@ export const createReadonlyPureSelector = <T>(
 		...options,
 		type,
 		subject,
+		getFrom,
 		install: (s: Store) => createReadonlyPureSelector(s, options, family),
-		get: getSelf,
-		...(family && { family }),
+	}
+	if (family) {
+		readonlySelector.family = family
 	}
 	target.readonlySelectors.set(key, readonlySelector)
 	const token: ReadonlyPureSelectorToken<T> = {

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

@@ -7,18 +7,15 @@ import type {
 import type { WritableHeldSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
-import { markDone } from "../operation"
-import { become } from "../set-state"
 import type { Store } from "../store"
 import { Subject } from "../subject"
-import { isRootStore } from "../transaction"
 import { registerSelector } from "./register-selector"
 
-export const createWritableHeldSelector = <T extends object>(
+export function createWritableHeldSelector<T extends object>(
 	store: Store,
 	options: WritableHeldSelectorOptions<T>,
 	family: FamilyMetadata | undefined,
-): WritableHeldSelectorToken<T> => {
+): WritableHeldSelectorToken<T> {
 	const target = newest(store)
 	const subject = new Subject<{ newValue: T; oldValue: T }>()
 	const covered = new Set<string>()
@@ -28,7 +25,7 @@ export const createWritableHeldSelector = <T extends object>(
 	const { find, get, json } = setterToolkit
 	const getterToolkit = { find, get, json }
 
-	const getSelf = (getFn = options.get, innerTarget = newest(store)): T => {
+	const getFrom = (innerTarget: Store): T => {
 		const upstreamStates = innerTarget.selectorGraph.getRelationEntries({
 			downstreamSelectorKey: key,
 		})
@@ -38,33 +35,27 @@ export const createWritableHeldSelector = <T extends object>(
 			}
 		}
 		innerTarget.selectorAtoms.delete(key)
-		getFn(getterToolkit, constant)
+		options.get(getterToolkit, constant)
 		writeToCache(innerTarget, mySelector, constant)
 		store.logger.info(`✨`, type, key, `=`, constant)
 		covered.clear()
 		return constant
 	}
 
-	const setSelf = (next: T | ((oldValue: T) => T)): void => {
-		const innerTarget = newest(store)
-		const oldValue = getSelf(options.get, innerTarget)
-		const newValue = become(next)(oldValue)
-		store.logger.info(`📝`, type, key, `set (`, oldValue, `->`, newValue, `)`)
-		writeToCache(innerTarget, mySelector, newValue)
-		markDone(innerTarget, key)
-		if (isRootStore(innerTarget)) {
-			subject.next({ newValue, oldValue })
-		}
-		options.set(setterToolkit, newValue)
+	const setSelf = (): void => {
+		options.set(setterToolkit, constant)
 	}
+
 	const mySelector: WritableHeldSelector<T> = {
 		...options,
 		type,
 		subject,
+		getFrom,
+		setSelf,
 		install: (s: Store) => createWritableHeldSelector(s, options, family),
-		get: getSelf,
-		set: setSelf,
-		...(family && { family }),
+	}
+	if (family) {
+		mySelector.family = family
 	}
 	target.writableSelectors.set(key, mySelector)