@vuu-ui/vuu-shell 3.3.11 → 4.0.0-alpha.1

package/src/workspace-management/WorkspaceProvider.js

@@ -1,209 +1,730 @@
 import { jsx } from "react/jsx-runtime";
-import { isLayoutJSON, resolveJSONPath } from "@vuu-ui/vuu-layout";
+import { GRID_LAYOUT_DOCUMENT_KIND, GRID_LAYOUT_DOCUMENT_VERSION, createSequentialGridLayoutIdAllocator, remapGridLayoutDocumentIds } from "@heswell/grid-layout";
 import { useNotifications } from "@vuu-ui/vuu-notifications";
-import { VuuShellLocation, WorkspaceContext, logger } from "@vuu-ui/vuu-utils";
-import { useCallback, useContext, useEffect, useRef, useState } from "react";
-import { usePersistenceManager } from "../persistence-manager/index.js";
-import { getWorkspaceWithLayoutJSON, loadingJSON } from "./defaultWorkspaceJSON.js";
-const { info: info } = logger("useLayoutManager");
-const ensureLayoutHasTitle = (layout, layoutMetadata)=>{
-    if (layout.props?.title !== void 0) return layout;
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { useOptionalWorkspacePersistenceService } from "../persistence-manager/index.js";
+import { WorkspaceController } from "./WorkspaceController.js";
+import { APPLICATION_SESSION_VERSION, NAMED_WORKSPACE_DEFINITION_VERSION, WORKSPACE_SNAPSHOT_VERSION, cloneWorkspaceValue } from "./workspace-schemas.js";
+const emptyLayout = {
+    components: [],
+    kind: GRID_LAYOUT_DOCUMENT_KIND,
+    layout: {
+        columns: [
+            "1fr"
+        ],
+        id: "empty-workspace",
+        items: [
+            {
+                column: {
+                    span: 1,
+                    start: 1
+                },
+                id: "empty-workspace-placeholder",
+                row: {
+                    span: 1,
+                    start: 1
+                }
+            }
+        ],
+        placeholderIds: [
+            "empty-workspace-placeholder"
+        ],
+        rows: [
+            "1fr"
+        ],
+        stacks: []
+    },
+    version: GRID_LAYOUT_DOCUMENT_VERSION
+};
+const emptyWorkspaceSnapshot = {
+    componentState: {},
+    layout: emptyLayout,
+    version: WORKSPACE_SNAPSHOT_VERSION
+};
+const missing = async ()=>{
+    throw new Error("WorkspaceProvider is not mounted");
+};
+const WorkspaceContext = /*#__PURE__*/ createContext({
+    activeWorkspaceInstanceId: null,
+    closeWorkspace: missing,
+    createWorkspaceFromSnapshot: async ()=>{
+        throw new Error("WorkspaceProvider is not mounted");
+    },
+    controllers: [],
+    deleteNamedWorkspace: missing,
+    getApplicationSetting: ()=>void 0,
+    getApplicationSettings: ()=>void 0,
+    namedWorkspaces: [],
+    openNamedWorkspace: missing,
+    openSystemWorkspace: missing,
+    renameWorkspace: missing,
+    saveActiveWorkspaceAs: missing,
+    saveApplicationSettings: missing,
+    selectWorkspace: missing,
+    setApplicationSetting: missing,
+    settings: {},
+    scopeIdentity: "missing",
+    status: "loading",
+    systemWorkspaces: [],
+    resetApplication: missing
+});
+let nextWorkspaceInstance = 1;
+const createInstanceId = ()=>`workspace-${Date.now().toString(36)}-${nextWorkspaceInstance++}`;
+const errorFrom = (cause, message)=>cause instanceof Error ? cause : new Error(message);
+class StaleWorkspaceScopeError extends Error {
+    constructor(){
+        super("Workspace operation belongs to an inactive persistence scope");
+        this.name = "StaleWorkspaceScopeError";
+    }
+}
+const remapSnapshot = (source, instanceId)=>{
+    const { document, mappings } = remapGridLayoutDocumentIds(source.layout, createSequentialGridLayoutIdAllocator(instanceId));
+    const componentIds = new Map(mappings.filter(({ kind })=>"component" === kind).map(({ newId, oldId })=>[
+            oldId,
+            newId
+        ]));
     return {
-        ...layout,
-        props: {
-            ...layout.props,
-            title: layoutMetadata.name
-        }
+        version: WORKSPACE_SNAPSHOT_VERSION,
+        layout: document,
+        componentState: Object.fromEntries(Object.entries(source.componentState).map(([id, state])=>[
+                componentIds.get(id) ?? id,
+                cloneWorkspaceValue(state)
+            ]))
     };
 };
-const loadingApplicationJSON = {
-    workspaceJSON: loadingJSON
-};
-const WorkspaceProvider = ({ TabstripProps, children, layoutJSON, activeLayoutIndex, layoutPlaceholderJSON, showTabs, workspaceJSON: customWorkspaceJSON })=>{
-    const [layoutMetadata, setLayoutMetadata] = useState([]);
-    const [, forceRefresh] = useState({});
+const WorkspaceProvider = ({ activeLayoutIndex, children, componentRenderers, defaultWorkspace, layoutJSON, layoutPlaceholderJSON, persistenceService: serviceProp, settingsCodecs, showTabs, systemWorkspaces = [], TabstripProps, userId, workspaceJSON })=>{
+    const inheritedService = useOptionalWorkspacePersistenceService();
+    const service = serviceProp ?? inheritedService;
     const { showNotification } = useNotifications();
-    const persistenceManager = usePersistenceManager();
-    const applicationJSONRef = useRef(loadingApplicationJSON);
-    const setApplicationJSON = useCallback((applicationJSON, rerender = true)=>{
-        applicationJSONRef.current = applicationJSON;
-        if (rerender) forceRefresh({});
-    }, []);
-    const setWorkspaceJSON = useCallback((workspaceJSON, rerender = true)=>{
-        setApplicationJSON({
-            ...applicationJSONRef.current,
-            workspaceJSON
-        }, rerender);
-    }, [
-        setApplicationJSON
-    ]);
-    const setApplicationSettings = useCallback((settings)=>{
-        setApplicationJSON({
-            ...applicationJSONRef.current,
-            settings: {
-                ...applicationJSONRef.current.settings,
-                ...settings
-            }
-        }, false);
+    const [controllers, setControllers] = useState([]);
+    const controllersRef = useRef([]);
+    const [session, setSession] = useState();
+    const sessionRef = useRef(void 0);
+    const [namedWorkspaces, setNamedWorkspaces] = useState([]);
+    const [loadedScope, setLoadedScope] = useState();
+    const [loadError, setLoadError] = useState();
+    const generation = useRef(0);
+    const operationQueue = useRef(Promise.resolve());
+    const resetGeneration = useRef(0);
+    const resetPending = useRef(false);
+    const scopeKey = service ? `${service.scope.applicationNamespace}/${service.scope.applicationId}/${service.scope.userId}/authenticated:${userId ?? service.scope.userId}` : "missing";
+    const scopeIsValid = void 0 !== service && (!userId || service.scope.userId === userId);
+    const activeScope = useRef({
+        generation: 0,
+        scopeKey,
+        service
+    });
+    if (activeScope.current.scopeKey !== scopeKey || activeScope.current.service !== service) activeScope.current = {
+        generation: ++generation.current,
+        scopeKey,
+        service
+    };
+    const status = loadedScope !== scopeKey ? "loading" : loadError ? "error" : 0 === controllers.length ? "empty" : "ready";
+    const notifyError = useCallback((header, cause)=>{
+        const error = errorFrom(cause, header);
+        showNotification({
+            content: error.message,
+            header,
+            status: "error",
+            type: "toast"
+        });
+        return error;
+    }, [
+        showNotification
+    ]);
+    const captureScope = useCallback((expectedService = service, expectedScopeKey = scopeKey)=>{
+        const active = activeScope.current;
+        if (!expectedService || active.service !== expectedService || active.scopeKey !== expectedScopeKey || active.generation !== generation.current) throw new StaleWorkspaceScopeError();
+        return {
+            generation: active.generation,
+            scopeKey: active.scopeKey,
+            service: expectedService
+        };
     }, [
-        setApplicationJSON
+        scopeKey,
+        service
     ]);
+    const assertScope = useCallback((guard)=>{
+        const active = activeScope.current;
+        if (generation.current !== guard.generation || active.generation !== guard.generation || active.scopeKey !== guard.scopeKey || active.service !== guard.service) throw new StaleWorkspaceScopeError();
+    }, []);
+    const replaceControllers = useCallback((next)=>{
+        controllersRef.current = next;
+        setControllers(next);
+    }, []);
     useEffect(()=>{
-        persistenceManager?.loadMetadata().then((metadata)=>{
-            setLayoutMetadata(metadata);
-        }).catch((error)=>{
-            showNotification({
-                content: "Could not load list of available layouts",
-                header: "Failed to Load Layouts",
-                status: "error",
-                type: "toast"
-            });
-            console.error("Error occurred while retrieving metadata", error);
-        });
-        persistenceManager?.loadApplicationJSON().then((applicationJSON)=>{
-            if (applicationJSON) {
-                info?.("applicationJSON loaded successfully");
-                setApplicationJSON(applicationJSON);
-            } else {
-                const workspaceJSON = getWorkspaceWithLayoutJSON(customWorkspaceJSON, layoutJSON, activeLayoutIndex, {
-                    TabstripProps,
-                    showTabs
-                });
-                info?.(`applicationJSON not found, getting defaultWorkspaceJSON,
-            ${JSON.stringify(workspaceJSON, null, 2)}
-            `);
-                setApplicationJSON({
-                    workspaceJSON
+        for (const controller of controllersRef.current)controller.dispose();
+        controllersRef.current = [];
+        setControllers([]);
+        setSession(void 0);
+        sessionRef.current = void 0;
+        setNamedWorkspaces([]);
+        setLoadError(void 0);
+        setLoadedScope(void 0);
+        operationQueue.current = Promise.resolve();
+        resetGeneration.current = 0;
+        resetPending.current = false;
+        if (!service) {
+            const error = notifyError("Workspace Persistence Is Not Configured", new Error("Shell requires an injected WorkspacePersistenceService"));
+            setLoadError(error);
+            setLoadedScope(scopeKey);
+            return;
+        }
+        const legacyProps = [
+            void 0 === activeLayoutIndex ? void 0 : "activeLayoutIndex",
+            void 0 === layoutJSON ? void 0 : "layoutJSON",
+            void 0 === layoutPlaceholderJSON ? void 0 : "layoutPlaceholderJSON",
+            void 0 === showTabs ? void 0 : "showTabs",
+            void 0 === TabstripProps ? void 0 : "TabstripProps",
+            void 0 === workspaceJSON ? void 0 : "workspaceJSON"
+        ].filter((name)=>void 0 !== name);
+        if (legacyProps.length > 0) {
+            const error = notifyError("Legacy Workspace Configuration Is Not Supported", new Error(`WorkspaceProvider no longer accepts ${legacyProps.join(", ")}; inject a WorkspacePersistenceService and provide defaultWorkspace as a versioned snapshot`));
+            setLoadError(error);
+            setLoadedScope(scopeKey);
+            return;
+        }
+        if (!scopeIsValid) {
+            const error = notifyError("Workspace Scope Does Not Match", new Error(`Workspace persistence scope "${service.scope.userId}" does not match authenticated user "${userId}"`));
+            setLoadError(error);
+            setLoadedScope(scopeKey);
+            return;
+        }
+        const guard = captureScope();
+        const load = async ()=>{
+            const restored = [];
+            try {
+                assertScope(guard);
+                const [loadedSession, metadata] = await Promise.all([
+                    guard.service.loadApplicationSession(),
+                    guard.service.listNamedWorkspaceMetadata()
+                ]);
+                assertScope(guard);
+                if (loadedSession) {
+                    const descriptors = new Map(loadedSession.openWorkspaces.map((entry)=>[
+                            entry.instanceId,
+                            entry
+                        ]));
+                    for (const instanceId of loadedSession.workspaceOrder){
+                        const descriptor = descriptors.get(instanceId);
+                        if (!descriptor) throw new Error(`Session references missing workspace "${instanceId}"`);
+                        assertScope(guard);
+                        const record = await guard.service.loadWorkspaceSnapshot(descriptor.snapshotId);
+                        assertScope(guard);
+                        if (!record) throw new Error(`Snapshot for workspace "${instanceId}" was not found`);
+                        const definitionMetadata = metadata.find(({ id })=>id === descriptor.definitionId);
+                        restored.push(new WorkspaceController({
+                            definitionId: descriptor.definitionId,
+                            instanceId,
+                            name: descriptor.title ?? definitionMetadata?.name ?? instanceId,
+                            onError: (error)=>{
+                                try {
+                                    assertScope(guard);
+                                    notifyError("Failed to Save Workspace", error);
+                                } catch  {}
+                            },
+                            renderers: componentRenderers ?? (()=>{
+                                throw new Error("Workspace component renderers are required");
+                            })(),
+                            service: guard.service,
+                            revision: record.revision,
+                            settingsCodecs: settingsCodecs ?? (()=>{
+                                throw new Error("Workspace settings codecs are required");
+                            })(),
+                            snapshot: record.snapshot
+                        }));
+                    }
+                }
+                let resolvedSession = loadedSession ?? {
+                    activeWorkspaceInstanceId: null,
+                    openWorkspaces: [],
+                    settings: {},
+                    version: APPLICATION_SESSION_VERSION,
+                    workspaceOrder: []
+                };
+                if (!loadedSession && defaultWorkspace) {
+                    if (!componentRenderers || !settingsCodecs) throw new Error("Default workspace requires component renderers and settings codecs");
+                    const instanceId = createInstanceId();
+                    const initialSnapshot = remapSnapshot(defaultWorkspace, instanceId);
+                    const controller = new WorkspaceController({
+                        instanceId,
+                        name: "Workspace",
+                        onError: (error)=>{
+                            try {
+                                assertScope(guard);
+                                notifyError("Failed to Save Workspace", error);
+                            } catch  {}
+                        },
+                        renderers: componentRenderers,
+                        service: guard.service,
+                        settingsCodecs,
+                        snapshot: initialSnapshot
+                    });
+                    assertScope(guard);
+                    await controller.repository.save(initialSnapshot);
+                    assertScope(guard);
+                    restored.push(controller);
+                    resolvedSession = {
+                        activeWorkspaceInstanceId: instanceId,
+                        openWorkspaces: [
+                            {
+                                instanceId,
+                                snapshotId: instanceId,
+                                title: "Workspace"
+                            }
+                        ],
+                        settings: {},
+                        version: APPLICATION_SESSION_VERSION,
+                        workspaceOrder: [
+                            instanceId
+                        ]
+                    };
+                    await guard.service.saveApplicationSession(resolvedSession);
+                    assertScope(guard);
+                }
+                assertScope(guard);
+                replaceControllers(restored);
+                sessionRef.current = resolvedSession;
+                setSession(resolvedSession);
+                setNamedWorkspaces(metadata);
+                setLoadedScope(scopeKey);
+            } catch (cause) {
+                restored.forEach((controller)=>{
+                    controller.dispose();
                 });
+                if (!(cause instanceof StaleWorkspaceScopeError)) try {
+                    assertScope(guard);
+                    const error = notifyError("Failed to Load Workspaces", cause);
+                    setLoadError(error);
+                    setLoadedScope(scopeKey);
+                } catch  {}
             }
-        }).catch((error)=>{
-            showNotification({
-                content: "Could not load your latest view",
-                header: "Failed to Load Layout",
-                status: "error",
-                type: "toast"
-            });
-            console.error("Error occurred while retrieving application layout", error);
-        });
+        };
+        load();
+        return ()=>{
+            if (activeScope.current.generation === guard.generation) activeScope.current = {
+                ...activeScope.current,
+                generation: ++generation.current
+            };
+            for (const controller of controllersRef.current)controller.dispose();
+            controllersRef.current = [];
+        };
     }, [
-        TabstripProps,
+        componentRenderers,
         activeLayoutIndex,
-        customWorkspaceJSON,
+        assertScope,
+        captureScope,
+        defaultWorkspace,
         layoutJSON,
-        showNotification,
-        persistenceManager,
-        setApplicationJSON,
-        showTabs
-    ]);
-    const saveApplicationLayout = useCallback((layout)=>{
-        if (isLayoutJSON(layout)) {
-            setWorkspaceJSON(layout, false);
-            persistenceManager?.saveApplicationJSON(applicationJSONRef.current);
-        } else console.error("Tried to save invalid application layout", layout);
-    }, [
-        persistenceManager,
-        setWorkspaceJSON
-    ]);
-    const saveLayout = useCallback((metadata)=>{
-        let layoutToSave;
-        try {
-            const { workspaceJSON } = applicationJSONRef.current;
-            if (Array.isArray(workspaceJSON)) console.log("how do we identify the right thing to save");
-            else layoutToSave = resolveJSONPath(workspaceJSON, `#${VuuShellLocation.Workspace}.ACTIVE_CHILD`);
-        } catch (e) {}
-        if (layoutToSave && isLayoutJSON(layoutToSave)) persistenceManager?.createLayout(metadata, ensureLayoutHasTitle(layoutToSave, metadata)).then((metadata)=>{
-            showNotification({
-                content: `${metadata.name} saved successfully`,
-                header: "Layout Saved Successfully",
-                status: "success",
-                type: "toast"
+        layoutPlaceholderJSON,
+        notifyError,
+        replaceControllers,
+        scopeIsValid,
+        scopeKey,
+        service,
+        settingsCodecs,
+        showTabs,
+        TabstripProps,
+        userId,
+        workspaceJSON
+    ]);
+    const writeSession = useCallback(async (next, guard)=>{
+        assertScope(guard);
+        await guard.service.saveApplicationSession(next);
+        assertScope(guard);
+        sessionRef.current = next;
+        setSession(next);
+    }, [
+        assertScope
+    ]);
+    const enqueueOperation = useCallback((guard, operation)=>{
+        assertScope(guard);
+        if (resetPending.current) return Promise.reject(new Error("Workspace operation was blocked by application reset"));
+        const expectedResetGeneration = resetGeneration.current;
+        const result = operationQueue.current.catch(()=>void 0).then(async ()=>{
+            assertScope(guard);
+            if (resetGeneration.current !== expectedResetGeneration) throw new Error("Workspace operation was invalidated by application reset");
+            return operation();
+        });
+        operationQueue.current = result.then(()=>void 0, ()=>void 0);
+        return result;
+    }, [
+        assertScope
+    ]);
+    const addWorkspace = useCallback(async (sourceSnapshot, name, definitionId, operationGuard)=>{
+        if (!service || !componentRenderers || !settingsCodecs) throw new Error("Workspace runtime is not configured");
+        const guard = operationGuard ?? captureScope();
+        return enqueueOperation(guard, async ()=>{
+            assertScope(guard);
+            const instanceId = createInstanceId();
+            const snapshot = remapSnapshot(sourceSnapshot, instanceId);
+            const controller = new WorkspaceController({
+                definitionId,
+                instanceId,
+                name,
+                onError: (error)=>void notifyError("Failed to Save Workspace", error),
+                renderers: componentRenderers,
+                service: guard.service,
+                settingsCodecs,
+                snapshot
             });
-            setLayoutMetadata((prev)=>[
-                    ...prev,
-                    metadata
+            await controller.repository.save(snapshot);
+            assertScope(guard);
+            const current = sessionRef.current ?? {
+                activeWorkspaceInstanceId: null,
+                openWorkspaces: [],
+                settings: {},
+                version: APPLICATION_SESSION_VERSION,
+                workspaceOrder: []
+            };
+            try {
+                await writeSession({
+                    ...current,
+                    activeWorkspaceInstanceId: instanceId,
+                    openWorkspaces: [
+                        ...current.openWorkspaces,
+                        {
+                            ...void 0 === definitionId ? {} : {
+                                definitionId
+                            },
+                            instanceId,
+                            snapshotId: instanceId,
+                            title: name
+                        }
+                    ],
+                    workspaceOrder: [
+                        ...current.workspaceOrder,
+                        instanceId
+                    ]
+                }, guard);
+                assertScope(guard);
+                replaceControllers([
+                    ...controllersRef.current,
+                    controller
                 ]);
-        }).catch((error)=>{
-            showNotification({
-                content: `Failed to save layout ${metadata.name}`,
-                header: "Failed to Save Layout",
-                status: "error",
-                type: "toast"
-            });
-            console.error("Error occurred while saving layout", error);
+            } catch (cause) {
+                await controller.dispose();
+                assertScope(guard);
+                await guard.service.deleteWorkspaceSnapshot(instanceId);
+                assertScope(guard);
+                throw errorFrom(cause, "Failed to save application session");
+            }
+            return instanceId;
         });
-        else {
-            console.error("Tried to save invalid layout", layoutToSave);
-            showNotification({
-                content: "Cannot save invalid layout",
-                header: "Failed to Save Layout",
-                status: "error",
-                type: "toast"
+    }, [
+        componentRenderers,
+        assertScope,
+        captureScope,
+        enqueueOperation,
+        notifyError,
+        replaceControllers,
+        service,
+        settingsCodecs,
+        writeSession
+    ]);
+    const addDefinition = useCallback((definition, operationGuard)=>addWorkspace(definition.snapshot, definition.name, definition.id, operationGuard), [
+        addWorkspace
+    ]);
+    const openSystemWorkspace = useCallback(async (definition)=>{
+        await addDefinition(definition);
+    }, [
+        addDefinition
+    ]);
+    const createWorkspaceFromSnapshot = useCallback(async (snapshot, title = "Untitled")=>{
+        try {
+            return await addWorkspace(snapshot, title);
+        } catch (cause) {
+            if (!(cause instanceof StaleWorkspaceScopeError)) notifyError("Failed to Create Workspace", cause);
+            throw cause;
+        }
+    }, [
+        addWorkspace,
+        notifyError
+    ]);
+    const openNamedWorkspace = useCallback(async (definitionId)=>{
+        if (!service) throw new Error("Workspace persistence service is not configured");
+        const guard = captureScope();
+        const expectedResetGeneration = resetGeneration.current;
+        try {
+            assertScope(guard);
+            const definition = await guard.service.loadNamedWorkspaceDefinition(definitionId);
+            assertScope(guard);
+            if (resetGeneration.current !== expectedResetGeneration) throw new Error("Workspace operation was invalidated by application reset");
+            if (!definition) throw new Error(`Workspace definition "${definitionId}" was not found`);
+            await addDefinition(definition, guard);
+        } catch (cause) {
+            if (!(cause instanceof StaleWorkspaceScopeError)) notifyError("Failed to Open Workspace", cause);
+        }
+    }, [
+        addDefinition,
+        assertScope,
+        captureScope,
+        notifyError,
+        service
+    ]);
+    const selectWorkspace = useCallback(async (instanceId)=>{
+        const guard = captureScope();
+        await enqueueOperation(guard, async ()=>{
+            const current = sessionRef.current;
+            if (!current || !current.workspaceOrder.includes(instanceId)) throw new Error(`Workspace "${instanceId}" is not open`);
+            await writeSession({
+                ...current,
+                activeWorkspaceInstanceId: instanceId
+            }, guard);
+        });
+    }, [
+        captureScope,
+        enqueueOperation,
+        writeSession
+    ]);
+    const renameWorkspace = useCallback(async (instanceId, title)=>{
+        const trimmedTitle = title.trim();
+        if (!trimmedTitle) throw new Error("Workspace title must not be empty");
+        const guard = captureScope();
+        try {
+            await enqueueOperation(guard, async ()=>{
+                const current = sessionRef.current;
+                const controller = controllersRef.current.find((candidate)=>candidate.instanceId === instanceId);
+                if (!current || !controller) throw new Error(`Workspace "${instanceId}" is not open`);
+                await writeSession({
+                    ...current,
+                    openWorkspaces: current.openWorkspaces.map((workspace)=>workspace.instanceId === instanceId ? {
+                            ...workspace,
+                            title: trimmedTitle
+                        } : workspace)
+                }, guard);
+                assertScope(guard);
+                controller.rename(trimmedTitle);
+                replaceControllers([
+                    ...controllersRef.current
+                ]);
             });
+        } catch (cause) {
+            if (!(cause instanceof StaleWorkspaceScopeError)) notifyError("Failed to Rename Workspace", cause);
+            throw cause;
         }
     }, [
-        showNotification,
-        persistenceManager
+        assertScope,
+        captureScope,
+        enqueueOperation,
+        notifyError,
+        replaceControllers,
+        writeSession
+    ]);
+    const closeWorkspace = useCallback(async (instanceId)=>{
+        if (!service) throw new Error("Workspace persistence service is not configured");
+        const guard = captureScope();
+        await enqueueOperation(guard, async ()=>{
+            const current = sessionRef.current;
+            const controller = controllersRef.current.find((candidate)=>candidate.instanceId === instanceId);
+            if (!current || !controller) return;
+            const nextControllers = controllersRef.current.filter((candidate)=>candidate !== controller);
+            const closedIndex = current.workspaceOrder.indexOf(instanceId);
+            const order = current.workspaceOrder.filter((id)=>id !== instanceId);
+            const active = current.activeWorkspaceInstanceId === instanceId ? order[Math.min(closedIndex, order.length - 1)] ?? null : current.activeWorkspaceInstanceId;
+            await writeSession({
+                ...current,
+                activeWorkspaceInstanceId: active,
+                openWorkspaces: current.openWorkspaces.filter(({ instanceId: id })=>id !== instanceId),
+                workspaceOrder: order
+            }, guard);
+            assertScope(guard);
+            await controller.dispose();
+            replaceControllers(nextControllers);
+            await guard.service.deleteWorkspaceSnapshot(instanceId);
+            assertScope(guard);
+        });
+    }, [
+        assertScope,
+        captureScope,
+        enqueueOperation,
+        replaceControllers,
+        service,
+        writeSession
     ]);
-    const saveApplicationSettings = useCallback((settings, key)=>{
-        const { settings: applicationSettings } = applicationJSONRef.current;
-        key ? setApplicationSettings({
-            ...applicationSettings,
-            [key]: settings
-        }) : setApplicationSettings(settings);
-        persistenceManager?.saveApplicationJSON(applicationJSONRef.current);
+    const deleteNamedWorkspace = useCallback(async (definitionId)=>{
+        if (!service) throw new Error("Workspace persistence service is not configured");
+        const guard = captureScope();
+        assertScope(guard);
+        await guard.service.deleteNamedWorkspaceDefinition(definitionId);
+        assertScope(guard);
+        setNamedWorkspaces((current)=>current.filter(({ id })=>id !== definitionId));
     }, [
-        persistenceManager,
-        setApplicationSettings
+        assertScope,
+        captureScope,
+        service
     ]);
-    const getApplicationSettings = useCallback((key)=>{
-        const { settings } = applicationJSONRef.current;
-        return key ? settings?.[key] : settings;
-    }, []);
-    const loadLayoutById = useCallback((id)=>{
-        persistenceManager?.loadLayout(id).then((layoutJson)=>{
-            const { workspaceJSON: currentLayout } = applicationJSONRef.current;
-            if (Array.isArray(currentLayout)) console.log("how do we deal witha amulti layoput");
-            else setWorkspaceJSON({
-                ...currentLayout,
-                children: (currentLayout.children || []).concat(layoutJson),
-                props: {
-                    ...currentLayout.props,
-                    active: currentLayout.children?.length ?? 0
+    const saveActiveWorkspaceAs = useCallback(async (name, description)=>{
+        if (!service) throw new Error("Workspace persistence service is not configured");
+        const guard = captureScope();
+        assertScope(guard);
+        const activeId = sessionRef.current?.activeWorkspaceInstanceId;
+        const active = controllersRef.current.find(({ instanceId })=>instanceId === activeId);
+        if (!active) throw new Error("There is no active workspace to save");
+        const now = new Date().toISOString();
+        const id = createInstanceId();
+        const definition = {
+            createdAt: now,
+            ...void 0 === description ? {} : {
+                description
+            },
+            id,
+            name,
+            snapshot: active.snapshot,
+            updatedAt: now,
+            version: NAMED_WORKSPACE_DEFINITION_VERSION
+        };
+        await guard.service.saveNamedWorkspaceDefinition(definition);
+        assertScope(guard);
+        setNamedWorkspaces((current)=>[
+                ...current,
+                {
+                    createdAt: now,
+                    ...void 0 === description ? {} : {
+                        description
+                    },
+                    id,
+                    name,
+                    updatedAt: now,
+                    version: NAMED_WORKSPACE_DEFINITION_VERSION
                 }
-            });
-        }).catch((error)=>{
-            showNotification({
-                content: "Failed to load the requested layout",
-                header: "Failed to Load Layout",
-                status: "error",
-                type: "toast"
-            });
-            console.error("Error occurred while loading layout", error);
+            ]);
+    }, [
+        assertScope,
+        captureScope,
+        service
+    ]);
+    const setApplicationSetting = useCallback(async (key, value)=>{
+        const guard = captureScope();
+        await enqueueOperation(guard, async ()=>{
+            const current = sessionRef.current;
+            if (!current) throw new Error("Application session has not loaded");
+            await writeSession({
+                ...current,
+                settings: {
+                    ...current.settings,
+                    [key]: value
+                }
+            }, guard);
         });
     }, [
-        showNotification,
-        persistenceManager,
-        setWorkspaceJSON
+        captureScope,
+        enqueueOperation,
+        writeSession
     ]);
-    return /*#__PURE__*/ jsx(WorkspaceContext.Provider, {
-        value: {
-            getApplicationSettings,
-            layoutMetadata,
-            layoutPlaceholderJSON,
-            saveLayout,
-            workspaceJSON: applicationJSONRef.current.workspaceJSON,
-            saveApplicationLayout,
+    const saveApplicationSettings = useCallback(async (value, key)=>{
+        if (void 0 !== key) return void await setApplicationSetting(key, value);
+        if ("object" != typeof value || null === value || Array.isArray(value)) throw new Error("Application settings must be a JSON object");
+        const guard = captureScope();
+        await enqueueOperation(guard, async ()=>{
+            const current = sessionRef.current;
+            if (!current) throw new Error("Application session has not loaded");
+            await writeSession({
+                ...current,
+                settings: value
+            }, guard);
+        });
+    }, [
+        captureScope,
+        enqueueOperation,
+        setApplicationSetting,
+        writeSession
+    ]);
+    const resetApplication = useCallback(async ()=>{
+        const guard = captureScope();
+        assertScope(guard);
+        if (resetPending.current) throw new Error("Application reset is already in progress");
+        resetPending.current = true;
+        resetGeneration.current += 1;
+        const reset = operationQueue.current.catch(()=>void 0).then(async ()=>{
+            assertScope(guard);
+            const instanceIds = sessionRef.current?.openWorkspaces.map(({ snapshotId })=>snapshotId) ?? [];
+            await guard.service.deleteApplicationSession();
+            assertScope(guard);
+            await Promise.all(controllersRef.current.map((controller)=>controller.dispose()));
+            replaceControllers([]);
+            const emptySession = {
+                activeWorkspaceInstanceId: null,
+                openWorkspaces: [],
+                settings: {},
+                version: APPLICATION_SESSION_VERSION,
+                workspaceOrder: []
+            };
+            sessionRef.current = emptySession;
+            setSession(emptySession);
+            for (const snapshotId of instanceIds){
+                assertScope(guard);
+                await guard.service.deleteWorkspaceSnapshot(snapshotId);
+                assertScope(guard);
+            }
+        });
+        operationQueue.current = reset.then(()=>void 0, ()=>void 0);
+        try {
+            await reset;
+        } finally{
+            if (activeScope.current.generation === guard.generation && activeScope.current.scopeKey === guard.scopeKey) resetPending.current = false;
+        }
+    }, [
+        assertScope,
+        captureScope,
+        replaceControllers
+    ]);
+    const value = useMemo(()=>{
+        const settings = session?.settings ?? {};
+        const visibleControllers = "loading" === status ? [] : controllers;
+        const activeWorkspace = visibleControllers.find(({ instanceId })=>instanceId === session?.activeWorkspaceInstanceId);
+        return {
+            activeWorkspace,
+            activeWorkspaceInstanceId: session?.activeWorkspaceInstanceId ?? null,
+            closeWorkspace,
+            componentRenderers,
+            controllers: visibleControllers,
+            createWorkspaceFromSnapshot,
+            deleteNamedWorkspace,
+            error: loadError,
+            getApplicationSetting: (key)=>settings[key],
+            getApplicationSettings: (key)=>void 0 === key ? settings : settings[key],
+            namedWorkspaces,
+            openNamedWorkspace,
+            openSystemWorkspace,
+            renameWorkspace,
+            saveActiveWorkspaceAs,
             saveApplicationSettings,
-            loadLayoutById
-        },
+            selectWorkspace,
+            setApplicationSetting,
+            settings,
+            settingsCodecs,
+            scopeIdentity: scopeKey,
+            status,
+            systemWorkspaces,
+            resetApplication
+        };
+    }, [
+        closeWorkspace,
+        componentRenderers,
+        controllers,
+        createWorkspaceFromSnapshot,
+        deleteNamedWorkspace,
+        loadError,
+        namedWorkspaces,
+        openNamedWorkspace,
+        openSystemWorkspace,
+        renameWorkspace,
+        saveActiveWorkspaceAs,
+        saveApplicationSettings,
+        selectWorkspace,
+        session,
+        setApplicationSetting,
+        settingsCodecs,
+        scopeKey,
+        status,
+        systemWorkspaces,
+        resetApplication
+    ]);
+    return /*#__PURE__*/ jsx(WorkspaceContext.Provider, {
+        value: value,
         children: children
     });
 };
-const useWorkspace = ()=>{
-    const { workspaceJSON = getWorkspaceWithLayoutJSON(), ...contextProps } = useContext(WorkspaceContext);
-    return {
-        ...contextProps,
-        workspaceJSON
-    };
-};
-export { WorkspaceProvider, useWorkspace };
+const useWorkspace = ()=>useContext(WorkspaceContext);
+export { StaleWorkspaceScopeError, WorkspaceProvider, emptyWorkspaceSnapshot, useWorkspace };