@isograph/react-disposable-state 0.0.0-main-a8e129cf → 0.0.0-main-1ba744d7

package/.turbo/turbo-compile-libs.log

@@ -1,11 +1,11 @@
 ../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.20.0","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.0.0-main-a8e129cf compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.0.0-main-1ba744d7 compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsdown
 
 ℹ tsdown v0.20.1 powered by rolldown v1.0.0-rc.1
 ℹ config file: /home/runner/work/isograph/isograph/tsdown.config.ts 
-(node:2729) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=77ede110-960f-4f9b-b5d4-94a217d394dd is not specified and it doesn't parse as CommonJS.
+(node:2646) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=c042b2e9-7e41-49bd-a93d-2e3cc4113e4d is not specified and it doesn't parse as CommonJS.
 Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
 To eliminate this warning, add "type": "module" to /home/runner/work/isograph/isograph/package.json.
 (Use `node --trace-warnings ...` to show where the warning was created)

package/.turbo/turbo-tsc.log

@@ -1,5 +1,5 @@
 ../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.20.0","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.0.0-main-a8e129cf tsc /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.0.0-main-1ba744d7 tsc /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsc
 

package/dist/index.cjs

@@ -1,5 +1,6 @@
 const require_CacheItem = require('./CacheItem.cjs');
 const require_ParentCache = require('./ParentCache.cjs');
+const require_useEffectsRerunWithoutRender = require('./useEffectsRerunWithoutRender.cjs');
 const require_useCachedResponsivePrecommitValue = require('./useCachedResponsivePrecommitValue.cjs');
 const require_useHasCommittedRef = require('./useHasCommittedRef.cjs');
 const require_useUpdatableDisposableState = require('./useUpdatableDisposableState.cjs');
@@ -12,6 +13,7 @@ exports.UNASSIGNED_STATE = require_useUpdatableDisposableState.UNASSIGNED_STATE;
 exports.createTemporarilyRetainedCacheItem = require_CacheItem.createTemporarilyRetainedCacheItem;
 exports.useCachedResponsivePrecommitValue = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue;
 exports.useDisposableState = require_useDisposableState.useDisposableState;
+exports.useEffectsRerunWithoutRenderRef = require_useEffectsRerunWithoutRender.useEffectsRerunWithoutRenderRef;
 exports.useHasCommittedRef = require_useHasCommittedRef.useHasCommittedRef;
 exports.useLazyDisposableState = require_useLazyDisposableState.useLazyDisposableState;
 exports.useUpdatableDisposableState = require_useUpdatableDisposableState.useUpdatableDisposableState;

package/dist/index.d.cts

@@ -3,7 +3,8 @@ import { ParentCache } from "./ParentCache.cjs";
 import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.cjs";
 import { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState } from "./useUpdatableDisposableState.cjs";
 import { useDisposableState } from "./useDisposableState.cjs";
+import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.cjs";
 import { useHasCommittedRef } from "./useHasCommittedRef.cjs";
 import { useLazyDisposableState } from "./useLazyDisposableState.cjs";
 export * from "@isograph/disposable-types";
-export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };

package/dist/index.d.mts

@@ -3,7 +3,8 @@ import { ParentCache } from "./ParentCache.mjs";
 import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.mjs";
 import { UNASSIGNED_STATE, UnassignedState, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
 import { useDisposableState } from "./useDisposableState.mjs";
+import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.mjs";
 import { useHasCommittedRef } from "./useHasCommittedRef.mjs";
 import { useLazyDisposableState } from "./useLazyDisposableState.mjs";
 export * from "@isograph/disposable-types";
-export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, CacheItemOptions, CacheItemState, InParentCacheAndNotDisposed, NotInParentCacheAndDisposed, NotInParentCacheAndNotDisposed, ParentCache, UNASSIGNED_STATE, UnassignedState, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };

package/dist/index.mjs

@@ -1,5 +1,6 @@
 import { CacheItem, createTemporarilyRetainedCacheItem } from "./CacheItem.mjs";
 import { ParentCache } from "./ParentCache.mjs";
+import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.mjs";
 import { useCachedResponsivePrecommitValue } from "./useCachedResponsivePrecommitValue.mjs";
 import { useHasCommittedRef } from "./useHasCommittedRef.mjs";
 import { UNASSIGNED_STATE, useUpdatableDisposableState } from "./useUpdatableDisposableState.mjs";
@@ -8,4 +9,4 @@ import { useLazyDisposableState } from "./useLazyDisposableState.mjs";
 
 export * from "@isograph/disposable-types"
 
-export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };
+export { CacheItem, ParentCache, UNASSIGNED_STATE, createTemporarilyRetainedCacheItem, useCachedResponsivePrecommitValue, useDisposableState, useEffectsRerunWithoutRenderRef, useHasCommittedRef, useLazyDisposableState, useUpdatableDisposableState };

package/dist/useCachedResponsivePrecommitValue.cjs

@@ -1,5 +1,6 @@
 'use strict';
 
+const require_useEffectsRerunWithoutRender = require('./useEffectsRerunWithoutRender.cjs');
 let react = require("react");
 
 //#region src/useCachedResponsivePrecommitValue.ts
