@signal9/era-ui 3.17.0 → 4.0.0

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

@@ -1,9 +1,16 @@
-import { type WindowManager } from './wm.svelte.js';
+import { type PaneManager } from './pane-manager.svelte.js';
 export declare const WORKSPACE_STORAGE_KEY = "era-ui:workspace";
-/** Read a saved snapshot and apply it. Returns whether anything was restored. */
-export declare function loadWorkspace(wm: WindowManager, key?: string): boolean;
-/** Write the current desktop. Returns false when storage rejected it. */
-export declare function saveWorkspace(wm: WindowManager, key?: string): boolean;
+/**
+ * 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(pm: PaneManager, key?: string): boolean;
+/** Write the current desktop to both stores. Returns false if neither accepted it. */
+export declare function saveWorkspace(pm: PaneManager, 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.
@@ -12,12 +19,12 @@ export declare function clearWorkspace(key?: string): void;
  * component context). The load is synchronous and happens immediately, before
  * the first paint.
  *
- * Writes are debounced: dragging a window mutates `pos` on every pointer move,
+ * Writes are debounced: dragging a pane mutates `pos` on every pointer move,
  * and serialising the whole desktop per frame would be pointless work. The
  * trailing write always lands because the effect's teardown flushes a pending
  * timer.
  */
-export declare function persistWorkspace(wm: WindowManager, options?: {
+export declare function persistWorkspace(pm: PaneManager, options?: {
     key?: string;
     debounce?: number;
 }): {

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 pane 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 pane 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
+ * panes 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';
+import { readSnapshot } from './pane-manager.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(pm, 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;
+        pm.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(pm, key = WORKSPACE_STORAGE_KEY) {
+    const json = JSON.stringify(pm.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 */
+        }
     }
 }
 /**
@@ -79,22 +135,22 @@ export function clearWorkspace(key = WORKSPACE_STORAGE_KEY) {
  * component context). The load is synchronous and happens immediately, before
  * the first paint.
  *
- * Writes are debounced: dragging a window mutates `pos` on every pointer move,
+ * Writes are debounced: dragging a pane mutates `pos` on every pointer move,
  * and serialising the whole desktop per frame would be pointless work. The
  * trailing write always lands because the effect's teardown flushes a pending
  * timer.
  */
-export function persistWorkspace(wm, options = {}) {
+export function persistWorkspace(pm, 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.
+    const restored = loadWorkspace(pm, key);
+    // 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
         // changes. Reading these is the subscription.
-        wm.windows.forEach((w) => {
+        pm.panes.forEach((w) => {
             void w.pos.x;
             void w.pos.y;
             void w.size?.width;
@@ -105,12 +161,12 @@ export function persistWorkspace(wm, options = {}) {
             void w.workspaceId;
             void w.props;
         });
-        void wm.workspaces.length;
-        void wm.activeWorkspaceId;
+        void pm.workspaces.length;
+        void pm.activeWorkspaceId;
         const timer = setTimeout(() => {
             // untrack: snapshot() reads the same state this effect depends on, and
             // re-reading it inside would re-subscribe on every write.
-            untrack(() => saveWorkspace(wm, key));
+            untrack(() => saveWorkspace(pm, key));
         }, wait);
         return () => clearTimeout(timer);
     });

package/dist/ui/pane/pane.svelte

@@ -7,7 +7,7 @@
 	import Handle from './pane-handle.svelte';
 	import Content from './pane-content.svelte';
 	import Close from './pane-close.svelte';
-	import AppWindow from '@lucide/svelte/icons/app-window';
+	import AppPane from '@lucide/svelte/icons/app-window';
 
 	let {
 		ref = $bindable(null),
@@ -15,7 +15,7 @@
 		size = $bindable(null),
 		resizable = false,
 		title,
-		icon = AppWindow,
+		icon = AppPane,
 		disabled = false,
 		plugins = [],
 		onDragStart,

package/dist/ui/video-player/video-player.svelte

@@ -791,7 +791,7 @@
 
 	const playLabel = $derived(ended ? 'Replay' : paused ? 'Play' : 'Pause');
 	const muteLabel = $derived(mutedState || volumeState === 0 ? 'Unmute' : 'Mute');
-	// Prefer seekable.end when smaller than duration (HLS live windows); fall
+	// Prefer seekable.end when smaller than duration (HLS live panes); fall
 	// back to duration for VOD where the engine may report seekable === duration.
 	const timeMax = $derived(
 		seekableEnd > 0 && seekableEnd < (duration || Infinity)

package/package.json

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

package/dist/os/window.svelte.d.ts

@@ -1,7 +0,0 @@
-import { type AppWindow } from './wm.svelte.js';
-type $$ComponentProps = {
-    window: AppWindow;
-};
-declare const Window: import("svelte").Component<$$ComponentProps, {}, "">;
-type Window = ReturnType<typeof Window>;
-export default Window;