atom.io 0.30.7 → 0.31.1

package/internal/src/molecule.ts

@@ -0,0 +1,306 @@
+import type {
+	Above,
+	Claim,
+	CompoundFrom,
+	CompoundTypedKey,
+	Hierarchy,
+	MoleculeCreation,
+	MoleculeDisposal,
+	MoleculeTransfer,
+	SingularTypedKey,
+	Vassal,
+} from "atom.io"
+import type { Canonical, stringified } from "atom.io/json"
+import { parseJson, stringifyJson } from "atom.io/json"
+
+import { disposeFromStore, findInStore } from "./families"
+import { getTrace } from "./get-trace"
+import { newest } from "./lineage"
+import type { Store } from "./store"
+import { IMPLICIT } from "./store"
+import { isChildStore } from "./transaction"
+
+export type Molecule<K extends Canonical> = {
+	readonly key: K
+	readonly stringKey: stringified<K>
+	readonly dependsOn: `all` | `any`
+}
+
+export function makeRootMoleculeInStore<S extends string>(
+	key: S,
+	store: Store = IMPLICIT.STORE,
+): S {
+	const molecule = {
+		key,
+		stringKey: stringifyJson(key),
+		dependsOn: `any`,
+	} satisfies Molecule<S>
+	store.molecules.set(stringifyJson(key), molecule)
+	return key
+}
+
+export function allocateIntoStore<
+	H extends Hierarchy,
+	V extends Vassal<H>,
+	A extends Above<V, H>,
+>(
+	store: Store,
+	provenance: A,
+	key: V,
+	dependsOn: `all` | `any` = `any`,
+): Claim<V> {
+	const origin = provenance as Canonical | [Canonical, Canonical]
+	const stringKey = stringifyJson(key)
+	const invalidKeys: stringified<Canonical>[] = []
+	const target = newest(store)
+
+	if (Array.isArray(origin)) {
+		for (const formerClaim of origin) {
+			const claimString = stringifyJson(formerClaim)
+			const claim = target.molecules.get(claimString)
+			if (claim) {
+				store.moleculeGraph.set(claimString, stringKey, { source: claimString })
+			} else {
+				invalidKeys.push(claimString)
+			}
+		}
+	} else {
+		const claimString = stringifyJson(origin)
+		const claim = target.molecules.get(claimString)
+		if (claim) {
+			store.moleculeGraph.set(claimString, stringKey, { source: claimString })
+		} else {
+			invalidKeys.push(claimString)
+		}
+	}
+	if (invalidKeys.length === 0) {
+		target.molecules.set(stringKey, { key, stringKey, dependsOn })
+	}
+
+	const creationEvent: MoleculeCreation = {
+		type: `molecule_creation`,
+		key,
+		provenance: origin,
+	}
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.updates.push(creationEvent)
+	} else {
+		target.on.moleculeCreation.next(creationEvent)
+	}
+
+	for (const claim of invalidKeys) {
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === claim,
+		)
+		store.logger.error(
+			`❌`,
+			`molecule`,
+			key,
+			`allocation failed:`,
+			`Could not allocate to ${claim} in store "${store.config.name}".`,
+			disposal
+				? `\n   ${claim} was most recently disposed\n${disposal.trace}`
+				: `No previous disposal trace for ${claim} was found.`,
+		)
+	}
+
+	return key as Claim<V>
+}
+
+export function fuseWithinStore<
+	H extends Hierarchy,
+	C extends CompoundFrom<H>,
+	T extends C extends CompoundTypedKey<infer t, any, any> ? t : never,
+	A extends C extends CompoundTypedKey<any, infer a, any> ? a : never,
+	B extends C extends CompoundTypedKey<any, any, infer b> ? b : never,
+>(
+	store: Store,
+	type: T,
+	sideA: SingularTypedKey<A>,
+	sideB: SingularTypedKey<B>,
+): Claim<CompoundTypedKey<T, A, B>> {
+	const compoundKey: CompoundTypedKey<T, A, B> =
+		`T$--${type}==${sideA}++${sideB}`
+	const above = [sideA, sideB] as Above<Vassal<H>, H>
+	allocateIntoStore<H, Vassal<H>, Above<Vassal<H>, H>>(
+		store,
+		above,
+		compoundKey as Vassal<H>,
+		`all`,
+	)
+	return compoundKey
+}
+
+export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
+	store: Store,
+	claim: Claim<V>,
+): void {
+	const stringKey = stringifyJson(claim)
+
+	const molecule = store.molecules.get(stringKey)
+	if (!molecule) {
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === stringKey,
+		)
+		store.logger.error(
+			`❌`,
+			`molecule`,
+			claim,
+			`deallocation failed:`,
+			`Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+			disposal
+				? `\n   This state was most recently deallocated\n${disposal.trace}`
+				: `No previous disposal trace for ${stringKey} was found.`,
+		)
+		return
+	}
+
+	const joinKeys = store.moleculeJoins.getRelatedKeys(
+		molecule.key as string /* 💥 RECONCILE */,
+	)
+	if (joinKeys) {
+		for (const joinKey of joinKeys) {
+			const join = store.joins.get(joinKey)
+			if (join) {
+				join.relations.delete(molecule.key)
+				join.molecules.delete(molecule.stringKey) // get rid of
+			}
+		}
+	}
+	store.moleculeJoins.delete(molecule.stringKey)
+
+	const provenance: stringified<Canonical>[] = []
+
+	const values: [string, any][] = []
+	const disposalEvent: MoleculeDisposal = {
+		type: `molecule_disposal`,
+		key: molecule.key,
+		values,
+		provenance,
+	}
+	const target = newest(store)
+	target.molecules.delete(stringKey)
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.updates.push(disposalEvent)
+	}
+	const relatedMolecules = store.moleculeGraph.getRelationEntries({
+		downstreamMoleculeKey: molecule.stringKey,
+	})
+	if (relatedMolecules) {
+		for (const [relatedStringKey, { source }] of relatedMolecules) {
+			if (source === molecule.stringKey) {
+				const relatedKey = parseJson(relatedStringKey)
+				deallocateFromStore<any, any>(store, relatedKey)
+			} else {
+				provenance.push(source)
+			}
+		}
+	}
+	const familyKeys = target.moleculeData.getRelatedKeys(molecule.stringKey)
+	if (familyKeys) {
+		for (const familyKey of familyKeys) {
+			// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
+			const family = target.families.get(familyKey)!
+			const token = findInStore(store, family, molecule.key)
+			values.push([family.key, token])
+			disposeFromStore(store, token)
+		}
+	}
+
+	target.moleculeGraph.delete(molecule.stringKey)
+	target.moleculeJoins.delete(molecule.stringKey)
+	target.moleculeData.delete(molecule.stringKey)
+
+	if (!isTransaction) {
+		target.on.moleculeDisposal.next(disposalEvent)
+	}
+	target.molecules.delete(molecule.stringKey)
+
+	const trace = getTrace(new Error())
+	store.disposalTraces.add({ key: stringKey, trace })
+}
+export function claimWithinStore<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+	A extends Above<V, H>,
+>(
+	store: Store,
+	newProvenance: A,
+	claim: Claim<V>,
+	exclusive?: `exclusive`,
+): Claim<V> {
+	const stringKey = stringifyJson(claim)
+	const target = newest(store)
+	const molecule = target.molecules.get(stringKey)
+	if (!molecule) {
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === stringKey,
+		)
+		store.logger.error(
+			`❌`,
+			`molecule`,
+			claim,
+			`claim failed:`,
+			`Could not allocate to ${stringKey} in store "${store.config.name}".`,
+			disposal
+				? `\n   ${stringKey} was most recently disposed\n${disposal.trace}`
+				: `No previous disposal trace for ${stringKey} was found.`,
+		)
+		return claim
+	}
+
+	const newProvenanceKey = stringifyJson(newProvenance as Canonical)
+	const newProvenanceMolecule = target.molecules.get(newProvenanceKey)
+	if (!newProvenanceMolecule) {
+		const disposal = store.disposalTraces.buffer.find(
+			(item) => item?.key === newProvenanceKey,
+		)
+		store.logger.error(
+			`❌`,
+			`molecule`,
+			claim,
+			`claim failed:`,
+			`Could not allocate to ${newProvenanceKey} in store "${store.config.name}".`,
+			disposal
+				? `\n   ${newProvenanceKey} was most recently disposed\n${disposal.trace}`
+				: `No previous disposal trace for ${newProvenanceKey} was found.`,
+		)
+		return claim
+	}
+
+	const priorProvenance = store.moleculeGraph
+		.getRelationEntries({
+			downstreamMoleculeKey: molecule.stringKey,
+		})
+		.filter(([, { source }]) => source !== stringKey)
+		.map(([key]) => parseJson(key))
+	if (exclusive) {
+		target.moleculeGraph.delete(stringKey)
+	}
+	target.moleculeGraph.set(
+		{
+			upstreamMoleculeKey: newProvenanceMolecule.stringKey,
+			downstreamMoleculeKey: molecule.stringKey,
+		},
+		{
+			source: newProvenanceMolecule.stringKey,
+		},
+	)
+	const transferEvent: MoleculeTransfer = {
+		type: `molecule_transfer`,
+		key: molecule.key,
+		from: priorProvenance,
+		to: [newProvenanceMolecule.key],
+	}
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.updates.push(transferEvent)
+	}
+
+	return claim
+}

package/internal/src/mutable/transceiver.ts

@@ -1,11 +1,11 @@
 import type { Json } from "atom.io/json"
 
-export interface Transceiver<Signal extends Json.Serializable> {
-	do: (update: Signal) => number | `OUT_OF_RANGE` | null
-	undo: (update: Signal) => void
-	subscribe: (key: string, fn: (update: Signal) => void) => () => void
+export interface Transceiver<S extends Json.Serializable> {
+	do: (update: S) => number | `OUT_OF_RANGE` | null
+	undo: (update: S) => void
+	subscribe: (key: string, fn: (update: S) => void) => () => void
 	cacheUpdateNumber: number
-	getUpdateNumber: (update: Signal) => number
+	getUpdateNumber: (update: S) => number
 }
 
 export function isTransceiver(

package/internal/src/not-found-error.ts

@@ -1,37 +1,15 @@
-import { type Json, stringifyJson } from "atom.io/json"
+import type { AtomIOToken } from "atom.io"
+import { stringifyJson } from "atom.io/json"
 
-import type { AtomIOToken } from "./pretty-print"
 import { prettyPrintTokenType } from "./pretty-print"
 import type { Store } from "./store"
 
 export class NotFoundError extends Error {
-	public constructor(token: AtomIOToken, store: Store)
-	public constructor(
-		familyToken: AtomIOToken,
-		key: Json.Serializable,
-		store: Store,
-	)
-	public constructor(
-		...params:
-			| [token: AtomIOToken, key: Json.Serializable, store: Store]
-			| [token: AtomIOToken, store: Store]
-	) {
-		const token: AtomIOToken = params[0]
-		const store: Store = params.length === 2 ? params[1] : params[2]
-
-		if (params.length === 2) {
-			super(
-				`${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${
-					store.config.name
-				}".`,
-			)
-		} else {
-			const key = params[1]
-			super(
-				`${prettyPrintTokenType(token)} "${token.key}" member ${stringifyJson(key)} not found in store "${
-					store.config.name
-				}".`,
-			)
-		}
+	public constructor(token: AtomIOToken, store: Store) {
+		super(
+			`${prettyPrintTokenType(token)} ${stringifyJson(token.key)} not found in store "${
+				store.config.name
+			}".`,
+		)
 	}
 }

