atom.io 0.31.0 → 0.31.1

package/internal/src/molecule.ts

@@ -1,7 +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/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,18 +1,7 @@
-import type {
-	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 =
-	| 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/register-selector.ts

@@ -82,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/store/deposit.ts

@@ -1,5 +1,6 @@
 import type {
 	AtomFamilyToken,
+	AtomIOToken,
 	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -11,6 +12,8 @@ import type {
 	RegularAtomToken,
 	SelectorFamilyToken,
 	SelectorToken,
+	TimelineManageable,
+	TimelineToken,
 	TransactionToken,
 	WritableFamilyToken,
 	WritableSelectorFamilyToken,
@@ -22,6 +25,7 @@ import type { Canonical, Json } from "atom.io/json"
 import type {
 	Atom,
 	AtomFamily,
+	AtomIOInternalResource,
 	Func,
 	MutableAtom,
 	MutableAtomFamily,
@@ -33,6 +37,7 @@ import type {
 	RegularAtomFamily,
 	Selector,
 	SelectorFamily,
+	Timeline,
 	Transceiver,
 	WritableFamily,
 	WritableSelector,
@@ -80,16 +85,13 @@ export function deposit<T>(
 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: ReadableState<any>): ReadableToken<any>
+export function deposit(resource: AtomIOInternalResource): AtomIOToken
 
-export function deposit(
-	state: ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>,
-): ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func>
-
-export function deposit(
-	state: ReadableFamily<any, any> | ReadableState<any> | Transaction<Func>,
-): ReadableFamilyToken<any, any> | ReadableToken<any> | TransactionToken<Func> {
+export function deposit(state: AtomIOInternalResource): AtomIOToken {
 	const token = {
 		key: state.key,
 		type: state.type,

package/internal/src/store/withdraw.ts

@@ -1,5 +1,6 @@
 import type {
 	AtomFamilyToken,
+	AtomIOToken,
 	AtomToken,
 	MutableAtomFamilyToken,
 	MutableAtomToken,
@@ -24,8 +25,8 @@ import type { Canonical, Json } from "atom.io/json"
 import type {
 	Atom,
 	AtomFamily,
+	AtomIOInternalResource,
 	Func,
-	Molecule,
 	MutableAtom,
 	MutableAtomFamily,
 	ReadableFamily,
@@ -47,27 +48,6 @@ import type { Timeline } from "../timeline"
 import type { Transaction } from "../transaction"
 import type { Store } from "./store"
 
-export type Withdrawable =
-	| Atom<any>
-	| AtomFamily<any, any>
-	| Molecule<any>
-	| MutableAtom<any, any>
-	| MutableAtomFamily<any, any, any>
-	| ReadableFamily<any, any>
-	| ReadableState<any>
-	| ReadonlySelector<any>
-	| ReadonlySelectorFamily<any, any>
-	| RegularAtom<any>
-	| RegularAtomFamily<any, any>
-	| Selector<any>
-	| SelectorFamily<any, any>
-	| Timeline<any>
-	| Transaction<any>
-	| WritableFamily<any, any>
-	| WritableSelector<any>
-	| WritableSelectorFamily<any, any>
-	| WritableState<any>
-
 export function withdraw<T>(
 	token: RegularAtomToken<T>,
 	store: Store,
@@ -141,24 +121,25 @@ export function withdraw<T>(
 	store: Store,
 ): Timeline<T extends TimelineManageable ? T : never>
 
+export function withdraw<T>(
+	token: WritableToken<T>,
+	store: Store,
+): WritableState<T>
 export function withdraw<T>(
 	token: ReadableToken<T>,
 	store: Store,
 ): ReadableState<T>
 
 export function withdraw(
-	token:
-		| MutableAtomFamilyToken<any, any, any>
-		| MutableAtomToken<any, any>
-		| RegularAtomFamilyToken<any, any>
-		| RegularAtomToken<any>
-		| SelectorFamilyToken<any, any>
-		| SelectorToken<any>
-		| TimelineToken<any>
-		| TransactionToken<any>,
-	store: Store,
-): Withdrawable {
-	let withdrawn: Withdrawable | undefined
+	token: AtomIOToken,
+	store: Store,
+): AtomIOInternalResource
+
+export function withdraw(
+	token: AtomIOToken,
+	store: Store,
+): AtomIOInternalResource {
+	let withdrawn: AtomIOInternalResource | undefined
 	let target: Store | null = store
 	while (target !== null) {
 		switch (token.type) {

package/json/dist/index.js

@@ -1,5 +1,4 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-42UH5F5Q.js';
-import '../../dist/chunk-ICGFFQ3H.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-Y5MBNTVU.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, withdraw, seekInStore } from 'atom.io/internal';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atom.io",
-  "version": "0.31.0",
+  "version": "0.31.1",
   "description": "Composable and testable reactive data library.",
   "homepage": "https://atom.io.fyi",
   "sideEffects": false,
@@ -64,12 +64,12 @@
     "@typescript-eslint/utils": "8.24.1",
     "@vitest/coverage-v8": "3.0.6",
     "@vitest/ui": "3.0.6",
-    "bun-types": "1.2.2",
+    "bun-types": "1.2.3",
     "concurrently": "9.1.2",
     "drizzle-kit": "0.30.4",
     "drizzle-orm": "0.39.3",
-    "eslint": "9.20.1",
-    "happy-dom": "17.1.1",
+    "eslint": "9.21.0",
+    "happy-dom": "17.1.4",
     "http-proxy": "1.18.1",
     "motion": "12.4.7",
     "npmlog": "7.0.1",
@@ -90,7 +90,7 @@
     "vitest": "3.0.6",
     "zod": "3.24.2",
     "break-check": "0.6.6",
-    "recoverage": "0.0.6"
+    "recoverage": "0.0.7"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/realtime-server/src/ipc-sockets/child-socket.ts

@@ -1,5 +1,4 @@
 import type { ChildProcessWithoutNullStreams } from "node:child_process"
-import type { Console } from "node:console"
 
 import type { Json } from "atom.io/json"
 import { parseJson } from "atom.io/json"

package/realtime-server/src/realtime-server-stores/server-room-external-actions.ts

@@ -1,5 +1,5 @@
 import * as AtomIO from "atom.io"
-import { editRelations, editRelationsInStore, type Loadable } from "atom.io/data"
+import { editRelationsInStore, type Loadable } from "atom.io/data"
 import type { UserInRoomMeta } from "atom.io/realtime"
 import { roomIndex, usersInRooms } from "atom.io/realtime"
 

package/realtime-testing/dist/index.js

@@ -63,7 +63,6 @@ var setupRealtimeTestServer = (options) => {
         RTS.socketIndex,
         (index) => index.add(socketClaim)
       );
-      console.log(`${username} connected on ${socket.id}`);
       next();
     } else {
       next(new Error(`Authentication error`));
@@ -85,11 +84,11 @@ var setupRealtimeTestServer = (options) => {
       socket.onAnyOutgoing((event, ...args) => {
         console.log(`\u{1F6F0}  >>`, userKey, event, ...args);
       });
+      socket.on(`disconnect`, () => {
+        console.log(`${userKey} disconnected`);
+      });
     }
     options.server({ socket, enableLogging, silo });
-    socket.on(`disconnect`, () => {
-      console.log(`${userKey} disconnected`);
-    });
   });
   const dispose = async () => {
     await server.close();

package/realtime-testing/src/setup-realtime-test.tsx

@@ -130,7 +130,7 @@ export const setupRealtimeTestServer = (
 			setIntoStore(silo.store, RTS.socketIndex, (index) =>
 				index.add(socketClaim),
 			)
-			console.log(`${username} connected on ${socket.id}`)
+			// console.log(`${username} connected on ${socket.id}`)
 			next()
 		} else {
 			next(new Error(`Authentication error`))
@@ -153,11 +153,11 @@ export const setupRealtimeTestServer = (
 			socket.onAnyOutgoing((event, ...args) => {
 				console.log(`🛰  >>`, userKey, event, ...args)
 			})
+			socket.on(`disconnect`, () => {
+				console.log(`${userKey} disconnected`)
+			})
 		}
 		options.server({ socket, enableLogging, silo })
-		socket.on(`disconnect`, () => {
-			console.log(`${userKey} disconnected`)
-		})
 	})
 
 	const dispose = async () => {