atom.io 0.30.0 → 0.30.1

package/internal/dist/index.d.ts

@@ -22,20 +22,24 @@ declare function counterfeit<T, K extends Canonical, Key extends K>(token: Writa
 declare function counterfeit<T, K extends Canonical, Key extends K>(token: ReadableFamilyToken<T, K>, key: Key): ReadableToken<T>;
 declare function counterfeit<M extends MoleculeConstructor>(token: MoleculeFamilyToken<M>, key: MoleculeKey<M>): MoleculeKey<M>;
 
-interface JunctionEntries<Content extends Json.Object | null> extends Json.Object {
-    readonly relations: [string, string[]][];
+type JunctionEntriesBase<AType extends string, BType extends string, Content extends Json.Object | null> = {
+    readonly relations: ([AType, BType[]] | [BType, AType[]])[];
     readonly contents: [string, Content][];
+};
+interface JunctionEntries<AType extends string, BType extends string, Content extends Json.Object | null> extends Json.Object, JunctionEntriesBase<AType, BType, Content> {
 }
-interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object {
+type JunctionSchemaBase<ASide extends string, BSide extends string> = {
     readonly between: [a: ASide, b: BSide];
     readonly cardinality: `1:1` | `1:n` | `n:n`;
+};
+interface JunctionSchema<ASide extends string, BSide extends string> extends Json.Object, JunctionSchemaBase<ASide, BSide> {
 }
 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;
 };
 type ExternalStoreWithContentConfiguration<Content extends Json.Object> = {
@@ -47,45 +51,68 @@ type Empty<Obj extends object> = {
     [Key in keyof Obj]?: undefined;
 };
 type ExternalStoreConfiguration<Content extends Json.Object | null> = Content extends Json.Object ? BaseExternalStoreConfiguration & ExternalStoreWithContentConfiguration<Content> : BaseExternalStoreConfiguration & Empty<ExternalStoreWithContentConfiguration<Json.Object>>;
-type JunctionAdvancedConfiguration<Content extends Json.Object | null> = {
+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;
 };
-type JunctionJSON<ASide extends string, BSide extends string, Content extends Json.Object | null> = JunctionEntries<Content> & JunctionSchema<ASide, BSide>;
-declare class Junction<const ASide extends string, const BSide extends string, const Content extends Json.Object | null = null> {
+type JunctionJSON<ASide extends string, AType extends string, BSide extends string, BType extends string, Content extends Json.Object | null> = JunctionEntries<AType, BType, Content> & JunctionSchema<ASide, BSide>;
+declare 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> {
     readonly a: ASide;
     readonly b: BSide;
     readonly cardinality: `1:1` | `1:n` | `n:n`;
-    readonly relations: Map<string, Set<string>>;
+    readonly relations: Map<AType | BType, Set<AType> | Set<BType>>;
     readonly contents: Map<string, Content>;
     isContent: Refinement<unknown, Content> | null;
-    makeContentKey: (a: string, b: string) => string;
+    makeContentKey: (a: AType, b: BType) => string;
     warn?: (...args: any[]) => void;
-    getRelatedKeys(key: string): Set<string> | undefined;
-    protected addRelation(a: string, b: string): void;
-    protected deleteRelation(a: string, b: string): void;
-    protected replaceRelationsUnsafely(a: string, bs: string[]): void;
-    protected replaceRelationsSafely(a: string, bs: string[]): void;
+    getRelatedKeys(key: AType): Set<BType> | undefined;
+    getRelatedKeys(key: BType): Set<AType> | undefined;
+    getRelatedKeys(key: AType | BType): Set<AType> | Set<BType> | undefined;
+    protected addRelation(a: AType, b: BType): void;
+    protected deleteRelation(a: AType, b: BType): void;
+    protected replaceRelationsUnsafely(a: AType, bs: BType[]): void;
+    protected replaceRelationsUnsafely(b: BType, as: AType[]): void;
+    protected replaceRelationsSafely(a: AType, bs: BType[]): void;
+    protected replaceRelationsSafely(b: BType, as: AType[]): void;
     protected getContentInternal(contentKey: string): Content | undefined;
     protected setContent(contentKey: string, content: Content): void;
     protected deleteContent(contentKey: string): void;
-    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<Content>>, config?: JunctionAdvancedConfiguration<Content>);
-    toJSON(): JunctionJSON<ASide, BSide, Content>;
-    set(a: string, ...rest: Content extends null ? [b: string] : [b: string, content: Content]): this;
+    constructor(data: JunctionSchema<ASide, BSide> & Partial<JunctionEntries<AType, BType, Content>>, config?: JunctionAdvancedConfiguration<AType, BType, Content>);
+    toJSON(): JunctionJSON<ASide, AType, BSide, BType, Content>;
+    set(a: AType, ...rest: Content extends null ? [b: BType] : [b: BType, content: Content]): this;
     set(relation: {
-        [Key in ASide | BSide]: string;
-    }, ...rest: Content extends null ? [] | [b?: undefined] : [content: Content]): this;
-    delete(a: string, b?: string): this;
-    delete(relation: Record<ASide | BSide, string> | Record<ASide, string> | Record<BSide, string>, b?: undefined): this;
-    getRelatedKey(key: string): string | undefined;
-    replaceRelations(a: string, relations: Content extends null ? string[] : Record<string, Content>, config?: {
+        [Key in ASide]: AType;
+    } & {
+        [Key in BSide]: BType;
+    }, ...rest: Content extends null ? [] | [void?: undefined] : [content: Content]): this;
+    delete(a: AType, b?: BType): this;
+    delete(b: BType, a?: AType): this;
+    delete(relation: {
+        [Key in ASide]: AType;
+    } | {
+        [Key in BSide]: BType;
+    } | ({
+        [Key in ASide]: AType;
+    } & {
+        [Key in BSide]: BType;
+    }), b?: undefined): this;
+    getRelatedKey(key: AType): BType | undefined;
+    getRelatedKey(key: BType): AType | undefined;
+    replaceRelations(a: AType, relations: Content extends null ? BType[] : Record<BType, Content>, config?: {
+        reckless: boolean;
+    }): this;
+    replaceRelations(b: BType, relations: Content extends null ? AType[] : Record<AType, Content>, config?: {
         reckless: boolean;
     }): this;
-    getContent(a: string, b: string): Content | undefined;
-    getRelationEntries(input: Record<ASide, string> | Record<BSide, string>): [string, Content][];
-    has(a: string, b?: string): boolean;
+    getContent(a: AType, b: BType): Content | undefined;
+    getRelationEntries(input: Record<ASide, AType>): [BType, Content][];
+    getRelationEntries(input: Record<BSide, BType>): [AType, Content][];
+    has(a: AType, b?: BType): boolean;
+    has(b: BType, a?: AType): boolean;
 }
 
 type Func = (...parameters: any[]) => any;
@@ -163,7 +190,7 @@ type TransactionProgress<F extends Func> = {
 };
 type TransactionEpoch = {
     epoch: Map<string, number>;
-    actionContinuities: Junction<`continuity`, `action`>;
+    actionContinuities: Junction<`continuity`, string, `action`, string>;
 };
 
 declare function deposit<T>(state: RegularAtom<T>): RegularAtomToken<T>;
@@ -210,7 +237,7 @@ declare class Molecule<M extends MoleculeConstructor> implements MoleculeToken<M
     tokens: Map<string, ReadableToken<any>>;
     above: Map<string, Molecule<any>>;
     below: Map<string, Molecule<any>>;
-    joins: Map<string, Join<any, any, any, any>>;
+    joins: Map<string, Join<any, any, any, any, any, any>>;
     instance: InstanceType<M>;
     constructor(ctx: Molecule<any>[] | undefined, key: MoleculeKey<M>, family?: MoleculeFamilyToken<M>);
 }
@@ -306,8 +333,8 @@ declare class Store implements Lineage {
     selectors: Map<string, WritableSelector<any>>;
     readonlySelectors: Map<string, ReadonlySelector<any>>;
     atomsThatAreDefault: Set<string>;
-    selectorAtoms: Junction<"selectorKey", "atomKey", null>;
-    selectorGraph: Junction<"upstreamSelectorKey", "downstreamSelectorKey", {
+    selectorAtoms: Junction<"selectorKey", string, "atomKey", string, null>;
+    selectorGraph: Junction<"upstreamSelectorKey", string, "downstreamSelectorKey", string, {
         source: string;
     }>;
     trackers: Map<string, Tracker<Transceiver<any>>>;
@@ -315,7 +342,7 @@ declare class Store implements Lineage {
     transactions: Map<string, Transaction<Func>>;
     transactionMeta: TransactionEpoch | TransactionProgress<Func>;
     timelines: Map<string, Timeline<any>>;
-    timelineTopics: Junction<"timelineKey", "topicKey", {
+    timelineTopics: Junction<"timelineKey", string, "topicKey", string, {
         topicType: `atom_family` | `atom` | `molecule_family` | `molecule`;
     }>;
     disposalTraces: CircularBuffer<{
@@ -393,9 +420,9 @@ type Signal<TVR extends Transceiver<any>> = TVR extends Transceiver<infer S> ? S
 
 declare function createMutableAtom<T extends Transceiver<any>, J extends Json.Serializable>(store: Store, options: MutableAtomOptions<T, J>, family: FamilyMetadata | undefined): MutableAtomToken<T, J>;
 
-declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends string>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
+declare function createMutableAtomFamily<T extends Transceiver<any>, J extends Json.Serializable, K extends Canonical>(store: Store, options: MutableAtomFamilyOptions<T, J, K>, internalRoles?: string[]): MutableAtomFamilyToken<T, J, K>;
 
-declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends string>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
+declare const getJsonFamily: <Core extends Transceiver<Json.Serializable>, SerializableCore extends Json.Serializable, Key extends Canonical>(mutableAtomFamily: MutableAtomFamilyToken<Core, SerializableCore, Key>, store: Store) => WritableSelectorFamily<SerializableCore, Key>;
 
 declare const getJsonToken: <Core extends Transceiver<any>, SerializableCore extends Json.Serializable>(store: Store, mutableAtomToken: MutableAtomToken<Core, SerializableCore>) => WritableSelectorToken<SerializableCore>;
 
@@ -672,4 +699,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 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 };
+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 JunctionEntriesBase, type JunctionJSON, type JunctionSchema, type JunctionSchemaBase, 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,3 +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-7PUUHSXC.js';
-import '../../dist/chunk-ZKG6ZA4I.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-SMKF3ZNG.js';
+import '../../dist/chunk-ADMEAXYU.js';
 import '../../dist/chunk-XWL6SNVU.js';

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/make-molecule-in-store.ts

@@ -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`) {

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

@@ -31,7 +31,7 @@ export class Molecule<M extends MoleculeConstructor>
 	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>[] | undefined,