package/internal/src/pretty-print.ts

@@ -1,22 +1,7 @@
-import type {
-	MoleculeFamilyToken,
-	MoleculeToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	TimelineToken,
-	TransactionToken,
-} from "atom.io"
+import type { AtomIOToken } from "atom.io"
 
 const capitalize = (str: string) => str[0].toUpperCase() + str.slice(1)
 
-export type AtomIOToken =
-	| MoleculeFamilyToken<any>
-	| MoleculeToken<any>
-	| ReadableFamilyToken<any, any>
-	| ReadableToken<any>
-	| TimelineToken<any>
-	| TransactionToken<any>
-
 export function prettyPrintTokenType(token: AtomIOToken): string {
 	return token.type.split(`_`).map(capitalize).join(` `)
 }

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

@@ -20,7 +20,7 @@ export function disposeSelector(
 	} else {
 		const molecule = target.molecules.get(selector.family.subKey)
 		if (molecule) {
-			molecule.tokens.delete(key)
+			target.moleculeData.delete(selector.family.subKey, selector.family.key)
 		}
 		switch (selectorToken.type) {
 			case `selector`:
@@ -30,10 +30,6 @@ export function disposeSelector(
 						{ key: selector.family.key, type: `selector_family` },
 						store,
 					)
-					family.subject.next({
-						type: `state_disposal`,
-						token: selectorToken,
-					})
 				}
 				break
 			case `readonly_selector`:
@@ -45,6 +41,7 @@ export function disposeSelector(
 					)
 					family.subject.next({
 						type: `state_disposal`,
+						subType: `selector`,
 						token: selectorToken,
 					})
 				}
