@trackunit/react-components 3.5.2-alpha-34e3e456eda.0 → 3.5.3-alpha-b0d834f66ac.0

package/index.cjs.js

@@ -13456,6 +13456,30 @@ const readHashKey = (hash, key) => {
     }
     return undefined;
 };
+/**
+ * Lists the key of every named entry in a URL fragment, in order of first
+ * appearance. Foreign tokens (no `=`) are skipped and duplicates collapse.
+ *
+ * @param hash - The fragment string, with or without the leading `#`.
+ * @returns {Array<string>} The distinct entry keys.
+ */
+const listHashKeys = (hash) => {
+    const body = stripLeadingHash(hash);
+    if (body.length === 0) {
+        return [];
+    }
+    const keys = [];
+    for (const token of body.split(TOKEN_SEPARATOR)) {
+        const eqIndex = token.indexOf(KEY_VALUE_SEPARATOR);
+        if (eqIndex > 0) {
+            const key = token.slice(0, eqIndex);
+            if (!keys.includes(key)) {
+                keys.push(key);
+            }
+        }
+    }
+    return keys;
+};
 /**
  * Returns a new fragment string with the named entry written, replaced,
  * or removed. Foreign tokens are preserved in their original order; the
@@ -14078,41 +14102,6 @@ const rawLocalStorage = {
     read: (key) => localStorage.getItem(key),
     write: (key, value) => localStorage.setItem(key, value),
     remove: (key) => localStorage.removeItem(key),
-    keys: () => {
-        const keys = [];
-        for (let index = 0; index < localStorage.length; index++) {
-            const key = localStorage.key(index);
-            if (key !== null) {
-                keys.push(key);
-            }
-        }
-        return keys;
-    },
-};
-/* eslint-enable no-restricted-globals */
-/**
- * Whether some *other* identity that has used this browser wrote the URL
- * value: `owner` is the fingerprint of a user id that has state stored under
- * `key` in this localStorage. Storage keys are `<key>-<clientSideUserId>`
- * (see `useStorageKey`), so the ids can be recovered from the keys.
- *
- * A value with no owner, or one written on another device (no matching
- * storage here), is not foreign: that is a link someone shared.
- */
-const isUrlOwnedByOtherLocalIdentity = (key, owner, currentOwner) => {
-    if (owner === undefined || currentOwner === undefined || owner === currentOwner) {
-        return false;
-    }
-    const prefix = `${key}-`;
-    try {
-        return rawLocalStorage
-            .keys()
-            .filter(storageKey => storageKey.startsWith(prefix))
-            .some(storageKey => identityFingerprint(storageKey.slice(prefix.length)) === owner);
-    }
-    catch {
-        return false;
-    }
 };
 /**
  * Generic persistence hook that loads state from a URL slot (search param
@@ -14157,16 +14146,15 @@ const isUrlOwnedByOtherLocalIdentity = (key, owner, currentOwner) => {
  *   state on read (URL wins on shared keys). Use when `toUrlValue` deliberately
  *   omits fields so they still survive via localStorage. Default `false`.
  * @param options.urlLocation - Which URL slot backs the value (`"search"` or `"hash"`). Default `"search"`.
- * @param options.scopeUrlToIdentity - Stamp URL writes with the current identity and ignore
- *   URL values written by another identity that has state in this browser. Default `false`.
+ * @param options.stampUrlWithIdentity - Stamp URL writes with the current identity so the login
+ *   redirect can drop entries left by another account on this browser. Default `false`.
  */
