@signal9/era-ui 3.17.0 → 3.17.1

package/dist/os/workspace-storage.svelte.d.ts

@@ -1,9 +1,16 @@
 import { type WindowManager } from './wm.svelte.js';
 export declare const WORKSPACE_STORAGE_KEY = "era-ui:workspace";
-/** Read a saved snapshot and apply it. Returns whether anything was restored. */
+/**
+ * Read a saved snapshot and apply it. Returns whether anything was restored.
+ *
+ * Prefers this tab's own layout (sessionStorage) and falls back to the shared
+ * seed (localStorage), so a reload is exact and a brand-new tab still opens on
+ * your most recent arrangement.
+ */
 export declare function loadWorkspace(wm: WindowManager, key?: string): boolean;
-/** Write the current desktop. Returns false when storage rejected it. */
+/** Write the current desktop to both stores. Returns false if neither accepted it. */
 export declare function saveWorkspace(wm: WindowManager, key?: string): boolean;
+/** Forget the layout — this tab's and the shared seed. */
 export declare function clearWorkspace(key?: string): void;
 /**
  * Restore on setup, then save whenever the desktop changes.

package/dist/os/workspace-storage.svelte.js

@@ -1,75 +1,131 @@
 /**
  * Persisting the desktop across reloads.
  *
- * WHY localStorage, and not something newer
- * -----------------------------------------
- * The payload is a few kB of JSON that must be read BEFORE the first paint. That
- * one requirement rules out every modern alternative, because they are all async:
+ * WHERE IT IS STORED, AND WHY IT IS TWO PLACES
+ * --------------------------------------------
+ * A window layout is VIEW state, not document state — the same kind of thing as
+ * scroll position. Nobody expects scrolling one tab to scroll another, and the
+ * same holds here: two tabs of the same app are two workspaces, not two views of
+ * one workspace. That observation decides the whole design.
  *
- *   IndexedDB       async. Large, structured, transactional — none of which this
- *                   needs, and the desktop would paint empty and then pop windows
- *                   in a frame later.
- *   OPFS            async, and built for large or binary files with real
- *                   read/write handles. A 2kB JSON blob is not that.
- *   Storage Buckets async, and still Chromium-only. Its actual feature is
- *                   per-bucket eviction and quota policy, which matters when you
- *                   have several independent stores to prioritise between. One
- *                   layout snapshot is not that either.
+ * So the live layout lives in sessionStorage, which is scoped to a single tab and
+ * survives reload. localStorage keeps a copy purely as the SEED for a tab that
+ * has no layout of its own yet.
  *
- * localStorage is synchronous, which here is the feature rather than the
- * compromise: the snapshot is read and applied during setup, so the desktop's
- * first paint is already the restored layout — no flash of an empty workspace.
+ *   sessionStorage   this tab's layout. Authoritative while the tab is open,
+ *                    isolated from every other tab, gone when it closes.
+ *   localStorage     the most recently saved layout, read only when a tab starts
+ *                    with an empty sessionStorage — i.e. a brand-new tab, so a
+ *                    fresh one opens on your last arrangement instead of nothing.
  *
- * The genuinely modern piece worth adopting IS used: navigator.storage.persist()
- * asks the browser to exempt this origin from eviction under storage pressure.
- * Without it localStorage is "best effort" and can be cleared when the device is
- * low on space. It is requested once, non-blocking, and its refusal is harmless.
+ * Two tabs therefore cannot clobber each other. They still race on the seed, but
+ * a lost race there only changes what a FUTURE new tab starts from — never what
+ * any open tab is showing.
+ *
+ * The alternatives, and why not:
+ *
+ *   `storage` event / BroadcastChannel — mirror every tab to one shared layout.
+ *     Both work, and both are wrong HERE: dragging a window in one tab would move
+ *     it in the other. That is the correct design for a synced setting (theme,
+ *     auth), not for a workspace.
+ *   Web Locks leader election — `navigator.locks.request()` held forever elects
+ *     one writer, which is how real single-writer coordination is done
+ *     (RxDB, Yjs providers). It fixes the clobber by making the other tabs
+ *     read-only, which is worse than isolation for symmetric tabs: whichever you
+ *     opened second silently stops remembering anything.
+ *   CRDT / merge — vast machinery for a value no one is collaborating on.
+ *
+ * WHY localStorage AND NOT SOMETHING NEWER
+ * ----------------------------------------
+ * The payload is a few kB of JSON that must be read BEFORE the first paint, which
+ * rules out every modern alternative, because they are all async: IndexedDB,
+ * OPFS, and Storage Buckets alike would paint an empty desktop and pop the
+ * windows in a frame later. Synchronous access is the feature here, not the
+ * compromise. Their real strengths do not apply either — OPFS is for large or
+ * binary files with read/write handles, and Storage Buckets exists for per-bucket
+ * eviction policy across several competing stores (and is Chromium-only). One
+ * ~300-byte layout is neither.
+ *
+ * The genuinely modern piece IS adopted: navigator.storage.persist() asks the
+ * browser to exempt this origin from eviction under storage pressure. Requested
+ * once, non-blocking, and a refusal is harmless.
  */
 import { untrack } from 'svelte';
 import { readSnapshot } from './wm.svelte.js';
 export const WORKSPACE_STORAGE_KEY = 'era-ui:workspace';
