atom.io 0.40.0 → 0.40.1

package/src/internal/join/get-join.ts

@@ -1,7 +1,9 @@
 import type { JoinToken } from "atom.io"
 import type { Json } from "atom.io/json"
 
-import { IMPLICIT, type Store } from "../store"
+import { eldest } from "../lineage"
+import type { Store } from "../store"
+import { IMPLICIT } from "../store"
 import { Join } from "./join-internal"
 
 export function getJoin<
@@ -24,7 +26,8 @@ export function getJoin<
 				`Join "${token.key}" not found in store "${store.config.name}"`,
 			)
 		}
-		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, store)
+		const root = eldest(store)
+		myJoin = new Join(rootJoin.options, rootJoin.defaultContent, root)
 		store.joins.set(token.key, myJoin)
 	}
 	return myJoin

package/src/internal/join/join-internal.ts

@@ -13,7 +13,7 @@ import type {
 	WriterToolkit,
 } from "atom.io"
 import { Anarchy } from "atom.io"
-import type { Canonical, Json, stringified } from "atom.io/json"
+import type { Json } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 import { SetRTX } from "atom.io/transceivers/set-rtx"
 
@@ -29,11 +29,11 @@ import type {
 	ExternalStoreConfiguration,
 } from "../junction"
 import { Junction } from "../junction"
-import type { Molecule } from "../molecule"
 import { createMutableAtomFamily, getJsonFamily, getJsonToken } from "../mutable"
 import { setIntoStore } from "../set-state"
 import type { Store } from "../store"
 import { IMPLICIT } from "../store"
+import type { RootStore } from "../transaction"
 
 export type JoinStateFamilies<
 	ASide extends string,
@@ -132,7 +132,6 @@ export class Join<
 	private toolkit: WriterToolkit
 	public options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>
 	public defaultContent: Content | undefined
-	public molecules: Map<string, Molecule<any>> = new Map()
 	public relations: Junction<ASide, AType, BSide, BType, Content>
 	public states: JoinStateFamilies<
 		ASide,
@@ -163,7 +162,7 @@ export class Join<
 	public constructor(
 		options: JoinOptions<ASide, AType, BSide, BType, Cardinality, Content>,
 		defaultContent: Content | undefined,
-		store: Store = IMPLICIT.STORE,
+		store: RootStore = IMPLICIT.STORE,
 	) {
 		type AnyKey = AType & BType
 
@@ -225,6 +224,9 @@ export class Join<
 				bKeys.delete(a)
 				return bKeys
 			})
+			const [x, y] = [a, b].sort()
+			const compositeKey = `${x}:${y}`
+			this.store.moleculeJoins.delete(compositeKey)
 		}
 		const replaceRelationsSafely: Write<
 			(a: string, newRelationsOfA: string[]) => void