@@ -38,16 +39,21 @@ let react = require("react");
 function useCachedResponsivePrecommitValue(parentCache, onCommit) {
 	const [, rerender] = (0, react.useState)(null);
 	const lastCommittedParentCache = (0, react.useRef)(null);
+	const effectsRerunWithoutRenderRef = require_useEffectsRerunWithoutRender.useEffectsRerunWithoutRenderRef();
 	(0, react.useEffect)(() => {
 		lastCommittedParentCache.current = parentCache;
-		const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
-		if (undisposedPair != null) onCommit(undisposedPair);
-		else {
-			const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
-			if (existingCacheItemCleanupPair != null) onCommit(existingCacheItemCleanupPair);
-			else onCommit(parentCache.factory());
-			rerender({});
+		if (!effectsRerunWithoutRenderRef.current) {
+			const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
+			if (undisposedPair != null) {
+				onCommit(undisposedPair);
+				return;
+			}
 		}
+		effectsRerunWithoutRenderRef.current = false;
+		const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
+		if (existingCacheItemCleanupPair != null) onCommit(existingCacheItemCleanupPair);
+		else onCommit(parentCache.factory());
+		rerender({});
 	}, [parentCache]);
 	if (lastCommittedParentCache.current === parentCache) return null;
 	const [cacheItem, item, disposeOfTemporaryRetain] = parentCache.getOrPopulateAndTemporaryRetain();

package/dist/useCachedResponsivePrecommitValue.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"useCachedResponsivePrecommitValue.d.cts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"mappings":";;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iCAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,GACzB,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,CAAA;EAC9B,KAAA,EAAO,CAAA;AAAA"}
+{"version":3,"file":"useCachedResponsivePrecommitValue.d.cts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"mappings":";;;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iCAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,GACzB,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,CAAA;EAC9B,KAAA,EAAO,CAAA;AAAA"}

package/dist/useCachedResponsivePrecommitValue.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"useCachedResponsivePrecommitValue.d.mts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"mappings":";;;;;;AAsCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iCAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,GACzB,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,CAAA;EAC9B,KAAA,EAAO,CAAA;AAAA"}
+{"version":3,"file":"useCachedResponsivePrecommitValue.d.mts","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"mappings":";;;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAgB,iCAAA,GAAA,CACd,WAAA,EAAa,WAAA,CAAY,CAAA,GACzB,QAAA,GAAW,IAAA,EAAM,eAAA,CAAgB,CAAA;EAC9B,KAAA,EAAO,CAAA;AAAA"}

package/dist/useCachedResponsivePrecommitValue.mjs

@@ -1,3 +1,4 @@
+import { useEffectsRerunWithoutRenderRef } from "./useEffectsRerunWithoutRender.mjs";
 import { useEffect, useRef, useState } from "react";
 
 //#region src/useCachedResponsivePrecommitValue.ts
@@ -36,16 +37,21 @@ import { useEffect, useRef, useState } from "react";
 function useCachedResponsivePrecommitValue(parentCache, onCommit) {
 	const [, rerender] = useState(null);
 	const lastCommittedParentCache = useRef(null);
+	const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();
 	useEffect(() => {
 		lastCommittedParentCache.current = parentCache;
-		const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
-		if (undisposedPair != null) onCommit(undisposedPair);
-		else {
-			const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
-			if (existingCacheItemCleanupPair != null) onCommit(existingCacheItemCleanupPair);
-			else onCommit(parentCache.factory());
-			rerender({});
+		if (!effectsRerunWithoutRenderRef.current) {
+			const undisposedPair = cacheItem.permanentRetainIfNotDisposed(disposeOfTemporaryRetain);
+			if (undisposedPair != null) {
+				onCommit(undisposedPair);
+				return;
+			}
 		}
+		effectsRerunWithoutRenderRef.current = false;
+		const existingCacheItemCleanupPair = parentCache.getAndPermanentRetainIfPresent();
+		if (existingCacheItemCleanupPair != null) onCommit(existingCacheItemCleanupPair);
+		else onCommit(parentCache.factory());
+		rerender({});
 	}, [parentCache]);
 	if (lastCommittedParentCache.current === parentCache) return null;
 	const [cacheItem, item, disposeOfTemporaryRetain] = parentCache.getOrPopulateAndTemporaryRetain();

package/dist/useCachedResponsivePrecommitValue.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useCachedResponsivePrecommitValue.mjs","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef, useState } from 'react';\nimport type { ParentCache } from './ParentCache';\n\n/**\n * useCachedResponsivePrecommitValue<T>\n * - Takes a mutable parent cache, a factory function, and an onCommit callback.\n * - Returns T before commit after every parent cache change, and null afterward.\n * - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.\n * - The T from the render phase is only temporarily retained. It may have been\n *   disposed by the time of the commit. If so, this hook checks the parent cache\n *   for another T or creates one, and passes this T to onCommit.\n * - If the T returned during the last render is not the same as the one that\n *   is passed to onCommit, during the commit phase, it will schedule another render.\n *\n * Invariant: the returned T has not been disposed during the tick of the render.\n * The T passed to the onCommit callback has not been disposed when the onCommit\n * callback is called.\n *\n * Passing a different parentCache:\n * - Pre-commit, passing a different parentCache has the effect of \"resetting\" this\n *   hook's state to the new cache's state. For example, if you have a cache associated\n *   with a set of variables (e.g. {name: \"Matthew\"}), and pass in another cache\n *   (e.g. associated with {name: \"James\"}), which is empty, the hook will fill that\n *   new cache with the factory function.\n * - Post-commit, passing a different parentCache will reset hook to the pre-commit\n *   state. The cache will return T before commit, then fill the new cache with the\n *   factory function and return null afterwards.\n *\n * Passing a different factory:\n * - Passing a different factory has no effect, except when factory is called,\n *   which is when the parent cache is being filled, or during commit.\n *\n * Passing a different onCommit:\n * - Passing a different onCommit has no effect, except for during commit.\n */\nexport function useCachedResponsivePrecommitValue<T>(\n  parentCache: ParentCache<T>,\n  onCommit: (pair: ItemCleanupPair<T>) => void,\n): { state: T } | null {\n  // TODO: there should be two APIs. One in which we always re-render if the\n  // committed item was not returned during the last render, and one in which\n  // we do not. The latter is useful for cases where every disposable item\n  // behaves identically, but must be loaded.\n  //\n  // This hook is the former, i.e. re-renders if the committed item has changed.\n  const [, rerender] = useState<{} | null>(null);\n  const lastCommittedParentCache = useRef<ParentCache<T> | null>(null);\n\n  useEffect(() => {\n    lastCommittedParentCache.current = parentCache;\n    // On commit, cacheItem may be disposed, because during the render phase,\n    // we only temporarily retained the item, and the temporary retain could have\n    // expired by the time of the commit.\n    //\n    // So, we can be in one of two states:\n    // - the item is not disposed. In that case, permanently retain and use that item.\n    // - the item is disposed. In that case, we can be in two states:\n    //   - the parent cache is not empty (due to another component rendering, or\n    //     another render of the same component.) In that case, permanently retain and\n    //     use the item from the parent cache. (Note: any item present in the parent\n    //     cache is not disposed.)\n    //   - the parent cache is empty. In that case, call factory, getting a new item\n    //     and a cleanup function.\n    //\n    // After the above, we have a non-disposed item and a cleanup function, which we\n    // can pass to onCommit.\n    const undisposedPair = cacheItem.permanentRetainIfNotDisposed(\n      disposeOfTemporaryRetain,\n    );\n    if (undisposedPair != null) {\n      onCommit(undisposedPair);\n    } else {\n      // The cache item we created during render has been disposed. Check if the parent\n      // cache is populated.\n      const existingCacheItemCleanupPair =\n        parentCache.getAndPermanentRetainIfPresent();\n      if (existingCacheItemCleanupPair != null) {\n        onCommit(existingCacheItemCleanupPair);\n      } else {\n        // We did not find an item in the parent cache, create a new one.\n        onCommit(parentCache.factory());\n      }\n      // TODO: Consider whether we always want to rerender if the committed item\n      // was not returned during the last render, or whether some callers will\n      // prefer opting out of this behavior (e.g. if every disposable item behaves\n      // identically, but must be loaded.)\n      rerender({});\n    }\n  }, [parentCache]);\n\n  if (lastCommittedParentCache.current === parentCache) {\n    return null;\n  }\n\n  // Safety: item is only safe to use (i.e. guaranteed not to have been disposed)\n  // during this tick.\n  const [cacheItem, item, disposeOfTemporaryRetain] =\n    parentCache.getOrPopulateAndTemporaryRetain();\n\n  return { state: item };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsCA,SAAgB,kCACd,aACA,UACqB;CAOrB,MAAM,GAAG,YAAY,SAAoB,KAAK;CAC9C,MAAM,2BAA2B,OAA8B,KAAK;AAEpE,iBAAgB;AACd,2BAAyB,UAAU;EAiBnC,MAAM,iBAAiB,UAAU,6BAC/B,yBACD;AACD,MAAI,kBAAkB,KACpB,UAAS,eAAe;OACnB;GAGL,MAAM,+BACJ,YAAY,gCAAgC;AAC9C,OAAI,gCAAgC,KAClC,UAAS,6BAA6B;OAGtC,UAAS,YAAY,SAAS,CAAC;AAMjC,YAAS,EAAE,CAAC;;IAEb,CAAC,YAAY,CAAC;AAEjB,KAAI,yBAAyB,YAAY,YACvC,QAAO;CAKT,MAAM,CAAC,WAAW,MAAM,4BACtB,YAAY,iCAAiC;AAE/C,QAAO,EAAE,OAAO,MAAM"}
+{"version":3,"file":"useCachedResponsivePrecommitValue.mjs","names":[],"sources":["../src/useCachedResponsivePrecommitValue.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef, useState } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useEffectsRerunWithoutRenderRef } from './useEffectsRerunWithoutRender';\n\n/**\n * useCachedResponsivePrecommitValue<T>\n * - Takes a mutable parent cache, a factory function, and an onCommit callback.\n * - Returns T before commit after every parent cache change, and null afterward.\n * - Calls onCommit with the ItemCleanupPair during commit after every parent cache change.\n * - The T from the render phase is only temporarily retained. It may have been\n *   disposed by the time of the commit. If so, this hook checks the parent cache\n *   for another T or creates one, and passes this T to onCommit.\n * - If the T returned during the last render is not the same as the one that\n *   is passed to onCommit, during the commit phase, it will schedule another render.\n *\n * Invariant: the returned T has not been disposed during the tick of the render.\n * The T passed to the onCommit callback has not been disposed when the onCommit\n * callback is called.\n *\n * Passing a different parentCache:\n * - Pre-commit, passing a different parentCache has the effect of \"resetting\" this\n *   hook's state to the new cache's state. For example, if you have a cache associated\n *   with a set of variables (e.g. {name: \"Matthew\"}), and pass in another cache\n *   (e.g. associated with {name: \"James\"}), which is empty, the hook will fill that\n *   new cache with the factory function.\n * - Post-commit, passing a different parentCache will reset hook to the pre-commit\n *   state. The cache will return T before commit, then fill the new cache with the\n *   factory function and return null afterwards.\n *\n * Passing a different factory:\n * - Passing a different factory has no effect, except when factory is called,\n *   which is when the parent cache is being filled, or during commit.\n *\n * Passing a different onCommit:\n * - Passing a different onCommit has no effect, except for during commit.\n */\nexport function useCachedResponsivePrecommitValue<T>(\n  parentCache: ParentCache<T>,\n  onCommit: (pair: ItemCleanupPair<T>) => void,\n): { state: T } | null {\n  // TODO: there should be two APIs. One in which we always re-render if the\n  // committed item was not returned during the last render, and one in which\n  // we do not. The latter is useful for cases where every disposable item\n  // behaves identically, but must be loaded.\n  //\n  // This hook is the former, i.e. re-renders if the committed item has changed.\n  const [, rerender] = useState<{} | null>(null);\n  const lastCommittedParentCache = useRef<ParentCache<T> | null>(null);\n\n  const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();\n\n  useEffect(() => {\n    lastCommittedParentCache.current = parentCache;\n    // On commit, cacheItem may be disposed, because during the render phase,\n    // we only temporarily retained the item, and the temporary retain could have\n    // expired by the time of the commit.\n    //\n    // So, we can be in one of two states:\n    // - the item is not disposed. In that case, permanently retain and use that item.\n    // - the item is disposed. In that case, we can be in two states:\n    //   - the parent cache is not empty (due to another component rendering, or\n    //     another render of the same component.) In that case, permanently retain and\n    //     use the item from the parent cache. (Note: any item present in the parent\n    //     cache is not disposed.)\n    //   - the parent cache is empty. In that case, call factory, getting a new item\n    //     and a cleanup function.\n    //\n    // After the above, we have a non-disposed item and a cleanup function, which we\n    // can pass to onCommit.\n    //\n    // When this effect runs again without a render (StrictMode's simulated\n    // remount, Fast Refresh, Activity), the render's temporary retain was\n    // already converted by the first run and released by the cleanup, so the\n    // item is re-acquired from the parent cache below instead.\n    if (!effectsRerunWithoutRenderRef.current) {\n      const undisposedPair = cacheItem.permanentRetainIfNotDisposed(\n        disposeOfTemporaryRetain,\n      );\n      if (undisposedPair != null) {\n        onCommit(undisposedPair);\n        return;\n      }\n    }\n    effectsRerunWithoutRenderRef.current = false;\n\n    // The cache item we created during render has been disposed. Check if the parent\n    // cache is populated.\n    const existingCacheItemCleanupPair =\n      parentCache.getAndPermanentRetainIfPresent();\n    if (existingCacheItemCleanupPair != null) {\n      onCommit(existingCacheItemCleanupPair);\n    } else {\n      // We did not find an item in the parent cache, create a new one.\n      onCommit(parentCache.factory());\n    }\n    // TODO: Consider whether we always want to rerender if the committed item\n    // was not returned during the last render, or whether some callers will\n    // prefer opting out of this behavior (e.g. if every disposable item behaves\n    // identically, but must be loaded.)\n    rerender({});\n  }, [parentCache]);\n\n  if (lastCommittedParentCache.current === parentCache) {\n    return null;\n  }\n\n  // Safety: item is only safe to use (i.e. guaranteed not to have been disposed)\n  // during this tick.\n  const [cacheItem, item, disposeOfTemporaryRetain] =\n    parentCache.getOrPopulateAndTemporaryRetain();\n\n  return { state: item };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,kCACd,aACA,UACqB;CAOrB,MAAM,GAAG,YAAY,SAAoB,KAAK;CAC9C,MAAM,2BAA2B,OAA8B,KAAK;CAEpE,MAAM,+BAA+B,iCAAiC;AAEtE,iBAAgB;AACd,2BAAyB,UAAU;AAsBnC,MAAI,CAAC,6BAA6B,SAAS;GACzC,MAAM,iBAAiB,UAAU,6BAC/B,yBACD;AACD,OAAI,kBAAkB,MAAM;AAC1B,aAAS,eAAe;AACxB;;;AAGJ,+BAA6B,UAAU;EAIvC,MAAM,+BACJ,YAAY,gCAAgC;AAC9C,MAAI,gCAAgC,KAClC,UAAS,6BAA6B;MAGtC,UAAS,YAAY,SAAS,CAAC;AAMjC,WAAS,EAAE,CAAC;IACX,CAAC,YAAY,CAAC;AAEjB,KAAI,yBAAyB,YAAY,YACvC,QAAO;CAKT,MAAM,CAAC,WAAW,MAAM,4BACtB,YAAY,iCAAiC;AAE/C,QAAO,EAAE,OAAO,MAAM"}

package/dist/useDisposableState.cjs

@@ -6,15 +6,16 @@ let react = require("react");
 function useDisposableState(parentCache) {
 	const itemCleanupPairRef = (0, react.useRef)(null);
 	const preCommitItem = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	const { state: stateFromDisposableStateHook, setState } = require_useUpdatableDisposableState.useUpdatableDisposableState();
 	(0, react.useEffect)(function cleanupItemCleanupPairRefAfterSetState() {
-		if (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE) if (itemCleanupPairRef.current != null) {
-			itemCleanupPairRef.current[1]();
-			itemCleanupPairRef.current = null;
-		} else throw new Error("itemCleanupPairRef.current is unexpectedly null. This indicates a bug in react-disposable-state.");
+		if (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE) {
+			if (itemCleanupPairRef.current != null) {
+				itemCleanupPairRef.current[1]();
+				itemCleanupPairRef.current = null;
+			}
+		}
 	}, [stateFromDisposableStateHook]);
 	(0, react.useEffect)(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
 		return () => {
@@ -23,7 +24,7 @@ function useDisposableState(parentCache) {
 				itemCleanupPairRef.current = null;
 			}
 		};
-	}, []);
+	}, [parentCache]);
 	const state = (stateFromDisposableStateHook !== require_useUpdatableDisposableState.UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ?? preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (state != null) return {
 		state,

package/dist/useDisposableState.mjs

@@ -6,15 +6,16 @@ import { useEffect, useRef } from "react";
 function useDisposableState(parentCache) {
 	const itemCleanupPairRef = useRef(null);
 	const preCommitItem = useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	const { state: stateFromDisposableStateHook, setState } = useUpdatableDisposableState();
 	useEffect(function cleanupItemCleanupPairRefAfterSetState() {
-		if (stateFromDisposableStateHook !== UNASSIGNED_STATE) if (itemCleanupPairRef.current != null) {
-			itemCleanupPairRef.current[1]();
-			itemCleanupPairRef.current = null;
-		} else throw new Error("itemCleanupPairRef.current is unexpectedly null. This indicates a bug in react-disposable-state.");
+		if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {
+			if (itemCleanupPairRef.current != null) {
+				itemCleanupPairRef.current[1]();
+				itemCleanupPairRef.current = null;
+			}
+		}
 	}, [stateFromDisposableStateHook]);
 	useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
 		return () => {
@@ -23,7 +24,7 @@ function useDisposableState(parentCache) {
 				itemCleanupPairRef.current = null;
 			}
 		};
-	}, []);
+	}, [parentCache]);
 	const state = (stateFromDisposableStateHook !== UNASSIGNED_STATE ? stateFromDisposableStateHook : null) ?? preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (state != null) return {
 		state,

package/dist/useDisposableState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useDisposableState.mjs","names":[],"sources":["../src/useDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport {\n  UNASSIGNED_STATE,\n  type UnassignedState,\n  useUpdatableDisposableState,\n} from './useUpdatableDisposableState';\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\nexport function useDisposableState<T = never>(\n  parentCache: ParentCache<T>,\n): UseUpdatableDisposableStateReturnValue<T> {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current?.[1]();\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  const { state: stateFromDisposableStateHook, setState } =\n    useUpdatableDisposableState<T>();\n\n  useEffect(\n    function cleanupItemCleanupPairRefAfterSetState() {\n      if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {\n        if (itemCleanupPairRef.current != null) {\n          itemCleanupPairRef.current[1]();\n          itemCleanupPairRef.current = null;\n        } else {\n          throw new Error(\n            'itemCleanupPairRef.current is unexpectedly null. ' +\n              'This indicates a bug in react-disposable-state.',\n          );\n        }\n      }\n    },\n    [stateFromDisposableStateHook],\n  );\n\n  useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {\n    return () => {\n      if (itemCleanupPairRef.current != null) {\n        itemCleanupPairRef.current[1]();\n        itemCleanupPairRef.current = null;\n      }\n    };\n  }, []);\n  const state: T | undefined =\n    (stateFromDisposableStateHook !== UNASSIGNED_STATE\n      ? stateFromDisposableStateHook\n      : null) ??\n    preCommitItem?.state ??\n    itemCleanupPairRef.current?.[0];\n\n  if (state != null) {\n    return {\n      state: state,\n      setState,\n    };\n  }\n\n  // Safety: we can be in one of three states. Pre-commit, in which case\n  // preCommitItem is assigned, post-commit but before setState has been\n  // called, in which case itemCleanupPairRef.current is assigned, or\n  // after setState has been called, in which case\n  // stateFromDisposableStateHook is assigned.\n  //\n  // Therefore, the type of state is T, not T | undefined. But the fact\n  // that we are in one of the three states is not reflected in the types.\n  // So we have to cast to T.\n  //\n  // Note that in the post-commit post-setState state, itemCleanupPairRef\n  // can still be assigned, during the render before the\n  // cleanupItemCleanupPairRefAfterSetState effect is called.\n  throw new Error(\n    'state was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let x: any;\n  const a = useDisposableState(x);\n  // This should be a compiler error, because the generic is inferred to be of\n  // type never. TODO determine why this doesn't break the build!\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  const b = useDisposableState<string | UnassignedState>(x);\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;;AAeA,SAAgB,mBACd,aAC2C;CAC3C,MAAM,qBAAqB,OAAkC,KAAK;CAElE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU,IAAI;AACjC,qBAAmB,UAAU;GAEhC;CAED,MAAM,EAAE,OAAO,8BAA8B,aAC3C,6BAAgC;AAElC,WACE,SAAS,yCAAyC;AAChD,MAAI,iCAAiC,iBACnC,KAAI,mBAAmB,WAAW,MAAM;AACtC,sBAAmB,QAAQ,IAAI;AAC/B,sBAAmB,UAAU;QAE7B,OAAM,IAAI,MACR,mGAED;IAIP,CAAC,6BAA6B,CAC/B;AAED,WAAU,SAAS,+CAA+C;AAChE,eAAa;AACX,OAAI,mBAAmB,WAAW,MAAM;AACtC,uBAAmB,QAAQ,IAAI;AAC/B,uBAAmB,UAAU;;;IAGhC,EAAE,CAAC;CACN,MAAM,SACH,iCAAiC,mBAC9B,+BACA,SACJ,eAAe,SACf,mBAAmB,UAAU;AAE/B,KAAI,SAAS,KACX,QAAO;EACE;EACP;EACD;AAgBH,OAAM,IAAI,MACR,+EACD"}
+{"version":3,"file":"useDisposableState.mjs","names":[],"sources":["../src/useDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport {\n  UNASSIGNED_STATE,\n  type UnassignedState,\n  useUpdatableDisposableState,\n} from './useUpdatableDisposableState';\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\nexport function useDisposableState<T = never>(\n  parentCache: ParentCache<T>,\n): UseUpdatableDisposableStateReturnValue<T> {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  const { state: stateFromDisposableStateHook, setState } =\n    useUpdatableDisposableState<T>();\n\n  useEffect(\n    function cleanupItemCleanupPairRefAfterSetState() {\n      if (stateFromDisposableStateHook !== UNASSIGNED_STATE) {\n        if (itemCleanupPairRef.current != null) {\n          itemCleanupPairRef.current[1]();\n          itemCleanupPairRef.current = null;\n        }\n      }\n    },\n    [stateFromDisposableStateHook],\n  );\n\n  useEffect(\n    function cleanupItemCleanupPairRefIfSetStateNotCalled() {\n      return () => {\n        if (itemCleanupPairRef.current != null) {\n          itemCleanupPairRef.current[1]();\n          // Forgotten so that nothing can release this pair a second time\n          // before an effect re-run (StrictMode, Fast Refresh) stores a new one.\n          itemCleanupPairRef.current = null;\n        }\n      };\n    },\n    [parentCache],\n  );\n  const state: T | undefined =\n    (stateFromDisposableStateHook !== UNASSIGNED_STATE\n      ? stateFromDisposableStateHook\n      : null) ??\n    preCommitItem?.state ??\n    itemCleanupPairRef.current?.[0];\n\n  if (state != null) {\n    return {\n      state: state,\n      setState,\n    };\n  }\n  // Safety: we can be in one of three states. Pre-commit, in which case\n  // preCommitItem is assigned, post-commit but before setState has been\n  // called, in which case itemCleanupPairRef.current is assigned, or\n  // after setState has been called, in which case\n  // stateFromDisposableStateHook is assigned.\n  //\n  // Therefore, the type of state is T, not T | undefined. But the fact\n  // that we are in one of the three states is not reflected in the types.\n  // So we have to cast to T.\n  //\n  // Note that in the post-commit post-setState state, itemCleanupPairRef\n  // can still be assigned, during the render before the\n  // cleanupItemCleanupPairRefAfterSetState effect is called.\n  throw new Error(\n    'state was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n\n// @ts-ignore\nfunction tsTests() {\n  let x: any;\n  const a = useDisposableState(x);\n  // This should be a compiler error, because the generic is inferred to be of\n  // type never. TODO determine why this doesn't break the build!\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  const b = useDisposableState<string | UnassignedState>(x);\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;;AAeA,SAAgB,mBACd,aAC2C;CAC3C,MAAM,qBAAqB,OAAkC,KAAK;CAElE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU;GAEhC;CAED,MAAM,EAAE,OAAO,8BAA8B,aAC3C,6BAAgC;AAElC,WACE,SAAS,yCAAyC;AAChD,MAAI,iCAAiC,kBACnC;OAAI,mBAAmB,WAAW,MAAM;AACtC,uBAAmB,QAAQ,IAAI;AAC/B,uBAAmB,UAAU;;;IAInC,CAAC,6BAA6B,CAC/B;AAED,WACE,SAAS,+CAA+C;AACtD,eAAa;AACX,OAAI,mBAAmB,WAAW,MAAM;AACtC,uBAAmB,QAAQ,IAAI;AAG/B,uBAAmB,UAAU;;;IAInC,CAAC,YAAY,CACd;CACD,MAAM,SACH,iCAAiC,mBAC9B,+BACA,SACJ,eAAe,SACf,mBAAmB,UAAU;AAE/B,KAAI,SAAS,KACX,QAAO;EACE;EACP;EACD;AAeH,OAAM,IAAI,MACR,+EACD"}

package/dist/useEffectsRerunWithoutRender.cjs

@@ -0,0 +1,27 @@
+let react = require("react");
+
+//#region src/useEffectsRerunWithoutRender.ts
+/**
+* Detects that React is running this component's effects again without a
+* render in between. That happens on StrictMode's simulated unmount and
+* remount on the first commit, on Fast Refresh, and when an `Activity`
+* boundary hides and then shows the component. In each case React runs every
+* effect's cleanup and then its mount, so a cleanup that sets a flag is
+* observable from the mounts that follow.
+*
+* Returns a ref whose `current` is `true` from the moment the cleanup ran until
+* the caller resets it. The effect that must tell a re-run apart from a first
+* mount reads it and sets it back to `false`; nothing else clears it.
+*/
+function useEffectsRerunWithoutRenderRef() {
+	const effectsRerunWithoutRenderRef = (0, react.useRef)(false);
+	(0, react.useEffect)(() => {
+		return () => {
+			effectsRerunWithoutRenderRef.current = true;
+		};
+	}, []);
+	return effectsRerunWithoutRenderRef;
+}
+
+//#endregion
+exports.useEffectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef;

package/dist/useEffectsRerunWithoutRender.d.cts

@@ -0,0 +1,19 @@
+import { MutableRefObject } from "react";
+
+//#region src/useEffectsRerunWithoutRender.d.ts
+/**
+ * Detects that React is running this component's effects again without a
+ * render in between. That happens on StrictMode's simulated unmount and
+ * remount on the first commit, on Fast Refresh, and when an `Activity`
+ * boundary hides and then shows the component. In each case React runs every
+ * effect's cleanup and then its mount, so a cleanup that sets a flag is
+ * observable from the mounts that follow.
+ *
+ * Returns a ref whose `current` is `true` from the moment the cleanup ran until
+ * the caller resets it. The effect that must tell a re-run apart from a first
+ * mount reads it and sets it back to `false`; nothing else clears it.
+ */
+declare function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean>;
+//#endregion
+export { useEffectsRerunWithoutRenderRef };
+//# sourceMappingURL=useEffectsRerunWithoutRender.d.cts.map

package/dist/useEffectsRerunWithoutRender.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectsRerunWithoutRender.d.cts","names":[],"sources":["../src/useEffectsRerunWithoutRender.ts"],"mappings":";;;;;AAcA;;;;;;;;;;iBAAgB,+BAAA,CAAA,GAAmC,gBAAA"}

package/dist/useEffectsRerunWithoutRender.d.mts

@@ -0,0 +1,19 @@
+import { MutableRefObject } from "react";
+
+//#region src/useEffectsRerunWithoutRender.d.ts
+/**
+ * Detects that React is running this component's effects again without a
+ * render in between. That happens on StrictMode's simulated unmount and
+ * remount on the first commit, on Fast Refresh, and when an `Activity`
+ * boundary hides and then shows the component. In each case React runs every
+ * effect's cleanup and then its mount, so a cleanup that sets a flag is
+ * observable from the mounts that follow.
+ *
+ * Returns a ref whose `current` is `true` from the moment the cleanup ran until
+ * the caller resets it. The effect that must tell a re-run apart from a first
+ * mount reads it and sets it back to `false`; nothing else clears it.
+ */
+declare function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean>;
+//#endregion
+export { useEffectsRerunWithoutRenderRef };
+//# sourceMappingURL=useEffectsRerunWithoutRender.d.mts.map

package/dist/useEffectsRerunWithoutRender.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectsRerunWithoutRender.d.mts","names":[],"sources":["../src/useEffectsRerunWithoutRender.ts"],"mappings":";;;;;AAcA;;;;;;;;;;iBAAgB,+BAAA,CAAA,GAAmC,gBAAA"}

package/dist/useEffectsRerunWithoutRender.mjs

@@ -0,0 +1,28 @@
+import { useEffect, useRef } from "react";
+
+//#region src/useEffectsRerunWithoutRender.ts
+/**
+* Detects that React is running this component's effects again without a
+* render in between. That happens on StrictMode's simulated unmount and
+* remount on the first commit, on Fast Refresh, and when an `Activity`
+* boundary hides and then shows the component. In each case React runs every
+* effect's cleanup and then its mount, so a cleanup that sets a flag is
+* observable from the mounts that follow.
+*
+* Returns a ref whose `current` is `true` from the moment the cleanup ran until
+* the caller resets it. The effect that must tell a re-run apart from a first
+* mount reads it and sets it back to `false`; nothing else clears it.
+*/
+function useEffectsRerunWithoutRenderRef() {
+	const effectsRerunWithoutRenderRef = useRef(false);
+	useEffect(() => {
+		return () => {
+			effectsRerunWithoutRenderRef.current = true;
+		};
+	}, []);
+	return effectsRerunWithoutRenderRef;
+}
+
+//#endregion
+export { useEffectsRerunWithoutRenderRef };
+//# sourceMappingURL=useEffectsRerunWithoutRender.mjs.map

package/dist/useEffectsRerunWithoutRender.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEffectsRerunWithoutRender.mjs","names":[],"sources":["../src/useEffectsRerunWithoutRender.ts"],"sourcesContent":["import { type MutableRefObject, useEffect, useRef } from 'react';\n\n/**\n * Detects that React is running this component's effects again without a\n * render in between. That happens on StrictMode's simulated unmount and\n * remount on the first commit, on Fast Refresh, and when an `Activity`\n * boundary hides and then shows the component. In each case React runs every\n * effect's cleanup and then its mount, so a cleanup that sets a flag is\n * observable from the mounts that follow.\n *\n * Returns a ref whose `current` is `true` from the moment the cleanup ran until\n * the caller resets it. The effect that must tell a re-run apart from a first\n * mount reads it and sets it back to `false`; nothing else clears it.\n */\nexport function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean> {\n  const effectsRerunWithoutRenderRef = useRef(false);\n  useEffect(() => {\n    return () => {\n      effectsRerunWithoutRenderRef.current = true;\n    };\n  }, []);\n  return effectsRerunWithoutRenderRef;\n}\n"],"mappings":";;;;;;;;;;;;;;;AAcA,SAAgB,kCAA6D;CAC3E,MAAM,+BAA+B,OAAO,MAAM;AAClD,iBAAgB;AACd,eAAa;AACX,gCAA6B,UAAU;;IAExC,EAAE,CAAC;AACN,QAAO"}

package/dist/useLazyDisposableState.cjs

@@ -16,16 +16,16 @@ let react = require("react");
 function useLazyDisposableState(parentCache) {
 	const itemCleanupPairRef = (0, react.useRef)(null);
 	const preCommitItem = require_useCachedResponsivePrecommitValue.useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	(0, react.useEffect)(() => {
 		return () => {
 			const cleanupFn = itemCleanupPairRef.current?.[1];
 			if (cleanupFn == null) throw new Error("cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.");
-			return cleanupFn();
+			cleanupFn();
+			itemCleanupPairRef.current = null;
 		};
-	}, []);
+	}, [parentCache]);
 	const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (returnedItem != null) return { state: returnedItem };
 	throw new Error("returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.");

package/dist/useLazyDisposableState.mjs

@@ -14,16 +14,16 @@ import { useEffect, useRef } from "react";
 function useLazyDisposableState(parentCache) {
 	const itemCleanupPairRef = useRef(null);
 	const preCommitItem = useCachedResponsivePrecommitValue(parentCache, (pair) => {
-		itemCleanupPairRef.current?.[1]();
 		itemCleanupPairRef.current = pair;
 	});
 	useEffect(() => {
 		return () => {
 			const cleanupFn = itemCleanupPairRef.current?.[1];
 			if (cleanupFn == null) throw new Error("cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.");
-			return cleanupFn();
+			cleanupFn();
+			itemCleanupPairRef.current = null;
 		};
-	}, []);
+	}, [parentCache]);
 	const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 	if (returnedItem != null) return { state: returnedItem };
 	throw new Error("returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.");

package/dist/useLazyDisposableState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useLazyDisposableState.mjs","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport { type UnassignedState } from './useUpdatableDisposableState';\n\n/**\n * useLazyDisposableState<T>\n * - Takes a mutable parent cache and a factory function\n * - Returns { state: T }\n *\n * This lazily loads the disposable item using useCachedResponsivePrecommitValue, then\n * (on commit) sets it in state. The item continues to be returned after\n * commit and is disposed when the hook unmounts.\n */\nexport function useLazyDisposableState<T>(\n  parentCache: ParentCache<Exclude<T, UnassignedState>>,\n): {\n  state: T;\n} {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current?.[1]();\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  useEffect(() => {\n    return () => {\n      const cleanupFn = itemCleanupPairRef.current?.[1];\n      // TODO confirm useEffect is called in order.\n      if (cleanupFn == null) {\n        throw new Error(\n          'cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.',\n        );\n      }\n      return cleanupFn();\n    };\n  }, []);\n\n  const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];\n\n  if (returnedItem != null) {\n    return { state: returnedItem };\n  }\n\n  // Safety: This can't happen. For renders before the initial commit, preCommitItem\n  // is non-null. During the initial commit, we assign itemCleanupPairRef.current,\n  // so during subsequent renders, itemCleanupPairRef.current is non-null.\n  throw new Error(\n    'returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,uBACd,aAGA;CACA,MAAM,qBAAqB,OAAkC,KAAK;CAElE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU,IAAI;AACjC,qBAAmB,UAAU;GAEhC;AAED,iBAAgB;AACd,eAAa;GACX,MAAM,YAAY,mBAAmB,UAAU;AAE/C,OAAI,aAAa,KACf,OAAM,IAAI,MACR,+EACD;AAEH,UAAO,WAAW;;IAEnB,EAAE,CAAC;CAEN,MAAM,eAAe,eAAe,SAAS,mBAAmB,UAAU;AAE1E,KAAI,gBAAgB,KAClB,QAAO,EAAE,OAAO,cAAc;AAMhC,OAAM,IAAI,MACR,sFACD"}
+{"version":3,"file":"useLazyDisposableState.mjs","names":[],"sources":["../src/useLazyDisposableState.ts"],"sourcesContent":["'use strict';\n\nimport type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useEffect, useRef } from 'react';\nimport type { ParentCache } from './ParentCache';\nimport { useCachedResponsivePrecommitValue } from './useCachedResponsivePrecommitValue';\nimport { type UnassignedState } from './useUpdatableDisposableState';\n\n/**\n * useLazyDisposableState<T>\n * - Takes a mutable parent cache and a factory function\n * - Returns { state: T }\n *\n * This lazily loads the disposable item using useCachedResponsivePrecommitValue, then\n * (on commit) sets it in state. The item continues to be returned after\n * commit and is disposed when the hook unmounts.\n */\nexport function useLazyDisposableState<T>(\n  parentCache: ParentCache<Exclude<T, UnassignedState>>,\n): {\n  state: T;\n} {\n  const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);\n  const preCommitItem = useCachedResponsivePrecommitValue(\n    parentCache,\n    (pair) => {\n      itemCleanupPairRef.current = pair;\n    },\n  );\n\n  useEffect(() => {\n    return () => {\n      const cleanupFn = itemCleanupPairRef.current?.[1];\n      // TODO confirm useEffect is called in order.\n      if (cleanupFn == null) {\n        throw new Error(\n          'cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.',\n        );\n      }\n      cleanupFn();\n      itemCleanupPairRef.current = null;\n    };\n  }, [parentCache]);\n\n  const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];\n\n  if (returnedItem != null) {\n    return { state: returnedItem };\n  }\n\n  // Safety: This can't happen. For renders before the initial commit, preCommitItem\n  // is non-null. During the initial commit, we assign itemCleanupPairRef.current,\n  // so during subsequent renders, itemCleanupPairRef.current is non-null.\n  throw new Error(\n    'returnedItem was unexpectedly null. This indicates a bug in react-disposable-state.',\n  );\n}\n"],"mappings":";;;;;;;;;;;;;AAiBA,SAAgB,uBACd,aAGA;CACA,MAAM,qBAAqB,OAAkC,KAAK;CAClE,MAAM,gBAAgB,kCACpB,cACC,SAAS;AACR,qBAAmB,UAAU;GAEhC;AAED,iBAAgB;AACd,eAAa;GACX,MAAM,YAAY,mBAAmB,UAAU;AAE/C,OAAI,aAAa,KACf,OAAM,IAAI,MACR,+EACD;AAEH,cAAW;AACX,sBAAmB,UAAU;;IAE9B,CAAC,YAAY,CAAC;CAEjB,MAAM,eAAe,eAAe,SAAS,mBAAmB,UAAU;AAE1E,KAAI,gBAAgB,KAClB,QAAO,EAAE,OAAO,cAAc;AAMhC,OAAM,IAAI,MACR,sFACD"}

package/dist/useUpdatableDisposableState.cjs

@@ -60,7 +60,11 @@ function useUpdatableDisposableState() {
 	});
 	(0, react.useEffect)(() => {
 		return function disposeAllRemainingItems() {
-			for (const undisposedICI of undisposedICIs.current) undisposedICI.cleanup();
+			for (const undisposedICI of undisposedICIs.current) {
+				undisposedICIs.current.delete(undisposedICI);
+				undisposedICI.cleanup();
+			}
+			setStateICI(UNASSIGNED_STATE);
 		};
 	}, []);
 	return {

package/dist/useUpdatableDisposableState.mjs

@@ -60,7 +60,11 @@ function useUpdatableDisposableState() {
 	});
 	useEffect(() => {
 		return function disposeAllRemainingItems() {
-			for (const undisposedICI of undisposedICIs.current) undisposedICI.cleanup();
+			for (const undisposedICI of undisposedICIs.current) {
+				undisposedICIs.current.delete(undisposedICI);
+				undisposedICI.cleanup();
+			}
+			setStateICI(UNASSIGNED_STATE);
 		};
 	}, []);
 	return {

package/dist/useUpdatableDisposableState.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"useUpdatableDisposableState.mjs","names":[],"sources":["../src/useUpdatableDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { useHasCommittedRef } from './useHasCommittedRef';\n\nexport const UNASSIGNED_STATE: unique symbol = Symbol();\nexport type UnassignedState = typeof UNASSIGNED_STATE;\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T | UnassignedState;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\n/**\n * ICI stands for ItemCleanupIndex. Use a short name because it shows up a lot.\n *\n * Like an ItemCleanupPair<T>, but with an additional index and as a struct\n * for readability.\n *\n * Interally, we must keep track of the index of the state change. The disposable\n * items that are set in state are not guaranteed to be distinct according to ===,\n * as in `setState([1, dispose1]); setState([1, dispose2])`. Following this, we\n * would expect dispose1 to be called on commit. If state items were compared for\n * ===, then dispose1 would not be called in such a situation.\n *\n * Note that this comes at a runtime cost, and we may want to expose APIs that do\n * not incur this runtime cost, for example in cases where every disposable item is\n * distinguishable via ===.\n */\ntype ICI<T> = { item: T; cleanup: () => void; index: number };\n\n/**\n * useUpdatableDisposableState\n * - Returns a { state, setItem } object.\n * - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.\n * - setItem sets the T in state and adds it to a set.\n * - React's behavior is that when the hook commits, whatever item is currently\n *   returned from the useState hook is the oldest item which will ever be returned\n *   from that useState hook. (More newly created ones can later be returned with\n *   concurrent mode.)\n * - When this hook commits, all items up to, but not including, the item currently\n *   returned from the useState hook are disposed and removed from the set.\n *\n * Calling setState before the hook commits:\n * - Calling setState before the hook commits is disallowed because until the hook\n *   commits, React will not schedule any unmount callbacks, meaning that if this\n *   hook never commits, any disposable items passed to setState will never be\n *   disposed.\n * - We also cannot store them in some cache, because multiple components can share\n *   the same cache location (for example, if they are loading the same query from\n *   multiple components), so updating the cache with the disposable item will cause\n *   both components to show the updated data, which is almost certainly a bug.\n * - Note that calling setState before commit is probably an anti-pattern! Consider\n *   not doing it.\n * - If you must, the workaround is to lazily load the disposable item with\n *   useDisposableState or useLazyDisposableState, and update the cache location\n *   instead of calling setState before commit. One can update the cache location\n *   by calling setState on some parent component that has already mounted, and\n *   therefore passing in different props.\n *   - This may only work in concurrent mode, though.\n */\nexport function useUpdatableDisposableState<\n  T = never,\n>(): UseUpdatableDisposableStateReturnValue<T> {\n  const hasCommittedRef = useHasCommittedRef();\n\n  const undisposedICIs = useRef(new Set<ICI<T>>());\n  const setStateCountRef = useRef(0);\n\n  const [stateICI, setStateICI] = useState<ICI<T> | UnassignedState>(\n    UNASSIGNED_STATE,\n  );\n\n  const setStateAfterCommit = useCallback(\n    (itemCleanupPair: ItemCleanupPair<T>) => {\n      if (!hasCommittedRef.current) {\n        throw new Error(\n          'Calling setState before the component has committed is unsafe and disallowed.',\n        );\n      }\n\n      const ici: ICI<T> = {\n        item: itemCleanupPair[0],\n        cleanup: itemCleanupPair[1],\n        index: setStateCountRef.current,\n      };\n      setStateCountRef.current++;\n      undisposedICIs.current.add(ici);\n      setStateICI(ici);\n    },\n    [setStateICI],\n  );\n\n  useEffect(function cleanupUnreachableItems() {\n    const indexInState = stateICI !== UNASSIGNED_STATE ? stateICI.index : 0;\n\n    if (indexInState === 0) {\n      return;\n    }\n\n    for (const undisposedICI of undisposedICIs.current) {\n      if (undisposedICI.index === indexInState) {\n        break;\n      }\n      undisposedICIs.current.delete(undisposedICI);\n      undisposedICI.cleanup();\n    }\n  });\n\n  useEffect(() => {\n    return function disposeAllRemainingItems() {\n      for (const undisposedICI of undisposedICIs.current) {\n        undisposedICI.cleanup();\n      }\n    };\n  }, []);\n\n  return {\n    setState: setStateAfterCommit,\n    state: stateICI !== UNASSIGNED_STATE ? stateICI.item : UNASSIGNED_STATE,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  const a = useUpdatableDisposableState();\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  const b = useUpdatableDisposableState<string | UnassignedState>();\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;AAIA,MAAa,mBAAkC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDvD,SAAgB,8BAE+B;CAC7C,MAAM,kBAAkB,oBAAoB;CAE5C,MAAM,iBAAiB,uBAAO,IAAI,KAAa,CAAC;CAChD,MAAM,mBAAmB,OAAO,EAAE;CAElC,MAAM,CAAC,UAAU,eAAe,SAC9B,iBACD;CAED,MAAM,sBAAsB,aACzB,oBAAwC;AACvC,MAAI,CAAC,gBAAgB,QACnB,OAAM,IAAI,MACR,gFACD;EAGH,MAAM,MAAc;GAClB,MAAM,gBAAgB;GACtB,SAAS,gBAAgB;GACzB,OAAO,iBAAiB;GACzB;AACD,mBAAiB;AACjB,iBAAe,QAAQ,IAAI,IAAI;AAC/B,cAAY,IAAI;IAElB,CAAC,YAAY,CACd;AAED,WAAU,SAAS,0BAA0B;EAC3C,MAAM,eAAe,aAAa,mBAAmB,SAAS,QAAQ;AAEtE,MAAI,iBAAiB,EACnB;AAGF,OAAK,MAAM,iBAAiB,eAAe,SAAS;AAClD,OAAI,cAAc,UAAU,aAC1B;AAEF,kBAAe,QAAQ,OAAO,cAAc;AAC5C,iBAAc,SAAS;;GAEzB;AAEF,iBAAgB;AACd,SAAO,SAAS,2BAA2B;AACzC,QAAK,MAAM,iBAAiB,eAAe,QACzC,eAAc,SAAS;;IAG1B,EAAE,CAAC;AAEN,QAAO;EACL,UAAU;EACV,OAAO,aAAa,mBAAmB,SAAS,OAAO;EACxD"}
+{"version":3,"file":"useUpdatableDisposableState.mjs","names":[],"sources":["../src/useUpdatableDisposableState.ts"],"sourcesContent":["import type { ItemCleanupPair } from '@isograph/disposable-types';\nimport { useCallback, useEffect, useRef, useState } from 'react';\nimport { useHasCommittedRef } from './useHasCommittedRef';\n\nexport const UNASSIGNED_STATE: unique symbol = Symbol();\nexport type UnassignedState = typeof UNASSIGNED_STATE;\n\ntype UseUpdatableDisposableStateReturnValue<T> = {\n  state: T | UnassignedState;\n  setState: (pair: ItemCleanupPair<Exclude<T, UnassignedState>>) => void;\n};\n\n/**\n * ICI stands for ItemCleanupIndex. Use a short name because it shows up a lot.\n *\n * Like an ItemCleanupPair<T>, but with an additional index and as a struct\n * for readability.\n *\n * Interally, we must keep track of the index of the state change. The disposable\n * items that are set in state are not guaranteed to be distinct according to ===,\n * as in `setState([1, dispose1]); setState([1, dispose2])`. Following this, we\n * would expect dispose1 to be called on commit. If state items were compared for\n * ===, then dispose1 would not be called in such a situation.\n *\n * Note that this comes at a runtime cost, and we may want to expose APIs that do\n * not incur this runtime cost, for example in cases where every disposable item is\n * distinguishable via ===.\n */\ntype ICI<T> = { item: T; cleanup: () => void; index: number };\n\n/**\n * useUpdatableDisposableState\n * - Returns a { state, setItem } object.\n * - setItem accepts an ItemCleanupPair<T>, and throws if called before commit.\n * - setItem sets the T in state and adds it to a set.\n * - React's behavior is that when the hook commits, whatever item is currently\n *   returned from the useState hook is the oldest item which will ever be returned\n *   from that useState hook. (More newly created ones can later be returned with\n *   concurrent mode.)\n * - When this hook commits, all items up to, but not including, the item currently\n *   returned from the useState hook are disposed and removed from the set.\n *\n * Calling setState before the hook commits:\n * - Calling setState before the hook commits is disallowed because until the hook\n *   commits, React will not schedule any unmount callbacks, meaning that if this\n *   hook never commits, any disposable items passed to setState will never be\n *   disposed.\n * - We also cannot store them in some cache, because multiple components can share\n *   the same cache location (for example, if they are loading the same query from\n *   multiple components), so updating the cache with the disposable item will cause\n *   both components to show the updated data, which is almost certainly a bug.\n * - Note that calling setState before commit is probably an anti-pattern! Consider\n *   not doing it.\n * - If you must, the workaround is to lazily load the disposable item with\n *   useDisposableState or useLazyDisposableState, and update the cache location\n *   instead of calling setState before commit. One can update the cache location\n *   by calling setState on some parent component that has already mounted, and\n *   therefore passing in different props.\n *   - This may only work in concurrent mode, though.\n */\nexport function useUpdatableDisposableState<\n  T = never,\n>(): UseUpdatableDisposableStateReturnValue<T> {\n  const hasCommittedRef = useHasCommittedRef();\n\n  const undisposedICIs = useRef(new Set<ICI<T>>());\n  const setStateCountRef = useRef(0);\n\n  const [stateICI, setStateICI] = useState<ICI<T> | UnassignedState>(\n    UNASSIGNED_STATE,\n  );\n\n  const setStateAfterCommit = useCallback(\n    (itemCleanupPair: ItemCleanupPair<T>) => {\n      if (!hasCommittedRef.current) {\n        throw new Error(\n          'Calling setState before the component has committed is unsafe and disallowed.',\n        );\n      }\n\n      const ici: ICI<T> = {\n        item: itemCleanupPair[0],\n        cleanup: itemCleanupPair[1],\n        index: setStateCountRef.current,\n      };\n      setStateCountRef.current++;\n      undisposedICIs.current.add(ici);\n      setStateICI(ici);\n    },\n    [setStateICI],\n  );\n\n  useEffect(function cleanupUnreachableItems() {\n    const indexInState = stateICI !== UNASSIGNED_STATE ? stateICI.index : 0;\n\n    if (indexInState === 0) {\n      return;\n    }\n\n    for (const undisposedICI of undisposedICIs.current) {\n      if (undisposedICI.index === indexInState) {\n        break;\n      }\n      undisposedICIs.current.delete(undisposedICI);\n      undisposedICI.cleanup();\n    }\n  });\n\n  useEffect(() => {\n    return function disposeAllRemainingItems() {\n      for (const undisposedICI of undisposedICIs.current) {\n        undisposedICIs.current.delete(undisposedICI);\n        undisposedICI.cleanup();\n      }\n      setStateICI(UNASSIGNED_STATE);\n    };\n  }, []);\n\n  return {\n    setState: setStateAfterCommit,\n    state: stateICI !== UNASSIGNED_STATE ? stateICI.item : UNASSIGNED_STATE,\n  };\n}\n\n// @ts-ignore\nfunction tsTests() {\n  const a = useUpdatableDisposableState();\n  // @ts-expect-error\n  a.setState([UNASSIGNED_STATE, () => {}]);\n  // @ts-expect-error\n  a.setState(['asdf', () => {}]);\n  const b = useUpdatableDisposableState<string | UnassignedState>();\n  // @ts-expect-error\n  b.setState([UNASSIGNED_STATE, () => {}]);\n  b.setState(['asdf', () => {}]);\n}\n"],"mappings":";;;;AAIA,MAAa,mBAAkC,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDvD,SAAgB,8BAE+B;CAC7C,MAAM,kBAAkB,oBAAoB;CAE5C,MAAM,iBAAiB,uBAAO,IAAI,KAAa,CAAC;CAChD,MAAM,mBAAmB,OAAO,EAAE;CAElC,MAAM,CAAC,UAAU,eAAe,SAC9B,iBACD;CAED,MAAM,sBAAsB,aACzB,oBAAwC;AACvC,MAAI,CAAC,gBAAgB,QACnB,OAAM,IAAI,MACR,gFACD;EAGH,MAAM,MAAc;GAClB,MAAM,gBAAgB;GACtB,SAAS,gBAAgB;GACzB,OAAO,iBAAiB;GACzB;AACD,mBAAiB;AACjB,iBAAe,QAAQ,IAAI,IAAI;AAC/B,cAAY,IAAI;IAElB,CAAC,YAAY,CACd;AAED,WAAU,SAAS,0BAA0B;EAC3C,MAAM,eAAe,aAAa,mBAAmB,SAAS,QAAQ;AAEtE,MAAI,iBAAiB,EACnB;AAGF,OAAK,MAAM,iBAAiB,eAAe,SAAS;AAClD,OAAI,cAAc,UAAU,aAC1B;AAEF,kBAAe,QAAQ,OAAO,cAAc;AAC5C,iBAAc,SAAS;;GAEzB;AAEF,iBAAgB;AACd,SAAO,SAAS,2BAA2B;AACzC,QAAK,MAAM,iBAAiB,eAAe,SAAS;AAClD,mBAAe,QAAQ,OAAO,cAAc;AAC5C,kBAAc,SAAS;;AAEzB,eAAY,iBAAiB;;IAE9B,EAAE,CAAC;AAEN,QAAO;EACL,UAAU;EACV,OAAO,aAAa,mBAAmB,SAAS,OAAO;EACxD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react-disposable-state",
-  "version": "0.0.0-main-a8e129cf",
+  "version": "0.0.0-main-1ba744d7",
   "description": "Primitives for managing disposable state in React",
   "homepage": "https://isograph.dev",
   "main": "./dist/index.cjs",
@@ -8,13 +8,16 @@
   "author": "Isograph Labs",
   "license": "MIT",
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-a8e129cf"
+    "@isograph/disposable-types": "0.0.0-main-1ba744d7"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {
+    "@testing-library/react": "16.3.2",
     "@types/react": "18.3.1",
+    "@types/react-test-renderer": "^18.3.0",
+    "happy-dom": "20.4.0",
     "react-test-renderer": "^18.2.0",
     "typescript": "5.6.3"
   },

package/src/index.ts

@@ -4,6 +4,7 @@ export * from './CacheItem';
 export * from './ParentCache';
 export * from './useCachedResponsivePrecommitValue';
 export * from './useDisposableState';
+export * from './useEffectsRerunWithoutRender';
 export * from './useHasCommittedRef';
 export * from './useLazyDisposableState';
 export * from './useUpdatableDisposableState';

package/src/useCachedResponsivePrecommitValue.test.tsx

@@ -1,5 +1,9 @@
 import type { ItemCleanupPair } from '@isograph/disposable-types';
-import React, { type MutableRefObject } from 'react';
+import React, {
+  StrictMode,
+  type MutableRefObject,
+  type ReactElement,
+} from 'react';
 import { create } from 'react-test-renderer';
 import { assert, describe, expect, test, vi } from 'vitest';
 import type { CacheItem, CacheItemState } from './CacheItem';
@@ -52,9 +56,10 @@ function promiseAndResolver() {
 
 // The fact that sometimes we need to render in concurrent mode and sometimes
 // not is a bit worrisome.
-async function awaitableCreate(Component, isConcurrent: boolean) {
+async function awaitableCreate(Component: ReactElement, isConcurrent: boolean) {
   const element = create(
-    Component,
+    <StrictMode>{Component}</StrictMode>,
+    // @ts-expect-error
     isConcurrent ? { unstable_isConcurrent: true } : undefined,
   );
   await shortPromise();

package/src/useCachedResponsivePrecommitValue.ts

@@ -3,6 +3,7 @@
 import type { ItemCleanupPair } from '@isograph/disposable-types';
 import { useEffect, useRef, useState } from 'react';
 import type { ParentCache } from './ParentCache';
+import { useEffectsRerunWithoutRenderRef } from './useEffectsRerunWithoutRender';
 
 /**
  * useCachedResponsivePrecommitValue<T>
@@ -49,6 +50,8 @@ export function useCachedResponsivePrecommitValue<T>(
   const [, rerender] = useState<{} | null>(null);
   const lastCommittedParentCache = useRef<ParentCache<T> | null>(null);
 
+  const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();
+
   useEffect(() => {
     lastCommittedParentCache.current = parentCache;
     // On commit, cacheItem may be disposed, because during the render phase,
@@ -67,28 +70,37 @@ export function useCachedResponsivePrecommitValue<T>(
     //
     // After the above, we have a non-disposed item and a cleanup function, which we
     // can pass to onCommit.
-    const undisposedPair = cacheItem.permanentRetainIfNotDisposed(
-      disposeOfTemporaryRetain,
-    );
-    if (undisposedPair != null) {
-      onCommit(undisposedPair);
-    } else {
-      // The cache item we created during render has been disposed. Check if the parent
-      // cache is populated.
-      const existingCacheItemCleanupPair =
-        parentCache.getAndPermanentRetainIfPresent();
-      if (existingCacheItemCleanupPair != null) {
-        onCommit(existingCacheItemCleanupPair);
-      } else {
-        // We did not find an item in the parent cache, create a new one.
-        onCommit(parentCache.factory());
+    //
+    // When this effect runs again without a render (StrictMode's simulated
+    // remount, Fast Refresh, Activity), the render's temporary retain was
+    // already converted by the first run and released by the cleanup, so the
+    // item is re-acquired from the parent cache below instead.
+    if (!effectsRerunWithoutRenderRef.current) {
+      const undisposedPair = cacheItem.permanentRetainIfNotDisposed(
+        disposeOfTemporaryRetain,
+      );
+      if (undisposedPair != null) {
+        onCommit(undisposedPair);
+        return;
       }
-      // TODO: Consider whether we always want to rerender if the committed item
-      // was not returned during the last render, or whether some callers will
-      // prefer opting out of this behavior (e.g. if every disposable item behaves
-      // identically, but must be loaded.)
-      rerender({});
     }
+    effectsRerunWithoutRenderRef.current = false;
+
+    // The cache item we created during render has been disposed. Check if the parent
+    // cache is populated.
+    const existingCacheItemCleanupPair =
+      parentCache.getAndPermanentRetainIfPresent();
+    if (existingCacheItemCleanupPair != null) {
+      onCommit(existingCacheItemCleanupPair);
+    } else {
+      // We did not find an item in the parent cache, create a new one.
+      onCommit(parentCache.factory());
+    }
+    // TODO: Consider whether we always want to rerender if the committed item
+    // was not returned during the last render, or whether some callers will
+    // prefer opting out of this behavior (e.g. if every disposable item behaves
+    // identically, but must be loaded.)
+    rerender({});
   }, [parentCache]);
 
   if (lastCommittedParentCache.current === parentCache) {

package/src/useDisposableState.ts

@@ -21,7 +21,6 @@ export function useDisposableState<T = never>(
   const preCommitItem = useCachedResponsivePrecommitValue(
     parentCache,
     (pair) => {
-      itemCleanupPairRef.current?.[1]();
       itemCleanupPairRef.current = pair;
     },
   );
@@ -35,25 +34,25 @@ export function useDisposableState<T = never>(
         if (itemCleanupPairRef.current != null) {
           itemCleanupPairRef.current[1]();
           itemCleanupPairRef.current = null;
-        } else {
-          throw new Error(
-            'itemCleanupPairRef.current is unexpectedly null. ' +
-              'This indicates a bug in react-disposable-state.',
-          );
         }
       }
     },
     [stateFromDisposableStateHook],
   );
 
-  useEffect(function cleanupItemCleanupPairRefIfSetStateNotCalled() {
-    return () => {
-      if (itemCleanupPairRef.current != null) {
-        itemCleanupPairRef.current[1]();
-        itemCleanupPairRef.current = null;
-      }
-    };
-  }, []);
+  useEffect(
+    function cleanupItemCleanupPairRefIfSetStateNotCalled() {
+      return () => {
+        if (itemCleanupPairRef.current != null) {
+          itemCleanupPairRef.current[1]();
+          // Forgotten so that nothing can release this pair a second time
+          // before an effect re-run (StrictMode, Fast Refresh) stores a new one.
+          itemCleanupPairRef.current = null;
+        }
+      };
+    },
+    [parentCache],
+  );
   const state: T | undefined =
     (stateFromDisposableStateHook !== UNASSIGNED_STATE
       ? stateFromDisposableStateHook
@@ -67,7 +66,6 @@ export function useDisposableState<T = never>(
       setState,
     };
   }
-
   // Safety: we can be in one of three states. Pre-commit, in which case
   // preCommitItem is assigned, post-commit but before setState has been
   // called, in which case itemCleanupPairRef.current is assigned, or

package/src/useEffectsRerunWithoutRender.test.tsx

@@ -0,0 +1,54 @@
+import { render } from '@testing-library/react';
+import React, { useEffect } from 'react';
+import { describe, expect, test } from 'vitest';
+import { useEffectsRerunWithoutRenderRef } from './useEffectsRerunWithoutRender';
+
+function Probe({ dep, reports }: { dep: number; reports: boolean[] }) {
+  const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();
+  useEffect(() => {
+    reports.push(effectsRerunWithoutRenderRef.current);
+    effectsRerunWithoutRenderRef.current = false;
+  }, [dep, effectsRerunWithoutRenderRef]);
+  return null;
+}
+
+describe('useEffectsRerunWithoutRenderRef', () => {
+  test('under StrictMode, the first mount reads false and the simulated remount reads true', () => {
+    const reports: boolean[] = [];
+    render(<Probe dep={0} reports={reports} />, { reactStrictMode: true });
+
+    expect(reports).toEqual([false, true]);
+  });
+
+  test('without StrictMode, the mount reads false', () => {
+    const reports: boolean[] = [];
+    render(<Probe dep={0} reports={reports} />, { reactStrictMode: false });
+
+    expect(reports).toEqual([false]);
+  });
+
+  test('an effect run caused by a render reads false, once the remount has reset the ref', () => {
+    const reports: boolean[] = [];
+    const { rerender } = render(<Probe dep={0} reports={reports} />, {
+      reactStrictMode: true,
+    });
+    rerender(<Probe dep={1} reports={reports} />);
+
+    expect(reports).toEqual([false, true, false]);
+  });
+
+  test('the ref stays true until the caller resets it', () => {
+    const reads: boolean[] = [];
+    function NeverResets() {
+      const effectsRerunWithoutRenderRef = useEffectsRerunWithoutRenderRef();
+      useEffect(() => {
+        reads.push(effectsRerunWithoutRenderRef.current);
+      });
+      return null;
+    }
+    const { rerender } = render(<NeverResets />, { reactStrictMode: true });
+    rerender(<NeverResets />);
+
+    expect(reads).toEqual([false, true, true]);
+  });
+});

package/src/useEffectsRerunWithoutRender.ts

@@ -0,0 +1,23 @@
+import { type MutableRefObject, useEffect, useRef } from 'react';
+
+/**
+ * Detects that React is running this component's effects again without a
+ * render in between. That happens on StrictMode's simulated unmount and
+ * remount on the first commit, on Fast Refresh, and when an `Activity`
+ * boundary hides and then shows the component. In each case React runs every
+ * effect's cleanup and then its mount, so a cleanup that sets a flag is
+ * observable from the mounts that follow.
+ *
+ * Returns a ref whose `current` is `true` from the moment the cleanup ran until
+ * the caller resets it. The effect that must tell a re-run apart from a first
+ * mount reads it and sets it back to `false`; nothing else clears it.
+ */
+export function useEffectsRerunWithoutRenderRef(): MutableRefObject<boolean> {
+  const effectsRerunWithoutRenderRef = useRef(false);
+  useEffect(() => {
+    return () => {
+      effectsRerunWithoutRenderRef.current = true;
+    };
+  }, []);
+  return effectsRerunWithoutRenderRef;
+}

package/src/useLazyDisposableState.test.tsx

@@ -1,9 +1,9 @@
 import type { ItemCleanupPair } from '@isograph/disposable-types';
-import React, { useEffect, useState } from 'react';
-import { create } from 'react-test-renderer';
-import { describe, expect, test, vi } from 'vitest';
+import { configure, renderHook } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
 import { ParentCache } from './ParentCache';
 import { useLazyDisposableState } from './useLazyDisposableState';
+configure({ reactStrictMode: true });
 
 function createCache<T>(value: T) {
   const disposeItem = vi.fn();
@@ -26,46 +26,85 @@ function promiseWithResolvers() {
 }
 
 describe('useLazyDisposableState', async () => {
-  test('on cache change, it should dispose previous cache', async () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  test('on render it should read the cache', async () => {
     const cache1 = createCache(1);
-    const cache2 = createCache(2);
-    const renders = vi.fn();
 
-    let unmounted = promiseWithResolvers();
-    let committed = promiseWithResolvers();
+    const { result } = renderHook(
+      (props) => useLazyDisposableState(props.parentCache),
+      {
+        initialProps: {
+          parentCache: cache1.cache,
+        },
+      },
+    );
 
-    function TestComponent() {
-      const [cache, setCache] = useState(cache1.cache);
-      const { state } = useLazyDisposableState(cache);
+    expect(result.current.state).toEqual(1);
+    expect(cache1.cache.factory).toHaveBeenCalledOnce();
+  });
 
-      useEffect(() => {
-        setCache(cache2.cache);
+  test('on unmount it should dispose the cache', async () => {
+    const cache1 = createCache(1);
 
-        return () => {
-          unmounted.resolve();
-        };
-      }, []);
+    const { unmount } = renderHook(
+      (props) => useLazyDisposableState(props.parentCache),
+      {
+        initialProps: {
+          parentCache: cache1.cache,
+        },
+      },
+    );
 
-      useEffect(() => {
-        if (state === 1) return;
-        committed.resolve();
-      }, [state]);
+    unmount();
+    vi.runAllTimers();
+    expect(cache1.disposeItem).toHaveBeenCalledOnce();
+  });
 
-      renders(state);
+  test('on cache change, it should read new cache', async () => {
+    const cache1 = createCache(1);
+    const cache2 = createCache(2);
 
-      return null;
-    }
+    const { result, rerender, unmount } = renderHook(
+      (props) => useLazyDisposableState(props.parentCache),
+      {
+        initialProps: {
+          parentCache: cache1.cache,
+        },
+      },
+    );
 
-    const root = create(<TestComponent />, { unstable_isConcurrent: true });
-    await committed.promise;
-    expect(cache1.disposeItem).toHaveBeenCalled();
-    expect(cache1.cache.factory).toHaveBeenCalledOnce();
-    root.unmount();
-    await unmounted.promise;
-    expect(cache2.disposeItem).toHaveBeenCalled();
+    rerender({
+      parentCache: cache2.cache,
+    });
+
+    expect(result.current.state).toEqual(2);
     expect(cache2.cache.factory).toHaveBeenCalledOnce();
-    expect(renders).toHaveBeenNthCalledWith(1, 1);
-    expect(renders).toHaveBeenNthCalledWith(2, 2);
-    expect(renders).toHaveBeenCalledTimes(2);
+  });
+
+  test('on cache change, it should dispose previous cache', async () => {
+    const cache1 = createCache(1);
+    const cache2 = createCache(2);
+
+    const { rerender } = renderHook(
+      (props) => useLazyDisposableState(props.parentCache),
+      {
+        initialProps: {
+          parentCache: cache1.cache,
+        },
+      },
+    );
+
+    rerender({
+      parentCache: cache2.cache,
+    });
+
+    vi.runAllTimers();
+    expect(cache1.disposeItem).toHaveBeenCalledOnce();
   });
 });

package/src/useLazyDisposableState.ts

@@ -21,11 +21,9 @@ export function useLazyDisposableState<T>(
   state: T;
 } {
   const itemCleanupPairRef = useRef<ItemCleanupPair<T> | null>(null);
-
   const preCommitItem = useCachedResponsivePrecommitValue(
     parentCache,
     (pair) => {
-      itemCleanupPairRef.current?.[1]();
       itemCleanupPairRef.current = pair;
     },
   );
@@ -39,9 +37,10 @@ export function useLazyDisposableState<T>(
           'cleanupFn unexpectedly null. This indicates a bug in react-disposable-state.',
         );
       }
-      return cleanupFn();
+      cleanupFn();
+      itemCleanupPairRef.current = null;
     };
-  }, []);
+  }, [parentCache]);
 
   const returnedItem = preCommitItem?.state ?? itemCleanupPairRef.current?.[0];
 

package/src/useUpdatableDisposableState.test.tsx

@@ -1,4 +1,4 @@
-import React, { type MutableRefObject } from 'react';
+import React, { type MutableRefObject, StrictMode } from 'react';
 import { create } from 'react-test-renderer';
 import { describe, expect, test, vi } from 'vitest';
 import {
@@ -51,7 +51,8 @@ function promiseAndResolver() {
 // not is a bit worrisome.
 async function awaitableCreate(Component, isConcurrent: boolean) {
   const element = create(
-    Component,
+    <StrictMode>{Component}</StrictMode>,
+
     isConcurrent ? { unstable_isConcurrent: true } : undefined,
   );
   await shortPromise();

package/src/useUpdatableDisposableState.ts

@@ -109,8 +109,10 @@ export function useUpdatableDisposableState<
   useEffect(() => {
     return function disposeAllRemainingItems() {
       for (const undisposedICI of undisposedICIs.current) {
+        undisposedICIs.current.delete(undisposedICI);
         undisposedICI.cleanup();
       }
+      setStateICI(UNASSIGNED_STATE);
     };
   }, []);
 

package/vitest.config.ts

@@ -0,0 +1,8 @@
+import { defineProject } from 'vitest/config';
+
+export default defineProject({
+  test: {
+    globals: true,
+    environment: 'happy-dom',
+  },
+});