-/** Read a saved snapshot and apply it. Returns whether anything was restored. */
-export function loadWorkspace(wm, key = WORKSPACE_STORAGE_KEY) {
-    if (typeof localStorage === 'undefined')
-        return false;
-    let raw = null;
+/** Both stores, newest-first: this tab's own layout, then the new-tab seed. */
+function stores() {
+    const out = [];
     try {
-        raw = localStorage.getItem(key);
+        if (typeof sessionStorage !== 'undefined')
+            out.push(sessionStorage);
     }
     catch {
-        return false; // private mode, or storage disabled
+        /* storage disabled */
     }
-    if (!raw)
-        return false;
-    // readSnapshot is the gate: this string is untrusted (hand-edited, stale, or
-    // written by a newer version), so it is validated rather than cast.
-    const snapshot = readSnapshot(raw);
-    if (!snapshot)
-        return false;
-    wm.applySnapshot(snapshot);
-    return true;
-}
-/** Write the current desktop. Returns false when storage rejected it. */
-export function saveWorkspace(wm, key = WORKSPACE_STORAGE_KEY) {
-    if (typeof localStorage === 'undefined')
-        return false;
     try {
-        localStorage.setItem(key, JSON.stringify(wm.snapshot()));
-        return true;
+        if (typeof localStorage !== 'undefined')
+            out.push(localStorage);
     }
     catch {
-        // Quota exceeded or private mode. A layout is convenience state, so this
-        // stays silent — unlike the Notes store, where a failed save loses writing
-        // and the user has to be told.
-        return false;
+        /* private mode */
     }
+    return out;
 }
-export function clearWorkspace(key = WORKSPACE_STORAGE_KEY) {
-    try {
-        localStorage?.removeItem(key);
+/**
+ * Read a saved snapshot and apply it. Returns whether anything was restored.
+ *
+ * Prefers this tab's own layout (sessionStorage) and falls back to the shared
+ * seed (localStorage), so a reload is exact and a brand-new tab still opens on
+ * your most recent arrangement.
+ */
+export function loadWorkspace(wm, key = WORKSPACE_STORAGE_KEY) {
+    for (const store of stores()) {
+        let raw = null;
+        try {
+            raw = store.getItem(key);
+        }
+        catch {
+            continue;
+        }
+        if (!raw)
+            continue;
+        // readSnapshot is the gate: this string is untrusted (hand-edited, stale, or
+        // written by a newer version), so it is validated rather than cast.
+        const snapshot = readSnapshot(raw);
+        if (!snapshot)
+            continue;
+        wm.applySnapshot(snapshot);
+        return true;
     }
-    catch {
-        /* nothing to do — the goal was for it to be gone */
+    return false;
+}
+/** Write the current desktop to both stores. Returns false if neither accepted it. */
+export function saveWorkspace(wm, key = WORKSPACE_STORAGE_KEY) {
+    const json = JSON.stringify(wm.snapshot());
+    let ok = false;
+    for (const store of stores()) {
+        try {
+            store.setItem(key, json);
+            ok = true;
+        }
+        catch {
+            // Quota exceeded or private mode. A layout is convenience state, so this
+            // stays silent — unlike the Notes store, where a failed save loses
+            // writing and the user has to be told.
+        }
+    }
+    return ok;
+}
+/** Forget the layout — this tab's and the shared seed. */
+export function clearWorkspace(key = WORKSPACE_STORAGE_KEY) {
+    for (const store of stores()) {
+        try {
+            store.removeItem(key);
+        }
+        catch {
+            /* nothing to do — the goal was for it to be gone */
+        }
     }
 }
 /**
@@ -88,8 +144,8 @@ export function persistWorkspace(wm, options = {}) {
     const key = options.key ?? WORKSPACE_STORAGE_KEY;
     const wait = options.debounce ?? 400;
     const restored = loadWorkspace(wm, key);
-    // Ask for durable storage. Fire-and-forget: a refusal (or an engine without
-    // the API) just leaves the default best-effort behaviour.
+    // Fire-and-forget: a refusal (or an engine without the API) just leaves the
+    // default best-effort behaviour.
     void navigator?.storage?.persist?.().catch(() => { });
     $effect(() => {
         // Touch what a snapshot is made of, so the effect re-runs when any of it

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@signal9/era-ui",
-	"version": "3.17.0",
+	"version": "3.17.1",
 	"scripts": {
 		"dev": "vite dev --host",
 		"build": "vite build && npm run prepack",