@effuse/store 1.0.0

package/src/composition/compose.ts

@@ -0,0 +1,194 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { signal, type Signal } from '@effuse/core';
+import type { Store, StoreDefinition } from '../core/types.js';
+import { createStore as createStoreImpl } from '../core/store.js';
+import {
+	createCancellationToken,
+	type CancellationToken,
+} from '../actions/cancellation.js';
+
+// Composed store container
+export interface ComposedStore<T, D extends readonly Store<unknown>[]> {
+	store: Store<T>;
+	dependencies: D;
+	computed: <R>(
+		selector: (
+			state: T,
+			deps: { [K in keyof D]: ReturnType<D[K]['getSnapshot']> }
+		) => R
+	) => Signal<R>;
+	computedAsync: <R>(
+		asyncSelector: (
+			state: T,
+			deps: { [K in keyof D]: ReturnType<D[K]['getSnapshot']> },
+			token: CancellationToken
+		) => Promise<R>,
+		initialValue: R
+	) => Signal<R> & { pending: Signal<boolean>; cleanup: () => void };
+}
+
+// Compose stores with dependencies
+export const composeStores = <T, D extends readonly Store<unknown>[]>(
+	mainStore: Store<T>,
+	dependencies: D
+): ComposedStore<T, D> => {
+	const getDependencySnapshots = (): {
+		[K in keyof D]: ReturnType<D[K]['getSnapshot']>;
+	} => {
+		return dependencies.map((dep) => dep.getSnapshot()) as {
+			[K in keyof D]: ReturnType<D[K]['getSnapshot']>;
+		};
+	};
+
+	return {
+		store: mainStore,
+		dependencies,
+		computed: <R>(
+			selector: (
+				state: T,
+				deps: { [K in keyof D]: ReturnType<D[K]['getSnapshot']> }
+			) => R
+		): Signal<R> => {
+			const mainSnapshot = mainStore.getSnapshot() as T;
+			const depSnapshots = getDependencySnapshots();
+			const initialValue = selector(mainSnapshot, depSnapshots);
+			const derived = signal<R>(initialValue);
+
+			const update = () => {
+				const mainState = mainStore.getSnapshot() as T;
+				const depStates = getDependencySnapshots();
+				const newValue = selector(mainState, depStates);
+				if (derived.value !== newValue) {
+					derived.value = newValue;
+				}
+			};
+
+			mainStore.subscribe(update);
+			for (const dep of dependencies) {
+				dep.subscribe(update);
+			}
+
+			return derived;
+		},
+		computedAsync: <R>(
+			asyncSelector: (
+				state: T,
+				deps: { [K in keyof D]: ReturnType<D[K]['getSnapshot']> },
+				token: CancellationToken
+			) => Promise<R>,
+			initialValue: R
+		): Signal<R> & { pending: Signal<boolean>; cleanup: () => void } => {
+			const derived = signal<R>(initialValue);
+			const pending = signal<boolean>(false);
+			let currentToken = createCancellationToken();
+			const unsubscribers: (() => void)[] = [];
+
+			const update = () => {
+				currentToken.cancel();
+				currentToken = createCancellationToken();
+				const myToken = currentToken;
+				pending.value = true;
+
+				const mainState = mainStore.getSnapshot() as T;
+				const depStates = getDependencySnapshots();
+
+				asyncSelector(mainState, depStates, myToken)
+					.then((newValue) => {
+						if (!myToken.isCancelled && derived.value !== newValue) {
+							derived.value = newValue;
+						}
+					})
+					.catch(() => {})
+					.finally(() => {
+						if (!myToken.isCancelled) {
+							pending.value = false;
+						}
+					});
+			};
+
+			unsubscribers.push(mainStore.subscribe(update));
+			for (const dep of dependencies) {
+				unsubscribers.push(dep.subscribe(update));
+			}
+			update();
+
+			const result = derived as Signal<R> & {
+				pending: Signal<boolean>;
+				cleanup: () => void;
+			};
+			result.pending = pending;
+			result.cleanup = () => {
+				currentToken.cancel();
+				for (const unsub of unsubscribers) unsub();
+			};
+
+			return result;
+		},
+	};
+};
+
+// Store slice definition
+export interface StoreSlice<T extends object, P extends object> {
+	create: (parent: Store<P>) => Store<T>;
+}
+
+// Define reusable store slice
+export const defineSlice = <T extends object, P extends object>(
+	name: string,
+	factory: (parent: Store<P>) => StoreDefinition<T>
+): StoreSlice<T, P> => {
+	return {
+		create: (parent: Store<P>): Store<T> => {
+			const definition = factory(parent);
+			return createStoreImpl<T>(name, definition);
+		},
+	};
+};
+
+// Merge multiple stores
+export const mergeStores = <A, B>(
+	storeA: Store<A>,
+	storeB: Store<B>
+): {
+	getSnapshot: () => ReturnType<Store<A>['getSnapshot']> &
+		ReturnType<Store<B>['getSnapshot']>;
+	subscribe: (callback: () => void) => () => void;
+} => {
+	return {
+		getSnapshot: () => ({
+			...storeA.getSnapshot(),
+			...storeB.getSnapshot(),
+		}),
+		subscribe: (callback: () => void) => {
+			const unsubA = storeA.subscribe(callback);
+			const unsubB = storeB.subscribe(callback);
+			return () => {
+				unsubA();
+				unsubB();
+			};
+		},
+	};
+};

