@bolt-foundry/gambit 0.8.6-rc.2 → 0.8.6-rc.4

package/esm/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.d.ts

@@ -1,173 +1,173 @@
 export declare const gambitWorkspaceVerifyBatchRunCreateMutation: import("../src/hooks/defineGambitMutation.js").GambitMutationDefinition<import("../__generated__/__isograph/Mutation/GambitWorkspaceVerifyBatchRunCreate/param_type.js").Mutation__GambitWorkspaceVerifyBatchRunCreate__param, {
-    readonly workspace: ({
-        readonly id: (string | null);
-        readonly scenarioDecks: (ReadonlyArray<{
-            readonly id: (string | null);
-            readonly label: (string | null);
+    readonly workspace: {
+        readonly id: string;
+        readonly scenarioDecks: ReadonlyArray<{
+            readonly id: string;
+            readonly label: string;
             readonly description: (string | null);
-            readonly path: (string | null);
-        }> | null);
-        readonly verification: ({
-            readonly graderDecks: ({
-                readonly edges: (ReadonlyArray<({
-                    readonly node: ({
-                        readonly id: (string | null);
-                        readonly label: (string | null);
+            readonly path: string;
+        }>;
+        readonly verification: {
+            readonly graderDecks: {
+                readonly edges: ReadonlyArray<{
+                    readonly node: {
+                        readonly id: string;
+                        readonly label: string;
                         readonly description: (string | null);
-                        readonly path: (string | null);
-                    } | null);
-                } | null)> | null);
-            } | null);
-            readonly batches: ({
-                readonly edges: (ReadonlyArray<({
-                    readonly node: ({
-                        readonly id: (string | null);
-                        readonly workspaceId: (string | null);
+                        readonly path: string;
+                    };
+                }>;
+            };
+            readonly batches: {
+                readonly edges: ReadonlyArray<{
+                    readonly node: {
+                        readonly id: string;
+                        readonly workspaceId: string;
                         readonly scenarioDeckId: (string | null);
-                        readonly graderId: (string | null);
-                        readonly scenarioRuns: (number | null);
-                        readonly graderRepeatsPerScenario: (number | null);
-                        readonly status: (string | null);
+                        readonly graderId: string;
+                        readonly scenarioRuns: number;
+                        readonly graderRepeatsPerScenario: number;
+                        readonly status: string;
                         readonly startedAt: (string | null);
                         readonly finishedAt: (string | null);
-                        readonly requested: (number | null);
-                        readonly active: (number | null);
-                        readonly completed: (number | null);
-                        readonly failed: (number | null);
-                        readonly scenarioRunsCompleted: (number | null);
-                        readonly scenarioRunsFailed: (number | null);
-                        readonly requests: ({
-                            readonly edges: (ReadonlyArray<({
-                                readonly node: ({
-                                    readonly id: (string | null);
+                        readonly requested: number;
+                        readonly active: number;
+                        readonly completed: number;
+                        readonly failed: number;
+                        readonly scenarioRunsCompleted: number;
+                        readonly scenarioRunsFailed: number;
+                        readonly requests: {
+                            readonly edges: ReadonlyArray<{
+                                readonly node: {
+                                    readonly id: string;
                                     readonly scenarioRunId: (string | null);
-                                    readonly status: (string | null);
+                                    readonly status: string;
                                     readonly runId: (string | null);
                                     readonly error: (string | null);
-                                } | null);
-                            } | null)> | null);
-                        } | null);
+                                };
+                            }>;
+                        };
                         readonly metrics: ({
-                            readonly scenarioRunCountRequested: (number | null);
-                            readonly scenarioRunCountCompleted: (number | null);
-                            readonly scenarioRunCountFailed: (number | null);
-                            readonly gradeSampleCountRequested: (number | null);
-                            readonly gradeSampleCountCompleted: (number | null);
-                            readonly gradeSampleCountFailed: (number | null);
-                            readonly executionFailureCount: (number | null);
-                            readonly gradingFailureCount: (number | null);
+                            readonly scenarioRunCountRequested: number;
+                            readonly scenarioRunCountCompleted: number;
+                            readonly scenarioRunCountFailed: number;
+                            readonly gradeSampleCountRequested: number;
+                            readonly gradeSampleCountCompleted: number;
+                            readonly gradeSampleCountFailed: number;
+                            readonly executionFailureCount: number;
+                            readonly gradingFailureCount: number;
                             readonly passRate: (number | null);
                             readonly scoreMin: (number | null);
                             readonly scoreMedian: (number | null);
                             readonly scoreMax: (number | null);
                             readonly scoreMean: (number | null);
-                            readonly outlierScenarioRuns: ({
-                                readonly edges: (ReadonlyArray<({
-                                    readonly node: ({
-                                        readonly key: (string | null);
-                                        readonly scenarioRunId: (string | null);
-                                        readonly gradeSampleCount: (number | null);
-                                        readonly completedSampleCount: (number | null);
-                                        readonly executionFailureCount: (number | null);
-                                        readonly gradingFailureCount: (number | null);
+                            readonly outlierScenarioRuns: {
+                                readonly edges: ReadonlyArray<{
+                                    readonly node: {
+                                        readonly key: string;
+                                        readonly scenarioRunId: string;
+                                        readonly gradeSampleCount: number;
+                                        readonly completedSampleCount: number;
+                                        readonly executionFailureCount: number;
+                                        readonly gradingFailureCount: number;
                                         readonly averageScore: (number | null);
                                         readonly minScore: (number | null);
                                         readonly maxScore: (number | null);
-                                        readonly failed: (boolean | null);
+                                        readonly failed: boolean;
                                         readonly minRunId: (string | null);
                                         readonly maxRunId: (string | null);
                                         readonly messageRefId: (string | null);
-                                    } | null);
-                                } | null)> | null);
-                            } | null);
-                            readonly failureReasons: ({
-                                readonly edges: (ReadonlyArray<({
-                                    readonly node: ({
-                                        readonly key: (string | null);
-                                        readonly kind: (string | null);
-                                        readonly reason: (string | null);
-                                        readonly count: (number | null);
-                                    } | null);
-                                } | null)> | null);
-                            } | null);
+                                    };
+                                }>;
+                            };
+                            readonly failureReasons: {
+                                readonly edges: ReadonlyArray<{
+                                    readonly node: {
+                                        readonly key: string;
+                                        readonly kind: string;
+                                        readonly reason: string;
+                                        readonly count: number;
+                                    };
+                                }>;
+                            };
                         } | null);
-                    } | null);
-                } | null)> | null);
-            } | null);
-        } | null);
-    } | null);
-    readonly batch: ({
-        readonly id: (string | null);
-        readonly workspaceId: (string | null);
+                    };
+                }>;
+            };
+        };
+    };
+    readonly batch: {
+        readonly id: string;
+        readonly workspaceId: string;
         readonly scenarioDeckId: (string | null);
-        readonly graderId: (string | null);
-        readonly scenarioRuns: (number | null);
-        readonly graderRepeatsPerScenario: (number | null);
-        readonly status: (string | null);
+        readonly graderId: string;
+        readonly scenarioRuns: number;
+        readonly graderRepeatsPerScenario: number;
+        readonly status: string;
         readonly startedAt: (string | null);
         readonly finishedAt: (string | null);
-        readonly requested: (number | null);
-        readonly active: (number | null);
-        readonly completed: (number | null);
-        readonly failed: (number | null);
-        readonly scenarioRunsCompleted: (number | null);
-        readonly scenarioRunsFailed: (number | null);
-        readonly requests: ({
-            readonly edges: (ReadonlyArray<({
-                readonly node: ({
-                    readonly id: (string | null);
+        readonly requested: number;
+        readonly active: number;
+        readonly completed: number;
+        readonly failed: number;
+        readonly scenarioRunsCompleted: number;
+        readonly scenarioRunsFailed: number;
+        readonly requests: {
+            readonly edges: ReadonlyArray<{
+                readonly node: {
+                    readonly id: string;
                     readonly scenarioRunId: (string | null);
-                    readonly status: (string | null);
+                    readonly status: string;
                     readonly runId: (string | null);
                     readonly error: (string | null);
-                } | null);
-            } | null)> | null);
-        } | null);
+                };
+            }>;
+        };
         readonly metrics: ({
-            readonly scenarioRunCountRequested: (number | null);
-            readonly scenarioRunCountCompleted: (number | null);
-            readonly scenarioRunCountFailed: (number | null);
-            readonly gradeSampleCountRequested: (number | null);
-            readonly gradeSampleCountCompleted: (number | null);
-            readonly gradeSampleCountFailed: (number | null);
-            readonly executionFailureCount: (number | null);
-            readonly gradingFailureCount: (number | null);
+            readonly scenarioRunCountRequested: number;
+            readonly scenarioRunCountCompleted: number;
+            readonly scenarioRunCountFailed: number;
+            readonly gradeSampleCountRequested: number;
+            readonly gradeSampleCountCompleted: number;
+            readonly gradeSampleCountFailed: number;
+            readonly executionFailureCount: number;
+            readonly gradingFailureCount: number;
             readonly passRate: (number | null);
             readonly scoreMin: (number | null);
             readonly scoreMedian: (number | null);
             readonly scoreMax: (number | null);
             readonly scoreMean: (number | null);
-            readonly outlierScenarioRuns: ({
-                readonly edges: (ReadonlyArray<({
-                    readonly node: ({
-                        readonly key: (string | null);
-                        readonly scenarioRunId: (string | null);
-                        readonly gradeSampleCount: (number | null);
-                        readonly completedSampleCount: (number | null);
-                        readonly executionFailureCount: (number | null);
-                        readonly gradingFailureCount: (number | null);
+            readonly outlierScenarioRuns: {
+                readonly edges: ReadonlyArray<{
+                    readonly node: {
+                        readonly key: string;
+                        readonly scenarioRunId: string;
+                        readonly gradeSampleCount: number;
+                        readonly completedSampleCount: number;
+                        readonly executionFailureCount: number;
+                        readonly gradingFailureCount: number;
                         readonly averageScore: (number | null);
                         readonly minScore: (number | null);
                         readonly maxScore: (number | null);
-                        readonly failed: (boolean | null);
+                        readonly failed: boolean;
                         readonly minRunId: (string | null);
                         readonly maxRunId: (string | null);
                         readonly messageRefId: (string | null);
-                    } | null);
-                } | null)> | null);
-            } | null);
-            readonly failureReasons: ({
-                readonly edges: (ReadonlyArray<({
-                    readonly node: ({
-                        readonly key: (string | null);
-                        readonly kind: (string | null);
-                        readonly reason: (string | null);
-                        readonly count: (number | null);
-                    } | null);
-                } | null)> | null);
-            } | null);
+                    };
+                }>;
+            };
+            readonly failureReasons: {
+                readonly edges: ReadonlyArray<{
+                    readonly node: {
+                        readonly key: string;
+                        readonly kind: string;
+                        readonly reason: string;
+                        readonly count: number;
+                    };
+                }>;
+            };
         } | null);
-    } | null);
-} | null, import("../__generated__/__isograph/Mutation/GambitWorkspaceVerifyBatchRunCreate/raw_response_type.js").Mutation__GambitWorkspaceVerifyBatchRunCreate__raw_response_type>;
+    };
+}, import("../__generated__/__isograph/Mutation/GambitWorkspaceVerifyBatchRunCreate/raw_response_type.js").Mutation__GambitWorkspaceVerifyBatchRunCreate__raw_response_type>;
 export default gambitWorkspaceVerifyBatchRunCreateMutation;
 //# sourceMappingURL=GambitWorkspaceVerifyBatchRunCreateMutation.d.ts.map