@@ -57,6 +54,7 @@ export function disposeSelector(
 		if (isChildStore(target) && target.transactionMeta.phase === `building`) {
 			target.transactionMeta.update.updates.push({
 				type: `state_disposal`,
+				subType: `selector`,
 				token: selectorToken,
 			})
 		} else {

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

@@ -1,7 +1,4 @@
 import type {
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeToken,
 	ReadableFamilyToken,
 	ReadableToken,
 	setState,
@@ -14,7 +11,6 @@ import type { seekState } from "atom.io/immortal"
 import type { Json } from "atom.io/json"
 
 import { findInStore, seekInStore } from "../families"
-import { getFromStore } from "../get-state"
 import { readOrComputeValue } from "../get-state/read-or-compute-value"
 import { newest } from "../lineage"
 import { getJsonToken } from "../mutable"
@@ -31,39 +27,19 @@ export const registerSelector = (
 ): SetterToolkit => ({
 	get: (
 		...params:
-			| [MoleculeFamilyToken<any>, Json.Serializable]
-			| [MoleculeToken<MoleculeConstructor>]
 			| [ReadableFamilyToken<any, any>, Json.Serializable]
 			| [ReadableToken<any>]
 	) => {
 		const target = newest(store)
-		let dependency: MoleculeToken<MoleculeConstructor> | ReadableToken<any>
+		let dependency: ReadableToken<any>
 
 		if (params.length === 2) {
 			const [family, key] = params
-			switch (family.type) {
-				case `molecule_family`:
-					return getFromStore(store, family, key)
-				default:
-					if (store.config.lifespan === `ephemeral`) {
-						dependency = findInStore(store, family, key)
-					} else {
-						const maybeDependency = seekInStore(store, family, key)
-						if (maybeDependency) {
-							dependency = maybeDependency
-						} else {
-							throw new NotFoundError(family, key, store)
-						}
-					}
-			}
+			dependency = findInStore(store, family, key)
 		} else {
 			;[dependency] = params
 		}
 
-		if (dependency.type === `molecule`) {
-			return getFromStore(store, dependency)
-		}
-
 		const dependencyState = withdraw(dependency, store)
 		const dependencyValue = readOrComputeValue(dependencyState, store)
 
@@ -106,14 +82,7 @@ export const registerSelector = (
 			const family = params[0]
 			const key = params[1]
 			value = params[2]
-			const maybeToken =
-				store.config.lifespan === `ephemeral`
-					? findInStore(store, family, key)
-					: seekInStore(store, family, key)
-			if (!maybeToken) {
-				throw new NotFoundError(family, key, store)
-			}
-			token = maybeToken
+			token = findInStore(store, family, key)
 		}
 		const target = newest(store)
 		const state = withdraw(token, target)

package/internal/src/set-state/set-into-store.ts

@@ -50,9 +50,10 @@ export function setIntoStore<T, New extends T>(
 		token = findInStore(store, family, key)
 	}
 
-	if (`counterfeit` in token) {
+	if (`counterfeit` in token && `family` in token) {
+		const subKey = token.family.subKey
 		const disposal = store.disposalTraces.buffer.find(
-			(item) => item?.key === token.key,
+			(item) => item?.key === subKey,
 		)
 		store.logger.error(
 			`❌`,

package/internal/src/store/counterfeit.ts

@@ -1,10 +1,6 @@
 import type {
 	AtomFamilyToken,
 	AtomToken,
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeKey,
-	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -75,35 +71,25 @@ export function counterfeit<T, K extends Canonical, Key extends K>(
 	key: Key,
 ): ReadableToken<T>
 
-export function counterfeit<M extends MoleculeConstructor>(
-	token: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-): MoleculeKey<M>
-
 export function counterfeit(
-	token: MoleculeFamilyToken<any> | ReadableFamilyToken<any, any>,
+	token: ReadableFamilyToken<any, any>,
 	key: Canonical,
-): MoleculeToken<any> | ReadableToken<any> {
+): ReadableToken<any> {
 	const subKey = stringifyJson(key)
 	const fullKey = `${token.key}(${subKey})`
 	const type = FAMILY_MEMBER_TOKEN_TYPES[token.type]
 	const stateToken = {
 		key: fullKey,
 		type,
-	} satisfies MoleculeToken<any> | ReadableToken<any>
-	if (type === `molecule`) {
-		Object.assign(stateToken, {
-			key,
-			family: token,
-		})
-	} else {
-		Object.assign(stateToken, {
-			family: {
-				key: token.key,
-				subKey,
-			},
-		})
-	}
+	} satisfies ReadableToken<any>
+
+	Object.assign(stateToken, {
+		family: {
+			key: token.key,
+			subKey,
+		},
+	})
+
 	Object.assign(stateToken, { counterfeit: true })
 	return stateToken
 }

package/internal/src/store/deposit.ts

@@ -1,10 +1,7 @@
 import type {
 	AtomFamilyToken,
+	AtomIOToken,
 	AtomToken,
-	MoleculeConstructor,
-	MoleculeFamily,
-	MoleculeFamilyToken,
-	MoleculeToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
 	ReadableFamilyToken,
@@ -15,6 +12,8 @@ import type {
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
+	TimelineManageable,
+	TimelineToken,
 	TransactionToken,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
@@ -26,8 +25,8 @@ import type { Canonical, Json } from "atom.io/json"
 import type {
 	Atom,
 	AtomFamily,
+	AtomIOInternalResource,
 	Func,
-	Molecule,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -38,6 +37,7 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
+	Timeline,
 	Transceiver,
 	WritableFamily,
 	WritableSelector,
@@ -82,48 +82,16 @@ export function deposit<T>(
 	state: ReadableFamily<T, any>,
 ): ReadableFamilyToken<T, any>
 
-export function deposit<M extends MoleculeConstructor>(
-	state: MoleculeFamily<M>,
-): MoleculeFamilyToken<M>
-export function deposit<M extends MoleculeConstructor>(
-	state: Molecule<M>,
-): MoleculeToken<M>
-
 export function deposit<T extends Func>(
 	state: Transaction<T>,
 ): TransactionToken<T>
+export function deposit<M extends TimelineManageable>(
+	state: Timeline<M>,
+): TimelineToken<M>
 
-export function deposit(
-	state: Molecule<any> | ReadableState<any>,
-): MoleculeToken<any> | ReadableToken<any>
-
-export function deposit(
-	state:
-		| Molecule<any>
-		| MoleculeFamily<any>
-		| ReadableFamily<any, any>
-		| ReadableState<any>
-		| Transaction<Func>,
-):
-	| MoleculeFamilyToken<any>
-	| MoleculeToken<any>
-	| ReadableFamilyToken<any, any>
-	| ReadableToken<any>
-	| TransactionToken<Func>
+export function deposit(resource: AtomIOInternalResource): AtomIOToken
 
-export function deposit(
-	state:
-		| Molecule<any>
-		| MoleculeFamily<any>
-		| ReadableFamily<any, any>
-		| ReadableState<any>
-		| Transaction<Func>,
-):
-	| MoleculeFamilyToken<any>
-	| MoleculeToken<any>
-	| ReadableFamilyToken<any, any>
-	| ReadableToken<any>
-	| TransactionToken<Func> {
+export function deposit(state: AtomIOInternalResource): AtomIOToken {
 	const token = {
 		key: state.key,
 		type: state.type,