@storybook/react-native 10.4.3 → 10.4.5-canary-20260529144515

package/dist/index.js

@@ -88,7 +88,7 @@ function hasInitialValue(atom) {
 	return "init" in atom;
 }
 function isActuallyWritableAtom(atom) {
-	return !!atom.write;
+	return typeof atom.write === "function";
 }
 function hasOnMount(atom) {
 	return !!atom.onMount;
@@ -121,25 +121,23 @@ function getMountedOrPendingDependents(atom, atomState, mountedMap) {
 	for (const a of pendingDependents) dependents.add(a);
 	return dependents;
 }
-const BUILDING_BLOCK_atomRead = (_store, atom, ...params) => atom.read(...params);
-const BUILDING_BLOCK_atomWrite = (_store, atom, ...params) => atom.write(...params);
-const BUILDING_BLOCK_atomOnInit = (store, atom) => {
-	var _a;
-	return (_a = atom.INTERNAL_onInit) == null ? void 0 : _a.call(atom, store);
-};
-const BUILDING_BLOCK_atomOnMount = (_store, atom, setAtom) => {
+function hasOnInit(atom) {
+	return !!atom.INTERNAL_onInit;
+}
+const BUILDING_BLOCK_atomRead = (_buildingBlocks, _store, atom, ...params) => atom.read(...params);
+const BUILDING_BLOCK_atomWrite = (_buildingBlocks, _store, atom, ...params) => atom.write(...params);
+const BUILDING_BLOCK_atomOnInit = (_buildingBlocks, store, atom) => atom.INTERNAL_onInit(store);
+const BUILDING_BLOCK_atomOnMount = (_buildingBlocks, _store, atom, setAtom) => {
 	var _a;
 	return (_a = atom.onMount) == null ? void 0 : _a.call(atom, setAtom);
 };
-const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
+const BUILDING_BLOCK_ensureAtomState = (buildingBlocks, store, atom) => {
 	var _a;
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const atomStateMap = buildingBlocks[0];
-	const storeHooks = buildingBlocks[6];
-	const atomOnInit = buildingBlocks[9];
-	if (({}.env ? {}.env.MODE : void 0) !== "production" && !atom) throw new Error("Atom is undefined or null");
 	let atomState = atomStateMap.get(atom);
 	if (!atomState) {
+		const storeHooks = buildingBlocks[6];
+		const atomOnInit = buildingBlocks[9];
 		atomState = {
 			d: /* @__PURE__ */ new Map(),
 			p: /* @__PURE__ */ new Set(),
@@ -147,13 +145,12 @@ const BUILDING_BLOCK_ensureAtomState = (store, atom) => {
 		};
 		atomStateMap.set(atom, atomState);
 		(_a = storeHooks.i) == null || _a.call(storeHooks, atom);
-		atomOnInit?.(store, atom);
+		if (hasOnInit(atom)) atomOnInit(buildingBlocks, store, atom);
 	}
 	return atomState;
 };
-const BUILDING_BLOCK_flushCallbacks = (store) => {
+const BUILDING_BLOCK_flushCallbacks = (buildingBlocks, store) => {
 	var _a;
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const mountedMap = buildingBlocks[1];
 	const changedAtoms = buildingBlocks[3];
 	const mountCallbacks = buildingBlocks[4];
@@ -182,12 +179,11 @@ const BUILDING_BLOCK_flushCallbacks = (store) => {
 		for (const fn of mountCallbacks) callbacks.add(fn);
 		mountCallbacks.clear();
 		for (const fn of callbacks) call(fn);
-		if (changedAtoms.size) recomputeInvalidatedAtoms(store);
+		if (changedAtoms.size) recomputeInvalidatedAtoms(buildingBlocks, store);
 	} while (changedAtoms.size || unmountCallbacks.size || mountCallbacks.size);
 	if (errors.length) throw new AggregateError(errors);
 };
-const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
-	const buildingBlocks = getInternalBuildingBlocks(store);
+const BUILDING_BLOCK_recomputeInvalidatedAtoms = (buildingBlocks, store) => {
 	const mountedMap = buildingBlocks[1];
 	const invalidatedAtoms = buildingBlocks[2];
 	const changedAtoms = buildingBlocks[3];
@@ -203,7 +199,7 @@ const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
 	const stackStates = [];
 	for (const atom of changedAtoms) {
 		stackAtoms.push(atom);
-		stackStates.push(ensureAtomState(store, atom));
+		stackStates.push(ensureAtomState(buildingBlocks, store, atom));
 	}
 	while (stackAtoms.length) {
 		const top = stackAtoms.length - 1;
@@ -227,7 +223,7 @@ const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
 		visiting.add(a);
 		for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) if (!visiting.has(d)) {
 			stackAtoms.push(d);
-			stackStates.push(ensureAtomState(store, d));
+			stackStates.push(ensureAtomState(buildingBlocks, store, d));
 		}
 	}
 	for (let i = sortedReversedAtoms.length - 1; i >= 0; --i) {
@@ -240,16 +236,15 @@ const BUILDING_BLOCK_recomputeInvalidatedAtoms = (store) => {
 		}
 		if (hasChangedDeps) {
 			invalidatedAtoms.set(a, aState.n);
-			readAtomState(store, a);
-			mountDependencies(store, a);
+			readAtomState(buildingBlocks, store, a);
+			mountDependencies(buildingBlocks, store, a);
 		}
 		invalidatedAtoms.delete(a);
 	}
 };
 const storeMutationSet = /* @__PURE__ */ new WeakSet();
-const BUILDING_BLOCK_readAtomState = (store, atom) => {
+const BUILDING_BLOCK_readAtomState = (buildingBlocks, store, atom) => {
 	var _a, _b;
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const mountedMap = buildingBlocks[1];
 	const invalidatedAtoms = buildingBlocks[2];
 	const changedAtoms = buildingBlocks[3];
@@ -264,7 +259,7 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
 	const setAtomStateValueOrPromise = buildingBlocks[20];
 	const registerAbortHandler = buildingBlocks[26];
 	const storeEpochHolder = buildingBlocks[28];
-	const atomState = ensureAtomState(store, atom);
+	const atomState = ensureAtomState(buildingBlocks, store, atom);
 	const storeEpochNumber = storeEpochHolder[0];
 	if (isAtomStateInitialized(atomState)) {
 		if (mountedMap.has(atom) && invalidatedAtoms.get(atom) !== atomState.n || atomState.m === storeEpochNumber) {
@@ -272,7 +267,7 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
 			return atomState;
 		}
 		let hasChangedDeps = false;
-		for (const [a, n] of atomState.d) if (readAtomState(store, a).n !== n) {
+		for (const [a, n] of atomState.d) if (readAtomState(buildingBlocks, store, a).n !== n) {
 			hasChangedDeps = true;
 			break;
 		}
@@ -289,22 +284,22 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
 	const mountDependenciesIfAsync = () => {
 		if (mountedMap.has(atom)) {
 			const shouldRecompute = !changedAtoms.size;
-			mountDependencies(store, atom);
+			mountDependencies(buildingBlocks, store, atom);
 			if (shouldRecompute) {
-				recomputeInvalidatedAtoms(store);
-				flushCallbacks(store);
+				recomputeInvalidatedAtoms(buildingBlocks, store);
+				flushCallbacks(buildingBlocks, store);
 			}
 		}
 	};
 	const getter = (a) => {
 		var _a2;
 		if (a === atom) {
-			const aState2 = ensureAtomState(store, a);
-			if (!isAtomStateInitialized(aState2)) if (hasInitialValue(a)) setAtomStateValueOrPromise(store, a, a.init);
+			const aState2 = ensureAtomState(buildingBlocks, store, a);
+			if (!isAtomStateInitialized(aState2)) if (hasInitialValue(a)) setAtomStateValueOrPromise(buildingBlocks, store, a, a.init);
 			else throw new Error("no atom init");
 			return returnAtomValue(aState2);
 		}
-		const aState = readAtomState(store, a);
+		const aState = readAtomState(buildingBlocks, store, a);
 		try {
 			return returnAtomValue(aState);
 		} finally {
@@ -328,10 +323,10 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
 			if (!setSelf && isActuallyWritableAtom(atom)) setSelf = (...args) => {
 				if (({}.env ? {}.env.MODE : void 0) !== "production" && isSync) console.warn("setSelf function cannot be called in sync");
 				if (!isSync) try {
-					return writeAtomState(store, atom, ...args);
+					return writeAtomState(buildingBlocks, store, atom, args);
 				} finally {
-					recomputeInvalidatedAtoms(store);
-					flushCallbacks(store);
+					recomputeInvalidatedAtoms(buildingBlocks, store);
+					flushCallbacks(buildingBlocks, store);
 				}
 			};
 			return setSelf;
@@ -341,11 +336,11 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
 	const prevInvalidated = invalidatedAtoms.get(atom) === prevEpochNumber;
 	try {
 		if (({}.env ? {}.env.MODE : void 0) !== "production") storeMutationSet.delete(store);
-		const valueOrPromise = atomRead(store, atom, getter, options);
+		const valueOrPromise = atomRead(buildingBlocks, store, atom, getter, options);
 		if (({}.env ? {}.env.MODE : void 0) !== "production" && storeMutationSet.has(store)) console.warn("Detected store mutation during atom read. This is not supported.");
-		setAtomStateValueOrPromise(store, atom, valueOrPromise);
+		setAtomStateValueOrPromise(buildingBlocks, store, atom, valueOrPromise);
 		if (isPromiseLike$1(valueOrPromise)) {
-			registerAbortHandler(store, valueOrPromise, () => controller == null ? void 0 : controller.abort());
+			registerAbortHandler(buildingBlocks, store, valueOrPromise, () => controller == null ? void 0 : controller.abort());
 			const settle = () => {
 				pruneDependencies();
 				mountDependenciesIfAsync();
@@ -370,17 +365,16 @@ const BUILDING_BLOCK_readAtomState = (store, atom) => {
 		}
 	}
 };
-const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
-	const buildingBlocks = getInternalBuildingBlocks(store);
+const BUILDING_BLOCK_invalidateDependents = (buildingBlocks, store, atom) => {
 	const mountedMap = buildingBlocks[1];
 	const invalidatedAtoms = buildingBlocks[2];
 	const ensureAtomState = buildingBlocks[11];
 	const stack = [atom];
 	while (stack.length) {
 		const a = stack.pop();
-		const aState = ensureAtomState(store, a);
+		const aState = ensureAtomState(buildingBlocks, store, a);
 		for (const d of getMountedOrPendingDependents(a, aState, mountedMap)) {
-			const dState = ensureAtomState(store, d);
+			const dState = ensureAtomState(buildingBlocks, store, d);
 			if (invalidatedAtoms.get(d) !== dState.n) {
 				invalidatedAtoms.set(d, dState.n);
 				stack.push(d);
@@ -388,8 +382,7 @@ const BUILDING_BLOCK_invalidateDependents = (store, atom) => {
 		}
 	}
 };
-const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
-	const buildingBlocks = getInternalBuildingBlocks(store);
+const BUILDING_BLOCK_writeAtomState = (buildingBlocks, store, atom, args) => {
 	const changedAtoms = buildingBlocks[3];
 	const storeHooks = buildingBlocks[6];
 	const atomWrite = buildingBlocks[8];
@@ -403,42 +396,41 @@ const BUILDING_BLOCK_writeAtomState = (store, atom, ...args) => {
 	const setAtomStateValueOrPromise = buildingBlocks[20];
 	const storeEpochHolder = buildingBlocks[28];
 	let isSync = true;
-	const getter = (a) => returnAtomValue(readAtomState(store, a));
+	const getter = (a) => returnAtomValue(readAtomState(buildingBlocks, store, a));
 	const setter = (a, ...args2) => {
 		var _a;
-		const aState = ensureAtomState(store, a);
+		const aState = ensureAtomState(buildingBlocks, store, a);
 		try {
 			if (a === atom) {
 				if (!hasInitialValue(a)) throw new Error("atom not writable");
 				if (({}.env ? {}.env.MODE : void 0) !== "production") storeMutationSet.add(store);
 				const prevEpochNumber = aState.n;
 				const v = args2[0];
-				setAtomStateValueOrPromise(store, a, v);
-				mountDependencies(store, a);
+				setAtomStateValueOrPromise(buildingBlocks, store, a, v);
+				mountDependencies(buildingBlocks, store, a);
 				if (prevEpochNumber !== aState.n) {
 					++storeEpochHolder[0];
 					changedAtoms.add(a);
-					invalidateDependents(store, a);
+					invalidateDependents(buildingBlocks, store, a);
 					(_a = storeHooks.c) == null || _a.call(storeHooks, a);
 				}
 				return;
-			} else return writeAtomState(store, a, ...args2);
+			} else return writeAtomState(buildingBlocks, store, a, args2);
 		} finally {
 			if (!isSync) {
-				recomputeInvalidatedAtoms(store);
-				flushCallbacks(store);
+				recomputeInvalidatedAtoms(buildingBlocks, store);
+				flushCallbacks(buildingBlocks, store);
 			}
 		}
 	};
 	try {
-		return atomWrite(store, atom, getter, setter, ...args);
+		return atomWrite(buildingBlocks, store, atom, getter, setter, ...args);
 	} finally {
 		isSync = false;
 	}
 };
-const BUILDING_BLOCK_mountDependencies = (store, atom) => {
+const BUILDING_BLOCK_mountDependencies = (buildingBlocks, store, atom) => {
 	var _a;
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const mountedMap = buildingBlocks[1];
 	const changedAtoms = buildingBlocks[3];
 	const storeHooks = buildingBlocks[6];
@@ -446,28 +438,27 @@ const BUILDING_BLOCK_mountDependencies = (store, atom) => {
 	const invalidateDependents = buildingBlocks[15];
 	const mountAtom = buildingBlocks[18];
 	const unmountAtom = buildingBlocks[19];
-	const atomState = ensureAtomState(store, atom);
+	const atomState = ensureAtomState(buildingBlocks, store, atom);
 	const mounted = mountedMap.get(atom);
 	if (mounted && atomState.d.size > 0) {
 		for (const [a, n] of atomState.d) if (!mounted.d.has(a)) {
-			const aState = ensureAtomState(store, a);
-			mountAtom(store, a).t.add(atom);
+			const aState = ensureAtomState(buildingBlocks, store, a);
+			mountAtom(buildingBlocks, store, a).t.add(atom);
 			mounted.d.add(a);
 			if (n !== aState.n) {
 				changedAtoms.add(a);
-				invalidateDependents(store, a);
+				invalidateDependents(buildingBlocks, store, a);
 				(_a = storeHooks.c) == null || _a.call(storeHooks, a);
 			}
 		}
 		for (const a of mounted.d) if (!atomState.d.has(a)) {
 			mounted.d.delete(a);
-			unmountAtom(store, a)?.t.delete(atom);
+			unmountAtom(buildingBlocks, store, a)?.t.delete(atom);
 		}
 	}
 };
-const BUILDING_BLOCK_mountAtom = (store, atom) => {
+const BUILDING_BLOCK_mountAtom = (buildingBlocks, store, atom) => {
 	var _a;
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const mountedMap = buildingBlocks[1];
 	const mountCallbacks = buildingBlocks[4];
 	const storeHooks = buildingBlocks[6];
@@ -478,11 +469,11 @@ const BUILDING_BLOCK_mountAtom = (store, atom) => {
 	const readAtomState = buildingBlocks[14];
 	const writeAtomState = buildingBlocks[16];
 	const mountAtom = buildingBlocks[18];
-	const atomState = ensureAtomState(store, atom);
+	const atomState = ensureAtomState(buildingBlocks, store, atom);
 	let mounted = mountedMap.get(atom);
 	if (!mounted) {
-		readAtomState(store, atom);
-		for (const a of atomState.d.keys()) mountAtom(store, a).t.add(atom);
+		readAtomState(buildingBlocks, store, atom);
+		for (const a of atomState.d.keys()) mountAtom(buildingBlocks, store, a).t.add(atom);
 		mounted = {
 			l: /* @__PURE__ */ new Set(),
 			d: new Set(atomState.d.keys()),
@@ -494,16 +485,16 @@ const BUILDING_BLOCK_mountAtom = (store, atom) => {
 				let isSync = true;
 				const setAtom = (...args) => {
 					try {
-						return writeAtomState(store, atom, ...args);
+						return writeAtomState(buildingBlocks, store, atom, args);
 					} finally {
 						if (!isSync) {
-							recomputeInvalidatedAtoms(store);
-							flushCallbacks(store);
+							recomputeInvalidatedAtoms(buildingBlocks, store);
+							flushCallbacks(buildingBlocks, store);
 						}
 					}
 				};
 				try {
-					const onUnmount = atomOnMount(store, atom, setAtom);
+					const onUnmount = atomOnMount(buildingBlocks, store, atom, setAtom);
 					if (onUnmount) mounted.u = () => {
 						isSync = true;
 						try {
@@ -522,15 +513,14 @@ const BUILDING_BLOCK_mountAtom = (store, atom) => {
 	}
 	return mounted;
 };
-const BUILDING_BLOCK_unmountAtom = (store, atom) => {
+const BUILDING_BLOCK_unmountAtom = (buildingBlocks, store, atom) => {
 	var _a, _b;
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const mountedMap = buildingBlocks[1];
 	const unmountCallbacks = buildingBlocks[5];
 	const storeHooks = buildingBlocks[6];
 	const ensureAtomState = buildingBlocks[11];
 	const unmountAtom = buildingBlocks[19];
-	const atomState = ensureAtomState(store, atom);
+	const atomState = ensureAtomState(buildingBlocks, store, atom);
 	let mounted = mountedMap.get(atom);
 	if (!mounted || mounted.l.size) return mounted;
 	let isDependent = false;
@@ -542,63 +532,60 @@ const BUILDING_BLOCK_unmountAtom = (store, atom) => {
 		if (mounted.u) unmountCallbacks.add(mounted.u);
 		mounted = void 0;
 		mountedMap.delete(atom);
-		for (const a of atomState.d.keys()) unmountAtom(store, a)?.t.delete(atom);
+		for (const a of atomState.d.keys()) unmountAtom(buildingBlocks, store, a)?.t.delete(atom);
 		(_b = storeHooks.u) == null || _b.call(storeHooks, atom);
 		return;
 	}
 	return mounted;
 };
-const BUILDING_BLOCK_setAtomStateValueOrPromise = (store, atom, valueOrPromise) => {
-	const buildingBlocks = getInternalBuildingBlocks(store);
+const BUILDING_BLOCK_setAtomStateValueOrPromise = (buildingBlocks, store, atom, valueOrPromise) => {
 	const ensureAtomState = buildingBlocks[11];
 	const abortPromise = buildingBlocks[27];
-	const atomState = ensureAtomState(store, atom);
+	const atomState = ensureAtomState(buildingBlocks, store, atom);
 	const hasPrevValue = "v" in atomState;
 	const prevValue = atomState.v;
-	if (isPromiseLike$1(valueOrPromise)) for (const a of atomState.d.keys()) addPendingPromiseToDependency(atom, valueOrPromise, ensureAtomState(store, a));
+	if (isPromiseLike$1(valueOrPromise)) for (const a of atomState.d.keys()) addPendingPromiseToDependency(atom, valueOrPromise, ensureAtomState(buildingBlocks, store, a));
 	atomState.v = valueOrPromise;
 	delete atomState.e;
 	if (!hasPrevValue || !Object.is(prevValue, atomState.v)) {
 		++atomState.n;
-		if (isPromiseLike$1(prevValue)) abortPromise(store, prevValue);
+		if (isPromiseLike$1(prevValue)) abortPromise(buildingBlocks, store, prevValue);
 	}
 };
-const BUILDING_BLOCK_storeGet = (store, atom) => {
-	const readAtomState = getInternalBuildingBlocks(store)[14];
-	return returnAtomValue(readAtomState(store, atom));
+const BUILDING_BLOCK_storeGet = (buildingBlocks, store, atom) => {
+	const readAtomState = buildingBlocks[14];
+	return returnAtomValue(readAtomState(buildingBlocks, store, atom));
 };
-const BUILDING_BLOCK_storeSet = (store, atom, ...args) => {
-	const buildingBlocks = getInternalBuildingBlocks(store);
+const BUILDING_BLOCK_storeSet = (buildingBlocks, store, atom, ...args) => {
 	const changedAtoms = buildingBlocks[3];
 	const flushCallbacks = buildingBlocks[12];
 	const recomputeInvalidatedAtoms = buildingBlocks[13];
 	const writeAtomState = buildingBlocks[16];
 	const prevChangedAtomsSize = changedAtoms.size;
 	try {
-		return writeAtomState(store, atom, ...args);
+		return writeAtomState(buildingBlocks, store, atom, args);
 	} finally {
 		if (changedAtoms.size !== prevChangedAtomsSize) {
-			recomputeInvalidatedAtoms(store);
-			flushCallbacks(store);
+			recomputeInvalidatedAtoms(buildingBlocks, store);
+			flushCallbacks(buildingBlocks, store);
 		}
 	}
 };
-const BUILDING_BLOCK_storeSub = (store, atom, listener) => {
-	const buildingBlocks = getInternalBuildingBlocks(store);
+const BUILDING_BLOCK_storeSub = (buildingBlocks, store, atom, listener) => {
 	const flushCallbacks = buildingBlocks[12];
 	const mountAtom = buildingBlocks[18];
 	const unmountAtom = buildingBlocks[19];
-	const listeners = mountAtom(store, atom).l;
+	const listeners = mountAtom(buildingBlocks, store, atom).l;
 	listeners.add(listener);
-	flushCallbacks(store);
+	flushCallbacks(buildingBlocks, store);
 	return () => {
 		listeners.delete(listener);
-		unmountAtom(store, atom);
-		flushCallbacks(store);
+		unmountAtom(buildingBlocks, store, atom);
+		flushCallbacks(buildingBlocks, store);
 	};
 };
-const BUILDING_BLOCK_registerAbortHandler = (store, promise, abortHandler) => {
-	const abortHandlersMap = getInternalBuildingBlocks(store)[25];
+const BUILDING_BLOCK_registerAbortHandler = (buildingBlocks, _store, promise, abortHandler) => {
+	const abortHandlersMap = buildingBlocks[25];
 	let abortHandlers = abortHandlersMap.get(promise);
 	if (!abortHandlers) {
 		abortHandlers = /* @__PURE__ */ new Set();
@@ -608,34 +595,27 @@ const BUILDING_BLOCK_registerAbortHandler = (store, promise, abortHandler) => {
 	}
 	abortHandlers.add(abortHandler);
 };
-const BUILDING_BLOCK_abortPromise = (store, promise) => {
-	getInternalBuildingBlocks(store)[25].get(promise)?.forEach((fn) => fn());
+const BUILDING_BLOCK_abortPromise = (buildingBlocks, _store, promise) => {
+	buildingBlocks[25].get(promise)?.forEach((fn) => fn());
 };
 const buildingBlockMap = /* @__PURE__ */ new WeakMap();
-const getInternalBuildingBlocks = (store) => {
+function getBuildingBlocks(store) {
 	const buildingBlocks = buildingBlockMap.get(store);
 	if (({}.env ? {}.env.MODE : void 0) !== "production" && !buildingBlocks) throw new Error("Store must be created by buildStore to read its building blocks");
-	return buildingBlocks;
-};
-function getBuildingBlocks(store) {
-	const buildingBlocks = getInternalBuildingBlocks(store);
 	const enhanceBuildingBlocks = buildingBlocks[24];
-	if (enhanceBuildingBlocks) return enhanceBuildingBlocks(buildingBlocks);
+	if (enhanceBuildingBlocks) return enhanceBuildingBlocks(buildingBlocks, store);
 	return buildingBlocks;
 }
-function buildStore(...buildArgs) {
+function buildStore(...partialBuildingBlocks) {
 	const store = {
 		get(atom) {
-			const storeGet = getInternalBuildingBlocks(store)[21];
-			return storeGet(store, atom);
+			return storeGet(buildingBlocks, store, atom);
 		},
 		set(atom, ...args) {
-			const storeSet = getInternalBuildingBlocks(store)[22];
-			return storeSet(store, atom, ...args);
+			return storeSet(buildingBlocks, store, atom, ...args);
 		},
 		sub(atom, listener) {
-			const storeSub = getInternalBuildingBlocks(store)[23];
-			return storeSub(store, atom, listener);
+			return storeSub(buildingBlocks, store, atom, listener);
 		}
 	};
 	const buildingBlocks = [
@@ -668,8 +648,11 @@ function buildStore(...buildArgs) {
 		BUILDING_BLOCK_registerAbortHandler,
 		BUILDING_BLOCK_abortPromise,
 		[0]
-	].map((fn, i) => buildArgs[i] || fn);
+	].map((fn, i) => partialBuildingBlocks[i] || fn);
 	buildingBlockMap.set(store, Object.freeze(buildingBlocks));
+	const storeGet = buildingBlocks[21];
+	const storeSet = buildingBlocks[22];
+	const storeSub = buildingBlocks[23];
 	return store;
 }
 //#endregion
@@ -740,7 +723,8 @@ const use = react$1.default.use || ((promise) => {
 });
 const continuablePromiseMap = /* @__PURE__ */ new WeakMap();
 const createContinuablePromise = (store, promise, getValue) => {
-	const registerAbortHandler = getBuildingBlocks(store)[26];
+	const buildingBlocks = getBuildingBlocks(store);
+	const registerAbortHandler = buildingBlocks[26];
 	let continuablePromise = continuablePromiseMap.get(promise);
 	if (!continuablePromise) {
 		continuablePromise = new Promise((resolve, reject) => {
@@ -758,14 +742,14 @@ const createContinuablePromise = (store, promise, getValue) => {
 						continuablePromiseMap.set(nextValue, continuablePromise);
 						curr = nextValue;
 						nextValue.then(onFulfilled(nextValue), onRejected(nextValue));
-						registerAbortHandler(store, nextValue, onAbort);
+						registerAbortHandler(buildingBlocks, store, nextValue, onAbort);
 					} else resolve(nextValue);
 				} catch (e) {
 					reject(e);
 				}
 			};
 			promise.then(onFulfilled(promise), onRejected(promise));
-			registerAbortHandler(store, promise, onAbort);
+			registerAbortHandler(buildingBlocks, store, promise, onAbort);
 		});
 		continuablePromiseMap.set(promise, continuablePromise);
 	}

package/dist/metro/withStorybook.js

@@ -86,7 +86,9 @@ function withStorybook(config, options = {
 	configPath: path.resolve(process.cwd(), "./.rnstorybook")
 }) {
 	const { configPath = path.resolve(process.cwd(), "./.rnstorybook"), websockets, useJs = false, enabled = true, docTools = true, liteMode = false, experimental_mcp = false } = options;
-	if (!(0, storybook_internal_common.optionalEnvToBoolean)(process.env.STORYBOOK_DISABLE_TELEMETRY) && enabled) (0, storybook_internal_telemetry.telemetry)(process.env.NODE_ENV === "production" ? "build" : "dev", {}).catch((e) => {});
+	const disableTelemetry = (0, storybook_internal_common.optionalEnvToBoolean)(process.env.STORYBOOK_DISABLE_TELEMETRY);
+	const server = require_env_tools.envVariableToBoolean(process.env.STORYBOOK_SERVER, true);
+	if (!disableTelemetry && enabled) (0, storybook_internal_telemetry.telemetry)(process.env.NODE_ENV === "production" ? "build" : "dev", {}).catch((e) => {});
 	if (!enabled) return {
 		...config,
 		resolver: {
@@ -112,12 +114,13 @@ function withStorybook(config, options = {
 		const generateHost = resolvedWs.host ?? (websockets === "auto" && !process.env.STORYBOOK_WS_HOST ? "auto" : void 0);
 		const port = resolvedWs.port ?? 7007;
 		const secured = resolvedWs.secured;
-		require_channelServer.createChannelServer({
+		const channelWebsocketsEnabled = Boolean(websockets) || Boolean(process.env.STORYBOOK_WS_HOST) || Boolean(resolvedWs.host);
+		if (server) require_channelServer.createChannelServer({
 			port,
 			host: bindHost,
 			configPath,
 			experimental_mcp,
-			websockets: Boolean(websockets) || Boolean(process.env.STORYBOOK_WS_HOST) || Boolean(resolvedWs.host),
+			websockets: channelWebsocketsEnabled,
 			secured,
 			ssl: websockets && websockets !== "auto" ? {
 				key: websockets.key,

package/dist/repack/withStorybook.js

@@ -71,12 +71,13 @@ var StorybookPlugin = class {
 	*/
 	applyEnabled(compiler, { configPath, websockets, useJs, docTools, liteMode, experimental_mcp }) {
 		const resolvedWs = require_env_tools.loadWebsocketEnvOverrides(websockets);
+		const server = require_env_tools.envVariableToBoolean(process.env.STORYBOOK_SERVER, true);
 		const bindHost = websockets === "auto" && !process.env.STORYBOOK_WS_HOST ? void 0 : resolvedWs.host;
 		const generateHost = resolvedWs.host ?? (websockets === "auto" && !process.env.STORYBOOK_WS_HOST ? "auto" : void 0);
 		const port = resolvedWs.port ?? 7007;
 		const secured = resolvedWs.secured;
 		const channelWebsocketsEnabled = Boolean(websockets) || Boolean(process.env.STORYBOOK_WS_HOST) || Boolean(resolvedWs.host);
-		if ((experimental_mcp || websockets != null || process.env.STORYBOOK_WS_HOST) && !this.serverStarted) {
+		if ((experimental_mcp || websockets != null || process.env.STORYBOOK_WS_HOST) && !this.serverStarted && server) {
 			this.serverStarted = true;
 			require_channelServer.createChannelServer({
 				port,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storybook/react-native",
-  "version": "10.4.3",
+  "version": "10.4.5-canary-20260529144515",
   "description": "A better way to develop React Native Components for your app",
   "keywords": [
     "react",
@@ -44,11 +44,11 @@
     "metro/**/*"
   ],
   "dependencies": {
-    "@storybook/mcp": "^0.6.1",
-    "@storybook/react": "^10.3.2",
-    "@storybook/react-native-theming": "^10.4.3",
-    "@storybook/react-native-ui": "^10.4.3",
-    "@storybook/react-native-ui-common": "^10.4.3",
+    "@storybook/mcp": "^0.7.0",
+    "@storybook/react": "^10.4.0",
+    "@storybook/react-native-theming": "10.4.5-canary-20260529144515",
+    "@storybook/react-native-ui": "10.4.5-canary-20260529144515",
+    "@storybook/react-native-ui-common": "10.4.5-canary-20260529144515",
     "@tmcp/adapter-valibot": "^0.1.4",
     "@tmcp/transport-http": "^0.8.5",
     "commander": "^14.0.2",
@@ -69,11 +69,11 @@
     "babel-jest": "^29.7.0",
     "babel-preset-expo": "^55.0.13",
     "jest": "^29.7.0",
-    "jest-expo": "~56.0.0",
+    "jest-expo": "~56.0.1",
     "jotai": "^2.19.0",
     "react": "19.2.3",
     "react-native": "0.85.3",
-    "storybook": "^10.3.2",
+    "storybook": "^10.4.0",
     "sucrase": "^3.35.1",
     "test-renderer": "^0.15.0",
     "tsdown": "^0.22.0",