package/esm/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GambitWorkspaceVerifyBatchRunCreateMutation.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mLAKvD,CAAC;AAEF,eAAe,2CAA2C,CAAC"}
+{"version":3,"file":"GambitWorkspaceVerifyBatchRunCreateMutation.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/mutations/GambitWorkspaceVerifyBatchRunCreateMutation.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,2CAA2C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4KAKvD,CAAC;AAEF,eAAe,2CAA2C,CAAC"}

package/esm/simulator-ui/src/AppIsoMinimal.d.ts

@@ -3,5 +3,8 @@ export declare function AppIsoMinimal(props: {
     entrypoint: any;
     params?: Record<string, string>;
     onNavigate?: (nextPath: string) => void;
+    fallback?: React.ReactNode;
+    rendererKey?: string;
+    shouldFetch?: "IfNecessary" | "No" | "Yes";
 }): React.JSX.Element;
 //# sourceMappingURL=AppIsoMinimal.d.ts.map

package/esm/simulator-ui/src/AppIsoMinimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AppIsoMinimal.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppIsoMinimal.tsx"],"names":[],"mappings":"AACA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAgI3D,wBAAgB,aAAa,CAAC,KAAK,EAAE;IAEnC,UAAU,EAAE,GAAG,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC,qBAkBA"}
+{"version":3,"file":"AppIsoMinimal.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppIsoMinimal.tsx"],"names":[],"mappings":"AACA,OAAO,KAAsC,MAAM,OAAO,CAAC;AAqI3D,wBAAgB,aAAa,CAAC,KAAK,EAAE;IAEnC,UAAU,EAAE,GAAG,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,aAAa,GAAG,IAAI,GAAG,KAAK,CAAC;CAC5C,qBAuBA"}

