@dxos/plugin-debug 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/src/capabilities/index.ts

@@ -2,9 +2,7 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
-
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const ReactContext = lazy(() => import('./react-context'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const DebugSettings = lazy(() => import('./settings'));
+export * from './app-graph-builder';
+export * from './react-context';
+export * from './react-surface';
+export * from './settings';

package/src/capabilities/react-context/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactContext = Capability.lazy('ReactContext', () => import('./react-context'));

package/src/capabilities/react-context/react-context.tsx

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { DevtoolsContextProvider } from '@dxos/devtools';
+
+import { meta } from '../../meta';
+
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Common.Capability.ReactContext, {
+      id: meta.id,
+      context: ({ children }) => <DevtoolsContextProvider>{children}</DevtoolsContextProvider>,
+    }),
+  ),
+);

package/src/capabilities/react-surface/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));

package/src/capabilities/react-surface/react-surface.tsx

@@ -0,0 +1,409 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import React, { useCallback } from 'react';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { useCapability, useLayout, useOperationInvoker, useSettingsState } from '@dxos/app-framework/react';
+import {
+  AutomergePanel,
+  ConfigPanel,
+  CredentialsPanel,
+  DeviceListPanel,
+  DiagnosticsPanel,
+  EdgeDashboardPanel,
+  FeedsPanel,
+  IdentityPanel,
+  InvocationTraceContainer,
+  KeyringPanel,
+  LoggingPanel,
+  MembersPanel,
+  MetadataPanel,
+  NetworkPanel,
+  ObjectsPanel,
+  QueuesPanel,
+  SchemaPanel,
+  SignalPanel,
+  SpaceInfoPanel,
+  SpaceListPanel,
+  StoragePanel,
+  SwarmPanel,
+  TestingPanel,
+  TracingPanel,
+  WorkflowPanel,
+} from '@dxos/devtools';
+import { Obj } from '@dxos/echo';
+import { log } from '@dxos/log';
+import { ClientCapabilities } from '@dxos/plugin-client';
+import { type Graph } from '@dxos/plugin-graph';
+import { ScriptOperation } from '@dxos/plugin-script/types';
+import { SpaceOperation } from '@dxos/plugin-space/types';
+import { type Space, SpaceState, isSpace, parseId } from '@dxos/react-client/echo';
+import { Layout } from '@dxos/react-ui-mosaic';
+import { Collection } from '@dxos/schema';
+
+import {
+  DebugGraph,
+  DebugObjectPanel,
+  DebugSettings,
+  DebugStatus,
+  DevtoolsOverviewContainer,
+  SpaceGenerator,
+  Wireframe,
+} from '../../components';
+import { meta } from '../../meta';
+import { DebugCapabilities, type DebugSettingsProps, Devtools } from '../../types';
+
+type SpaceDebug = {
+  type: string;
+  space: Space;
+};
+
+type GraphDebug = {
+  graph: Graph.Graph;
+  root: string;
+};
+
+const isSpaceDebug = (data: any): data is SpaceDebug => data?.type === `${meta.id}/space` && isSpace(data.space);
+const isGraphDebug = (data: any): data is GraphDebug => {
+  const graph = data?.graph;
+  return (
+    graph != null && typeof graph === 'object' && typeof graph.json === 'function' && typeof data?.root === 'string'
+  );
+};
+
+// TODO(wittjosiah): Factor out?
+const useCurrentSpace = () => {
+  const layout = useLayout();
+  const client = useCapability(ClientCapabilities.Client);
+  const { spaceId } = parseId(layout.workspace);
+  const space = spaceId ? client.spaces.get(spaceId) : undefined;
+  return space;
+};
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const capabilities = yield* Capability.Service;
+    const registry = capabilities.get(Common.Capability.AtomRegistry);
+    const settingsAtom = capabilities.get(DebugCapabilities.Settings);
+
+    return Capability.contributes(Common.Capability.ReactSurface, [
+      Common.createSurface({
+        id: `${meta.id}/plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: Common.Capability.Settings } =>
+          Common.Capability.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<DebugSettingsProps>(subject.atom);
+          return <DebugSettings settings={settings} onSettingsChange={updateSettings} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/space`,
+        role: 'article',
+        filter: (data): data is { subject: SpaceDebug } => isSpaceDebug(data.subject),
+        component: ({ role, data }) => {
+          const { invokePromise } = useOperationInvoker();
+
+          const handleCreateObject = useCallback(
+            (objects: Obj.Unknown[]) => {
+              if (!isSpace(data.subject.space)) {
+                return;
+              }
+
+              const collection =
+                data.subject.space.state.get() === SpaceState.SPACE_READY &&
+                data.subject.space.properties[Collection.Collection.typename]?.target;
+              if (!Obj.instanceOf(Collection.Collection, collection)) {
+                return;
+              }
+
+              objects.forEach((object) => {
+                void invokePromise(SpaceOperation.AddObject, {
+                  target: collection,
+                  object,
+                });
+              });
+            },
+            [data.subject.space, invokePromise],
+          );
+
+          return (
+            <Layout.Main role={role}>
+              <SpaceGenerator space={data.subject.space} onCreateObjects={handleCreateObject} />
+            </Layout.Main>
+          );
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/app-graph`,
+        role: 'article',
+        filter: (data): data is { subject: GraphDebug } => isGraphDebug(data.subject),
+        component: ({ data }) => <DebugGraph graph={data.subject.graph} root={data.subject.root} />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/wireframe`,
+        role: ['article', 'section'],
+        position: 'hoist',
+        filter: (data): data is { subject: Obj.Unknown } => {
+          const settings = registry.get(settingsAtom);
+          return Obj.isObject(data.subject) && !!settings.wireframe;
+        },
+        component: ({ data, role }) => (
+          <Wireframe label={`${role}:${name}`} object={data.subject} classNames='row-span-2 overflow-hidden' />
+        ),
+      }),
+      Common.createSurface({
+        id: `${meta.id}/object-debug`,
+        role: 'article',
+        filter: (data): data is { companionTo: Obj.Unknown } =>
+          data.subject === 'debug' && Obj.isObject(data.companionTo),
+        component: ({ data }) => <DebugObjectPanel object={data.companionTo} />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/devtools-overview`,
+        role: 'deck-companion--devtools',
+        component: () => <DevtoolsOverviewContainer />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/status`,
+        role: 'status',
+        component: () => <DebugStatus />,
+      }),
+
+      //
+      // Devtools
+      //
+
+      Common.createSurface({
+        id: `${meta.id}/client/config`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Config,
+        component: () => <ConfigPanel vaultSelector={false} />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/client/storage`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Storage,
+        component: () => <StoragePanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/client/logs`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Logs,
+        component: () => <LoggingPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/client/diagnostics`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Diagnostics,
+        component: () => <DiagnosticsPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/client/tracing`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Client.Tracing,
+        component: () => <TracingPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/halo/identity`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Identity,
+        component: () => <IdentityPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/halo/devices`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Devices,
+        component: () => <DeviceListPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/halo/keyring`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Keyring,
+        component: () => <KeyringPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/halo/credentials`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Halo.Credentials,
+        component: () => {
+          const space = useCurrentSpace();
+          return <CredentialsPanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/spaces`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Spaces,
+        component: () => {
+          const { invokePromise } = useOperationInvoker();
+          const handleSelect = useCallback(
+            () => invokePromise(Common.LayoutOperation.Open, { subject: [Devtools.Echo.Space] }),
+            [invokePromise],
+          );
+          return <SpaceListPanel onSelect={handleSelect} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/space`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Space,
+        component: () => {
+          const space = useCurrentSpace();
+          const { invokePromise } = useOperationInvoker();
+          const handleSelect = useCallback(
+            () => invokePromise(Common.LayoutOperation.Open, { subject: [Devtools.Echo.Feeds] }),
+            [invokePromise],
+          );
+          return <SpaceInfoPanel space={space} onSelectFeed={handleSelect} onSelectPipeline={handleSelect} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/feeds`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Feeds,
+        component: () => {
+          const space = useCurrentSpace();
+          return <FeedsPanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/objects`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Objects,
+        component: () => {
+          const space = useCurrentSpace();
+          return <ObjectsPanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/schema`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Schema,
+        component: () => {
+          const space = useCurrentSpace();
+          return <SchemaPanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/automerge`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Automerge,
+        component: () => {
+          const space = useCurrentSpace();
+          return <AutomergePanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/queues`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Queues,
+        component: () => <QueuesPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/members`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Members,
+        component: () => {
+          const space = useCurrentSpace();
+          return <MembersPanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/echo/metadata`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Echo.Metadata,
+        component: () => <MetadataPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/mesh/signal`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Mesh.Signal,
+        component: () => <SignalPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/mesh/swarm`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Mesh.Swarm,
+        component: () => <SwarmPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/mesh/network`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Mesh.Network,
+        component: () => {
+          const space = useCurrentSpace();
+          return <NetworkPanel space={space} />;
+        },
+      }),
+      // TODO(wittjosiah): Remove?
+      // createSurface({
+      //   id: `${meta.id}/agent/dashboard`,
+      //   role: 'article',
+      //   filter: (data): data is any => data.subject === Devtools.Agent.Dashboard,
+      //   component: () => <DashboardPanel />,
+      // }),
+      Common.createSurface({
+        id: `${meta.id}/edge/dashboard`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Dashboard,
+        component: () => <EdgeDashboardPanel />,
+      }),
+      Common.createSurface({
+        id: `${meta.id}/edge/workflows`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Workflows,
+        component: () => {
+          const space = useCurrentSpace();
+          return <WorkflowPanel space={space} />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/edge/traces`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Traces,
+        component: () => {
+          const space = useCurrentSpace();
+          const queueDxn = space?.properties.invocationTraceQueue?.dxn;
+          return <InvocationTraceContainer db={space?.db} queueDxn={queueDxn} detailAxis='block' />;
+        },
+      }),
+      Common.createSurface({
+        id: `${meta.id}/edge/testing`,
+        role: 'article',
+        filter: (data): data is any => data.subject === Devtools.Edge.Testing,
+        component: () => {
+          const { invokePromise } = useOperationInvoker();
+          const onSpaceCreate = useCallback(
+            async (space: Space) => {
+              await space.waitUntilReady();
+              await invokePromise(SpaceOperation.Migrate, { space });
+              await space.db.flush();
+            },
+            [invokePromise],
+          );
+          const onScriptPluginOpen = useCallback(
+            async (space: Space) => {
+              await space.waitUntilReady();
+              const createResult = await invokePromise(ScriptOperation.CreateScript, { db: space.db });
+              if (createResult.data?.object) {
+                await invokePromise(SpaceOperation.AddObject, { target: space.db, object: createResult.data.object });
+              }
+              log.info('script created', { result: createResult });
+              if (createResult.data?.object?.id) {
+                await invokePromise(Common.LayoutOperation.Open, {
+                  subject: [`${space.id}:${createResult.data.object.id}`],
+                });
+              }
+            },
+            [invokePromise],
+          );
+          return <TestingPanel onSpaceCreate={onSpaceCreate} onScriptPluginOpen={onScriptPluginOpen} />;
+        },
+      }),
+    ]);
+  }),
+);

package/src/capabilities/settings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+
+export const DebugSettings = Capability.lazy('DebugSettings', () => import('./settings'));

package/src/capabilities/settings/settings.ts

@@ -0,0 +1,30 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capability, Common } from '@dxos/app-framework';
+import { createKvsStore } from '@dxos/effect';
+
+import { meta } from '../../meta';
+import { DebugCapabilities, DebugSettingsSchema } from '../../types';
+
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: DebugSettingsSchema,
+      defaultValue: () => ({}),
+    });
+
+    return [
+      Capability.contributes(DebugCapabilities.Settings, settingsAtom),
+      Capability.contributes(Common.Capability.Settings, {
+        prefix: meta.id,
+        schema: DebugSettingsSchema,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/components/DebugGraph.tsx

@@ -5,10 +5,11 @@
 import React, { type FC } from 'react';
 
 import { Tree } from '@dxos/devtools';
-import { type Graph } from '@dxos/plugin-graph';
+import { Graph } from '@dxos/plugin-graph';
 
-export const DebugGraph: FC<{ graph: Graph; root: string }> = ({ graph, root }) => {
-  return <Tree data={graph.toJSON(root)} />;
+export type DebugGraphProps = { graph: Graph.Graph; root: string };
+export const DebugGraph: FC<DebugGraphProps> = ({ graph, root }) => {
+  return <Tree data={Graph.toJSON(graph, root)} />;
 };
 
 export default DebugGraph;

package/src/components/DebugObjectPanel.tsx

@@ -6,11 +6,11 @@ import React from 'react';
 
 import { type Obj } from '@dxos/echo';
 import { Clipboard, Input, Toolbar } from '@dxos/react-ui';
-import { StackItem } from '@dxos/react-ui-stack';
+import { Layout } from '@dxos/react-ui-mosaic';
 import { Json } from '@dxos/react-ui-syntax-highlighter';
 
 export type DebugObjectPanelProps = {
-  object: Obj.Any;
+  object: Obj.Unknown;
 };
 
 // TODO(burdon): Get schema and traverse references.
@@ -19,7 +19,7 @@ export const DebugObjectPanel = ({ object }: DebugObjectPanelProps) => {
 
   return (
     <Clipboard.Provider>
-      <StackItem.Content toolbar>
+      <Layout.Main toolbar>
         <Toolbar.Root>
           <Input.Root>
             <Input.TextInput disabled value={dxn} />
@@ -27,7 +27,7 @@ export const DebugObjectPanel = ({ object }: DebugObjectPanelProps) => {
           </Input.Root>
         </Toolbar.Root>
         <Json data={object} />
-      </StackItem.Content>
+      </Layout.Main>
     </Clipboard.Provider>
   );
 };

package/src/components/DebugSettings.tsx

@@ -4,11 +4,12 @@
 
 import React, { useEffect, useState } from 'react';
 
-import { Capabilities, useCapabilities } from '@dxos/app-framework';
+import { Common } from '@dxos/app-framework';
+import { useCapabilities } from '@dxos/app-framework/react';
 import { type ConfigProto, SaveConfig, Storage, defs } from '@dxos/config';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
-import { Button, Icon, Input, Select, Toast, useFileDownload, useTranslation } from '@dxos/react-ui';
+import { Icon, IconButton, Input, Select, Toast, useFileDownload, useTranslation } from '@dxos/react-ui';
 import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
 import { setDeep } from '@dxos/util';
 
@@ -25,14 +26,19 @@ const StorageAdapters = {
   idb: defs.Runtime.Client.Storage.StorageDriver.IDB,
 } as const;
 
-export const DebugSettings = ({ settings }: { settings: DebugSettingsProps }) => {
+export type DebugSettingsComponentProps = {
+  settings: DebugSettingsProps;
+  onSettingsChange: (fn: (current: DebugSettingsProps) => DebugSettingsProps) => void;
+};
+
+export const DebugSettings = ({ settings, onSettingsChange }: DebugSettingsComponentProps) => {
   const { t } = useTranslation(meta.id);
   const [toast, setToast] = useState<Toast>();
   const client = useClient();
   const download = useFileDownload();
   // TODO(mykola): Get updates from other places that change Config.
   const [storageConfig, setStorageConfig] = useState<ConfigProto>({});
-  const [upload] = useCapabilities(Capabilities.FileUploader);
+  const [upload] = useCapabilities(Common.Capability.FileUploader);
 
   useEffect(() => {
     void Storage().then((config) => setStorageConfig(config));
@@ -46,22 +52,30 @@ export const DebugSettings = ({ settings }: { settings: DebugSettingsProps }) =>
 
   const handleDownload = async () => {
     const data = await client.diagnostics();
-    const file = new Blob([JSON.stringify(data, undefined, 2)], { type: 'text/plain' });
+    const file = new Blob([JSON.stringify(data, undefined, 2)], {
+      type: 'text/plain',
+    });
     const fileName = `composer-${new Date().toISOString().replace(/\W/g, '-')}.json`;
     download(file, fileName);
 
     if (upload) {
-      const info = await upload(client.spaces.default, new File([file], fileName));
+      const info = await upload(client.spaces.default.db, new File([file], fileName));
       if (!info) {
         log.error('diagnostics failed to upload to IPFS');
         return;
       }
-      handleToast({ title: t('settings uploaded'), description: t('settings uploaded to clipboard') });
+      handleToast({
+        title: t('settings uploaded'),
+        description: t('settings uploaded to clipboard'),
+      });
 
       // TODO(nf): move to IpfsPlugin?
       const url = client.config.values.runtime!.services!.ipfs!.gateway + '/' + info.cid;
       void navigator.clipboard.writeText(url);
-      handleToast({ title: t('settings uploaded'), description: t('settings uploaded to clipboard') });
+      handleToast({
+        title: t('settings uploaded'),
+        description: t('settings uploaded to clipboard'),
+      });
       log.info('diagnostics', { url });
     }
   };
@@ -70,9 +84,15 @@ export const DebugSettings = ({ settings }: { settings: DebugSettingsProps }) =>
     try {
       const info = await client.repair();
       setStorageConfig(await Storage());
-      handleToast({ title: t('settings repair success'), description: JSON.stringify(info, undefined, 2) });
+      handleToast({
+        title: t('settings repair success'),
+        description: JSON.stringify(info, undefined, 2),
+      });
     } catch (err: any) {
-      handleToast({ title: t('settings repair failed'), description: err.message });
+      handleToast({
+        title: t('settings repair failed'),
+        description: err.message,
+      });
     }
   };
 
@@ -83,18 +103,24 @@ export const DebugSettings = ({ settings }: { settings: DebugSettingsProps }) =>
           <ControlItemInput title={t('settings wireframe')}>
             <Input.Switch
               checked={settings.wireframe}
-              onCheckedChange={(checked) => (settings.wireframe = !!checked)}
+              onCheckedChange={(checked) => onSettingsChange((s) => ({ ...s, wireframe: !!checked }))}
             />
           </ControlItemInput>
           <ControlItemInput title={t('settings download diagnostics')}>
-            <Button onClick={handleDownload}>
-              <Icon icon='ph--download-simple--regular' size={5} />
-            </Button>
+            <IconButton
+              icon='ph--download-simple--regular'
+              iconOnly
+              label={t('settings download diagnostics')}
+              onClick={handleDownload}
+            />
           </ControlItemInput>
           <ControlItemInput title={t('settings repair')}>
-            <Button onClick={handleRepair}>
-              <Icon icon='ph--first-aid-kit--regular' size={5} />
-            </Button>
+            <IconButton
+              icon='ph--first-aid-kit--regular'
+              iconOnly
+              label={t('settings repair')}
+              onClick={handleRepair}
+            />
           </ControlItemInput>
 
           {/* TODO(burdon): Move to layout? */}
@@ -114,7 +140,7 @@ export const DebugSettings = ({ settings }: { settings: DebugSettingsProps }) =>
             <Select.Root
               value={
                 Object.entries(StorageAdapters).find(
-                  ([name, value]) => value === storageConfig?.runtime?.client?.storage?.dataStore,
+                  ([_name, value]) => value === storageConfig?.runtime?.client?.storage?.dataStore,
                 )?.[0]
               }
               onValueChange={(value) => {