atom.io 0.29.4 → 0.30.0

package/internal/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as atom_io from 'atom.io';
-import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, MoleculeFamily, MoleculeToken, MoleculeFamilyOptions, StateCreation, StateDisposal, MoleculeParams, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
+import { MutableAtomFamilyToken, MutableAtomToken, RegularAtomFamilyToken, RegularAtomToken, AtomFamilyToken, AtomToken, WritableSelectorFamilyToken, WritableSelectorToken, ReadonlySelectorFamilyToken, ReadonlySelectorToken, SelectorFamilyToken, SelectorToken, WritableFamilyToken, WritableToken, ReadableFamilyToken, ReadableToken, MoleculeConstructor, MoleculeFamilyToken, MoleculeKey, TransactionToken, TransactionUpdate, TransactionOptions, ActorToolkit, MoleculeFamily, MoleculeToken, MoleculeFamilyOptions, StateCreation, StateDisposal, MoleculeParams, TimelineManageable, StateUpdate, TokenType, FamilyMetadata, MoleculeCreation, MoleculeDisposal, TimelineUpdate, TimelineOptions, TimelineToken, MoleculeCreationModern, MoleculeDisposalModern, AtomIOLogger, Logger, MutableAtomOptions, MutableAtomFamilyOptions, RegularAtomOptions, RegularAtomFamilyOptions, ReadonlySelectorFamilyOptions, WritableSelectorFamilyOptions, KeyedStateUpdate, ReadonlySelectorOptions, WritableSelectorOptions, SetterToolkit, UpdateHandler, TransactionUpdateHandler } from 'atom.io';
 import { Json, Canonical, JsonInterface } from 'atom.io/json';
 import { Join } from 'atom.io/data';
 import { Refinement } from 'atom.io/introspection';
@@ -94,7 +94,13 @@ type Flat<R extends {
 }> = {
     [K in keyof R]: R[K];
 };
-type Range<N extends number, A extends any[] = []> = A[`length`] extends N ? A[`length`] : A[`length`] | Range<N, [...A, any]>;
+type Count<N extends number, A extends any[] = []> = [
+    ...A,
+    any
+][`length`] extends N ? A[`length`] : A[`length`] | Count<N, [...A, any]>;
+type Each<E extends any[]> = {
+    [P in Count<E[`length`]>]: E[P];
+};
 
 declare const abortTransaction: (store: Store) => void;
 
@@ -198,13 +204,15 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     readonly type = "molecule";
     stringKey: string;
     family?: MoleculeFamilyToken<M>;
+    _dependsOn: `all` | `any`;
+    get dependsOn(): `all` | `any`;
     readonly subject: Subject<StateCreation<any> | StateDisposal<any>>;
     tokens: Map<string, ReadableToken<any>>;
     above: Map<string, Molecule<any>>;
     below: Map<string, Molecule<any>>;
     joins: Map<string, Join<any, any, any, any>>;
     instance: InstanceType<M>;
