@trackunit/react-components 3.8.2-alpha-775ca1816d6.0 → 3.8.3-alpha-e1e6a0f33ce.0

package/index.cjs.js

@@ -13931,11 +13931,15 @@ const rawLocalStorage = {
  *
  * `persistState` writes to localStorage (`storageSerializer`) and to the URL
  * (via `toUrlValue` + encoding).
- * Each slot skips a value deep-equal to its last write. The URL side starts
- * from the hydrated state, so echoing `initialState` writes no URL entry. The
- * storage side starts from what localStorage held, so a consumer that persists
- * `initialState` after opening a link saves that link's state for the account
- * that opened it, and a reload of the account's own link writes nothing.
+ * Each slot skips a value equal to its last write. The URL side compares what
+ * would land in the URL (the `toUrlValue` projection and the identity stamp),
+ * starting from the projection of the hydrated state and the stamp the URL
+ * carries: echoing `initialState`, or changing only a field the projection
+ * strips, writes no URL entry, while an equal state persisted after the
+ * identity resolves rewrites the URL with its stamp. The storage side starts
+ * from what localStorage held, so a consumer that persists `initialState`
+ * after opening a link saves that link's state for the account that opened
+ * it, and a reload of the account's own link writes nothing.
  * `persistToStorage` and `persistToUrl` are the same two halves exposed
  * separately for consumers that schedule them differently; passing `undefined`
  * removes the entry rather than writing an empty value.
@@ -13992,14 +13996,17 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
             return undefined;
         }
     }, [localStorageEnabled, storageKey]);