-const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue, enabled = true, localStorageEnabled = true, onExternalChange, replace, clientSideUserId, mergeWithStorageOnRead = false, urlLocation = "search", scopeUrlToIdentity = false, }) => {
+const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue, enabled = true, localStorageEnabled = true, onExternalChange, replace, clientSideUserId, mergeWithStorageOnRead = false, urlLocation = "search", stampUrlWithIdentity = false, }) => {
     const { encode, decode } = useCustomEncoding();
     // Fingerprint of the identity this hook writes URL values for. `undefined`
-    // while the identity is unresolved (or when scoping is off): writes are then
-    // unstamped and no URL value is treated as foreign. The read below re-runs
-    // once `storageKey` picks up the resolved identity.
-    const currentUrlOwner = react.useMemo(() => (scopeUrlToIdentity && clientSideUserId !== undefined ? identityFingerprint(clientSideUserId) : undefined), [scopeUrlToIdentity, clientSideUserId]);
+    // while the identity is unresolved (or when stamping is off): writes are
+    // then unstamped.
+    const currentUrlOwner = react.useMemo(() => (stampUrlWithIdentity && clientSideUserId !== undefined ? identityFingerprint(clientSideUserId) : undefined), [stampUrlWithIdentity, clientSideUserId]);
     const searchActive = enabled && urlLocation === "search";
     const hashActive = enabled && urlLocation === "hash";
     // Both URL-sync hooks are mounted unconditionally to satisfy the Rules of
@@ -14222,14 +14210,16 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
         legacySearchValueRef.current = legacySearchValue;
     }, [legacySearchValue]);
     const readPersistedState = react.useCallback(({ valueFromUrl, legacyValueFromUrl, validateState, transformFromUrlValue, }) => {
+        // The ownership stamp is only read at the login redirect (see
+        // `useStripForeignIdentityHash`); here it is unwrapped and discarded.
         const tryDecode = (raw) => {
             try {
-                const { owner, value } = unwrapUrlOwner(decode(raw));
+                const { value } = unwrapUrlOwner(decode(raw));
                 const transformed = transformFromUrlValue ? transformFromUrlValue(value) : value;
-                return { state: validateState(transformed), owner };
+                return validateState(transformed);
             }
             catch {
-                return { state: undefined, owner: undefined };
+                return undefined;
             }
         };
         const readStoredState = () => {
@@ -14250,30 +14240,14 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
         let urlState;
         let canonicalUrlValid = false;
         let usedLegacyUrl = false;
-        let rejectedAsForeign = false;
         if (enabled && valueFromUrl) {
-            const decoded = tryDecode(valueFromUrl);
-            // Another account on this browser left its state in the URL, or an
-            // unstamped bookmark/history entry would override a layout this user
-            // already saved. Treat the slot as empty so this user's storage wins
-            // and the restore effect below overwrites the stale entry.
-            const unstampedOverSavedState = scopeUrlToIdentity &&
-                decoded.owner === undefined &&
-                decoded.state !== undefined &&
-                currentUrlOwner !== undefined &&
-                readStoredState() !== undefined;
-            rejectedAsForeign =
-                unstampedOverSavedState ||
-                    (scopeUrlToIdentity && isUrlOwnedByOtherLocalIdentity(key, decoded.owner, currentUrlOwner));
-            urlState = rejectedAsForeign ? undefined : decoded.state;
+            urlState = tryDecode(valueFromUrl);
             if (urlState !== undefined) {
                 canonicalUrlValid = true;
             }
         }
-        // A legacy `?<key>=...` param next to a foreign hash came from the same
-        // other-account session, so it must not stand in for the rejected hash.
-        if (urlState === undefined && !rejectedAsForeign && enabled && legacyValueFromUrl) {
-            urlState = tryDecode(legacyValueFromUrl).state;
+        if (urlState === undefined && enabled && legacyValueFromUrl) {
+            urlState = tryDecode(legacyValueFromUrl);
             if (urlState !== undefined) {
                 usedLegacyUrl = true;
             }
@@ -14285,7 +14259,6 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: urlState,
                 canonicalUrlHasValidState: canonicalUrlValid,
                 needsUrlRestore: usedLegacyUrl,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         const storageState = readStoredState();
@@ -14296,7 +14269,6 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: { ...storageState, ...urlState },
                 canonicalUrlHasValidState: canonicalUrlValid,
                 needsUrlRestore: usedLegacyUrl,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         if (urlState !== undefined) {
@@ -14304,7 +14276,6 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: urlState,
                 canonicalUrlHasValidState: canonicalUrlValid,
                 needsUrlRestore: usedLegacyUrl,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         if (storageState !== undefined) {
@@ -14312,16 +14283,14 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: storageState,
                 canonicalUrlHasValidState: false,
                 needsUrlRestore: true,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         return {
             initialState: undefined,
             canonicalUrlHasValidState: false,
             needsUrlRestore: false,
-            urlRejectedAsForeign: rejectedAsForeign,
         };
-    }, [decode, enabled, localStorageEnabled, storageKey, mergeWithStorageOnRead, scopeUrlToIdentity, key, currentUrlOwner]);
+    }, [decode, enabled, localStorageEnabled, storageKey, mergeWithStorageOnRead]);
     // Every URL write goes through here so the ownership stamp is applied
     // uniformly (user edits, storage→URL restore, legacy search-param migration).
     const encodeForUrl = react.useCallback((state) => {
@@ -14348,7 +14317,7 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
             transformFromUrlValue: fromUrlValueRef.current,
         }));
     }, [persistedStateReadKey, readPersistedState]);
-    const { initialState, canonicalUrlHasValidState, needsUrlRestore, urlRejectedAsForeign } = persistedStateSnapshot;
+    const { initialState, canonicalUrlHasValidState, needsUrlRestore } = persistedStateSnapshot;
     // Late-hydration recovery: TanStack Router's `useSearch` can return an
     // empty object on the very first render of a route that's still in a
     // loader-driven pending phase. The `useState` initializer above runs
@@ -14359,13 +14328,11 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
     // `onMigrated`. We re-read here when:
     //   - the snapshot has nothing usable yet (`initialState === undefined`
     //     AND the canonical URL slot has no valid value), and