-    constructor(ctx: Molecule<any> | Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
+    constructor(ctx: Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
 
 declare function growMoleculeInStore<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(molecule: Molecule<any>, family: MutableAtomFamilyToken<T, J, K>, store: Store): MutableAtomToken<T, J>;
@@ -316,7 +324,7 @@ declare class Store implements Lineage {
     }>;
     molecules: Map<string, Molecule<any>>;
     moleculeFamilies: Map<string, Flat<atom_io.MoleculeFamilyToken<any> & {
-        subject: Subject<atom_io.MoleculeCreation<any> | atom_io.MoleculeDisposal>;
+        subject: Subject<atom_io.MoleculeCreationClassic<any> | atom_io.MoleculeDisposalClassic>;
         dependsOn: `all` | `any`;
         new: any;
     }>>;
@@ -331,9 +339,9 @@ declare class Store implements Lineage {
         transactionCreation: Subject<TransactionToken<Func>>;
         transactionApplying: StatefulSubject<TransactionProgress<Func> | null>;
         operationClose: Subject<OperationProgress>;
-        moleculeCreationStart: Subject<MoleculeToken<any>>;
+        moleculeCreationStart: Subject<MoleculeToken<any> | MoleculeCreationModern>;
         moleculeCreationDone: Subject<MoleculeToken<any>>;
-        moleculeDisposal: Subject<MoleculeToken<any>>;
+        moleculeDisposal: Subject<MoleculeToken<any> | MoleculeDisposalModern>;
     };
     operation: OperationProgress;
     config: {
@@ -664,4 +672,4 @@ type SelectorFamily<T, K extends Canonical> = ReadonlySelectorFamily<T, K> | Wri
 type WritableFamily<T, K extends Canonical> = AtomFamily<T, K> | WritableSelectorFamily<T, K>;
 type ReadableFamily<T, K extends Canonical> = AtomFamily<T, K> | SelectorFamily<T, K>;
 
-export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionJSON, type JunctionSchema, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type Range, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };
+export { type Atom, type AtomFamily, type AtomIOState, type AtomIOToken, type AtomKey, type BaseExternalStoreConfiguration, type ChildStore, type Count, type Each, type Empty, type EnvironmentData, type ExternalStoreConfiguration, type ExternalStoreWithContentConfiguration, FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, type Flat, type Func, Future, IMPLICIT, Junction, type JunctionAdvancedConfiguration, type JunctionEntries, type JunctionJSON, type JunctionSchema, LazyMap, type Lineage, type Modify, Molecule, type MutableAtom, type MutableAtomFamily, NotFoundError, type OperationProgress, type ReadableFamily, type ReadableState, type ReadonlySelector, type ReadonlySelectorFamily, type ReadonlySelectorKey, type RegularAtom, type RegularAtomFamily, type RootStore, type Selector, type SelectorFamily, type SelectorKey, type Signal, type StateKey, StatefulSubject, Store, Subject, TRANSACTION_PHASES, type Timeline, type TimelineAtomUpdate, type TimelineMoleculeCreation, type TimelineMoleculeDisposal, type TimelineSelectorUpdate, type TimelineStateCreation, type TimelineStateDisposal, type TimelineTransactionUpdate, Tracker, type Transaction, type TransactionEpoch, type TransactionPhase, type TransactionProgress, type Transceiver, type TransceiverMode, type Withdrawable, type WritableFamily, type WritableSelector, type WritableSelectorFamily, type WritableState, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw };

package/internal/dist/index.js

@@ -1,2 +1,3 @@
-export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-TCINPEYE.js';
+export { FAMILY_MEMBER_TOKEN_TYPES, FamilyTracker, Future, IMPLICIT, Junction, LazyMap, Molecule, NotFoundError, StatefulSubject, Store, Subject, TRANSACTION_PHASES, Tracker, abortTransaction, actUponStore, applyTransaction, arbitrary, assignTransactionToContinuity, become, buildTransaction, cacheValue, clearStore, closeOperation, counterfeit, createAtomFamily, createMoleculeFamily, createMutableAtom, createMutableAtomFamily, createReadonlySelector, createReadonlySelectorFamily, createRegularAtom, createRegularAtomFamily, createSelectorFamily, createStandaloneAtom, createStandaloneSelector, createTimeline, createTransaction, createWritableSelector, deposit, disposeAtom, disposeFromStore, disposeMolecule, disposeSelector, eldest, evictCachedValue, findInStore, getContinuityKey, getEnvironmentData, getEpochNumberOfAction, getEpochNumberOfContinuity, getFromStore, getJsonFamily, getJsonToken, getSelectorDependencyKeys, getUpdateFamily, getUpdateToken, growMoleculeInStore, ingestAtomUpdate, ingestCreationEvent, ingestDisposalEvent, ingestMoleculeCreationEvent, ingestMoleculeDisposalEvent, ingestSelectorUpdate, ingestTransactionUpdate, initFamilyMemberInStore, isAtomDefault, isAtomKey, isChildStore, isDone, isReadonlySelectorKey, isRootStore, isSelectorKey, isStateKey, isTransceiver, makeMoleculeInStore, markAtomAsDefault, markAtomAsNotDefault, markDone, newest, openOperation, prettyPrintTokenType, readCachedValue, readOrComputeValue, recallState, registerSelector, seekInStore, setAtomOrSelector, setEpochNumberOfAction, setEpochNumberOfContinuity, setIntoStore, subscribeInStore, subscribeToRootAtoms, subscribeToState, subscribeToTimeline, subscribeToTransaction, timeTravel, traceAllSelectorAtoms, traceSelectorAtoms, updateSelectorAtoms, withdraw } from '../../dist/chunk-7PUUHSXC.js';
+import '../../dist/chunk-ZKG6ZA4I.js';
 import '../../dist/chunk-XWL6SNVU.js';

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

@@ -1,13 +1,7 @@
 import type { AtomToken } from "atom.io"
 
 import type { Store } from ".."
-import {
-	disposeSelector,
-	getUpdateToken,
-	isChildStore,
-	newest,
-	withdraw,
-} from ".."
+import { getUpdateToken, isChildStore, newest, withdraw } from ".."
 
 export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 	const target = newest(store)
@@ -24,6 +18,7 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 			token: atomToken,
 			value: lastValue,
 		})