-    const readPersistedState = react.useCallback(({ valueFromUrl, validateState, transformFromUrlValue }) => {
+    const readPersistedState = react.useCallback(({ valueFromUrl, validateState, transformFromUrlValue, }) => {
         let urlState;
+        let urlStamp;
         if (valueFromUrl) {
             try {
-                // The ownership stamp is only read at the login redirect (see
-                // `useStripForeignIdentityHash`); here it is unwrapped and discarded.
-                const { value } = unwrapUrlOwner(decode(valueFromUrl));
+                // The ownership stamp decides nothing on read (the login redirect
+                // does that, see `useStripForeignIdentityHash`); it is kept only to
+                // seed the URL dedupe with what the URL is currently stamped with.
+                const { value, owner } = unwrapUrlOwner(decode(valueFromUrl));
                 urlState = validateState(transformFromUrlValue ? transformFromUrlValue(value) : value);
+                urlStamp = urlState === undefined ? undefined : { owner };
             }
             catch {
                 urlState = undefined;
@@ -14021,13 +14028,14 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
         else {
             hydrated = urlState;
         }
-        return { initialState: hydrated, storedState: stored };
+        return { initialState: hydrated, storedState: stored, urlValue: urlStamp };
     }, [decode, mergeWithStorageOnRead, readStoredState]);
+    // The shareable projection of `state`: what a URL write carries before
+    // encoding. The URL dedupe compares this, not the whole state, so a change
+    // confined to a field `toUrlValue` strips is not a URL change.
+    const projectForUrl = react.useCallback((state) => (toUrlValueRef.current ? toUrlValueRef.current(state) : state), []);
     // Every URL write goes through here so the ownership stamp is applied uniformly.
-    const encodeForUrl = react.useCallback((state) => {
-        const value = toUrlValueRef.current ? toUrlValueRef.current(state) : state;
-        return encode(currentUrlOwner === undefined ? value : wrapUrlOwner(value, currentUrlOwner));
-    }, [encode, currentUrlOwner]);
+    const encodeUrlWrite = react.useCallback(({ projected, owner }) => encode(owner === undefined ? projected : wrapUrlOwner(projected, owner)), [encode]);
     // `readPersistedState` changes identity exactly when an input that changes
     // what a read returns does (storage key, storage/merge options), so the
     // snapshot is re-read then and only then — synchronously, in the render
@@ -14043,20 +14051,33 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
         setSnapshot(readSnapshot());
     }
     const { initialState, storedState } = snapshot;
-    // Last value written to each slot, for deduping. The URL side starts as the
-    // hydrated value, so a consumer that echoes `initialState` on mount writes
-    // nothing: a layout read from storage must not grow a URL entry (GLU-2396).
+    // Last value written to each slot, for deduping. Two refs, not one, because
+    // a consumer may schedule the two writes differently (storage at once, URL
+    // debounced). Both are re-seeded whenever the snapshot is re-read so the
+    // first write to a newly scoped key is never skipped.
+    //
     // The storage side starts as what storage held, so persisting the hydrated
     // state after opening a link writes only when the URL changed something.
-    // Both are re-seeded whenever the snapshot is re-read so the first write to
-    // a newly scoped key is never skipped. Two refs, not one, because a consumer
-    // may schedule the two writes differently (storage at once, URL debounced).
+    //
+    // The URL side holds what a write would put in the URL: the shareable
+    // projection plus the owner stamp. It starts as the projection of the
+    // hydrated value, so a consumer that echoes `initialState` on mount, or
+    // changes only a field the projection strips, writes nothing: a layout read
+    // from storage must not grow a URL entry (GLU-2396). Its owner starts as the
+    // stamp the URL carries (or the current owner when the URL is empty), so an
+    // equal state persisted after the identity resolves still rewrites the URL
+    // with its stamp.
+    const urlOwnerSeed = snapshot.urlValue ? snapshot.urlValue.owner : currentUrlOwner;
+    const seedUrlWrite = react.useCallback((project) => initialState === undefined ? undefined : { projected: project(initialState), owner: urlOwnerSeed }, [initialState, urlOwnerSeed]);
     const lastStoredRef = react.useRef(storedState);
-    const lastUrlRef = react.useRef(initialState);
+    // The first seed is computed during render, so it projects with the
+    // `toUrlValue` prop rather than reading `toUrlValueRef` (refs are not read
+    // in render); the projection is cheap, and later seeds come from the effect.
+    const lastUrlRef = react.useRef(seedUrlWrite(state => (toUrlValue ? toUrlValue(state) : state)));
     react.useEffect(() => {
         lastStoredRef.current = storedState;
-        lastUrlRef.current = initialState;
-    }, [initialState, storedState]);
+        lastUrlRef.current = seedUrlWrite(projectForUrl);
+    }, [seedUrlWrite, projectForUrl, storedState]);
     const persistToStorage = react.useCallback((state) => {
         if (!localStorageEnabled) {
             return;
@@ -14078,12 +14099,24 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
         }
     }, [localStorageEnabled, storageKey]);
     const persistToUrl = react.useCallback((state) => {
-        if (state !== undefined && dequal.dequal(lastUrlRef.current, state)) {
+        if (state === undefined) {
+            lastUrlRef.current = undefined;
+            updateUrlValue(undefined);
+            return;
+        }
+        const write = { projected: projectForUrl(state), owner: currentUrlOwner };
+        const last = lastUrlRef.current;
+        // Same projection: write only to add or change a stamp. An unresolved
+        // identity never rewrites a stamped URL just to strip the stamp; it is
+        // re-stamped once the identity resolves.
+        if (last !== undefined &&
+            dequal.dequal(last.projected, write.projected) &&
+            (last.owner === write.owner || write.owner === undefined)) {
             return;
         }
-        lastUrlRef.current = state;
-        updateUrlValue(state === undefined ? undefined : encodeForUrl(state));
-    }, [encodeForUrl, updateUrlValue]);
+        lastUrlRef.current = write;
+        updateUrlValue(encodeUrlWrite(write));
+    }, [currentUrlOwner, encodeUrlWrite, projectForUrl, updateUrlValue]);
     const persistState = react.useCallback((state) => {
         persistToStorage(state);
         persistToUrl(state);

package/index.esm.js

@@ -13930,11 +13930,15 @@ const rawLocalStorage = {
  *
  * `persistState` writes to localStorage (`storageSerializer`) and to the URL
  * (via `toUrlValue` + encoding).
- * Each slot skips a value deep-equal to its last write. The URL side starts
- * from the hydrated state, so echoing `initialState` writes no URL entry. The
- * storage side starts from what localStorage held, so a consumer that persists
- * `initialState` after opening a link saves that link's state for the account
- * that opened it, and a reload of the account's own link writes nothing.
+ * Each slot skips a value equal to its last write. The URL side compares what
+ * would land in the URL (the `toUrlValue` projection and the identity stamp),
+ * starting from the projection of the hydrated state and the stamp the URL
+ * carries: echoing `initialState`, or changing only a field the projection
+ * strips, writes no URL entry, while an equal state persisted after the
+ * identity resolves rewrites the URL with its stamp. The storage side starts
+ * from what localStorage held, so a consumer that persists `initialState`
+ * after opening a link saves that link's state for the account that opened
+ * it, and a reload of the account's own link writes nothing.
  * `persistToStorage` and `persistToUrl` are the same two halves exposed
  * separately for consumers that schedule them differently; passing `undefined`
  * removes the entry rather than writing an empty value.
@@ -13991,14 +13995,17 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
             return undefined;
         }
     }, [localStorageEnabled, storageKey]);
