atom.io 0.29.5 → 0.30.1

package/internal/src/junction.ts

@@ -1,23 +1,36 @@
 import type { Refinement } from "atom.io/introspection"
 import type { Json } from "atom.io/json"
+import { B } from "vitest/dist/chunks/benchmark.JVlTzojj.js"
 
-export interface JunctionEntries<Content extends Json.Object | null>
-	extends Json.Object {
-	readonly relations: [string, string[]][]
+export type JunctionEntriesBase<
+	AType extends string,
+	BType extends string,
+	Content extends Json.Object | null,
+> = {
+	readonly relations: ([AType, BType[]] | [BType, AType[]])[]
 	readonly contents: [string, Content][]
 }
-export interface JunctionSchema<ASide extends string, BSide extends string>
-	extends Json.Object {
+export interface JunctionEntries<
+	AType extends string,
+	BType extends string,
+	Content extends Json.Object | null,
+> extends Json.Object,
+		JunctionEntriesBase<AType, BType, Content> {}
+
+export type JunctionSchemaBase<ASide extends string, BSide extends string> = {
 	readonly between: [a: ASide, b: BSide]
 	readonly cardinality: `1:1` | `1:n` | `n:n`
 }
+export interface JunctionSchema<ASide extends string, BSide extends string>
+	extends Json.Object,
+		JunctionSchemaBase<ASide, BSide> {}
 
 export type BaseExternalStoreConfiguration = {
 	addRelation: (a: string, b: string) => void
 	deleteRelation: (a: string, b: string) => void
 	replaceRelationsSafely: (a: string, bs: string[]) => void
 	replaceRelationsUnsafely: (a: string, bs: string[]) => void
-	getRelatedKeys: (key: string) => Set<string> | undefined
+	getRelatedKeys(key: string): Set<string> | undefined
 	has: (a: string, b?: string) => boolean
 }
 
@@ -39,41 +52,56 @@ export type ExternalStoreConfiguration<Content extends Json.Object | null> =
 		: BaseExternalStoreConfiguration &
 				Empty<ExternalStoreWithContentConfiguration<Json.Object>>
 
-export type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
+export type JunctionAdvancedConfiguration<
+	AType extends string,
+	BType extends string,
+	Content extends Json.Object | null,
+> = {
 	warn?: (...args: any[]) => void
 	externalStore?: ExternalStoreConfiguration<Content>
+	isAType?: Refinement<string, AType>
+	isBType?: Refinement<string, BType>
 	isContent?: Refinement<unknown, Content>
-	makeContentKey?: (a: string, b: string) => string
+	makeContentKey?: (a: AType, b: BType) => string
 }
 
 export type JunctionJSON<
 	ASide extends string,
+	AType extends string,
 	BSide extends string,
+	BType extends string,
 	Content extends Json.Object | null,
-> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>
+> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>
 
 export class Junction<
 	const ASide extends string,
+	const AType extends string,
 	const BSide extends string,
+	const BType extends string,
 	const Content extends Json.Object | null = null,
 > {
 	public readonly a: ASide
 	public readonly b: BSide
 	public readonly cardinality: `1:1` | `1:n` | `n:n`
-	public readonly relations = new Map<string, Set<string>>()
+	public readonly relations = new Map<AType | BType, Set<AType> | Set<BType>>()
 	public readonly contents = new Map<string, Content>()
 
 	public isContent: Refinement<unknown, Content> | null
-	public makeContentKey = (a: string, b: string): string => `${a}:${b}`
+	public makeContentKey = (a: AType, b: BType): string => `${a}:${b}`
 
 	public warn?: (...args: any[]) => void
 
-	public getRelatedKeys(key: string): Set<string> | undefined {
+	public getRelatedKeys(key: AType): Set<BType> | undefined
+	public getRelatedKeys(key: BType): Set<AType> | undefined
+	public getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined
+	public getRelatedKeys(
+		key: AType | BType,
+	): Set<AType> | Set<BType> | undefined {
 		return this.relations.get(key)
 	}
-	protected addRelation(a: string, b: string): void {
-		let aRelations = this.relations.get(a)
-		let bRelations = this.relations.get(b)
+	protected addRelation(a: AType, b: BType): void {
+		let aRelations = this.relations.get(a) as Set<BType> | undefined
+		let bRelations = this.relations.get(b) as Set<AType> | undefined
 		if (aRelations) {
 			aRelations.add(b)
 		} else {
@@ -87,14 +115,14 @@ export class Junction<
 			this.relations.set(b, bRelations)
 		}
 	}
-	protected deleteRelation(a: string, b: string): void {
-		const aRelations = this.relations.get(a)
+	protected deleteRelation(a: AType, b: BType): void {
+		const aRelations = this.relations.get(a) as Set<BType> | undefined
 		if (aRelations) {
 			aRelations.delete(b)
 			if (aRelations.size === 0) {
 				this.relations.delete(a)
 			}
-			const bRelations = this.relations.get(b)
+			const bRelations = this.relations.get(b) as Set<AType> | undefined
 			if (bRelations) {
 				bRelations.delete(a)
 				if (bRelations.size === 0) {
@@ -104,36 +132,46 @@ export class Junction<
 		}
 	}
 
-	protected replaceRelationsUnsafely(a: string, bs: string[]): void {
-		this.relations.set(a, new Set(bs))
-		for (const b of bs) {
-			const bRelations = new Set([a])
-			this.relations.set(b, bRelations)
+	protected replaceRelationsUnsafely(a: AType, bs: BType[]): void
+	protected replaceRelationsUnsafely(b: BType, as: AType[]): void
+	protected replaceRelationsUnsafely(
+		x: AType | BType,
+		ys: AType[] | BType[],
+	): void {
+		this.relations.set(x as AType, new Set(ys as BType[]))
+		for (const y of ys) {
+			const yRelations = new Set<AType>().add(x as AType)
+			this.relations.set(y, yRelations)
 		}
 	}
-	protected replaceRelationsSafely(a: string, bs: string[]): void {
-		const aRelationsPrev = this.relations.get(a)
-		if (aRelationsPrev) {
-			for (const b of aRelationsPrev) {
-				const bRelations = this.relations.get(b)
-				if (bRelations) {
-					if (bRelations.size === 1) {
-						this.relations.delete(b)
+	protected replaceRelationsSafely(a: AType, bs: BType[]): void
+	protected replaceRelationsSafely(b: BType, as: AType[]): void
+	protected replaceRelationsSafely<
+		XType extends AType | BType,
+		YType extends XType extends AType ? BType : AType,
+	>(x: XType, ys: YType[]): void {
+		const xRelationsPrev = this.relations.get(x)
+		if (xRelationsPrev) {
+			for (const y of xRelationsPrev) {
+				const yRelations = this.relations.get(y) as Set<XType> | undefined
+				if (yRelations) {
+					if (yRelations.size === 1) {
+						this.relations.delete(y)
 					} else {
-						bRelations.delete(a)
+						yRelations.delete(x)
 					}
-					this.contents.delete(this.makeContentKey(a, b))
+					this.contents.delete(this.makeContentKey(x as any, y as any)) // sort XY to AB ❗
 				}
 			}
 		}
-		this.relations.set(a, new Set(bs))
-		for (const b of bs) {
-			let bRelations = this.relations.get(b)
-			if (bRelations) {
-				bRelations.add(a)
+		this.relations.set(x, new Set(ys) as any)
+		for (const y of ys) {
+			let yRelations = this.relations.get(y) as Set<XType> | undefined
+			if (yRelations) {
+				yRelations.add(x)
 			} else {
-				bRelations = new Set([a])
-				this.relations.set(b, bRelations)
+				yRelations = new Set<XType>().add(x)
+				this.relations.set(y, yRelations as any)
 			}
 		}
 	}
@@ -149,15 +187,18 @@ export class Junction<
 	}
 
 	public constructor(
-		data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>,
-		config?: JunctionAdvancedConfiguration<Content>,
+		data: JunctionSchema<ASide, BSide> &
+			Partial<JunctionEntries<AType, BType, Content>>,
+		config?: JunctionAdvancedConfiguration<AType, BType, Content>,
 	) {
 		this.a = data.between[0]
 		this.b = data.between[1]
 
 		this.cardinality = data.cardinality
 		if (!config?.externalStore) {
-			this.relations = new Map(data.relations?.map(([a, b]) => [a, new Set(b)]))
+			this.relations = new Map(
+				data.relations?.map(([x, ys]) => [x, new Set(ys as AType[])]),
+			)
 			this.contents = new Map(data.contents)
 		}
 		this.isContent = config?.isContent ?? null
@@ -179,7 +220,10 @@ export class Junction<
 			this.replaceRelationsUnsafely = (a, bs) => {
 				externalStore.replaceRelationsUnsafely(a, bs)
 			}
-			this.getRelatedKeys = (key) => externalStore.getRelatedKeys(key)
+			this.getRelatedKeys = ((key) =>
+				externalStore.getRelatedKeys(
+					key,
+				)) as typeof Junction.prototype.getRelatedKeys
 			if (externalStore.getContent) {
 				this.getContentInternal = (contentKey) => {
 					return externalStore.getContent(contentKey) as any
@@ -192,7 +236,7 @@ export class Junction<
 				}
 			}
 			for (const [x, ys] of data.relations ?? []) {
-				for (const y of ys) this.addRelation(x, y)
+				for (const y of ys) this.addRelation(x as AType, y as BType) // sort XY to AB ❗
 			}
 			for (const [contentKey, content] of data.contents ?? []) {
 				this.setContent(contentKey, content)
@@ -202,33 +246,35 @@ export class Junction<
 			this.warn = config.warn
 		}
 	}
-	public toJSON(): JunctionJSON<ASide, BSide, Content> {
+	public toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content> {
 		return {
 			between: [this.a, this.b],
 			cardinality: this.cardinality,
-			relations: [...this.relations.entries()].map(([a, b]) => [a, [...b]]),
+			relations: [...this.relations.entries()].map(
+				([a, b]) => [a, [...b]] as [AType, BType[]],
+			),
 			contents: [...this.contents.entries()],
 		}
 	}
 
 	public set(
-		a: string,
-		...rest: Content extends null ? [b: string] : [b: string, content: Content]
+		a: AType,
+		...rest: Content extends null ? [b: BType] : [b: BType, content: Content]
 	): this
 	public set(
-		relation: { [Key in ASide | BSide]: string },
-		...rest: Content extends null ? [] | [b?: undefined] : [content: Content]
+		relation: { [Key in ASide]: AType } & { [Key in BSide]: BType },
+		...rest: Content extends null ? [] | [void?: undefined] : [content: Content]
 	): this
 	public set(
-		a: string | { [Key in ASide | BSide]: string },
+		a: AType | ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
 		...rest: Content extends null
-			? [] | [b?: string | undefined]
-			: [b: string, content: Content] | [content: Content]
+			? [] | [b?: BType | undefined]
+			: [b: BType, content: Content] | [content: Content]
 	): this {
-		const b: string =
+		const b: BType =
 			typeof rest[0] === `string`
 				? rest[0]
-				: (a[this.b as keyof typeof a] as string)
+				: (a[this.b as keyof typeof a] as BType)
 		const content: Content | undefined =
 			(rest[1] ?? typeof rest[0] === `string`) ? undefined : (rest[0] as Content)
 		a = typeof a === `string` ? a : a[this.a]
@@ -236,7 +282,7 @@ export class Junction<
 			// biome-ignore lint/suspicious/noFallthroughSwitchClause: perfect here
 			case `1:1`: {
 				const bPrev = this.getRelatedKey(a)
-				if (bPrev && bPrev !== b) this.delete(bPrev, a)
+				if (bPrev && bPrev !== b) this.delete(a, bPrev)
 			}
 			case `1:n`: {
 				const aPrev = this.getRelatedKey(b)
@@ -251,29 +297,32 @@ export class Junction<
 		return this
 	}
 
-	public delete(a: string, b?: string): this
+	public delete(a: AType, b?: BType): this
+	public delete(b: BType, a?: AType): this
 	public delete(
 		relation:
-			| Record<ASide | BSide, string>
-			| Record<ASide, string>
-			| Record<BSide, string>,
+			| { [Key in ASide]: AType }
+			| { [Key in BSide]: BType }
+			| ({ [Key in ASide]: AType } & { [Key in BSide]: BType }),
 		b?: undefined,
 	): this
 	public delete(
 		x:
+			| AType
+			| BType
 			| Record<ASide | BSide, string>
 			| Record<ASide, string>
-			| Record<BSide, string>
-			| string,
-		b?: string,
+			| Record<BSide, string>,
+		b?: AType | BType,
 	): this {
 		// @ts-expect-error we deduce that this.b may index x
-		b = typeof b === `string` ? b : (x[this.b] as string | undefined)
-		// @ts-expect-error we deduce that this.a may index x
-		const a = typeof x === `string` ? x : (x[this.a] as string | undefined)
+		b = typeof b === `string` ? (b as BType) : (x[this.b] as BType | undefined)
+		const a =
+			// @ts-expect-error we deduce that this.a may index x
+			typeof x === `string` ? (x as AType) : (x[this.a] as AType | undefined)
 
 		if (a === undefined && typeof b === `string`) {
-			const bRelations = this.getRelatedKeys(b)
+			const bRelations = this.getRelatedKeys(b) as Set<AType>
 			if (bRelations) {
 				for (const bRelation of bRelations) {
 					this.delete(bRelation, b)
@@ -296,7 +345,9 @@ export class Junction<
 		return this
 	}
 
-	public getRelatedKey(key: string): string | undefined {
+	public getRelatedKey(key: AType): BType | undefined
+	public getRelatedKey(key: BType): AType | undefined
+	public getRelatedKey(key: AType | BType): AType | BType | undefined {
 		const relations = this.getRelatedKeys(key)
 		if (relations) {
 			if (relations.size > 1) {
@@ -315,37 +366,52 @@ export class Junction<
 	}
 
 	public replaceRelations(
-		a: string,
-		relations: Content extends null ? string[] : Record<string, Content>,
+		a: AType,
+		relations: Content extends null ? BType[] : Record<BType, Content>,
+		config?: { reckless: boolean },
+	): this
+	public replaceRelations(
+		b: BType,
+		relations: Content extends null ? AType[] : Record<AType, Content>,
+		config?: { reckless: boolean },
+	): this
+	public replaceRelations<
+		XType extends AType | BType,
+		YType extends XType extends AType ? BType : AType,
+	>(
+		x: XType,
+		relations: Content extends null ? YType[] : Record<YType, Content>,
 		config?: { reckless: boolean },
 	): this {
 		const hasContent = !Array.isArray(relations)
-		const bs = hasContent ? Object.keys(relations) : relations
+		const ys = (hasContent ? Object.keys(relations) : relations) as YType[]
 		if (config?.reckless) {
-			this.replaceRelationsUnsafely(a, bs)
+			this.replaceRelationsUnsafely(x as any, ys as any)
 		} else {
-			this.replaceRelationsSafely(a, bs)
+			this.replaceRelationsSafely(x as any, ys as any)
 		}
 		if (hasContent) {
-			for (const b of bs) {
-				const contentKey = this.makeContentKey(a, b)
-				const content = relations[b] as Content
+			for (const y of ys) {
+				const contentKey = this.makeContentKey(x as any, y as any) // sort XY to AB ❗
+				const content = (relations as Record<YType, Content>)[y]
 				this.setContent(contentKey, content)
 			}
 		}
 		return this
 	}
 
-	public getContent(a: string, b: string): Content | undefined {
+	public getContent(a: AType, b: BType): Content | undefined {
 		const contentKey = this.makeContentKey(a, b)
 		return this.getContentInternal(contentKey)
 	}
 
+	public getRelationEntries(input: Record<ASide, AType>): [BType, Content][]
+	public getRelationEntries(input: Record<BSide, BType>): [AType, Content][]
 	public getRelationEntries(
-		input: Record<ASide, string> | Record<BSide, string>,
-	): [string, Content][] {
-		const a: string | undefined = (input as any)[this.a]
-		const b: string | undefined = (input as any)[this.b]
+		input: Record<ASide, AType> | Record<BSide, BType>,
+	): [AType | BType, Content][] {
+		const a: AType | undefined = (input as any)[this.a]
+		const b: BType | undefined = (input as any)[this.b]
 		if (a !== undefined && b === undefined) {
 			const aRelations = this.getRelatedKeys(a)
 			if (aRelations) {
@@ -365,10 +431,12 @@ export class Junction<
 		return []
 	}
 
-	public has(a: string, b?: string): boolean {
+	public has(a: AType, b?: BType): boolean
+	public has(b: BType, a?: AType): boolean
+	public has(a: AType | BType, b?: AType | BType): boolean {
 		if (b) {
 			const setA = this.getRelatedKeys(a)
-			return setA?.has(b) ?? false
+			return setA?.has(b as any) ?? false
 		}
 		return this.relations.has(a)
 	}

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,
@@ -82,7 +82,9 @@ export function makeMoleculeInStore<M extends MoleculeConstructor>(
 		},
 		env: () => getEnvironmentData(newest(rootStore)),
 		bond: ((
-			token: JoinToken<any, any, any, any> | ReadableFamilyToken<any, any>,
+			token:
+				| JoinToken<any, any, any, any, any, any>
+				| ReadableFamilyToken<any, any>,
 			maybeRole,
 		) => {
 			if (token.type === `join`) {
@@ -93,12 +95,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 +169,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,30 +18,34 @@ 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>
 	>()
 	public tokens = new Map<string, ReadableToken<any>>()
 	public above = new Map<string, Molecule<any>>()
 	public below = new Map<string, Molecule<any>>()
-	public joins = new Map<string, Join<any, any, any, any>>()
+	public joins = new Map<string, Join<any, any, 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/mutable/create-mutable-atom-family.ts

@@ -7,7 +7,7 @@ import type {
 	StateCreation,
 	StateDisposal,
 } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 import { selectJsonFamily, stringifyJson } from "atom.io/json"
 
 import { type MutableAtomFamily, prettyPrintTokenType } from ".."
@@ -21,7 +21,7 @@ import type { Transceiver } from "./transceiver"
 export function createMutableAtomFamily<
 	T extends Transceiver<any>,
 	J extends Json.Serializable,
-	K extends string,
+	K extends Canonical,
 >(
 	store: Store,
 	options: MutableAtomFamilyOptions<T, J, K>,

package/internal/src/mutable/get-json-family.ts

@@ -1,5 +1,5 @@
 import type { MutableAtomFamilyToken } from "atom.io"
-import type { Json } from "atom.io/json"
+import type { Canonical, Json } from "atom.io/json"
 
 import type { WritableSelectorFamily } from ".."
 import { newest } from "../lineage"
@@ -9,7 +9,7 @@ import type { Transceiver } from "./transceiver"
 export const getJsonFamily = <
 	Core extends Transceiver<Json.Serializable>,
 	SerializableCore extends Json.Serializable,
-	Key extends string,
+	Key extends Canonical,
 >(
 	mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>,
 	store: Store,

package/internal/src/store/store.ts

@@ -1,6 +1,8 @@
 import type {
 	AtomToken,
 	Logger,
+	MoleculeCreationModern,
+	MoleculeDisposalModern,
 	MoleculeFamily,
 	MoleculeToken,
 	ReadonlySelectorToken,
@@ -54,7 +56,9 @@ export class Store implements Lineage {
 	})
 	public selectorGraph = new Junction<
 		`upstreamSelectorKey`,
+		string,
 		`downstreamSelectorKey`,
+		string,
 		{ source: string }
 	>(
 		{
@@ -86,7 +90,9 @@ export class Store implements Lineage {
 	public timelines = new Map<string, Timeline<any>>()
 	public timelineTopics = new Junction<
 		`timelineKey`,
+		string,
 		`topicKey`,
+		string,
 		{ topicType: `atom_family` | `atom` | `molecule_family` | `molecule` }
 	>({
 		between: [`timelineKey`, `topicKey`],
@@ -115,9 +121,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 }