-    //   - a legacy value has just appeared, and
-    //   - the canonical slot was not rejected (a legacy value next to a foreign
-    //     or unstamped-over-saved hash is ignored by the read anyway).
+    //   - a legacy value has just appeared.
     // Once `initialState` is populated, this effect's guard short-circuits
     // and the rest of the lifecycle (restore + migration) takes over.
     react.useEffect(() => {
-        if (initialState !== undefined || canonicalUrlHasValidState || urlRejectedAsForeign) {
+        if (initialState !== undefined || canonicalUrlHasValidState) {
             return;
         }
         if (legacySearchValue === undefined) {
@@ -14377,7 +14344,7 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
             validateState: validateRef.current,
             transformFromUrlValue: fromUrlValueRef.current,
         }));
-    }, [legacySearchValue, initialState, canonicalUrlHasValidState, urlRejectedAsForeign, readPersistedState]);
+    }, [legacySearchValue, initialState, canonicalUrlHasValidState, readPersistedState]);
     const lastPersistedRef = react.useRef(initialState);
     react.useEffect(() => {
         lastPersistedRef.current = initialState;
@@ -14408,16 +14375,13 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
     // suppress `onMigrated`, otherwise a valid legacy value would be lost
     // on the next reload (see `canonicalUrlHasValidState` for the same
     // reasoning in the restore effect above).
-    // A rejected hash counts as "already has a value" too. The legacy param
-    // beside a foreign stamp or an unstamped hash that lost to saved state is
-    // stripped without being written into this user's storage or hash.
     useMigrateLegacySearchParam({
         key,
         enabled: hashActive,
         decode,
         fromUrlValue,
         validate,
-        hashAlreadyHasValue: canonicalUrlHasValidState || urlRejectedAsForeign,
+        hashAlreadyHasValue: canonicalUrlHasValidState,
         onMigrated: react.useCallback((migrated) => {
             if (dequal.dequal(lastPersistedRef.current, migrated)) {
                 return;
@@ -14453,6 +14417,101 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
     return react.useMemo(() => ({ initialState, persistState, clearState }), [initialState, persistState, clearState]);
 };
 
+/**
+ * Enumerates localStorage keys. Kept local so this file's exemption from the
+ * no-direct-storage-access rule is centralised, as in `usePersistedState`.
+ */
+/* eslint-disable no-restricted-globals */
+const localStorageKeys = () => {
+    const keys = [];
+    for (let index = 0; index < localStorage.length; index++) {
+        const key = localStorage.key(index);
+        if (key !== null) {
+            keys.push(key);
+        }
+    }
+    return keys;
+};
+/* eslint-enable no-restricted-globals */
+/**
+ * Whether some *other* identity that has used this browser wrote the URL
+ * value: `owner` is the fingerprint of a user id that has state stored under
+ * `key` in this localStorage. Storage keys are `<key>-<clientSideUserId>`
+ * (see `useStorageKey`), so the ids can be recovered from the keys.
+ *
+ * A value with no owner, or one written on another device (no matching
+ * storage here), is not foreign: that is a link someone shared.
+ */
+const isOwnedByOtherLocalIdentity = (key, owner, currentOwner) => {
+    if (owner === undefined || owner === currentOwner) {
+        return false;
+    }
+    const prefix = `${key}-`;
+    try {
+        return localStorageKeys()
+            .filter(storageKey => storageKey.startsWith(prefix))
+            .some(storageKey => identityFingerprint(storageKey.slice(prefix.length)) === owner);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Removes a URL's hash entries that were written by another account on this
+ * browser, so a login redirect does not hand one account's persisted state
+ * (e.g. an asset list layout) to the next account that signs in.
+ *
+ * `usePersistedState` stamps every hash it writes with a fingerprint of the
+ * writing `clientSideUserId` (see `stampUrlWithIdentity`). On load the hash
+ * always wins, so links and bookmarks work for anyone. The URL also survives
+ * the login redirect (`redirectToLogin(location.href)`), which is how the
+ * previous account's layout reached the next account on a shared PC
+ * (GLU-2396). This hook is applied at that boundary only.
+ *
+ * An entry is removed when it is stamped by a *different* identity that has
+ * state stored in this browser under the same key. Unstamped entries, entries
+ * stamped by the reader, and entries whose author has no storage here (a
+ * link shared from another device) are kept.
+ *
+ * @returns {(url: string | undefined, clientSideUserId: string | undefined) => string}
+ *   Returns `url` with the foreign entries removed. A missing url comes back
+ *   as `""`. The URL is returned as-is when it has no hash or when
+ *   `clientSideUserId` is unknown.
+ */
+const useStripForeignIdentityHash = () => {
+    const { decode } = useCustomEncoding();
+    return react.useCallback((url, clientSideUserId) => {
+        if (typeof url !== "string") {
+            return "";
+        }
+        const hashIndex = url.indexOf("#");
+        if (clientSideUserId === undefined || hashIndex === -1) {
+            return url;
+        }
+        const base = url.slice(0, hashIndex);
+        const hash = url.slice(hashIndex);
+        const currentOwner = identityFingerprint(clientSideUserId);
+        let next = hash;
+        for (const key of listHashKeys(hash)) {
+            const raw = readHashKey(hash, key);
+            if (raw === undefined) {
+                continue;
+            }
+            let owner;
+            try {
+                owner = unwrapUrlOwner(decode(raw)).owner;
+            }
+            catch {
+                continue;
+            }
+            if (isOwnedByOtherLocalIdentity(key, owner, currentOwner)) {
+                next = writeHashKey(next, key, undefined);
+            }
+        }
+        return `${base}${next}`;
+    }, [decode]);
+};
+
 const OVERSCAN = 10;
 const DEFAULT_ROW_HEIGHT = 50;
 /**
@@ -15873,6 +15932,7 @@ exports.useSessionStorageReducer = useSessionStorageReducer;
 exports.useSheet = useSheet;
 exports.useSheetSnap = useSheetSnap;
 exports.useStorageKey = useStorageKey;
+exports.useStripForeignIdentityHash = useStripForeignIdentityHash;
 exports.useTextSearch = useTextSearch;
 exports.useTimeout = useTimeout;
 exports.useViewportBreakpoints = useViewportBreakpoints;

package/index.esm.js

@@ -13455,6 +13455,30 @@ const readHashKey = (hash, key) => {
     }
     return undefined;
 };
+/**
+ * Lists the key of every named entry in a URL fragment, in order of first
+ * appearance. Foreign tokens (no `=`) are skipped and duplicates collapse.
+ *
+ * @param hash - The fragment string, with or without the leading `#`.
+ * @returns {Array<string>} The distinct entry keys.
+ */
+const listHashKeys = (hash) => {
+    const body = stripLeadingHash(hash);
+    if (body.length === 0) {
+        return [];
+    }
+    const keys = [];
+    for (const token of body.split(TOKEN_SEPARATOR)) {
+        const eqIndex = token.indexOf(KEY_VALUE_SEPARATOR);
+        if (eqIndex > 0) {
+            const key = token.slice(0, eqIndex);
+            if (!keys.includes(key)) {
+                keys.push(key);
+            }
+        }
+    }
+    return keys;
+};
 /**
  * Returns a new fragment string with the named entry written, replaced,
  * or removed. Foreign tokens are preserved in their original order; the
@@ -14077,41 +14101,6 @@ const rawLocalStorage = {
     read: (key) => localStorage.getItem(key),
     write: (key, value) => localStorage.setItem(key, value),
     remove: (key) => localStorage.removeItem(key),
-    keys: () => {
-        const keys = [];
-        for (let index = 0; index < localStorage.length; index++) {
-            const key = localStorage.key(index);
-            if (key !== null) {
-                keys.push(key);
-            }
-        }
-        return keys;
-    },
-};
-/* eslint-enable no-restricted-globals */
-/**
- * Whether some *other* identity that has used this browser wrote the URL
- * value: `owner` is the fingerprint of a user id that has state stored under
- * `key` in this localStorage. Storage keys are `<key>-<clientSideUserId>`
- * (see `useStorageKey`), so the ids can be recovered from the keys.
- *
- * A value with no owner, or one written on another device (no matching
- * storage here), is not foreign: that is a link someone shared.
- */
-const isUrlOwnedByOtherLocalIdentity = (key, owner, currentOwner) => {
-    if (owner === undefined || currentOwner === undefined || owner === currentOwner) {
-        return false;
-    }
-    const prefix = `${key}-`;
-    try {
-        return rawLocalStorage
-            .keys()
-            .filter(storageKey => storageKey.startsWith(prefix))
-            .some(storageKey => identityFingerprint(storageKey.slice(prefix.length)) === owner);
-    }
-    catch {
-        return false;
-    }
 };
 /**
  * Generic persistence hook that loads state from a URL slot (search param
@@ -14156,16 +14145,15 @@ const isUrlOwnedByOtherLocalIdentity = (key, owner, currentOwner) => {
  *   state on read (URL wins on shared keys). Use when `toUrlValue` deliberately
  *   omits fields so they still survive via localStorage. Default `false`.
  * @param options.urlLocation - Which URL slot backs the value (`"search"` or `"hash"`). Default `"search"`.
- * @param options.scopeUrlToIdentity - Stamp URL writes with the current identity and ignore
- *   URL values written by another identity that has state in this browser. Default `false`.
+ * @param options.stampUrlWithIdentity - Stamp URL writes with the current identity so the login
+ *   redirect can drop entries left by another account on this browser. Default `false`.
  */
-const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue, enabled = true, localStorageEnabled = true, onExternalChange, replace, clientSideUserId, mergeWithStorageOnRead = false, urlLocation = "search", scopeUrlToIdentity = false, }) => {
+const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue, enabled = true, localStorageEnabled = true, onExternalChange, replace, clientSideUserId, mergeWithStorageOnRead = false, urlLocation = "search", stampUrlWithIdentity = false, }) => {
     const { encode, decode } = useCustomEncoding();
     // Fingerprint of the identity this hook writes URL values for. `undefined`
-    // while the identity is unresolved (or when scoping is off): writes are then
-    // unstamped and no URL value is treated as foreign. The read below re-runs
-    // once `storageKey` picks up the resolved identity.
-    const currentUrlOwner = useMemo(() => (scopeUrlToIdentity && clientSideUserId !== undefined ? identityFingerprint(clientSideUserId) : undefined), [scopeUrlToIdentity, clientSideUserId]);
+    // while the identity is unresolved (or when stamping is off): writes are
+    // then unstamped.
+    const currentUrlOwner = useMemo(() => (stampUrlWithIdentity && clientSideUserId !== undefined ? identityFingerprint(clientSideUserId) : undefined), [stampUrlWithIdentity, clientSideUserId]);
     const searchActive = enabled && urlLocation === "search";
     const hashActive = enabled && urlLocation === "hash";
     // Both URL-sync hooks are mounted unconditionally to satisfy the Rules of
@@ -14221,14 +14209,16 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
         legacySearchValueRef.current = legacySearchValue;
     }, [legacySearchValue]);
     const readPersistedState = useCallback(({ valueFromUrl, legacyValueFromUrl, validateState, transformFromUrlValue, }) => {
+        // The ownership stamp is only read at the login redirect (see
+        // `useStripForeignIdentityHash`); here it is unwrapped and discarded.
         const tryDecode = (raw) => {
             try {
-                const { owner, value } = unwrapUrlOwner(decode(raw));
+                const { value } = unwrapUrlOwner(decode(raw));
                 const transformed = transformFromUrlValue ? transformFromUrlValue(value) : value;
-                return { state: validateState(transformed), owner };
+                return validateState(transformed);
             }
             catch {
-                return { state: undefined, owner: undefined };
+                return undefined;
             }
         };
         const readStoredState = () => {
@@ -14249,30 +14239,14 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
         let urlState;
         let canonicalUrlValid = false;
         let usedLegacyUrl = false;
-        let rejectedAsForeign = false;
         if (enabled && valueFromUrl) {
-            const decoded = tryDecode(valueFromUrl);
-            // Another account on this browser left its state in the URL, or an
-            // unstamped bookmark/history entry would override a layout this user
-            // already saved. Treat the slot as empty so this user's storage wins
-            // and the restore effect below overwrites the stale entry.
-            const unstampedOverSavedState = scopeUrlToIdentity &&
-                decoded.owner === undefined &&
-                decoded.state !== undefined &&
-                currentUrlOwner !== undefined &&
-                readStoredState() !== undefined;
-            rejectedAsForeign =
-                unstampedOverSavedState ||
-                    (scopeUrlToIdentity && isUrlOwnedByOtherLocalIdentity(key, decoded.owner, currentUrlOwner));
-            urlState = rejectedAsForeign ? undefined : decoded.state;
+            urlState = tryDecode(valueFromUrl);
             if (urlState !== undefined) {
                 canonicalUrlValid = true;
             }
         }
-        // A legacy `?<key>=...` param next to a foreign hash came from the same
-        // other-account session, so it must not stand in for the rejected hash.
-        if (urlState === undefined && !rejectedAsForeign && enabled && legacyValueFromUrl) {
-            urlState = tryDecode(legacyValueFromUrl).state;
+        if (urlState === undefined && enabled && legacyValueFromUrl) {
+            urlState = tryDecode(legacyValueFromUrl);
             if (urlState !== undefined) {
                 usedLegacyUrl = true;
             }
@@ -14284,7 +14258,6 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: urlState,
                 canonicalUrlHasValidState: canonicalUrlValid,
                 needsUrlRestore: usedLegacyUrl,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         const storageState = readStoredState();
@@ -14295,7 +14268,6 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: { ...storageState, ...urlState },
                 canonicalUrlHasValidState: canonicalUrlValid,
                 needsUrlRestore: usedLegacyUrl,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         if (urlState !== undefined) {
@@ -14303,7 +14275,6 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: urlState,
                 canonicalUrlHasValidState: canonicalUrlValid,
                 needsUrlRestore: usedLegacyUrl,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         if (storageState !== undefined) {
@@ -14311,16 +14282,14 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
                 initialState: storageState,
                 canonicalUrlHasValidState: false,
                 needsUrlRestore: true,
-                urlRejectedAsForeign: rejectedAsForeign,
             };
         }
         return {
             initialState: undefined,
             canonicalUrlHasValidState: false,
             needsUrlRestore: false,
-            urlRejectedAsForeign: rejectedAsForeign,
         };
-    }, [decode, enabled, localStorageEnabled, storageKey, mergeWithStorageOnRead, scopeUrlToIdentity, key, currentUrlOwner]);
+    }, [decode, enabled, localStorageEnabled, storageKey, mergeWithStorageOnRead]);
     // Every URL write goes through here so the ownership stamp is applied
     // uniformly (user edits, storage→URL restore, legacy search-param migration).
     const encodeForUrl = useCallback((state) => {
@@ -14347,7 +14316,7 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
             transformFromUrlValue: fromUrlValueRef.current,
         }));
     }, [persistedStateReadKey, readPersistedState]);
-    const { initialState, canonicalUrlHasValidState, needsUrlRestore, urlRejectedAsForeign } = persistedStateSnapshot;
+    const { initialState, canonicalUrlHasValidState, needsUrlRestore } = persistedStateSnapshot;
     // Late-hydration recovery: TanStack Router's `useSearch` can return an
     // empty object on the very first render of a route that's still in a
     // loader-driven pending phase. The `useState` initializer above runs
@@ -14358,13 +14327,11 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
     // `onMigrated`. We re-read here when:
     //   - the snapshot has nothing usable yet (`initialState === undefined`
     //     AND the canonical URL slot has no valid value), and
-    //   - a legacy value has just appeared, and
-    //   - the canonical slot was not rejected (a legacy value next to a foreign
-    //     or unstamped-over-saved hash is ignored by the read anyway).
+    //   - a legacy value has just appeared.
     // Once `initialState` is populated, this effect's guard short-circuits
     // and the rest of the lifecycle (restore + migration) takes over.
     useEffect(() => {
-        if (initialState !== undefined || canonicalUrlHasValidState || urlRejectedAsForeign) {
+        if (initialState !== undefined || canonicalUrlHasValidState) {
             return;
         }
         if (legacySearchValue === undefined) {
@@ -14376,7 +14343,7 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
             validateState: validateRef.current,
             transformFromUrlValue: fromUrlValueRef.current,
         }));
-    }, [legacySearchValue, initialState, canonicalUrlHasValidState, urlRejectedAsForeign, readPersistedState]);
+    }, [legacySearchValue, initialState, canonicalUrlHasValidState, readPersistedState]);
     const lastPersistedRef = useRef(initialState);
     useEffect(() => {
         lastPersistedRef.current = initialState;
@@ -14407,16 +14374,13 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
     // suppress `onMigrated`, otherwise a valid legacy value would be lost
     // on the next reload (see `canonicalUrlHasValidState` for the same
     // reasoning in the restore effect above).
-    // A rejected hash counts as "already has a value" too. The legacy param
-    // beside a foreign stamp or an unstamped hash that lost to saved state is
-    // stripped without being written into this user's storage or hash.
     useMigrateLegacySearchParam({
         key,
         enabled: hashActive,
         decode,
         fromUrlValue,
         validate,
-        hashAlreadyHasValue: canonicalUrlHasValidState || urlRejectedAsForeign,
+        hashAlreadyHasValue: canonicalUrlHasValidState,
         onMigrated: useCallback((migrated) => {
             if (dequal(lastPersistedRef.current, migrated)) {
                 return;
@@ -14452,6 +14416,101 @@ const usePersistedState = ({ key, validate, serialize, toUrlValue, fromUrlValue,
     return useMemo(() => ({ initialState, persistState, clearState }), [initialState, persistState, clearState]);
 };
 
+/**
+ * Enumerates localStorage keys. Kept local so this file's exemption from the
+ * no-direct-storage-access rule is centralised, as in `usePersistedState`.
+ */
+/* eslint-disable no-restricted-globals */
+const localStorageKeys = () => {
+    const keys = [];
+    for (let index = 0; index < localStorage.length; index++) {
+        const key = localStorage.key(index);
+        if (key !== null) {
+            keys.push(key);
+        }
+    }
+    return keys;
+};
+/* eslint-enable no-restricted-globals */
+/**
+ * Whether some *other* identity that has used this browser wrote the URL
+ * value: `owner` is the fingerprint of a user id that has state stored under
+ * `key` in this localStorage. Storage keys are `<key>-<clientSideUserId>`
+ * (see `useStorageKey`), so the ids can be recovered from the keys.
+ *
+ * A value with no owner, or one written on another device (no matching
+ * storage here), is not foreign: that is a link someone shared.
+ */
+const isOwnedByOtherLocalIdentity = (key, owner, currentOwner) => {
+    if (owner === undefined || owner === currentOwner) {
+        return false;
+    }
+    const prefix = `${key}-`;
+    try {
+        return localStorageKeys()
+            .filter(storageKey => storageKey.startsWith(prefix))
+            .some(storageKey => identityFingerprint(storageKey.slice(prefix.length)) === owner);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Removes a URL's hash entries that were written by another account on this
+ * browser, so a login redirect does not hand one account's persisted state
+ * (e.g. an asset list layout) to the next account that signs in.
+ *
+ * `usePersistedState` stamps every hash it writes with a fingerprint of the
+ * writing `clientSideUserId` (see `stampUrlWithIdentity`). On load the hash
+ * always wins, so links and bookmarks work for anyone. The URL also survives
+ * the login redirect (`redirectToLogin(location.href)`), which is how the
+ * previous account's layout reached the next account on a shared PC
+ * (GLU-2396). This hook is applied at that boundary only.
+ *
+ * An entry is removed when it is stamped by a *different* identity that has
+ * state stored in this browser under the same key. Unstamped entries, entries
+ * stamped by the reader, and entries whose author has no storage here (a
+ * link shared from another device) are kept.
+ *
+ * @returns {(url: string | undefined, clientSideUserId: string | undefined) => string}
+ *   Returns `url` with the foreign entries removed. A missing url comes back
+ *   as `""`. The URL is returned as-is when it has no hash or when
+ *   `clientSideUserId` is unknown.
+ */
+const useStripForeignIdentityHash = () => {
+    const { decode } = useCustomEncoding();
+    return useCallback((url, clientSideUserId) => {
+        if (typeof url !== "string") {
+            return "";
+        }
+        const hashIndex = url.indexOf("#");
+        if (clientSideUserId === undefined || hashIndex === -1) {
+            return url;
+        }
+        const base = url.slice(0, hashIndex);
+        const hash = url.slice(hashIndex);
+        const currentOwner = identityFingerprint(clientSideUserId);
+        let next = hash;
+        for (const key of listHashKeys(hash)) {
+            const raw = readHashKey(hash, key);
+            if (raw === undefined) {
+                continue;
+            }
+            let owner;
+            try {
+                owner = unwrapUrlOwner(decode(raw)).owner;
+            }
+            catch {
+                continue;
+            }
+            if (isOwnedByOtherLocalIdentity(key, owner, currentOwner)) {
+                next = writeHashKey(next, key, undefined);
+            }
+        }
+        return `${base}${next}`;
+    }, [decode]);
+};
+
 const OVERSCAN = 10;
 const DEFAULT_ROW_HEIGHT = 50;
 /**
@@ -15682,4 +15741,4 @@ const useWindowActivity = ({ onFocus, onBlur, skip = false } = { onBlur: undefin
  */
 setupLibraryTranslations();
 
-export { Alert, Badge, Breadcrumb, Button, Card, CardBody, CardFooter, CardHeader, Collapse, CompletionStatusIndicator, CopyButton, DEFAULT_SKELETON_PREFERENCE_CARD_PROPS, DetailsList, EmptyState, EmptyValue, ExternalLink, GridAreas, Heading, Highlight, HorizontalOverflowScroller, Icon, IconButton, IdentityCard, IdentityCardSkeleton, Indicator, KPI, KPICard, KPICardSkeleton, KPISkeleton, LabeledValue, LabeledValueList, List, ListItem, MAX_HASH_LENGTH, MAX_URL_LENGTH, MenuContent, MenuDivider, MenuItem, MenuTree, MoreMenu, Notice, PackageNameStoryComponent, Page, PageContent, PageHeader, PageHeaderKpiMetrics, PageHeaderSecondaryActions, PageHeaderTitle, Pagination, Polygon, Popover, PopoverContent, PopoverTitle, PopoverTrigger, Portal, PreferenceCard, PreferenceCardSkeleton, Prompt, ROLE_CARD, SHEET_TRANSITION_DURATION, SHEET_TRANSITION_DURATION_MS, SHEET_TRANSITION_EASING, SectionHeader, SegmentedValueBar, Sheet, Sidebar, SidebarContentLayout, SkeletonBlock, SkeletonLabel, SkeletonLines, Spacer, Spinner, StarButton, Tab, TabContent, TabList, Tabs, Tag, Text, ToggleGroup, Tooltip, TrendIndicator, TrendIndicators, ValueBar, ZStack, createGrid, cvaButton, cvaButtonPrefixSuffix, cvaButtonSpinner, cvaButtonSpinnerContainer, cvaClickable, cvaContainerStyles, cvaContentContainer, cvaContentWrapper, cvaDescriptionCard, cvaIconBackground, cvaIconButton, cvaImgStyles, cvaIndicator, cvaIndicatorIcon, cvaIndicatorIconBackground, cvaIndicatorLabel, cvaIndicatorPing, cvaInputContainer, cvaInteractableItem, cvaList, cvaListContainer, cvaListItem$1 as cvaListItem, cvaMenu, cvaMenuItem, cvaMenuItemLabel, cvaMenuItemPrefix, cvaMenuItemStyle, cvaMenuItemSuffix, cvaMenuList, cvaMenuListDivider, cvaMenuListItem, cvaMenuListMultiSelect, cvaPageHeader, cvaPageHeaderContainer, cvaPageHeaderHeading, cvaPreferenceCard, cvaTitleCard, cvaToggleGroup, cvaToggleGroupWithSlidingBackground, cvaToggleItem, cvaToggleItemContent, cvaToggleItemText, cvaZStackContainer, cvaZStackItem, defaultPageSize, docs, getDevicePixelRatio, getValueBarColorByValue, iconColorNames, iconPalette, noPagination, preferenceCardGrid, useBidirectionalScroll, useClickOutside, useContainerBreakpoints, useContinuousTimeout, useCopyToClipboard, useCursorUrlSync, useCustomEncoding, useDebounce, useDevicePixelRatio, useElevatedReducer, useElevatedState, useGridAreas, useHashParamSync, useHold, useHover, useInfiniteScroll, useIsFirstRender, useIsFullscreen, useIsTextTruncated, useKeyboardShortcut, useList, useListItemHeight, useLocalStorage, useLocalStorageReducer, useMeasure, useMenuSearchField, useMenuTree, useMergeRefs, useModifierKey, useOptionalPopoverContext, useOverflowBorder, useOverflowItems, usePersistedState, usePopoverContext, usePrevious, usePrompt, useRandomCSSLengths, useRelayPagination, useResize, useScrollBlock, useScrollDetection, useSearchParamSync, useSelfUpdatingRef, useSessionStorage, useSessionStorageReducer, useSheet, useSheetSnap, useStorageKey, useTextSearch, useTimeout, useViewportBreakpoints, useWatch, useWindowActivity };
+export { Alert, Badge, Breadcrumb, Button, Card, CardBody, CardFooter, CardHeader, Collapse, CompletionStatusIndicator, CopyButton, DEFAULT_SKELETON_PREFERENCE_CARD_PROPS, DetailsList, EmptyState, EmptyValue, ExternalLink, GridAreas, Heading, Highlight, HorizontalOverflowScroller, Icon, IconButton, IdentityCard, IdentityCardSkeleton, Indicator, KPI, KPICard, KPICardSkeleton, KPISkeleton, LabeledValue, LabeledValueList, List, ListItem, MAX_HASH_LENGTH, MAX_URL_LENGTH, MenuContent, MenuDivider, MenuItem, MenuTree, MoreMenu, Notice, PackageNameStoryComponent, Page, PageContent, PageHeader, PageHeaderKpiMetrics, PageHeaderSecondaryActions, PageHeaderTitle, Pagination, Polygon, Popover, PopoverContent, PopoverTitle, PopoverTrigger, Portal, PreferenceCard, PreferenceCardSkeleton, Prompt, ROLE_CARD, SHEET_TRANSITION_DURATION, SHEET_TRANSITION_DURATION_MS, SHEET_TRANSITION_EASING, SectionHeader, SegmentedValueBar, Sheet, Sidebar, SidebarContentLayout, SkeletonBlock, SkeletonLabel, SkeletonLines, Spacer, Spinner, StarButton, Tab, TabContent, TabList, Tabs, Tag, Text, ToggleGroup, Tooltip, TrendIndicator, TrendIndicators, ValueBar, ZStack, createGrid, cvaButton, cvaButtonPrefixSuffix, cvaButtonSpinner, cvaButtonSpinnerContainer, cvaClickable, cvaContainerStyles, cvaContentContainer, cvaContentWrapper, cvaDescriptionCard, cvaIconBackground, cvaIconButton, cvaImgStyles, cvaIndicator, cvaIndicatorIcon, cvaIndicatorIconBackground, cvaIndicatorLabel, cvaIndicatorPing, cvaInputContainer, cvaInteractableItem, cvaList, cvaListContainer, cvaListItem$1 as cvaListItem, cvaMenu, cvaMenuItem, cvaMenuItemLabel, cvaMenuItemPrefix, cvaMenuItemStyle, cvaMenuItemSuffix, cvaMenuList, cvaMenuListDivider, cvaMenuListItem, cvaMenuListMultiSelect, cvaPageHeader, cvaPageHeaderContainer, cvaPageHeaderHeading, cvaPreferenceCard, cvaTitleCard, cvaToggleGroup, cvaToggleGroupWithSlidingBackground, cvaToggleItem, cvaToggleItemContent, cvaToggleItemText, cvaZStackContainer, cvaZStackItem, defaultPageSize, docs, getDevicePixelRatio, getValueBarColorByValue, iconColorNames, iconPalette, noPagination, preferenceCardGrid, useBidirectionalScroll, useClickOutside, useContainerBreakpoints, useContinuousTimeout, useCopyToClipboard, useCursorUrlSync, useCustomEncoding, useDebounce, useDevicePixelRatio, useElevatedReducer, useElevatedState, useGridAreas, useHashParamSync, useHold, useHover, useInfiniteScroll, useIsFirstRender, useIsFullscreen, useIsTextTruncated, useKeyboardShortcut, useList, useListItemHeight, useLocalStorage, useLocalStorageReducer, useMeasure, useMenuSearchField, useMenuTree, useMergeRefs, useModifierKey, useOptionalPopoverContext, useOverflowBorder, useOverflowItems, usePersistedState, usePopoverContext, usePrevious, usePrompt, useRandomCSSLengths, useRelayPagination, useResize, useScrollBlock, useScrollDetection, useSearchParamSync, useSelfUpdatingRef, useSessionStorage, useSessionStorageReducer, useSheet, useSheetSnap, useStorageKey, useStripForeignIdentityHash, useTextSearch, useTimeout, useViewportBreakpoints, useWatch, useWindowActivity };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trackunit/react-components",
-  "version": "3.5.2-alpha-34e3e456eda.0",
+  "version": "3.5.3-alpha-b0d834f66ac.0",
   "repository": "https://github.com/Trackunit/manager",
   "license": "SEE LICENSE IN LICENSE.txt",
   "migrations": "./migrations.json",
@@ -9,21 +9,21 @@
   },
   "dependencies": {
     "@radix-ui/react-slot": "^1.2.3",
-    "@radix-ui/react-tabs": "^1.1.13",
+    "@radix-ui/react-tabs": "^1.1.21",
     "react-helmet-async": "^1.3.0",
     "@floating-ui/react": "^0.26.25",
     "string-ts": "^2.0.0",
     "tailwind-merge": "^2.0.0",
-    "@trackunit/ui-design-tokens": "1.17.2-alpha-34e3e456eda.0",
-    "@trackunit/css-class-variance-utilities": "2.2.2-alpha-34e3e456eda.0",
-    "@trackunit/shared-utils": "1.18.2-alpha-34e3e456eda.0",
-    "@trackunit/ui-icons": "1.16.2-alpha-34e3e456eda.0",
-    "es-toolkit": "^1.39.10",
-    "@tanstack/react-virtual": "^3.14.3",
+    "@trackunit/ui-design-tokens": "1.17.3-alpha-b0d834f66ac.0",
+    "@trackunit/css-class-variance-utilities": "2.2.3-alpha-b0d834f66ac.0",
+    "@trackunit/shared-utils": "1.18.3-alpha-b0d834f66ac.0",
+    "@trackunit/ui-icons": "1.16.3-alpha-b0d834f66ac.0",
+    "es-toolkit": "^1.52.0",
+    "@tanstack/react-virtual": "^3.14.13",
     "dequal": "^2.0.3",
-    "fflate": "^0.8.2",
+    "fflate": "^0.8.3",
     "zod": "^3.25.76",
-    "@trackunit/i18n-library-translation": "2.7.2-alpha-34e3e456eda.0"
+    "@trackunit/i18n-library-translation": "2.7.3-alpha-b0d834f66ac.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",

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

@@ -46,6 +46,14 @@
  *   entry whose token has no `=` is treated as foreign content and ignored.
  */
 export declare const readHashKey: (hash: string, key: string) => string | undefined;
+/**
+ * Lists the key of every named entry in a URL fragment, in order of first
+ * appearance. Foreign tokens (no `=`) are skipped and duplicates collapse.
+ *
+ * @param hash - The fragment string, with or without the leading `#`.
+ * @returns {Array<string>} The distinct entry keys.
+ */
+export declare const listHashKeys: (hash: string) => Array<string>;
 /**
  * Returns a new fragment string with the named entry written, replaced,
  * or removed. Foreign tokens are preserved in their original order; the

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

@@ -41,23 +41,18 @@ type UsePersistedStateOptions<TState> = {
     readonly urlLocation?: UrlPersistenceLocation;
     /**
      * When `true`, every URL write is stamped with a fingerprint of
-     * `clientSideUserId`, and a URL value stamped by a *different* identity
-     * that also has state stored in this browser (under the same `key`) is
-     * ignored on read — the current user's localStorage wins and is written
-     * back over the stale URL entry.
+     * `clientSideUserId` (`{ o: <fingerprint>, v: <payload> }`). Reads are
+     * unaffected: the URL still wins on load for everyone, so links and
+     * bookmarks render for whoever opens them.
      *
-     * The URL is shared by every account that signs in from the same browser
-     * (history, bookmarks, login redirects carry it along) and it takes
-     * precedence over per-user storage, so without this the previous account's
-     * state replaces the next account's saved state (GLU-2396).
-     *
-     * Values stamped by an identity with no storage here (a link shared from
-     * another device) still render. An unstamped value written before this
-     * option existed renders only when the current user has nothing saved;
-     * otherwise their localStorage wins and the hash is restamped, because a
-     * bookmark or history entry is never rewritten on its own. Default `false`.
+     * The stamp exists for the login redirect. The URL is shared by every
+     * account that signs in from the same browser and `redirectToLogin`
+     * carries it through to the next account, which is how one account's
+     * state replaced another's on a shared PC (GLU-2396). At that boundary
+     * `useStripForeignIdentityHash` drops entries stamped by a different
+     * identity that has state stored in this browser. Default `false`.
      */
-    readonly scopeUrlToIdentity?: boolean;
+    readonly stampUrlWithIdentity?: boolean;
 };
 type UsePersistedStateReturn<TState> = {
     readonly initialState: TState | undefined;
@@ -107,8 +102,8 @@ type UsePersistedStateReturn<TState> = {
  *   state on read (URL wins on shared keys). Use when `toUrlValue` deliberately
  *   omits fields so they still survive via localStorage. Default `false`.
  * @param options.urlLocation - Which URL slot backs the value (`"search"` or `"hash"`). Default `"search"`.
- * @param options.scopeUrlToIdentity - Stamp URL writes with the current identity and ignore
- *   URL values written by another identity that has state in this browser. Default `false`.
+ * @param options.stampUrlWithIdentity - Stamp URL writes with the current identity so the login
+ *   redirect can drop entries left by another account on this browser. Default `false`.
  */
-export declare const usePersistedState: <TState extends object>({ key, validate, serialize, toUrlValue, fromUrlValue, enabled, localStorageEnabled, onExternalChange, replace, clientSideUserId, mergeWithStorageOnRead, urlLocation, scopeUrlToIdentity, }: UsePersistedStateOptions<TState>) => UsePersistedStateReturn<TState>;
+export declare const usePersistedState: <TState extends object>({ key, validate, serialize, toUrlValue, fromUrlValue, enabled, localStorageEnabled, onExternalChange, replace, clientSideUserId, mergeWithStorageOnRead, urlLocation, stampUrlWithIdentity, }: UsePersistedStateOptions<TState>) => UsePersistedStateReturn<TState>;
 export {};

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

@@ -0,0 +1,23 @@
+/**
+ * Removes a URL's hash entries that were written by another account on this
+ * browser, so a login redirect does not hand one account's persisted state
+ * (e.g. an asset list layout) to the next account that signs in.
+ *
+ * `usePersistedState` stamps every hash it writes with a fingerprint of the
+ * writing `clientSideUserId` (see `stampUrlWithIdentity`). On load the hash
+ * always wins, so links and bookmarks work for anyone. The URL also survives
+ * the login redirect (`redirectToLogin(location.href)`), which is how the
+ * previous account's layout reached the next account on a shared PC
+ * (GLU-2396). This hook is applied at that boundary only.
+ *
+ * An entry is removed when it is stamped by a *different* identity that has
+ * state stored in this browser under the same key. Unstamped entries, entries
+ * stamped by the reader, and entries whose author has no storage here (a
+ * link shared from another device) are kept.
+ *
+ * @returns {(url: string | undefined, clientSideUserId: string | undefined) => string}
+ *   Returns `url` with the foreign entries removed. A missing url comes back
+ *   as `""`. The URL is returned as-is when it has no hash or when
+ *   `clientSideUserId` is unknown.
+ */
+export declare const useStripForeignIdentityHash: () => ((url: string | undefined, clientSideUserId: string | undefined) => string);

package/src/index.d.ts

@@ -129,6 +129,7 @@ export * from "./hooks/persistence/useHashParamSync";
 export * from "./hooks/persistence/usePersistedState";
 export * from "./hooks/persistence/useSearchParamSync";
 export * from "./hooks/persistence/useStorageKey";
+export * from "./hooks/persistence/useStripForeignIdentityHash";
 export * from "./hooks/useBidirectionalScroll";
 export * from "./hooks/useClickOutside";
 export * from "./hooks/useContainerBreakpoints";