atom.io 0.30.6 → 0.31.0

package/src/molecule.ts

@@ -1,138 +1,16 @@
-import type {
-	ActorToolkit,
-	MoleculeCreation,
-	MoleculeCreationClassic,
-	MoleculeDisposal,
-	MoleculeDisposalClassic,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
-	WritableToken,
-} from "atom.io"
-import type { JoinToken } from "atom.io/data"
-import type { Flat, Store, Subject, Transceiver } from "atom.io/internal"
-import {
-	createMoleculeFamily,
-	IMPLICIT,
-	makeMoleculeInStore,
-	Molecule,
-} from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Molecule, Store } from "atom.io/internal"
+import { IMPLICIT } from "atom.io/internal"
 import { stringifyJson } from "atom.io/json"
 
-export type CtorToolkit<K extends Canonical> = Flat<
-	Omit<ActorToolkit, `find`> & {
-		bond<T extends Transceiver<any>, J extends Json.Serializable>(
-			family: MutableAtomFamilyToken<T, J, K>,
-		): MutableAtomToken<T, J>
-		bond<T>(family: RegularAtomFamilyToken<T, K>): RegularAtomToken<T>
-		bond<T>(family: WritableSelectorFamilyToken<T, K>): WritableSelectorToken<T>
-		bond<T>(family: ReadonlySelectorFamilyToken<T, K>): ReadonlySelectorToken<T>
-		bond<T>(family: WritableFamilyToken<T, K>): WritableToken<T>
-		bond<T>(family: ReadableFamilyToken<T, K>): ReadableToken<T>
-		bond<J extends JoinToken<any, any, any, any, any, any>>(
-			joinToken: J,
-			role: {
-				as: J extends JoinToken<infer A, string, infer B, string, any, any>
-					? A | B
-					: never
-			},
-		): J extends JoinToken<any, any, any, any, any, infer Content>
-			? Content extends null
-				? { relatedKeys: ReadonlySelectorToken<string[]> }
-				: {
-						relatedKeys: ReadonlySelectorToken<string[]>
-						relatedEntries: ReadonlySelectorToken<
-							[key: string, value: Content][]
-						>
-					}
-			: never
-
-		claim(below: MoleculeToken<any>, options: { exclusive: boolean }): void
-
-		spawn<Key extends Canonical, Ctor extends MoleculeConstructor>(
-			family: MoleculeFamilyToken<Ctor>,
-			key: Key,
-			...params: MoleculeParams<Ctor>
-		): MoleculeToken<Ctor>
-	}
->
-export type MoleculeConstructor = new (
-	toolkit: CtorToolkit<any>,
-	key: any,
-	...params: any
-) => any
-
-type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : any[]
-
-export type MoleculeParams<M extends MoleculeConstructor> = Tail<
-	Tail<ConstructorParameters<M>>
->
-
-export type MoleculeFamilyOptions<M extends MoleculeConstructor> = {
-	key: string
-	dependsOn?: `all` | `any`
-	new: M
-}
-export type MoleculeFamilyToken<M extends MoleculeConstructor> = {
-	key: string
-	type: `molecule_family`
-	dependsOn: `all` | `any`
-	__M?: M
-}
-export type MoleculeFamily<M extends MoleculeConstructor> = Flat<
-	MoleculeFamilyToken<M> & {
-		subject: Subject<MoleculeCreationClassic<M> | MoleculeDisposalClassic>
-		dependsOn: `all` | `any`
-		new: M
-	}
->
-export type MoleculeToken<M extends MoleculeConstructor> = {
-	key: MoleculeKey<M>
-	type: `molecule`
-	family?: MoleculeFamilyToken<M>
-	__M?: M
-}
-
-export function moleculeFamily<M extends MoleculeConstructor>(
-	options: MoleculeFamilyOptions<M>,
-): MoleculeFamilyToken<M> {
-	return createMoleculeFamily(IMPLICIT.STORE, options)
-}
-
-export function makeMolecule<M extends MoleculeConstructor>(
-	context: MoleculeToken<any> | MoleculeToken<any>[],
-	family: MoleculeFamilyToken<M>,
-	key: MoleculeKey<M>,
-	...params: MoleculeParams<M>
-): MoleculeToken<M> {
-	return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params)
-}
-
-export type MoleculeType<T extends MoleculeFamilyToken<any>> =
-	T extends MoleculeFamilyToken<infer M>
-		? M
-		: T extends MoleculeToken<infer M>
-			? M
-			: never
-export type MoleculeKey<M extends MoleculeConstructor> = InstanceType<M>[`key`]
-
-export function makeRootMoleculeInStore(
-	key: string,
+export function makeRootMoleculeInStore<S extends string>(
+	key: S,
 	store: Store = IMPLICIT.STORE,
-): MoleculeToken<ObjectConstructor> {
-	const molecule = new Molecule(undefined, key)
-	store.molecules.set(stringifyJson(key), molecule)
-	return {
+): S {
+	const molecule = {
 		key,
-		type: `molecule`,
-	} as const
+		stringKey: stringifyJson(key),
+		dependsOn: `any`,
+	} satisfies Molecule<S>
+	store.molecules.set(stringifyJson(key), molecule)
+	return key
 }

package/src/silo.ts

@@ -3,7 +3,6 @@ import {
 	actUponStore,
 	arbitrary,
 	createAtomFamily,
-	createMoleculeFamily,
 	createSelectorFamily,
 	createStandaloneAtom,
 	createStandaloneSelector,
@@ -12,7 +11,6 @@ import {
 	disposeFromStore,
 	findInStore,
 	getFromStore,
-	makeMoleculeInStore,
 	setIntoStore,
 	Store,
 	subscribeInStore,
@@ -22,8 +20,6 @@ import {
 import type {
 	disposeState,
 	getState,
-	makeMolecule,
-	moleculeFamily,
 	redo,
 	setState,
 	subscribe,
@@ -49,8 +45,7 @@ export class Silo {
 	public subscribe: typeof subscribe
 	public undo: typeof undo
 	public redo: typeof redo
-	public moleculeFamily: typeof moleculeFamily
-	public makeMolecule: typeof makeMolecule
+
 	public runTransaction: typeof runTransaction
 	public constructor(config: Store[`config`], fromStore: Store | null = null) {
 		const s = new Store(config, fromStore)
@@ -83,12 +78,6 @@ export class Silo {
 		this.redo = (token) => {
 			timeTravel(s, `redo`, token)
 		}
-		this.moleculeFamily = ((options: Parameters<typeof moleculeFamily>[0]) => {
-			return createMoleculeFamily(s, options)
-		}) as typeof moleculeFamily
-		this.makeMolecule = (...params: Parameters<typeof makeMolecule>) => {
-			return makeMoleculeInStore(s, ...params)
-		}
 		this.runTransaction = (token, id = arbitrary()) => actUponStore(token, id, s)
 	}
 }

package/src/timeline.ts

@@ -1,4 +1,3 @@
-import type { MoleculeFamilyToken } from "atom.io"
 import type {
 	Timeline,
 	TimelineAtomUpdate,
@@ -31,7 +30,7 @@ export type TimelineToken<M> = {
 
 export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 	key: string
-	scope: (ManagedAtom | MoleculeFamilyToken<any>)[]
+	scope: ManagedAtom[]
 	shouldCapture?: (
 		update: TimelineUpdate<ManagedAtom>,
 		timeline: Timeline<TimelineManageable>,
@@ -40,7 +39,7 @@ export type TimelineOptions<ManagedAtom extends TimelineManageable> = {
 
 export type TimelineUpdate<ManagedAtom extends TimelineManageable> =
 	| TimelineAtomUpdate<ManagedAtom>
-	| TimelineMoleculeCreation<any>
+	| TimelineMoleculeCreation
 	| TimelineMoleculeDisposal
 	| TimelineSelectorUpdate<ManagedAtom>
 	| TimelineStateCreation<AtomOnly<ManagedAtom>>

package/src/transaction.ts

@@ -1,12 +1,4 @@
-import type {
-	getState,
-	makeMolecule,
-	MoleculeConstructor,
-	MoleculeFamilyToken,
-	MoleculeParams,
-	MoleculeToken,
-	setState,
-} from "atom.io"
+import type { getState, setState } from "atom.io"
 import type { findState } from "atom.io/ephemeral"
 import type { seekState } from "atom.io/immortal"
 import type { EnvironmentData, Func, Transceiver } from "atom.io/internal"
@@ -16,7 +8,7 @@ import {
 	createTransaction,
 	IMPLICIT,
 } from "atom.io/internal"
-import type { Canonical, Json } from "atom.io/json"
+import type { Canonical, Json, stringified } from "atom.io/json"
 
 import type {
 	disposeState,
@@ -37,50 +29,46 @@ export type StateCreation<Token extends ReadableToken<any>> = {
 	type: `state_creation`
 	token: Token
 }
-export type StateDisposal<Token extends ReadableToken<any>> = {
+export type AtomDisposal<Token extends ReadableToken<any>> = {
 	type: `state_disposal`
+	subType: `atom`
 	token: Token
-	value?: TokenType<Token>
+	value: TokenType<Token>
 }
-
-export type MoleculeCreationClassic<M extends MoleculeConstructor> = {
-	type: `molecule_creation`
-	subType: `classic`
-	token: MoleculeToken<M>
-	family: MoleculeFamilyToken<M>
-	context: MoleculeToken<any>[]
-	params: MoleculeParams<M>
+export type SelectorDisposal<Token extends ReadableToken<any>> = {
+	type: `state_disposal`
+	subType: `selector`
+	token: Token
 }
-export type MoleculeCreationModern = {
+export type StateDisposal<Token extends ReadableToken<any>> =
+	| AtomDisposal<Token>
+	| SelectorDisposal<Token>
+
+export type MoleculeCreation = {
 	type: `molecule_creation`
-	subType: `modern`
 	key: Canonical
 	provenance: Canonical
 }
-export type MoleculeCreation<M extends MoleculeConstructor> =
-	| MoleculeCreationClassic<M>
-	| MoleculeCreationModern
-export type MoleculeDisposalClassic = {
+
+export type MoleculeDisposal = {
 	type: `molecule_disposal`
-	subType: `classic`
-	token: MoleculeToken<any>
-	family: MoleculeFamilyToken<any>
-	context: MoleculeToken<any>[]
+	key: Canonical
+	provenance: stringified<Canonical>[]
 	values: [key: string, value: any][]
 }
-export type MoleculeDisposalModern = {
-	type: `molecule_disposal`
-	subType: `modern`
+
+export type MoleculeTransfer = {
+	type: `molecule_transfer`
 	key: Canonical
-	provenance: Canonical
-	values: [key: string, value: any][]
+	from: Canonical[]
+	to: Canonical[]
 }
-export type MoleculeDisposal = MoleculeDisposalClassic | MoleculeDisposalModern
 
 export type TransactionUpdateContent =
 	| KeyedStateUpdate<unknown>
-	| MoleculeCreation<any>
+	| MoleculeCreation
 	| MoleculeDisposal
+	| MoleculeTransfer
 	| StateCreation<ReadableToken<unknown>>
 	| StateDisposal<ReadableToken<unknown>>
 	| TransactionUpdate<Func>
@@ -113,7 +101,6 @@ export type ActorToolkit = Readonly<{
 	json: <T extends Transceiver<any>, J extends Json.Serializable>(
 		state: MutableAtomToken<T, J>,
 	) => WritableSelectorToken<J>
-	make: typeof makeMolecule
 	dispose: typeof disposeState
 	run: typeof runTransaction
 	env: () => EnvironmentData

package/dist/chunk-ADMEAXYU.js

@@ -1,167 +0,0 @@
-import { createMoleculeFamily, IMPLICIT, makeMoleculeInStore, Molecule, newest, isChildStore, disposeFromStore } from 'atom.io/internal';
-import { stringifyJson } from 'atom.io/json';
-
-// src/molecule.ts
-function moleculeFamily(options) {
-  return createMoleculeFamily(IMPLICIT.STORE, options);
-}
-function makeMolecule(context, family, key, ...params) {
-  return makeMoleculeInStore(IMPLICIT.STORE, context, family, key, ...params);
-}
-function makeRootMoleculeInStore(key, store = IMPLICIT.STORE) {
-  const molecule = new Molecule(void 0, key);
-  store.molecules.set(stringifyJson(key), molecule);
-  return {
-    key,
-    type: `molecule`
-  };
-}
-var $provenance = Symbol(`provenance`);
-function allocateIntoStore(store, provenance, key) {
-  const stringKey = stringifyJson(key);
-  try {
-    const above = [];
-    let allocationAttachmentStyle;
-    if (provenance === `root`) {
-      above.push(store.molecules.get(`"root"`));
-      allocationAttachmentStyle = `all`;
-    } else if (typeof provenance === `string` && provenance.startsWith(T$)) {
-      allocationAttachmentStyle = `any`;
-      const provenanceKey = stringifyJson(provenance);
-      const provenanceMolecule = store.molecules.get(provenanceKey);
-      if (!provenanceMolecule) {
-        throw new Error(
-          `Molecule ${provenanceKey} not found in store "${store.config.name}"`
-        );
-      }
-      above.push(provenanceMolecule);
-    } else {
-      const allocationIsCompound = key.startsWith(`T$--`);
-      if (allocationIsCompound) {
-        allocationAttachmentStyle = `all`;
-        for (const claim of provenance) {
-          const provenanceKey = stringifyJson(claim);
-          const provenanceMolecule = store.molecules.get(provenanceKey);
-          if (!provenanceMolecule) {
-            throw new Error(
-              `Molecule ${provenanceKey} not found in store "${store.config.name}"`
-            );
-          }
-          above.push(provenanceMolecule);
-        }
-      } else {
-        allocationAttachmentStyle = `any`;
-        const provenanceKey = stringifyJson(provenance);
-        const provenanceMolecule = store.molecules.get(provenanceKey);
-        if (!provenanceMolecule) {
-          throw new Error(
-            `Molecule ${provenanceKey} not found in store "${store.config.name}"`
-          );
-        }
-        above.push(provenanceMolecule);
-      }
-    }
-    const molecule = new Molecule(above, key);
-    molecule._dependsOn = allocationAttachmentStyle;
-    store.molecules.set(stringKey, molecule);
-    for (const aboveMolecule of above) {
-      aboveMolecule.below.set(molecule.stringKey, molecule);
-    }
-    const creationEvent = {
-      type: `molecule_creation`,
-      subType: `modern`,
-      key: molecule.key,
-      provenance
-    };
-    const target = newest(store);
-    const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-    if (isTransaction) {
-      target.transactionMeta.update.updates.push(creationEvent);
-    } else {
-      target.on.moleculeCreationStart.next(creationEvent);
-    }
-  } catch (thrown) {
-    if (thrown instanceof Error) {
-      store.logger.error(
-        `\u274C`,
-        `molecule`,
-        stringKey,
-        `allocation failed:`,
-        thrown.message
-      );
-    }
-  }
-  return key;
-}
-function deallocateFromStore(store, claim) {
-  const stringKey = stringifyJson(claim);
-  const molecule = store.molecules.get(stringKey);
-  if (!molecule) {
-    throw new Error(
-      `Molecule ${stringKey} not found in store "${store.config.name}"`
-    );
-  }
-  for (const join of molecule.joins.values()) {
-    join.relations.delete(molecule.key);
-    join.molecules.delete(molecule.stringKey);
-  }
-  let provenance;
-  if (molecule.above.size === 1) {
-    const above = molecule.above.values().next().value;
-    provenance = above.key;
-  } else {
-    provenance = [...molecule.above.values()].map(({ key }) => key);
-  }
-  const values = [];
-  for (const stateToken of molecule.tokens.values()) {
-    const tokenFamily = stateToken.family;
-    values.push([tokenFamily.key, store.valueMap.get(stateToken.key)]);
-  }
-  for (const state of molecule.tokens.values()) {
-    disposeFromStore(store, state);
-  }
-  for (const child of molecule.below.values()) {
-    if (child.dependsOn === `all`) {
-      deallocateFromStore(store, child.key);
-    } else {
-      child.above.delete(molecule.stringKey);
-      if (child.above.size === 0) {
-        deallocateFromStore(store, child.key);
-      }
-    }
-  }
-  molecule.below.clear();
-  const disposalEvent = {
-    type: `molecule_disposal`,
-    subType: `modern`,
-    key: molecule.key,
-    values,
-    provenance
-  };
-  const target = newest(store);
-  const isTransaction = isChildStore(target) && target.transactionMeta.phase === `building`;
-  if (isTransaction) {
-    target.transactionMeta.update.updates.push(disposalEvent);
-  } else {
-    target.on.moleculeDisposal.next(disposalEvent);
-  }
-  target.molecules.delete(molecule.stringKey);
-  for (const parent of molecule.above.values()) {
-    parent.below.delete(molecule.stringKey);
-  }
-}
-function realm(store) {
-  const root = makeRootMoleculeInStore(`root`, store);
-  return {
-    root,
-    allocate: (provenance, key) => {
-      return allocateIntoStore(store, provenance, key);
-    },
-    deallocate: (claim) => {
-      deallocateFromStore(store, claim);
-    }
-  };
-}
-var T$ = `T$`;
-
-export { $provenance, T$, allocateIntoStore, deallocateFromStore, makeMolecule, makeRootMoleculeInStore, moleculeFamily, realm };

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

@@ -1,30 +0,0 @@
-import type {
-	MoleculeConstructor,
-	MoleculeCreationClassic,
-	MoleculeFamily,
-	MoleculeFamilyOptions,
-	MoleculeFamilyToken,
-} from "atom.io"
-
-import type { Store } from "../store"
-import { Subject } from "../subject"
-
-export function createMoleculeFamily<M extends MoleculeConstructor>(
-	store: Store,
-	options: MoleculeFamilyOptions<M>,
-): MoleculeFamilyToken<M> {
-	const subject = new Subject<MoleculeCreationClassic<M>>()
-
-	const token = {
-		type: `molecule_family`,
-		key: options.key,
-		dependsOn: options.dependsOn ?? `all`,
-	} as const satisfies MoleculeFamilyToken<M>
-	const family = {
-		...token,
-		subject,
-		new: options.new,
-	} satisfies MoleculeFamily<M>
-	store.moleculeFamilies.set(options.key, family)
-	return token
-}

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

@@ -1,79 +0,0 @@
-import type {
-	MoleculeConstructor,
-	MoleculeDisposal,
-	MoleculeDisposalClassic,
-	MoleculeToken,
-} from "atom.io"
-
-import { disposeFromStore } from "../families"
-import type { Store } from "../store"
-import { deposit, withdraw } from "../store"
-import { isChildStore } from "../transaction"
-import type { Molecule } from "./molecule-internal"
-
-export function disposeMolecule<M extends MoleculeConstructor>(
-	token: MoleculeToken<M>,
-	store: Store,
-): void {
-	let molecule: Molecule<M>
-	molecule = withdraw(token, store)
-	const { family } = token
-
-	for (const join of molecule.joins.values()) {
-		join.relations.delete(molecule.key)
-		join.molecules.delete(molecule.stringKey)
-	}
-
-	const context: MoleculeToken<any>[] = []
-	for (const above of molecule.above.values()) {
-		context.push(deposit(above))
-	}
-	const values: [string, any][] = []
-	for (const stateToken of molecule.tokens.values()) {
-		// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
-		const tokenFamily = stateToken.family!
-		values.push([tokenFamily.key, store.valueMap.get(stateToken.key)])
-	}
-
-	if (family) {
-		const Formula = withdraw(family, store)
-		const disposalEvent: MoleculeDisposalClassic = {
-			type: `molecule_disposal`,
-			subType: `classic`,
-			token,
-			family,
-			context,
-			values,
-		}
-		if (token.family) {
-			disposalEvent.family = token.family
-		}
-		for (const state of molecule.tokens.values()) {
-			disposeFromStore(store, state)
-		}
-		for (const child of molecule.below.values()) {
-			if (child.dependsOn === `all`) {
-				disposeMolecule(child, store)
-			} else {
-				child.above.delete(molecule.stringKey)
-				if (child.above.size === 0) {
-					disposeMolecule(child, store)
-				}
-			}
-		}
-		molecule.below.clear()
-
-		const isTransaction =
-			isChildStore(store) && store.transactionMeta.phase === `building`
-		if (isTransaction) {
-			store.transactionMeta.update.updates.push(disposalEvent)
-		} else {
-			Formula.subject.next(disposalEvent)
-		}
-		store.molecules.delete(molecule.stringKey)
-	}
-
-	for (const parent of molecule.above.values()) {
-		parent.below.delete(molecule.stringKey)
-	}
-}

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

@@ -1,95 +0,0 @@
-import type {
-	AtomFamilyToken,
-	AtomToken,
-	MutableAtomFamilyToken,
-	MutableAtomToken,
-	ReadableFamilyToken,
-	ReadableToken,
-	ReadonlySelectorFamilyToken,
-	ReadonlySelectorToken,
-	RegularAtomFamilyToken,
-	RegularAtomToken,
-	SelectorFamilyToken,
-	SelectorToken,
-	WritableFamilyToken,
-	WritableSelectorFamilyToken,
-	WritableSelectorToken,
-	WritableToken,
-} from "atom.io"
-import type { Canonical, Json } from "atom.io/json"
-
-import type {
-	AtomFamily,
-	MutableAtomFamily,
-	ReadableFamily,
-	ReadonlySelectorFamily,
-	RegularAtomFamily,
-	SelectorFamily,
-	WritableFamily,
-	WritableSelectorFamily,
-} from ".."
-import { initFamilyMemberInStore } from "../families"
-import type { Transceiver } from "../mutable"
-import type { Store } from "../store"
-import { isChildStore } from "../transaction"
-import type { Molecule } from "./molecule-internal"
-
-export 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>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: RegularAtomFamilyToken<T, K>,
-	store: Store,
-): RegularAtomToken<T>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: AtomFamilyToken<T, K>,
-	store: Store,
-): AtomToken<T>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: WritableSelectorFamilyToken<T, K>,
-	store: Store,
-): WritableSelectorToken<T>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: ReadonlySelectorFamilyToken<T, K>,
-	store: Store,
-): ReadonlySelectorToken<T>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: SelectorFamilyToken<T, K>,
-	store: Store,
-): SelectorToken<T>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: WritableFamilyToken<T, K>,
-	store: Store,
-): WritableToken<T>
-export function growMoleculeInStore<T, K extends Canonical>(
-	molecule: Molecule<any>,
-	family: ReadableFamilyToken<T, K>,
-	store: Store,
-): ReadableToken<T>
-export function growMoleculeInStore(
-	molecule: Molecule<any>,
-	family: ReadableFamilyToken<any, any>,
-	store: Store,
-): ReadableToken<any> {
-	const stateToken = initFamilyMemberInStore(store, family, molecule.key)
-	molecule.tokens.set(stateToken.key, stateToken)
-	const isTransaction =
-		isChildStore(store) && store.transactionMeta.phase === `building`
-	const moleculeInProgress = store.moleculeInProgress === molecule.key
-	if (!isTransaction && !moleculeInProgress) {
-		molecule.subject.next({ type: `state_creation`, token: stateToken })
-	}
-	return stateToken
-}

package/internal/src/molecule/index.ts

@@ -1,5 +0,0 @@
-export * from "./create-molecule-family"
-export * from "./dispose-molecule"
-export * from "./grow-molecule-in-store"
-export * from "./make-molecule-in-store"
-export * from "./molecule-internal"