@vuu-ui/vuu-shell 4.0.0-alpha.9 → 4.0.0-beta.2

package/src/workspace-management/WorkspaceProvider.js

@@ -1,730 +1,209 @@
 import { jsx } from "react/jsx-runtime";
-import { GRID_LAYOUT_DOCUMENT_KIND, GRID_LAYOUT_DOCUMENT_VERSION, createSequentialGridLayoutIdAllocator, remapGridLayoutDocumentIds } from "@vuu-ui/grid-layout";
+import { isLayoutJSON, resolveJSONPath } from "@vuu-ui/vuu-layout";
 import { useNotifications } from "@vuu-ui/vuu-notifications";
-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
-        ]));
+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;
     return {
-        version: WORKSPACE_SNAPSHOT_VERSION,
-        layout: document,
-        componentState: Object.fromEntries(Object.entries(source.componentState).map(([id, state])=>[
-                componentIds.get(id) ?? id,
-                cloneWorkspaceValue(state)
-            ]))
+        ...layout,
+        props: {
+            ...layout.props,
+            title: layoutMetadata.name
+        }
     };
 };
-const WorkspaceProvider = ({ activeLayoutIndex, children, componentRenderers, defaultWorkspace, layoutJSON, layoutPlaceholderJSON, persistenceService: serviceProp, settingsCodecs, showTabs, systemWorkspaces = [], TabstripProps, userId, workspaceJSON })=>{
-    const inheritedService = useOptionalWorkspacePersistenceService();
-    const service = serviceProp ?? inheritedService;
+const loadingApplicationJSON = {
+    workspaceJSON: loadingJSON
+};
+const WorkspaceProvider = ({ TabstripProps, children, layoutJSON, activeLayoutIndex, layoutPlaceholderJSON, showTabs, workspaceJSON: customWorkspaceJSON })=>{
+    const [layoutMetadata, setLayoutMetadata] = useState([]);
+    const [, forceRefresh] = useState({});
     const { showNotification } = useNotifications();
-    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
-        };
+    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);
     }, [
-        scopeKey,
-        service
+        setApplicationJSON
     ]);
-    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(()=>{
-        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();
+        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
                 });
-                if (!(cause instanceof StaleWorkspaceScopeError)) try {
-                    assertScope(guard);
-                    const error = notifyError("Failed to Load Workspaces", cause);
-                    setLoadError(error);
-                    setLoadedScope(scopeKey);
-                } catch  {}
             }
-        };
-        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 = [];
-        };
+        }).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);
+        });
     }, [
-        componentRenderers,
+        TabstripProps,
         activeLayoutIndex,
-        assertScope,
-        captureScope,
-        defaultWorkspace,
+        customWorkspaceJSON,
         layoutJSON,
-        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
+        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"
             });
-            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
+            setLayoutMetadata((prev)=>[
+                    ...prev,
+                    metadata
                 ]);
-            } catch (cause) {
-                await controller.dispose();
-                assertScope(guard);
-                await guard.service.deleteWorkspaceSnapshot(instanceId);
-                assertScope(guard);
-                throw errorFrom(cause, "Failed to save application session");
-            }
-            return instanceId;
-        });
-    }, [
-        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);
+        }).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);
         });
-    }, [
-        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
-                ]);
+        else {
+            console.error("Tried to save invalid layout", layoutToSave);
+            showNotification({
+                content: "Cannot save invalid layout",
+                header: "Failed to Save Layout",
+                status: "error",
+                type: "toast"
             });
-        } catch (cause) {
-            if (!(cause instanceof StaleWorkspaceScopeError)) notifyError("Failed to Rename Workspace", cause);
-            throw cause;
         }
     }, [
-        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
+        showNotification,
+        persistenceManager
     ]);
-    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));
-    }, [
-        assertScope,
-        captureScope,
-        service
-    ]);
-    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
-                }
-            ]);
+    const saveApplicationSettings = useCallback((settings, key)=>{
+        const { settings: applicationSettings } = applicationJSONRef.current;
+        key ? setApplicationSettings({
+            ...applicationSettings,
+            [key]: settings
+        }) : setApplicationSettings(settings);
+        persistenceManager?.saveApplicationJSON(applicationJSONRef.current);
     }, [
-        assertScope,
-        captureScope,
-        service
+        persistenceManager,
+        setApplicationSettings
     ]);
-    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
+    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
                 }
-            }, guard);
-        });
-    }, [
-        captureScope,
-        enqueueOperation,
-        writeSession
-    ]);
-    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);
-            }
+            });
+        }).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);
         });
-        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,
-            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
+        showNotification,
+        persistenceManager,
+        setWorkspaceJSON
     ]);
     return /*#__PURE__*/ jsx(WorkspaceContext.Provider, {
-        value: value,
+        value: {
+            getApplicationSettings,
+            layoutMetadata,
+            layoutPlaceholderJSON,
+            saveLayout,
+            workspaceJSON: applicationJSONRef.current.workspaceJSON,
+            saveApplicationLayout,
+            saveApplicationSettings,
+            loadLayoutById
+        },
         children: children
     });
 };
-const useWorkspace = ()=>useContext(WorkspaceContext);
-export { StaleWorkspaceScopeError, WorkspaceProvider, emptyWorkspaceSnapshot, useWorkspace };
+const useWorkspace = ()=>{
+    const { workspaceJSON = getWorkspaceWithLayoutJSON(), ...contextProps } = useContext(WorkspaceContext);
+    return {
+        ...contextProps,
+        workspaceJSON
+    };
+};
+export { WorkspaceProvider, useWorkspace };