+
 		const molecule = target.molecules.get(atom.family.subKey)
 		if (molecule) {
 			molecule.tokens.delete(key)
@@ -32,7 +27,8 @@ export function disposeAtom(atomToken: AtomToken<unknown>, store: Store): void {
 		target.valueMap.delete(key)
 		target.selectorAtoms.delete(key)
 		target.atomsThatAreDefault.delete(key)
-		target.timelineTopics.delete(key)
+		store.timelineTopics.delete(key)
+
 		if (atomToken.type === `mutable_atom`) {
 			const updateToken = getUpdateToken(atomToken)
 			disposeAtom(updateToken, store)

package/internal/src/index.ts

@@ -42,7 +42,7 @@ export * from "./subject"
 export * from "./subscribe"
 export * from "./timeline"
 export * from "./transaction"
-export * from "./utility-types"
+export type * from "./utility-types"
 
 export type AtomIOState = {
 	key: string

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

@@ -8,10 +8,11 @@ import type {
 import { parseJson, stringifyJson } from "atom.io/json"
 
 import {
-	disposeFromStore,
-	findInStore,
-	initFamilyMemberInStore,
-} from "../families"
+	allocateIntoStore,
+	deallocateFromStore,
+} from "~/packages/atom.io/src/allocate"
+
+import { disposeFromStore, findInStore } from "../families"
 import { growMoleculeInStore, makeMoleculeInStore } from "../molecule"
 import { type Store, withdraw } from "../store"
 
@@ -70,16 +71,30 @@ export function ingestMoleculeCreationEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			makeMoleculeInStore(
-				store,
-				update.context,
-				update.family,
-				update.token.key,
-				...update.params,
-			)
+			switch (update.subType) {
+				case `classic`:
+					makeMoleculeInStore(
+						store,
+						update.context,
+						update.family,
+						update.token.key,
+						...update.params,
+					)
+					break
+				case `modern`:
+					allocateIntoStore<any, any, any>(store, update.provenance, update.key)
+					break
+			}
 			break
 		case `oldValue`:
-			disposeFromStore(store, update.token)
+			switch (update.subType) {
+				case `classic`:
+					disposeFromStore(store, update.token)
+					break
+				case `modern`:
+					deallocateFromStore<any, any, any>(store, update.key)
+					break
+			}
 			break
 	}
 }
@@ -90,25 +105,54 @@ export function ingestMoleculeDisposalEvent(
 ): void {
 	switch (applying) {
 		case `newValue`:
-			disposeFromStore(store, update.token)
+			switch (update.subType) {
+				case `classic`:
+					disposeFromStore(store, update.token)
+					break
+				case `modern`:
+					deallocateFromStore<any, any, any>(store, update.key)
+					break
+			}
 			break
 		case `oldValue`:
 			{
-				const moleculeToken = makeMoleculeInStore(
-					store,
-					update.context,
-					update.family,
-					update.token.key,
-				)
-				for (const [familyKey, value] of update.values) {
-					const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`
-					const molecule = withdraw(moleculeToken, store)
-					const alreadyCreated = molecule.tokens.has(memberKey)
-					const family = store.families.get(familyKey)
-					if (family && !alreadyCreated) {
-						growMoleculeInStore(molecule, family, store)
+				// TODO: Handle classic vs modern molecules
+				switch (update.subType) {
+					case `classic`:
+						{
+							const moleculeToken = makeMoleculeInStore(
+								store,
+								update.context,
+								update.family,
+								update.token.key,
+							)
+							for (const [familyKey, value] of update.values) {
+								const memberKey = `${familyKey}(${stringifyJson(moleculeToken.key)})`
+								const molecule = withdraw(moleculeToken, store)
+								const alreadyCreated = molecule.tokens.has(memberKey)
+								const family = store.families.get(familyKey)
+								if (family && !alreadyCreated) {
+									growMoleculeInStore(molecule, family, store)
+								}
+								store.valueMap.set(memberKey, value)
+							}
+						}
+						break
+					case `modern`: {
+						allocateIntoStore<any, any, any>(
+							store,
+							update.provenance,
+							update.key,
+						)
+						for (const [familyKey, value] of update.values) {
+							const family = store.families.get(familyKey)
+							if (family) {
+								findInStore(store, family, update.key)
+								const memberKey = `${familyKey}(${stringifyJson(update.key)})`
+								store.valueMap.set(memberKey, value)
+							}
+						}
 					}
-					store.valueMap.set(memberKey, value)
 				}
 			}
 			break

package/internal/src/molecule/create-molecule-family.ts

@@ -1,6 +1,6 @@
 import type {
 	MoleculeConstructor,
-	MoleculeCreation,
+	MoleculeCreationClassic,
 	MoleculeFamily,
 	MoleculeFamilyOptions,
 	MoleculeFamilyToken,
@@ -13,7 +13,7 @@ export function createMoleculeFamily<M extends MoleculeConstructor>(
 	store: Store,
 	options: MoleculeFamilyOptions<M>,
 ): MoleculeFamilyToken<M> {
-	const subject = new Subject<MoleculeCreation<M>>()
+	const subject = new Subject<MoleculeCreationClassic<M>>()
 
 	const token = {
 		type: `molecule_family`,

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

@@ -1,6 +1,7 @@
 import type {
 	MoleculeConstructor,
 	MoleculeDisposal,
+	MoleculeDisposalClassic,
 	MoleculeToken,
 } from "atom.io"
 
@@ -36,8 +37,9 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 
 	if (family) {
 		const Formula = withdraw(family, store)
-		const disposalEvent: MoleculeDisposal = {
+		const disposalEvent: MoleculeDisposalClassic = {
 			type: `molecule_disposal`,
+			subType: `classic`,
 			token,
 			family,
 			context,
@@ -50,7 +52,7 @@ export function disposeMolecule<M extends MoleculeConstructor>(
 			disposeFromStore(store, state)
 		}
 		for (const child of molecule.below.values()) {
-			if (child.family?.dependsOn === `all`) {
+			if (child.dependsOn === `all`) {
 				disposeMolecule(child, store)
 			} else {
 				child.above.delete(molecule.stringKey)

package/internal/src/molecule/make-molecule-in-store.ts

@@ -2,7 +2,7 @@ import type {
 	CtorToolkit,
 	getState,
 	MoleculeConstructor,
-	MoleculeCreation,
+	MoleculeCreationClassic,
 	MoleculeFamilyToken,
 	MoleculeKey,
 	MoleculeParams,
@@ -93,12 +93,11 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 				const unsubFromFamily = family.subject.subscribe(
 					`join:${token.key}-${stringKey}`,
 					(event) => {
-						if (
-							event.type === `molecule_disposal` &&
-							stringifyJson(event.token.key) === stringKey
-						) {
-							unsubFromFamily()
-							join.molecules.delete(stringKey)
+						if (event.type === `molecule_disposal`) {
+							if (stringifyJson(event.token.key) === stringKey) {
+								unsubFromFamily()
+								join.molecules.delete(stringKey)
+							}
 						}
 					},
 				)
@@ -168,11 +167,12 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 
 	const update = {
 		type: `molecule_creation`,
+		subType: `classic`,
 		token,
 		family: familyToken,
 		context: contextArray,
 		params,
-	} satisfies MoleculeCreation<M>
+	} satisfies MoleculeCreationClassic<M>
 
 	if (isRootStore(target)) {
 		family.subject.next(update)

package/internal/src/molecule/molecule-internal.ts

@@ -18,6 +18,13 @@ export class Molecule<M extends MoleculeConstructor>
 	public readonly type = `molecule`
 	public stringKey: string
 	public family?: MoleculeFamilyToken<M>
+	public _dependsOn: `all` | `any`
+	public get dependsOn(): `all` | `any` {
+		if (this.family) {
+			return this.family.dependsOn
+		}
+		return this._dependsOn
+	}
 	public readonly subject = new Subject<
 		StateCreation<any> | StateDisposal<any>
 	>()
@@ -27,21 +34,18 @@ export class Molecule<M extends MoleculeConstructor>
 	public joins = new Map<string, Join<any, any, any, any>>()
 	public instance: InstanceType<M>
 	public constructor(
-		ctx: Molecule<any> | Molecule<any>[] | undefined,
+		ctx: Molecule<any>[] | undefined,
 		public readonly key: MoleculeKey<M>,
 		family?: MoleculeFamilyToken<M>,
 	) {
 		this.stringKey = stringifyJson(key)
 		if (family) {
 			this.family = family
+			this._dependsOn = family.dependsOn
 		}
 		if (ctx) {
-			if (Array.isArray(ctx)) {
-				for (const molecule of ctx) {
-					this.above.set(molecule.stringKey, molecule)
-				}
-			} else {
-				this.above.set(ctx.stringKey, ctx)
+			for (const molecule of ctx) {
+				this.above.set(molecule.stringKey, molecule)
 			}
 		}
 	}

package/internal/src/store/store.ts

@@ -1,6 +1,8 @@
 import type {
 	AtomToken,
 	Logger,
+	MoleculeCreationModern,
+	MoleculeDisposalModern,
 	MoleculeFamily,
 	MoleculeToken,
 	ReadonlySelectorToken,
@@ -115,9 +117,11 @@ export class Store implements Lineage {
 			null,
 		),
 		operationClose: new Subject<OperationProgress>(),
-		moleculeCreationStart: new Subject<MoleculeToken<any>>(),
+		moleculeCreationStart: new Subject<
+			MoleculeCreationModern | MoleculeToken<any>
+		>(),
 		moleculeCreationDone: new Subject<MoleculeToken<any>>(),
-		moleculeDisposal: new Subject<MoleculeToken<any>>(),
+		moleculeDisposal: new Subject<MoleculeDisposalModern | MoleculeToken<any>>(),
 	}
 	public operation: OperationProgress = { open: false }
 

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

@@ -25,6 +25,7 @@ import { newest } from "../lineage"
 import { getUpdateToken } from "../mutable"
 import { type Store, withdraw } from "../store"
 import { Subject } from "../subject"
+import { isChildStore } from "../transaction"
 import type { Flat, Func } from "../utility-types"
 
 export type TimelineAtomUpdate<ManagedAtom extends TimelineManageable> = Flat<
@@ -371,74 +372,81 @@ function addMoleculeFamilyToTimeline(
 					`got a molecule creation or disposal`,
 					creationOrDisposal,
 				)
-				switch (creationOrDisposal.type) {
-					case `molecule_creation`:
-						{
-							store.timelineTopics.set(
-								{
-									topicKey: creationOrDisposal.token.key,
-									timelineKey: tl.key,
-								},
-								{ topicType: `molecule` },
-							)
-							const txUpdateInProgress =
-								newest(store).on.transactionApplying.state?.update
-							if (txUpdateInProgress) {
-								joinTransaction(tl, txUpdateInProgress, store)
-							} else if (tl.timeTraveling === null) {
-								const event = Object.assign(creationOrDisposal, {
-									timestamp: Date.now(),
-								})
-								tl.history.push(event)
-								tl.at = tl.history.length
-								tl.subject.next(event)
-							}
-							const molecule = withdraw(creationOrDisposal.token, store)
+				if (creationOrDisposal.subType === `classic`) {
+					switch (creationOrDisposal.type) {
+						case `molecule_creation`:
+							{
+								store.timelineTopics.set(
+									{
+										topicKey: creationOrDisposal.token.key,
+										timelineKey: tl.key,
+									},
+									{ topicType: `molecule` },
+								)
+								const txUpdateInProgress =
+									newest(store).on.transactionApplying.state?.update
+								if (txUpdateInProgress) {
+									joinTransaction(tl, txUpdateInProgress, store)
+								} else if (tl.timeTraveling === null) {
+									const event = Object.assign(creationOrDisposal, {
+										timestamp: Date.now(),
+									})
+									tl.history.push(event)
+									tl.at = tl.history.length
+									tl.subject.next(event)
+								}
+								const molecule = withdraw(creationOrDisposal.token, store)
 
-							for (const token of molecule.tokens.values()) {
-								switch (token.type) {
-									case `atom`:
-									case `mutable_atom`:
-										addAtomToTimeline(token, tl, store)
-										break
+								for (const token of molecule.tokens.values()) {
+									switch (token.type) {
+										case `atom`:
+										case `mutable_atom`:
+											addAtomToTimeline(token, tl, store)
+											break
+									}
 								}
+								tl.subscriptions.set(
+									molecule.key,
+									molecule.subject.subscribe(
+										`timeline:${tl.key}`,
+										(stateCreationOrDisposal) => {
+											handleStateLifecycleEvent(
+												stateCreationOrDisposal,
+												tl,
+												store,
+											)
+										},
+									),
+								)
 							}
-							tl.subscriptions.set(
-								molecule.key,
-								molecule.subject.subscribe(
-									`timeline:${tl.key}`,
-									(stateCreationOrDisposal) => {
-										handleStateLifecycleEvent(stateCreationOrDisposal, tl, store)
-									},
-								),
-							)
-						}
-						break
-					case `molecule_disposal`:
-						{
-							const txUpdateInProgress =
-								newest(store).on.transactionApplying.state?.update
-							if (txUpdateInProgress) {
-								joinTransaction(tl, txUpdateInProgress, store)
-							} else if (tl.timeTraveling === null) {
-								const event = Object.assign(creationOrDisposal, {
-									timestamp: Date.now(),
-								})
-								tl.history.push(event)
-								tl.at = tl.history.length
-								tl.subject.next(event)
-							}
-							const moleculeKey = creationOrDisposal.token.key
-							tl.subscriptions.get(moleculeKey)?.()
-							tl.subscriptions.delete(moleculeKey)
-							for (const [familyKey] of creationOrDisposal.values) {
-								const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`
-								tl.subscriptions.get(stateKey)?.()
-								tl.subscriptions.delete(stateKey)
-								store.timelineTopics.delete(stateKey)
+							break
+						case `molecule_disposal`:
+							{
+								const txUpdateInProgress =
+									newest(store).on.transactionApplying.state?.update
+								if (txUpdateInProgress) {
+									joinTransaction(tl, txUpdateInProgress, store)
+								} else if (tl.timeTraveling === null) {
+									const event = Object.assign(creationOrDisposal, {
+										timestamp: Date.now(),
+									})
+									tl.history.push(event)
+									tl.at = tl.history.length
+									tl.subject.next(event)
+								}
+								const moleculeKey = stringifyJson(creationOrDisposal.token.key)
+
+								tl.subscriptions.get(moleculeKey)?.()
+								tl.subscriptions.delete(moleculeKey)
+								for (const [familyKey] of creationOrDisposal.values) {
+									const stateKey = `${familyKey}(${stringifyJson(moleculeKey)})`
+									tl.subscriptions.get(stateKey)?.()
+									tl.subscriptions.delete(stateKey)
+									store.timelineTopics.delete(stateKey)
+								}
 							}
-						}
-						break
+							break
+					}
 				}
 			}),
 		)