package/src/composition/index.ts

@@ -0,0 +1,31 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export {
+	composeStores,
+	defineSlice,
+	mergeStores,
+	type ComposedStore,
+	type StoreSlice,
+} from './compose.js';

package/src/config/constants.ts

@@ -0,0 +1,110 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Config, Duration, Effect } from 'effect';
+
+// Storage key prefix
+export const STORAGE_PREFIX = 'effuse-store:';
+// Root scope identifier
+export const ROOT_SCOPE_ID = '__root__';
+// Scope identifier prefix
+export const SCOPE_PREFIX = 'scope_';
+
+// Default timeout milliseconds
+export const DEFAULT_TIMEOUT_MS = 5000;
+
+// Default timeout duration
+export const DEFAULT_TIMEOUT = Duration.millis(DEFAULT_TIMEOUT_MS);
+
+// Initial retry delay
+export const DEFAULT_RETRY_INITIAL_DELAY_MS = 100;
+// Maximum retry delay
+export const DEFAULT_RETRY_MAX_DELAY_MS = 5000;
+// Retry backoff factor
+export const DEFAULT_RETRY_BACKOFF_FACTOR = 2;
+
+// Internal constants collection
+export const StoreConstants = {
+	STORAGE_PREFIX,
+	ROOT_SCOPE_ID,
+	SCOPE_PREFIX,
+	DEBUG_PREFIX: '[store]',
+	DEVTOOLS_PREFIX: 'Effuse:',
+	DEFAULT_TIMEOUT_MS,
+} as const;
+
+// Store configuration parameters
+export const StoreConfigOptions = {
+	persistByDefault: Config.boolean('EFFUSE_STORE_PERSIST').pipe(
+		Config.withDefault(false)
+	),
+	storagePrefix: Config.string('EFFUSE_STORE_PREFIX').pipe(
+		Config.withDefault(STORAGE_PREFIX)
+	),
+	debug: Config.boolean('EFFUSE_STORE_DEBUG').pipe(Config.withDefault(false)),
+	devtools: Config.boolean('EFFUSE_STORE_DEVTOOLS').pipe(
+		Config.withDefault(false)
+	),
+};
+
+// Store configuration values
+export interface StoreConfigValues {
+	persistByDefault: boolean;
+	storagePrefix: string;
+	debug: boolean;
+	devtools: boolean;
+}
+
+// Load configuration values
+export const loadStoreConfigValues: Effect.Effect<StoreConfigValues> =
+	Effect.all({
+		persistByDefault: StoreConfigOptions.persistByDefault,
+		storagePrefix: StoreConfigOptions.storagePrefix,
+		debug: StoreConfigOptions.debug,
+		devtools: StoreConfigOptions.devtools,
+	}).pipe(
+		Effect.catchAll(() =>
+			Effect.succeed({
+				persistByDefault: false,
+				storagePrefix: STORAGE_PREFIX,
+				debug: false,
+				devtools: false,
+			})
+		)
+	);
+
+let cachedConfig: StoreConfigValues | null = null;
+
+// Access store configuration
+export const getStoreConfig = (): StoreConfigValues => {
+	if (!cachedConfig) {
+		cachedConfig = Effect.runSync(loadStoreConfigValues);
+	}
+	return cachedConfig;
+};
+
+// Reset configuration cache
+export const resetStoreConfigCache = (): void => {
+	cachedConfig = null;
+};

package/src/config/index.ts

@@ -0,0 +1,40 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export {
+	STORAGE_PREFIX,
+	ROOT_SCOPE_ID,
+	SCOPE_PREFIX,
+	DEFAULT_TIMEOUT_MS,
+	DEFAULT_RETRY_INITIAL_DELAY_MS,
+	DEFAULT_RETRY_MAX_DELAY_MS,
+	DEFAULT_RETRY_BACKOFF_FACTOR,
+	StoreConstants,
+	StoreConfigOptions,
+	loadStoreConfigValues,
+	getStoreConfig,
+	resetStoreConfigCache,
+	DEFAULT_TIMEOUT,
+	type StoreConfigValues,
+} from './constants.js';

package/src/context/index.ts