@@ -267,9 +269,9 @@ export class Join<
 								relationsOfB.clear()
 							}
 							for (const previousOwner of previousOwnersToDispose) {
-								const sorted = [newRelationB, previousOwner].sort()
-								const compositeKey = `"${sorted[0]}:${sorted[1]}"`
-								this.molecules.delete(compositeKey)
+								const [x, y] = [newRelationB, previousOwner].sort()
+								const compositeKey = `${x}:${y}`
+								store.moleculeJoins.delete(compositeKey)
 							}
 						}
 						if (!newRelationBIsAlreadyRelated) {
@@ -310,14 +312,8 @@ export class Join<
 		const baseExternalStoreConfiguration: BaseExternalStoreConfiguration = {
 			getRelatedKeys: (key) => getRelatedKeys(this.toolkit, key),
 			addRelation: (a, b) => {
-				this.store.moleculeJoins.set(
-					a as stringified<Canonical> /* 💥 RECONCILE */,
-					options.key,
-				)
-				this.store.moleculeJoins.set(
-					b as stringified<Canonical> /* 💥 RECONCILE */,
-					options.key,
-				)
+				this.store.moleculeJoins.set(`"${a}"`, options.key)
+				this.store.moleculeJoins.set(`"${b}"`, options.key)
 				addRelation(this.toolkit, a, b)
 			},
 			deleteRelation: (a, b) => {
@@ -364,9 +360,7 @@ export class Join<
 				setContent: (contentKey: ContentKey, content: Content) => {
 					setContent(this.toolkit, contentKey, content)
 				},
-				deleteContent: (contentKey: ContentKey) => {
-					this.realm.deallocate(contentKey)
-				},
+				deleteContent: (_: ContentKey) => {},
 			}
 			externalStore = Object.assign(
 				baseExternalStoreConfiguration,
@@ -384,8 +378,8 @@ export class Join<
 				isBType: options.isBType,
 				makeContentKey: (...args) => {
 					const [a, b] = args
-					const sorted = args.sort()
-					const compositeKey = `${sorted[0]}:${sorted[1]}`
+					const [x, y] = args.sort()
+					const compositeKey = `${x}:${y}`
 					const aMolecule = store.molecules.get(stringifyJson(a))
 					const bMolecule = store.molecules.get(stringifyJson(b))
 					if (!aMolecule) {
@@ -394,6 +388,7 @@ export class Join<
 					if (!bMolecule) {
 						this.realm.allocate(options.key, b)
 					}
+
 					this.realm.allocate(a, compositeKey, `all`)
 					this.realm.claim(b, compositeKey)
 					this.store.moleculeJoins.set(compositeKey, options.key)

package/src/internal/lineage.ts

@@ -4,9 +4,20 @@ export interface Lineage {
 	child: typeof this | null
 }
 
-export function newest<T extends Lineage>(scion: T): T {
+export function newest<T extends Lineage>(
+	scion: T,
+): Exclude<T[`child`], null> | T {
 	while (scion.child !== null) {
 		scion = scion.child
 	}
 	return scion
 }
+
+export function eldest<T extends Lineage>(
+	scion: T,
+): Exclude<T[`parent`], T[`child`] | null> {
+	while (scion.parent !== null) {
+		scion = scion.parent
+	}
+	return scion as Exclude<T[`parent`], T[`child`] | null>
+}

package/src/internal/molecule.ts

@@ -8,18 +8,20 @@ import type {
 	MoleculeDisposalEvent,
 	MoleculeTransferEvent,
 	SingularTypedKey,
+	TransactionToken,
 	Vassal,
 } from "atom.io"
 import type { Canonical, stringified } from "atom.io/json"
 import { parseJson, stringifyJson } from "atom.io/json"
 
-import { disposeFromStore, findInStore } from "./families"
+import { disposeFromStore } from "./families"
 import { getFromStore } from "./get-state"
 import { getTrace } from "./get-trace"
 import { newest } from "./lineage"
 import type { Store } from "./store"
 import { IMPLICIT } from "./store"
-import { isChildStore } from "./transaction"
+import type { RootStore } from "./transaction"
+import { createTransaction, isChildStore } from "./transaction"
 
 export type Molecule<K extends Canonical> = {
 	readonly key: K
@@ -135,23 +137,35 @@ export function fuseWithinStore<
 	return compoundKey
 }
 
+export function createDeallocateTX<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+>(store: RootStore): TransactionToken<(claim: Claim<V>) => void> {
+	return createTransaction(store, {
+		key: `[Internal] deallocate`,
+		do: (_, claim: Claim<V>): void => {
+			deallocateFromStore<H, V>(newest(store), claim)
+		},
+	})
+}
+
 export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
-	store: Store,
+	target: Store,
 	claim: Claim<V>,
 ): void {
 	const stringKey = stringifyJson(claim)
 
-	const molecule = store.molecules.get(stringKey)
+	const molecule = target.molecules.get(stringKey)
 	if (!molecule) {
-		const disposal = store.disposalTraces.buffer.find(
+		const disposal = target.disposalTraces.buffer.find(
 			(item) => item?.key === stringKey,
 		)
-		store.logger.error(
+		target.logger.error(
 			`❌`,
 			`key`,
 			claim,
 			`deallocation failed:`,
-			`Could not find allocation for ${stringKey} in store "${store.config.name}".`,
+			`Could not find allocation for ${stringKey} in store "${target.config.name}".`,
 			disposal
 				? `\n   This state was most recently deallocated\n${disposal.trace}`
 				: `No previous disposal trace for ${stringKey} was found.`,
@@ -159,45 +173,29 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		return
 	}
 
-	const joinKeys = store.moleculeJoins.getRelatedKeys(
-		molecule.key as string /* 💥 RECONCILE */,
-	)
+	const joinKeys = target.moleculeJoins.getRelatedKeys(stringKey)
 	if (joinKeys) {
 		for (const joinKey of joinKeys) {
-			const join = store.joins.get(joinKey)
+			const join = target.joins.get(joinKey)
 			if (join) {
-				join.relations.delete(molecule.key)
-				join.molecules.delete(molecule.stringKey) // get rid of
+				join.relations.delete(claim)
 			}
 		}
 	}
-	store.moleculeJoins.delete(molecule.stringKey)
+	target.moleculeJoins.delete(stringKey)
 
 	const provenance: stringified<Canonical>[] = []
 
 	const values: [string, any][] = []
-	const disposalEvent: MoleculeDisposalEvent = {
-		type: `molecule_disposal`,
-		key: molecule.key,
-		values,
-		provenance,
-		timestamp: Date.now(),
-	}
-	const target = newest(store)
-	target.molecules.delete(stringKey)
-	const isTransaction =
-		isChildStore(target) && target.transactionMeta.phase === `building`
-	if (isTransaction) {
-		target.transactionMeta.update.subEvents.push(disposalEvent)
-	}
-	const relatedMolecules = store.moleculeGraph.getRelationEntries({
-		downstreamMoleculeKey: molecule.stringKey,
+
+	const relatedMolecules = target.moleculeGraph.getRelationEntries({
+		downstreamMoleculeKey: stringKey,
 	})
 	if (relatedMolecules) {
 		for (const [relatedStringKey, { source }] of relatedMolecules) {
-			if (source === molecule.stringKey) {
+			if (source === stringKey) {
 				const relatedKey = parseJson(relatedStringKey)
-				deallocateFromStore<any, any>(store, relatedKey)
+				deallocateFromStore<any, any>(target, relatedKey)
 			} else {
 				provenance.push(source)
 			}
@@ -208,12 +206,24 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 		for (const familyKey of familyKeys) {
 			// biome-ignore lint/style/noNonNullAssertion: tokens of molecules must have a family
 			const family = target.families.get(familyKey)!
-			const token = findInStore(store, family, molecule.key)
-			const value = getFromStore(store, token)
+			const value = getFromStore(target, family, claim)
 			values.push([family.key, value])
-			disposeFromStore(store, token)
+			disposeFromStore(target, family, claim)
 		}
 	}
+	const disposalEvent: MoleculeDisposalEvent = {
+		type: `molecule_disposal`,
+		key: molecule.key,
+		values,
+		provenance,
+		timestamp: Date.now(),
+	}
+	target.molecules.delete(stringKey)
+	const isTransaction =
+		isChildStore(target) && target.transactionMeta.phase === `building`
+	if (isTransaction) {
+		target.transactionMeta.update.subEvents.push(disposalEvent)
+	}
 
 	target.moleculeGraph.delete(molecule.stringKey)
 	target.moleculeJoins.delete(molecule.stringKey)
@@ -225,8 +235,26 @@ export function deallocateFromStore<H extends Hierarchy, V extends Vassal<H>>(
 	target.molecules.delete(molecule.stringKey)
 
 	const trace = getTrace(new Error())
-	store.disposalTraces.add({ key: stringKey, trace })
+	target.disposalTraces.add({ key: stringKey, trace })
+}
+
+export function createClaimTX<
+	H extends Hierarchy,
+	V extends Exclude<Vassal<H>, CompoundTypedKey>,
+	A extends Above<V, H>,
+>(
+	store: RootStore,
+): TransactionToken<
+	(newProvenance: A, claim: Claim<V>, exclusive?: `exclusive`) => void
+> {
+	return createTransaction(store, {
+		key: `[Internal] claim`,
+		do: (_, newProvenance, claim, exclusive) => {
+			claimWithinStore<H, V, A>(store, newProvenance, claim, exclusive)
+		},
+	})
 }
+
 export function claimWithinStore<
 	H extends Hierarchy,
 	V extends Exclude<Vassal<H>, CompoundTypedKey>,

package/src/internal/mutable/create-mutable-atom-family.ts

@@ -10,10 +10,10 @@ import { PRETTY_TOKEN_TYPES } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { stringifyJson } from "atom.io/json"
 
-import { createWritablePureSelectorFamily, type MutableAtomFamily } from ".."
+import type { MutableAtomFamily, RootStore } from ".."
+import { createWritablePureSelectorFamily } from ".."
 import { newest } from "../lineage"
 import { createMutableAtom } from "../mutable"
-import type { Store } from "../store"
 import { Subject } from "../subject"
 import { FamilyTracker } from "./tracker-family"
 import type { AsJSON, Transceiver } from "./transceiver"
@@ -22,7 +22,7 @@ export function createMutableAtomFamily<
 	T extends Transceiver<any, any, any>,
 	K extends Canonical,
 >(
-	store: Store,
+	store: RootStore,
 	options: MutableAtomFamilyOptions<T, K>,
 	internalRoles?: string[],
 ): MutableAtomFamilyToken<T, K> {
@@ -67,7 +67,7 @@ export function createMutableAtomFamily<
 	const atomFamily = Object.assign(familyFunction, familyToken, {
 		class: options.class,
 		subject,
-		install: (s: Store) => createMutableAtomFamily(s, options),
+		install: (s: RootStore) => createMutableAtomFamily(s, options),
 		internalRoles,
 	}) satisfies MutableAtomFamily<T, K>
 

package/src/internal/mutable/create-mutable-atom.ts

@@ -5,7 +5,7 @@ import type {
 	UpdateHandler,
 } from "atom.io"
 
-import type { MutableAtom } from ".."
+import type { MutableAtom, RootStore } from ".."
 import { createStandaloneSelector, resetInStore, setIntoStore } from ".."
 import { newest } from "../lineage"
 import { deposit, type Store } from "../store"
@@ -45,7 +45,7 @@ export function createMutableAtom<T extends Transceiver<any, any, any>>(
 	const newAtom: MutableAtom<T> = {
 		...options,
 		type,
-		install: (s: Store) => {
+		install: (s: RootStore) => {
 			s.logger.info(`🛠️`, `atom`, key, `installing in store "${s.config.name}"`)
 			return createMutableAtom(s, options, family)
 		},

package/src/internal/mutable/tracker-family.ts

@@ -2,9 +2,9 @@ import type { MutableAtomToken, StateLifecycleEvent } from "atom.io"
 import type { Canonical } from "atom.io/json"
 import { parseJson } from "atom.io/json"
 
-import type { MutableAtomFamily, RegularAtomFamily } from ".."
+import type { MutableAtomFamily, RegularAtomFamily, RootStore } from ".."
 import { createRegularAtomFamily } from "../families"
-import { type Store, withdraw } from "../store"
+import { withdraw } from "../store"
 import { Tracker } from "./tracker"
 import type { SignalFrom, Transceiver } from "./transceiver"
 
@@ -17,7 +17,7 @@ export class FamilyTracker<
 	public readonly latestSignalAtoms: RegularAtomFamily<SignalFrom<T> | null, K>
 	public readonly mutableAtoms: MutableAtomFamily<T, K>
 
-	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: Store) {
+	public constructor(mutableAtoms: MutableAtomFamily<T, K>, store: RootStore) {
 		const latestSignalAtoms = createRegularAtomFamily<SignalFrom<T> | null, K>(
 			store,
 			{

package/src/internal/selector/create-readonly-held-selector.ts

@@ -4,7 +4,7 @@ import type {
 	ReadonlyHeldSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyHeldSelector } from ".."
+import type { ReadonlyHeldSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -47,7 +47,7 @@ export function createReadonlyHeldSelector<T extends object>(
 		type,
 		subject,
 		getFrom,
-		install: (s: Store) => createReadonlyHeldSelector(s, options, family),
+		install: (s: RootStore) => createReadonlyHeldSelector(s, options, family),
 	}
 	if (family) readonlySelector.family = family
 

package/src/internal/selector/create-readonly-pure-selector.ts

@@ -4,7 +4,7 @@ import type {
 	ReadonlyPureSelectorToken,
 } from "atom.io"
 
-import type { ReadonlyPureSelector } from ".."
+import type { ReadonlyPureSelector, RootStore } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -48,7 +48,7 @@ export function createReadonlyPureSelector<T>(
 		type,
 		subject,
 		getFrom,
-		install: (s: Store) => createReadonlyPureSelector(s, options, family),
+		install: (s: RootStore) => createReadonlyPureSelector(s, options, family),
 	}
 	if (family) readonlySelector.family = family
 

package/src/internal/selector/create-writable-held-selector.ts

@@ -4,7 +4,7 @@ import type {
 	WritableHeldSelectorToken,
 } from "atom.io"
 
-import type { WritableHeldSelector } from ".."
+import type { RootStore, WritableHeldSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -54,7 +54,7 @@ export function createWritableHeldSelector<T extends object>(
 		subject,
 		getFrom,
 		setSelf,
-		install: (s: Store) => createWritableHeldSelector(s, options, family),
+		install: (s: RootStore) => createWritableHeldSelector(s, options, family),
 	}
 	if (family) mySelector.family = family
 

package/src/internal/selector/create-writable-pure-selector.ts

@@ -4,7 +4,7 @@ import type {
 	WritablePureSelectorToken,
 } from "atom.io"
 
-import type { WritablePureSelector } from ".."
+import type { RootStore, WritablePureSelector } from ".."
 import { writeToCache } from "../caching"
 import { newest } from "../lineage"
 import type { Store } from "../store"
@@ -54,7 +54,7 @@ export function createWritablePureSelector<T>(
 		subject,
 		getFrom,
 		setSelf,
-		install: (s: Store) => createWritablePureSelector(s, options, family),
+		install: (s: RootStore) => createWritablePureSelector(s, options, family),
 	}
 	if (family) mySelector.family = family
 

package/src/internal/set-state/become.ts

@@ -1,9 +1,7 @@
 import { isFn } from "../is-fn"
 
-export type Modify<T> = (thing: T) => T
-
 export function become<T>(
-	nextVersionOfThing: Modify<T> | T,
+	nextVersionOfThing: T | ((prev: T) => T),
 	originalThing: T,
 ): T {
 	if (isFn(nextVersionOfThing)) {

package/src/internal/set-state/dispatch-state-update.ts

@@ -28,7 +28,7 @@ export function dispatchOrDeferStateUpdate<T>(
 	if (stateIsNewlyCreated && family) {
 		state.subject.next({ newValue })
 		const stateCreationEvent: StateCreationEvent<any> & TimelineEvent<any> = {
-			write: true,
+			checkpoint: true,
 			type: `state_creation`,
 			subType: `writable`,
 			token,

package/src/internal/set-state/reset-in-store.ts

@@ -14,21 +14,19 @@ export function resetInStore<K extends Canonical>(
 	key: K,
 ): void
 
-export function resetInStore<T>(
+export function resetInStore<T, K extends Canonical, Key extends K>(
 	store: Store,
 	...params:
-		| [token: WritableFamilyToken<T, Canonical>, key: Canonical]
+		| [token: WritableFamilyToken<T, K>, key: Key]
+		| [token: WritableToken<T>]
+): void
+
+export function resetInStore<T, K extends Canonical, Key extends K>(
+	store: Store,
+	...params:
+		| [token: WritableFamilyToken<T, K>, key: Key]
 		| [token: WritableToken<T>]
 ): void {
-	let token: WritableToken<T>
-	let family: WritableFamilyToken<T, Canonical> | null
-	let key: Canonical | null
-	if (params.length === 1) {
-		token = params[0]
-		setIntoStore(store, token, RESET_STATE)
-	} else {
-		family = params[0]
-		key = params[1]
-		setIntoStore(store, family, key, RESET_STATE)
-	}
+	const subParams = [...params, RESET_STATE] as const
+	setIntoStore(store, ...subParams)
 }

package/src/internal/set-state/set-into-store.ts

@@ -23,12 +23,36 @@ export function setIntoStore<
 	value: New | typeof RESET_STATE | ((oldValue: T) => New),
 ): void
 
-export function setIntoStore<T, New extends T>(
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+>(
+	store: Store,
+	...params:
+		| [
+				token: WritableFamilyToken<T, K>,
+				key: Key,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+		| [
+				token: WritableToken<T>,
+				value: New | typeof RESET_STATE | ((oldValue: T) => New),
+		  ]
+): void
+
+export function setIntoStore<
+	T,
+	K extends Canonical,
+	New extends T,
+	Key extends K,
+>(
 	store: Store,
 	...params:
 		| [
-				token: WritableFamilyToken<T, Canonical>,
-				key: Canonical,
+				token: WritableFamilyToken<T, K>,
+				key: Key,
 				value: New | typeof RESET_STATE | ((oldValue: T) => New),
 		  ]
 		| [

package/src/internal/store/store.ts

@@ -30,6 +30,8 @@ import type { OperationProgress } from "../operation"
 import { StatefulSubject, Subject } from "../subject"
 import type { Timeline } from "../timeline"
 import type {
+	ChildStore,
+	RootStore,
 	Transaction,
 	TransactionEpoch,
 	TransactionProgress,
@@ -39,8 +41,8 @@ import type { Fn } from "../utility-types"
 import { CircularBuffer } from "./circular-buffer"
 
 export class Store implements Lineage {
-	public parent: Store | null = null
-	public child: Store | null = null
+	public parent: ChildStore | RootStore | null = null
+	public child: ChildStore | null = null
 
 	public valueMap: Map<string, any> = new Map()
 	public defaults: Map<string, any> = new Map()
@@ -210,14 +212,14 @@ export class Store implements Lineage {
 				) {
 					continue
 				}
-				family.install(this)
+				family.install(this as RootStore)
 			}
 			const mutableHelpers = new Set<string>()
 			for (const [, atom] of store.atoms) {
 				if (mutableHelpers.has(atom.key)) {
 					continue
 				}
-				atom.install(this)
+				atom.install(this as RootStore)
 				if (atom.type === `mutable_atom`) {
 					const originalJsonToken = getJsonToken(store, atom)
 					const originalUpdateToken = getUpdateToken(atom)
@@ -226,19 +228,19 @@ export class Store implements Lineage {
 				}
 			}
 			for (const [, selector] of store.readonlySelectors) {
-				selector.install(this)
+				selector.install(this as RootStore)
 			}
 			for (const [, selector] of store.writableSelectors) {
 				if (mutableHelpers.has(selector.key)) {
 					continue
 				}
-				selector.install(this)
+				selector.install(this as RootStore)
 			}
 			for (const [, tx] of store.transactions) {
-				tx.install(this)
+				tx.install(this as RootStore)
 			}
 			for (const [, timeline] of store.timelines) {
-				timeline.install(this)
+				timeline.install(this as RootStore)
 			}
 		}
 	}
@@ -258,15 +260,15 @@ export type StoreEventCarrier = {
 }
 
 declare global {
-	var ATOM_IO_IMPLICIT_STORE: Store | undefined
+	var ATOM_IO_IMPLICIT_STORE: RootStore | undefined
 }
 
-export const IMPLICIT: { readonly STORE: Store } = {
-	get STORE(): Store {
+export const IMPLICIT: { readonly STORE: RootStore } = {
+	get STORE(): RootStore {
 		globalThis.ATOM_IO_IMPLICIT_STORE ??= new Store({
 			name: `IMPLICIT_STORE`,
 			lifespan: `ephemeral`,
-		})
+		}) as RootStore
 		return globalThis.ATOM_IO_IMPLICIT_STORE
 	},
 }