@@ -506,17 +514,32 @@ function filterTransactionUpdates(
 			}
 
 			let key: string
+			let familyKey: string | undefined
 			switch (updateFromTx.type) {
 				case `state_creation`:
 				case `state_disposal`:
+					key = updateFromTx.token.key
+					familyKey = updateFromTx.token.family?.key
+					break
 				case `molecule_creation`:
 				case `molecule_disposal`:
-					key = updateFromTx.token.key
+					switch (updateFromTx.subType) {
+						case `classic`:
+							key = updateFromTx.token.key
+							break
+						case `modern`:
+							return true // always include
+					}
 					break
 				default:
 					key = updateFromTx.key
+					familyKey = updateFromTx.family?.key
 					break
 			}
+			timelineTopics.has(key)
+			if (familyKey && timelineTopics.has(familyKey)) {
+				return true
+			}
 			return timelineTopics.has(key)
 		})
 		.map((updateFromTx) => {
@@ -543,13 +566,18 @@ function handleStateLifecycleEvent(
 		timestamp,
 	}) as TimelineUpdate<any>
 	if (!tl.timeTraveling) {
-		const txUpdateInProgress = newest(store).on.transactionApplying.state?.update
-		if (txUpdateInProgress) {
-			joinTransaction(tl, txUpdateInProgress, store)
+		const target = newest(store)
+		if (isChildStore(target)) {
+			// we don't want to update the true timeline while we are in a transaction
 		} else {
-			tl.history.push(timelineEvent)
-			tl.at = tl.history.length
-			tl.subject.next(timelineEvent)
+			const txUpdateInProgress = target.on.transactionApplying.state
+			if (txUpdateInProgress) {
+				joinTransaction(tl, txUpdateInProgress.update, store)
+			} else {
+				tl.history.push(timelineEvent)
+				tl.at = tl.history.length
+				tl.subject.next(timelineEvent)
+			}
 		}
 	}
 	switch (event.type) {

package/internal/src/utility-types.ts

@@ -4,6 +4,13 @@ export type Flat<R extends { [K in PropertyKey]: any }> = {
 	[K in keyof R]: R[K]
 }
 
-export type Range<N extends number, A extends any[] = []> = A[`length`] extends N
+export type Count<N extends number, A extends any[] = []> = [
+	...A,
+	any,
+][`length`] extends N
 	? A[`length`]
-	: A[`length`] | Range<N, [...A, any]>
+	: A[`length`] | Count<N, [...A, any]>
+
+export type Each<E extends any[]> = {
+	[P in Count<E[`length`]>]: E[P]
+}

package/json/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { Range, Flat, Store, Transceiver } from 'atom.io/internal';
+import { Count, Flat, Store, Transceiver } from 'atom.io/internal';
 import * as AtomIO from 'atom.io';
 
 type Entries<K extends PropertyKey = keyof any, V = any> = [K, V][];
 type KeyOfEntries<E extends Entries> = E extends [infer K, any][] ? K : never;
 type ValueOfEntry<E extends Entries, K extends KeyOfEntries<E>> = {
-    [P in Range<E[`length`]>]: E[P] extends [K, infer V] ? V : never;
-}[Range<E[`length`]>];
+    [P in Count<E[`length`]>]: E[P] extends [K, infer V] ? V : never;
+}[Count<E[`length`]>];
 type FromEntries<E extends Entries> = Flat<{
     [K in KeyOfEntries<E>]: ValueOfEntry<E, K>;
 }>;

package/json/dist/index.js

@@ -1,4 +1,5 @@
-import { createWritableSelectorFamily } from '../../dist/chunk-TCINPEYE.js';
+import { createWritableSelectorFamily } from '../../dist/chunk-7PUUHSXC.js';
+import '../../dist/chunk-ZKG6ZA4I.js';
 import '../../dist/chunk-XWL6SNVU.js';
 import { createStandaloneSelector, IMPLICIT, growMoleculeInStore, initFamilyMemberInStore, withdraw, seekInStore } from 'atom.io/internal';