package/esm/simulator-ui/src/AppIsoMinimal.js

@@ -31,7 +31,10 @@ class IsoErrorBoundary extends React.Component {
 }
 function IsoMinimalRenderer(props) {
     const redirectInFlightRef = useRef(null);
-    const { fragmentReference } = useLazyReference(props.entrypoint, props.params);
+    const fetchOptions = props.shouldFetch
+        ? { shouldFetch: props.shouldFetch }
+        : undefined;
+    const { fragmentReference } = useLazyReference(props.entrypoint, props.params, fetchOptions);
     const result = useResult(fragmentReference);
     useEffect(() => {
         if (result?.status !== 302) {
@@ -94,8 +97,8 @@ function IsoMinimalRenderer(props) {
     return React.createElement(Body, null);
 }
 export function AppIsoMinimal(props) {
-    const { entrypoint, params = {}, onNavigate, } = props;
+    const { entrypoint, params = {}, onNavigate, fallback = null, rendererKey, shouldFetch, } = props;
     return (React.createElement(IsoErrorBoundary, null,
-        React.createElement(Suspense, { fallback: React.createElement("div", null, "Loading Isograph entrypoint...") },
-            React.createElement(IsoMinimalRenderer, { entrypoint: entrypoint, params: params, onNavigate: onNavigate }))));
+        React.createElement(Suspense, { fallback: fallback },
+            React.createElement(IsoMinimalRenderer, { key: rendererKey, entrypoint: entrypoint, params: params, onNavigate: onNavigate, shouldFetch: shouldFetch }))));
 }

package/esm/simulator-ui/src/AppRoot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AppRoot.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAqD3D,wBAAgB,OAAO,CAAC,KAAK,EAAE;IAC7B,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,+BAwBA"}
+{"version":3,"file":"AppRoot.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppRoot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAiE3D,wBAAgB,OAAO,CAAC,KAAK,EAAE;IAC7B,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,+BA4BA"}

package/esm/simulator-ui/src/AppRoot.js

@@ -1,5 +1,5 @@
 import { IsographEnvironmentProvider } from "@isograph/react";
-import { useEffect, useState, useSyncExternalStore } from "react";
+import { useEffect, useSyncExternalStore } from "react";
 import { RouterProvider } from "./RouterContext.js";
 import { MinimalRouterRoot } from "./MinimalRouterRoot.js";
 import { getEnvironment } from "./isographEnvironment.js";
@@ -42,9 +42,17 @@ function subscribeToSystemColorScheme(onStoreChange) {
     }
     return () => { };
 }
+function subscribeToAppearance(onStoreChange) {
+    globalThis.addEventListener("storage", onStoreChange);
+    globalThis.addEventListener("gambit-simulator-theme-change", onStoreChange);
+    return () => {
+        globalThis.removeEventListener("storage", onStoreChange);
+        globalThis.removeEventListener("gambit-simulator-theme-change", onStoreChange);
+    };
+}
 export function AppRoot(props) {
     const environment = props.environment ?? getEnvironment();
-    const [appearance] = useState(readStoredAppearance);
+    const appearance = useSyncExternalStore(subscribeToAppearance, readStoredAppearance, readStoredAppearance);
     const systemPrefersDark = useSyncExternalStore(subscribeToSystemColorScheme, getSystemPrefersDark, getSystemPrefersDark);
     const theme = appearance === "system"
         ? (systemPrefersDark ? "dark" : "light")

package/esm/simulator-ui/src/AppShell.d.ts

@@ -3,11 +3,17 @@ export declare function AppShell(props: {
     Drawer: React.ComponentType<{
         open: boolean;
         onSelect: (workspaceId: string) => void;
+        onDelete: (workspaceId: string) => Promise<void>;
+        onDeleteAll: (workspaceIds: Array<string>) => Promise<void>;
         onClose: () => void;
         activeWorkspaceId?: string | null;
         bundleStamp: string | null;
         onCreateWorkspace?: () => void;
         creatingWorkspace?: boolean;
+        deletingWorkspaceId?: string | null;
+        deletingAll?: boolean;
+        appearance: "light" | "dark" | "system";
+        onAppearanceChange: (appearance: "light" | "dark" | "system") => void;
     }>;
     Workbench?: React.ComponentType<{
         open: boolean;

package/esm/simulator-ui/src/AppShell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AppShell.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppShell.tsx"],"names":[],"mappings":"AAsCA,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAC9B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC;QAC1B,IAAI,EAAE,OAAO,CAAC;QACd,QAAQ,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;QACxC,OAAO,EAAE,MAAM,IAAI,CAAC;QACpB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAClC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;KAC7B,CAAC,CAAC;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;QAC9B,IAAI,EAAE,OAAO,CAAC;KACf,CAAC,CAAC;CACJ,+BAkPA"}
+{"version":3,"file":"AppShell.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/AppShell.tsx"],"names":[],"mappings":"AAwCA,wBAAgB,QAAQ,CAAC,KAAK,EAAE;IAC9B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;IAC1B,MAAM,EAAE,KAAK,CAAC,aAAa,CAAC;QAC1B,IAAI,EAAE,OAAO,CAAC;QACd,QAAQ,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAC;QACxC,QAAQ,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QACjD,WAAW,EAAE,CAAC,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;QAC5D,OAAO,EAAE,MAAM,IAAI,CAAC;QACpB,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QAClC,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;QAC3B,iBAAiB,CAAC,EAAE,MAAM,IAAI,CAAC;QAC/B,iBAAiB,CAAC,EAAE,OAAO,CAAC;QAC5B,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACpC,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC;QACxC,kBAAkB,EAAE,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,KAAK,IAAI,CAAC;KACvE,CAAC,CAAC;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,aAAa,CAAC;QAC9B,IAAI,EAAE,OAAO,CAAC;KACf,CAAC,CAAC;CACJ,+BAmVA"}

package/esm/simulator-ui/src/AppShell.js

@@ -1,14 +1,16 @@
 import * as dntShim from "../../_dnt.shims.js";
-import { Suspense, useCallback, useMemo, useState } from "react";
+import { useCallback, useMemo, useState } from "react";
 import { buildWorkspacePath, parseWorkspaceRoute, } from "../../src/workspace_routes.js";
 import { verifyTabEnabled } from "./utils.js";
 import { useRouter } from "./RouterContext.js";
 import Button from "./gds/Button.js";
 import Icon from "./gds/Icon.js";
 import WorkbenchDrawer from "./WorkbenchDrawer.js";
-import { classNames } from "./utils.js";
+import { classNames, DOCS_PATH } from "./utils.js";
 import { useGambitTypedMutation } from "./hooks/useGambitTypedMutation.js";
 import gambitWorkspaceCreateMutation from "../mutations/GambitWorkspaceCreateMutation.js";
+import gambitWorkspaceDeleteMutation from "../mutations/GambitWorkspaceDeleteMutation.js";
+import DocsPage from "./DocsPage.js";
 function getDeckLabelForShell() {
     const globals = dntShim.dntGlobalThis;
     if (typeof globals.__GAMBIT_DECK_LABEL__ === "string" &&
@@ -25,6 +27,7 @@ function getDeckLabelForShell() {
     return "Unknown deck";
 }
 export function AppShell(props) {
+    const THEME_STORAGE_KEY = "gambit-simulator-theme";
     const { Drawer } = props;
     const { currentRoutePath, navigate } = useRouter();
     const routePrefix = useMemo(() => currentRoutePath === "/isograph" ||
@@ -41,7 +44,23 @@ export function AppShell(props) {
     const deckLabel = getDeckLabelForShell();
     const [drawerOpen, setDrawerOpen] = useState(false);
     const [workbenchOpen, setWorkbenchOpen] = useState(true);
+    const [deletingWorkspaceId, setDeletingWorkspaceId] = useState(null);
+    const [deletingAll, setDeletingAll] = useState(false);
+    const [appearance, setAppearance] = useState(() => {
+        try {
+            const savedTheme = globalThis.localStorage.getItem(THEME_STORAGE_KEY);
+            if (savedTheme === "light" || savedTheme === "dark" ||
+                savedTheme === "system") {
+                return savedTheme;
+            }
+        }
+        catch {
+            // ignore storage read errors and fall back to system
+        }
+        return "system";
+    });
     const createWorkspaceMutation = useGambitTypedMutation(gambitWorkspaceCreateMutation);
+    const deleteWorkspaceMutation = useGambitTypedMutation(gambitWorkspaceDeleteMutation);
     const Workbench = props.Workbench ?? WorkbenchDrawer;
     const activeWorkspaceId = useMemo(() => {
         const route = parseWorkspaceRoute(workspaceRoutePath);
@@ -54,6 +73,7 @@ export function AppShell(props) {
     const buildTabLabel = routePrefix ? "Build (isograph)" : "Build";
     const isWorkspacesPath = useMemo(() => workspaceRoutePath === "/workspaces" ||
         workspaceRoutePath === "/workspaces/new", [workspaceRoutePath]);
+    const isDocsPath = workspaceRoutePath === "/docs";
     const canOpenWorkbench = Boolean(activeWorkspaceId);
     const workbenchVisible = workbenchOpen && canOpenWorkbench;
     const handleSelectWorkspace = useCallback((workspaceId) => {
@@ -70,36 +90,86 @@ export function AppShell(props) {
             },
         });
     }, [createWorkspaceMutation, navigate, toPrefixedPath]);
+    const persistAppearance = useCallback((nextAppearance) => {
+        try {
+            globalThis.localStorage.setItem(THEME_STORAGE_KEY, nextAppearance);
+        }
+        catch {
+            // ignore storage write errors
+        }
+        globalThis.dispatchEvent(new Event("gambit-simulator-theme-change"));
+        setAppearance(nextAppearance);
+    }, []);
+    const runDeleteWorkspaceMutation = useCallback((workspaceId) => new Promise((resolve, reject) => {
+        deleteWorkspaceMutation.commit({ workspaceId }, {
+            onComplete: (result) => {
+                if (result?.deleted) {
+                    resolve();
+                    return;
+                }
+                reject(new Error(result?.error ?? `Failed to delete workspace ${workspaceId}`));
+            },
+            onError: () => {
+                reject(new Error(`Failed to delete workspace ${workspaceId}`));
+            },
+        });
+    }), [deleteWorkspaceMutation]);
+    const deleteWorkspace = useCallback(async (workspaceId) => {
+        setDeletingWorkspaceId(workspaceId);
+        try {
+            await runDeleteWorkspaceMutation(workspaceId);
+            if (workspaceId === activeWorkspaceId) {
+                navigate(toPrefixedPath("/workspaces"));
+            }
+        }
+        finally {
+            setDeletingWorkspaceId(null);
+        }
+    }, [activeWorkspaceId, navigate, runDeleteWorkspaceMutation, toPrefixedPath]);
+    const deleteAllWorkspaces = useCallback(async (workspaceIds) => {
+        const uniqueWorkspaceIds = Array.from(new Set(workspaceIds.filter((id) => id.trim().length > 0)));
+        if (uniqueWorkspaceIds.length === 0) {
+            return;
+        }
+        setDeletingAll(true);
+        try {
+            await Promise.allSettled(uniqueWorkspaceIds.map((workspaceId) => runDeleteWorkspaceMutation(workspaceId)));
+            navigate(toPrefixedPath("/workspaces"));
+        }
+        finally {
+            setDeletingAll(false);
+        }
+    }, [navigate, runDeleteWorkspaceMutation, toPrefixedPath]);
     return (React.createElement("div", { className: "app-root" },
         React.createElement("header", { className: "top-nav" },
             React.createElement("div", { className: "top-nav-left" },
                 React.createElement(Button, { "data-testid": "nav-sessions", className: classNames("sessions-toggle", drawerOpen && "active"), variant: "secondary", onClick: () => setDrawerOpen(true), "aria-label": "Open sessions drawer" },
-                    React.createElement(Icon, { name: "hamburgerMenu", size: 17, style: { color: "var(--color-text)" } })),
-                React.createElement("div", { className: "top-nav-buttons tab-anchor-group" },
-                    React.createElement("span", { className: "tab-anchor-indicator", "aria-hidden": "true" }),
-                    React.createElement(Button, { "data-testid": "nav-workspaces", tab: true, variant: isWorkspacesPath ? "primary" : "secondary", className: classNames("tab-anchor", isWorkspacesPath && "tab-anchor--active"), onClick: () => navigate(toPrefixedPath("/workspaces")) }, "Workspaces"),
-                    React.createElement(Button, { "data-testid": "nav-build", tab: true, variant: activeWorkspaceTab === "build" ? "primary" : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "build" && "tab-anchor--active"), onClick: () => {
-                            if (!activeWorkspaceId)
-                                return;
-                            navigate(toPrefixedPath(buildWorkspacePath("build", activeWorkspaceId)));
-                        }, disabled: !activeWorkspaceId }, buildTabLabel),
-                    React.createElement(Button, { "data-testid": "nav-test", tab: true, variant: activeWorkspaceTab === "test" ? "primary" : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "test" && "tab-anchor--active"), onClick: () => {
-                            if (!activeWorkspaceId)
-                                return;
-                            navigate(toPrefixedPath(buildWorkspacePath("test", activeWorkspaceId)));
-                        }, disabled: !activeWorkspaceId }, "Test"),
-                    React.createElement(Button, { "data-testid": "nav-grade", tab: true, variant: activeWorkspaceTab === "grade" ? "primary" : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "grade" && "tab-anchor--active"), onClick: () => {
-                            if (!activeWorkspaceId)
-                                return;
-                            navigate(toPrefixedPath(buildWorkspacePath("grade", activeWorkspaceId)));
-                        }, disabled: !activeWorkspaceId }, "Grade"),
-                    verifyTabEnabled && (React.createElement(Button, { "data-testid": "nav-verify", tab: true, variant: activeWorkspaceTab === "verify"
-                            ? "primary"
-                            : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "verify" && "tab-anchor--active"), onClick: () => {
-                            if (!activeWorkspaceId)
-                                return;
-                            navigate(toPrefixedPath(buildWorkspacePath("verify", activeWorkspaceId)));
-                        }, disabled: !activeWorkspaceId }, "Verify")))),
+                    React.createElement(Icon, { name: "hamburgerMenu", size: 17, style: { color: "var(--color-text)" } }))),
+            React.createElement("div", { className: "top-nav-buttons tab-anchor-group" },
+                React.createElement("span", { className: "tab-anchor-indicator", "aria-hidden": "true" }),
+                React.createElement(Button, { "data-testid": "nav-docs", tab: true, variant: isDocsPath ? "primary" : "secondary", className: classNames("tab-anchor", isDocsPath && "tab-anchor--active"), onClick: () => navigate(toPrefixedPath(DOCS_PATH)) }, "Docs"),
+                React.createElement(Button, { "data-testid": "nav-build", tab: true, variant: activeWorkspaceTab === "build" ? "primary" : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "build" && "tab-anchor--active"), onClick: () => {
+                        if (!activeWorkspaceId)
+                            return;
+                        navigate(toPrefixedPath(buildWorkspacePath("build", activeWorkspaceId)));
+                    }, disabled: !activeWorkspaceId }, buildTabLabel),
+                React.createElement(Button, { "data-testid": "nav-test", tab: true, variant: activeWorkspaceTab === "test" ? "primary" : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "test" && "tab-anchor--active"), onClick: () => {
+                        if (!activeWorkspaceId)
+                            return;
+                        navigate(toPrefixedPath(buildWorkspacePath("test", activeWorkspaceId)));
+                    }, disabled: !activeWorkspaceId }, "Test"),
+                React.createElement(Button, { "data-testid": "nav-grade", tab: true, variant: activeWorkspaceTab === "grade" ? "primary" : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "grade" && "tab-anchor--active"), onClick: () => {
+                        if (!activeWorkspaceId)
+                            return;
+                        navigate(toPrefixedPath(buildWorkspacePath("grade", activeWorkspaceId)));
+                    }, disabled: !activeWorkspaceId }, "Grade"),
+                verifyTabEnabled && (React.createElement(Button, { "data-testid": "nav-verify", tab: true, variant: activeWorkspaceTab === "verify"
+                        ? "primary"
+                        : "secondary", className: classNames("tab-anchor", activeWorkspaceTab === "verify" && "tab-anchor--active"), onClick: () => {
+                        if (!activeWorkspaceId)
+                            return;
+                        navigate(toPrefixedPath(buildWorkspacePath("verify", activeWorkspaceId)));
+                    }, disabled: !activeWorkspaceId }, "Verify"))),
             React.createElement("div", { className: "top-nav-center" },
                 React.createElement("span", { className: "top-nav-deck" }, deckLabel)),
             React.createElement("div", { className: "top-nav-right" },
@@ -112,7 +182,7 @@ export function AppShell(props) {
             React.createElement("main", { className: "page-shell" },
                 isWorkspacesPath && (React.createElement("div", { style: { padding: "12px 16px 0 16px" } },
                     React.createElement(Button, { "data-testid": "workspace-create-cta", variant: "primary", size: "small", onClick: createWorkspace, disabled: createWorkspaceMutation.inFlight }, "New workspace"))),
-                React.createElement(Suspense, { fallback: React.createElement("div", { style: { padding: "12px 16px" } }, "Loading...") }, props.children)),
+                isDocsPath ? React.createElement(DocsPage, null) : props.children),
             React.createElement(Workbench, { open: workbenchVisible })),
-        React.createElement(Drawer, { open: drawerOpen, onCreateWorkspace: createWorkspace, onSelect: handleSelectWorkspace, onClose: () => setDrawerOpen(false), activeWorkspaceId: activeWorkspaceId, bundleStamp: null, creatingWorkspace: createWorkspaceMutation.inFlight })));
+        React.createElement(Drawer, { open: drawerOpen, onCreateWorkspace: createWorkspace, onSelect: handleSelectWorkspace, onDelete: deleteWorkspace, onDeleteAll: deleteAllWorkspaces, onClose: () => setDrawerOpen(false), activeWorkspaceId: activeWorkspaceId, bundleStamp: null, creatingWorkspace: createWorkspaceMutation.inFlight, deletingWorkspaceId: deletingWorkspaceId, deletingAll: deletingAll, appearance: appearance, onAppearanceChange: persistAppearance })));
 }

package/esm/simulator-ui/src/DocsPage.d.ts

@@ -0,0 +1,2 @@
+export default function DocsPage(): import("react").JSX.Element;
+//# sourceMappingURL=DocsPage.d.ts.map

package/esm/simulator-ui/src/DocsPage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocsPage.d.ts","sourceRoot":"","sources":["../../../src/simulator-ui/src/DocsPage.tsx"],"names":[],"mappings":"AAcA,MAAM,CAAC,OAAO,UAAU,QAAQ,gCAsI/B"}