@@ -0,0 +1,39 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export {
+	createScope,
+	disposeScope,
+	enterScope,
+	exitScope,
+	getCurrentScope,
+	getRootScope,
+	registerScopedStore,
+	getScopedStore,
+	hasScopedStore,
+	runInScope,
+	withScope,
+	type ScopeNode,
+	type ScopeId,
+} from './scope.js';

package/src/context/scope.ts

@@ -0,0 +1,136 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import type { Store } from '../core/types.js';
+
+// Scope identifier
+export type ScopeId = string;
+
+// Scope tree node
+export interface ScopeNode {
+	id: ScopeId;
+	parent: ScopeNode | null;
+	stores: Map<string, Store<unknown>>;
+}
+
+const ROOT_SCOPE: ScopeNode = {
+	id: '__root__',
+	parent: null,
+	stores: new Map(),
+};
+
+let currentScope: ScopeNode = ROOT_SCOPE;
+const scopeRegistry = new Map<ScopeId, ScopeNode>([
+	[ROOT_SCOPE.id, ROOT_SCOPE],
+]);
+let scopeCounter = 0;
+
+// Initialize child scope
+export const createScope = (parentScope?: ScopeNode): ScopeNode => {
+	scopeCounter++;
+	const id = `scope_${String(scopeCounter)}`;
+	const node: ScopeNode = {
+		id,
+		parent: parentScope ?? currentScope,
+		stores: new Map(),
+	};
+	scopeRegistry.set(id, node);
+	return node;
+};
+
+// Dispose scope
+export const disposeScope = (scope: ScopeNode): void => {
+	scope.stores.clear();
+	scopeRegistry.delete(scope.id);
+};
+
+// Activate scope
+export const enterScope = (scope: ScopeNode): void => {
+	currentScope = scope;
+};
+
+// Exit active scope
+export const exitScope = (): void => {
+	if (currentScope.parent) {
+		currentScope = currentScope.parent;
+	}
+};
+
+// Current scope access
+export const getCurrentScope = (): ScopeNode => currentScope;
+
+// Root scope access
+export const getRootScope = (): ScopeNode => ROOT_SCOPE;
+
+// Register store in scope
+export const registerScopedStore = <T>(
+	name: string,
+	store: Store<T>,
+	scope: ScopeNode = currentScope
+): void => {
+	scope.stores.set(name, store as Store<unknown>);
+};
+
+// Find store in scope hierarchy
+export const getScopedStore = <T>(
+	name: string,
+	scope: ScopeNode = currentScope
+): Store<T> | null => {
+	let current: ScopeNode | null = scope;
+	while (current) {
+		const store = current.stores.get(name);
+		if (store) return store as Store<T>;
+		current = current.parent;
+	}
+	return null;
+};
+
+// Scope store detection
+export const hasScopedStore = (
+	name: string,
+	scope: ScopeNode = currentScope
+): boolean => {
+	return getScopedStore(name, scope) !== null;
+};
+
+// Execute in scope
+export const runInScope = <R>(scope: ScopeNode, fn: () => R): R => {
+	const prev = currentScope;
+	currentScope = scope;
+	try {
+		return fn();
+	} finally {
+		currentScope = prev;
+	}
+};
+
+// Execute in transient scope
+export const withScope = <R>(fn: (scope: ScopeNode) => R): R => {
+	const scope = createScope();
+	try {
+		return runInScope(scope, () => fn(scope));
+	} finally {
+		disposeScope(scope);
+	}
+};

package/src/core/index.ts

@@ -0,0 +1,36 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export { createStore, type CreateStoreOptions } from './store.js';
+export { createAtomicState, type AtomicState } from './state.js';
+export {
+	type Store,
+	type StoreState,
+	type StoreContext,
+	type StoreDefinition,
+	type StoreOptions,
+	type ActionContext,
+	type Middleware,
+	type InferStoreState,
+} from './types.js';

package/src/core/state.ts

@@ -0,0 +1,48 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2025 Chris M. Perez
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Effect, SubscriptionRef } from 'effect';
+
+// Atomic state management with synchronous accessors
+export interface AtomicState<T extends Record<string, unknown>> {
+	get: () => T;
+	set: (value: T) => void;
+	update: (fn: (state: T) => T) => void;
+}
+
+// Build atomic state container
+export const createAtomicState = <T extends Record<string, unknown>>(
+	initial: T
+): AtomicState<T> => {
+	const ref = Effect.runSync(SubscriptionRef.make(initial));
+	return {
+		get: () => Effect.runSync(SubscriptionRef.get(ref)),
+		set: (value: T) => {
+			Effect.runSync(SubscriptionRef.set(ref, value));
+		},
+		update: (fn: (state: T) => T) => {
+			Effect.runSync(SubscriptionRef.update(ref, fn));
+		},
+	};
+};