-    const readPersistedState = useCallback(({ valueFromUrl, validateState, transformFromUrlValue }) => {
+    const readPersistedState = useCallback(({ valueFromUrl, validateState, transformFromUrlValue, }) => {
         let urlState;
+        let urlStamp;
         if (valueFromUrl) {
             try {
-                // The ownership stamp is only read at the login redirect (see
-                // `useStripForeignIdentityHash`); here it is unwrapped and discarded.
-                const { value } = unwrapUrlOwner(decode(valueFromUrl));
+                // The ownership stamp decides nothing on read (the login redirect
+                // does that, see `useStripForeignIdentityHash`); it is kept only to
+                // seed the URL dedupe with what the URL is currently stamped with.
+                const { value, owner } = unwrapUrlOwner(decode(valueFromUrl));
                 urlState = validateState(transformFromUrlValue ? transformFromUrlValue(value) : value);
+                urlStamp = urlState === undefined ? undefined : { owner };
             }
             catch {
                 urlState = undefined;
@@ -14020,13 +14027,14 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
         else {
             hydrated = urlState;
         }
-        return { initialState: hydrated, storedState: stored };
+        return { initialState: hydrated, storedState: stored, urlValue: urlStamp };
     }, [decode, mergeWithStorageOnRead, readStoredState]);
+    // The shareable projection of `state`: what a URL write carries before
+    // encoding. The URL dedupe compares this, not the whole state, so a change
+    // confined to a field `toUrlValue` strips is not a URL change.
+    const projectForUrl = useCallback((state) => (toUrlValueRef.current ? toUrlValueRef.current(state) : state), []);
     // Every URL write goes through here so the ownership stamp is applied uniformly.
-    const encodeForUrl = useCallback((state) => {
-        const value = toUrlValueRef.current ? toUrlValueRef.current(state) : state;
-        return encode(currentUrlOwner === undefined ? value : wrapUrlOwner(value, currentUrlOwner));
-    }, [encode, currentUrlOwner]);
+    const encodeUrlWrite = useCallback(({ projected, owner }) => encode(owner === undefined ? projected : wrapUrlOwner(projected, owner)), [encode]);
     // `readPersistedState` changes identity exactly when an input that changes
     // what a read returns does (storage key, storage/merge options), so the
     // snapshot is re-read then and only then — synchronously, in the render
@@ -14042,20 +14050,33 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
         setSnapshot(readSnapshot());
     }
     const { initialState, storedState } = snapshot;
-    // Last value written to each slot, for deduping. The URL side starts as the
-    // hydrated value, so a consumer that echoes `initialState` on mount writes
-    // nothing: a layout read from storage must not grow a URL entry (GLU-2396).
+    // Last value written to each slot, for deduping. Two refs, not one, because
+    // a consumer may schedule the two writes differently (storage at once, URL
+    // debounced). Both are re-seeded whenever the snapshot is re-read so the
+    // first write to a newly scoped key is never skipped.
+    //
     // The storage side starts as what storage held, so persisting the hydrated
     // state after opening a link writes only when the URL changed something.
-    // Both are re-seeded whenever the snapshot is re-read so the first write to
-    // a newly scoped key is never skipped. Two refs, not one, because a consumer
-    // may schedule the two writes differently (storage at once, URL debounced).
+    //
+    // The URL side holds what a write would put in the URL: the shareable
+    // projection plus the owner stamp. It starts as the projection of the
+    // hydrated value, so a consumer that echoes `initialState` on mount, or
+    // changes only a field the projection strips, writes nothing: a layout read
+    // from storage must not grow a URL entry (GLU-2396). Its owner starts as the
+    // stamp the URL carries (or the current owner when the URL is empty), so an
+    // equal state persisted after the identity resolves still rewrites the URL
+    // with its stamp.
+    const urlOwnerSeed = snapshot.urlValue ? snapshot.urlValue.owner : currentUrlOwner;
+    const seedUrlWrite = useCallback((project) => initialState === undefined ? undefined : { projected: project(initialState), owner: urlOwnerSeed }, [initialState, urlOwnerSeed]);
     const lastStoredRef = useRef(storedState);
-    const lastUrlRef = useRef(initialState);
+    // The first seed is computed during render, so it projects with the
+    // `toUrlValue` prop rather than reading `toUrlValueRef` (refs are not read
+    // in render); the projection is cheap, and later seeds come from the effect.
+    const lastUrlRef = useRef(seedUrlWrite(state => (toUrlValue ? toUrlValue(state) : state)));
     useEffect(() => {
         lastStoredRef.current = storedState;
-        lastUrlRef.current = initialState;
-    }, [initialState, storedState]);
+        lastUrlRef.current = seedUrlWrite(projectForUrl);
+    }, [seedUrlWrite, projectForUrl, storedState]);
     const persistToStorage = useCallback((state) => {
         if (!localStorageEnabled) {
             return;
@@ -14077,12 +14098,24 @@ const usePersistedState = ({ key, validate, toUrlValue, fromUrlValue, localStora
         }
     }, [localStorageEnabled, storageKey]);
     const persistToUrl = useCallback((state) => {
-        if (state !== undefined && dequal(lastUrlRef.current, state)) {
+        if (state === undefined) {
+            lastUrlRef.current = undefined;
+            updateUrlValue(undefined);
+            return;
+        }
+        const write = { projected: projectForUrl(state), owner: currentUrlOwner };
+        const last = lastUrlRef.current;
+        // Same projection: write only to add or change a stamp. An unresolved
+        // identity never rewrites a stamped URL just to strip the stamp; it is
+        // re-stamped once the identity resolves.
+        if (last !== undefined &&
+            dequal(last.projected, write.projected) &&
+            (last.owner === write.owner || write.owner === undefined)) {
             return;
         }
-        lastUrlRef.current = state;
-        updateUrlValue(state === undefined ? undefined : encodeForUrl(state));
-    }, [encodeForUrl, updateUrlValue]);
+        lastUrlRef.current = write;
+        updateUrlValue(encodeUrlWrite(write));
+    }, [currentUrlOwner, encodeUrlWrite, projectForUrl, updateUrlValue]);
     const persistState = useCallback((state) => {
         persistToStorage(state);
         persistToUrl(state);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/react-components",
-  "version": "3.8.2-alpha-775ca1816d6.0",
+  "version": "3.8.3-alpha-e1e6a0f33ce.0",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "migrations": "./migrations.json",
@@ -14,16 +14,16 @@
     "@floating-ui/react": "^0.26.25",
     "string-ts": "^2.0.0",
     "tailwind-merge": "^2.0.0",
-    "@trackunit/ui-design-tokens": "1.18.5-alpha-775ca1816d6.0",
-    "@trackunit/css-class-variance-utilities": "2.3.5-alpha-775ca1816d6.0",
-    "@trackunit/shared-utils": "1.19.5-alpha-775ca1816d6.0",
-    "@trackunit/ui-icons": "1.17.5-alpha-775ca1816d6.0",
+    "@trackunit/ui-design-tokens": "1.18.6-alpha-e1e6a0f33ce.0",
+    "@trackunit/css-class-variance-utilities": "2.3.6-alpha-e1e6a0f33ce.0",
+    "@trackunit/shared-utils": "1.19.6-alpha-e1e6a0f33ce.0",
+    "@trackunit/ui-icons": "1.17.6-alpha-e1e6a0f33ce.0",
     "es-toolkit": "^1.52.0",
     "@tanstack/react-virtual": "^3.14.13",
     "dequal": "^2.0.3",
     "fflate": "^0.8.3",
     "zod": "^3.25.76",
-    "@trackunit/i18n-library-translation": "2.8.5-alpha-775ca1816d6.0"
+    "@trackunit/i18n-library-translation": "2.8.6-alpha-e1e6a0f33ce.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/hooks/persistence/usePersistedState.d.ts

@@ -81,11 +81,15 @@ type UsePersistedStateReturn<TState> = {
  *
  * `persistState` writes to localStorage (`storageSerializer`) and to the URL
  * (via `toUrlValue` + encoding).
- * Each slot skips a value deep-equal to its last write. The URL side starts
- * from the hydrated state, so echoing `initialState` writes no URL entry. The
- * storage side starts from what localStorage held, so a consumer that persists
- * `initialState` after opening a link saves that link's state for the account
- * that opened it, and a reload of the account's own link writes nothing.
+ * Each slot skips a value equal to its last write. The URL side compares what
+ * would land in the URL (the `toUrlValue` projection and the identity stamp),
+ * starting from the projection of the hydrated state and the stamp the URL
+ * carries: echoing `initialState`, or changing only a field the projection
+ * strips, writes no URL entry, while an equal state persisted after the
+ * identity resolves rewrites the URL with its stamp. The storage side starts
+ * from what localStorage held, so a consumer that persists `initialState`
+ * after opening a link saves that link's state for the account that opened
+ * it, and a reload of the account's own link writes nothing.
  * `persistToStorage` and `persistToUrl` are the same two halves exposed
  * separately for consumers that schedule them differently; passing `undefined`
  * removes the entry rather than writing an empty value.