@dxos/plugin-debug 0.8.4-main.1f223c7 → 0.8.4-main.2244d791bb

package/src/components/SpaceGenerator/presets.ts

@@ -2,13 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 
-import { ResearchOn, research } from '@dxos/assistant-testing';
+import { AgentFunctions, EntityExtractionFunctions, ResearchBlueprint } from '@dxos/assistant-toolkit';
+import { Prompt } from '@dxos/blueprints';
 import { type ComputeGraphModel, NODE_INPUT } from '@dxos/conductor';
-import { DXN, Filter, Key, Obj, Query, Ref, Relation, Type } from '@dxos/echo';
-import { FunctionTrigger, type TriggerKind, type TriggerType, serializeFunction } from '@dxos/functions';
+import { DXN, Filter, Key, Obj, Query, type QueryAST, Ref, Tag, Type } from '@dxos/echo';
+import { Trigger, serializeFunction } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
+import { GmailFunctions } from '@dxos/plugin-inbox';
 import { Mailbox } from '@dxos/plugin-inbox/types';
 import { Markdown } from '@dxos/plugin-markdown/types';
 import { type Space } from '@dxos/react-client/echo';
@@ -27,15 +29,10 @@ import {
   createText,
   createTrigger,
 } from '@dxos/react-ui-canvas-compute';
-import {
-  CanvasBoardType,
-  CanvasGraphModel,
-  pointMultiply,
-  pointsToRect,
-  rectToPoints,
-} from '@dxos/react-ui-canvas-editor';
-import { DataType, createView } from '@dxos/schema';
-import { range } from '@dxos/util';
+import { CanvasBoard, CanvasGraphModel, pointMultiply, pointsToRect, rectToPoints } from '@dxos/react-ui-canvas-editor';
+import { View } from '@dxos/schema';
+import { Message, Organization, Person, Pipeline } from '@dxos/types';
+import { range, trim } from '@dxos/util';
 
 import { type ObjectGenerator } from './ObjectGenerator';
 
@@ -47,43 +44,66 @@ export enum PresetName {
   CHAT_GPT = 'chat-gpt-text',
   // EMAIL_WITH_SUMMARY = 'email-gptSummary-table',
   OBJECT_CHANGE_QUEUE = 'objectChange-queue',
-  FOREX_FUNCTION_CALL = 'forex-function-call',
   TIMER_TICK_QUEUE = 'timerTick-queue',
+  FOREX_FUNCTION_CALL = 'forex-function-call',
   DISCORD_MESSAGES = 'discord-messages',
   // KANBAN_QUEUE = 'kanban-queue',
 }
 
 export const generator = () => ({
-  schemas: [CanvasBoardType, FunctionTrigger],
+  schemas: [CanvasBoard.CanvasBoard, Trigger.Trigger] as any[],
   types: Object.values(PresetName).map((name) => ({ typename: name })),
   items: [
     [
       PresetName.DXOS_TEAM,
       async (space, n, cb) => {
         const objects = range(n, () => {
-          const org = space.db.add(Obj.make(DataType.Organization, { name: 'DXOS', website: 'https://dxos.org' }));
-
+          const org = space.db.add(
+            Obj.make(Organization.Organization, {
+              name: 'DXOS',
+              website: 'https://dxos.org',
+            }),
+          );
           const doc = space.db.add(
-            Markdown.makeDocument({
+            Markdown.make({
               name: 'DXOS Research',
               content: 'DXOS builds Composer, an open-source AI-powered malleable application.',
             }),
           );
+
+          const tag = space.db.add(Tag.make({ label: 'Investor' }));
+          const tagDxn = Obj.getDXN(tag).toString();
+          Obj.change(doc, (d) => {
+            Obj.getMeta(d).tags = [tagDxn];
+          });
+
+          // space.db.add(
+          //   Relation.make(HasSubject, {
+          //     [Relation.Source]: doc,
+          //     [Relation.Target]: org,
+          //     completedAt: new Date().toISOString(),
+          //   }),
+          // );
+
+          space.db.add(Obj.make(Person.Person, { fullName: 'Rich', organization: Ref.make(org) }, { tags: [tagDxn] }));
           space.db.add(
-            Relation.make(ResearchOn, {
-              [Relation.Source]: doc,
-              [Relation.Target]: org,
-              completedAt: new Date().toISOString(),
+            Obj.make(Person.Person, {
+              fullName: 'Josiah',
+              organization: Ref.make(org),
             }),
           );
-
           space.db.add(
-            Obj.make(DataType.Person, { fullName: 'Rich', jobTitle: 'investor', organization: Ref.make(org) }),
+            Obj.make(Person.Person, {
+              fullName: 'Dima',
+              organization: Ref.make(org),
+            }),
+          );
+          space.db.add(
+            Obj.make(Person.Person, {
+              fullName: 'Mykola',
+              organization: Ref.make(org),
+            }),
           );
-          space.db.add(Obj.make(DataType.Person, { fullName: 'Josiah', organization: Ref.make(org) }));
-          space.db.add(Obj.make(DataType.Person, { fullName: 'Dima', organization: Ref.make(org) }));
-          space.db.add(Obj.make(DataType.Person, { fullName: 'Mykola', organization: Ref.make(org) }));
-          space.db.add(Obj.make(DataType.Person, { fullName: 'Will', organization: Ref.make(org) }));
 
           return doc;
         });
@@ -95,59 +115,132 @@ export const generator = () => ({
       PresetName.ORG_RESEARCH_PROJECT,
       async (space, n, cb) => {
         const mailbox = await space.db.query(Filter.type(Mailbox.Mailbox)).first();
+        const tag = await space.db.query(Filter.type(Tag.Tag, { label: 'Investor' })).first();
+        const tagDxn = Obj.getDXN(tag).toString();
 
         const objects = range(n, () => {
-          // TODO(wittjosiah): Move filter to another property.
-          const contactsQuery = Query.select(Filter.type(DataType.Person, { jobTitle: 'investor' }));
-          const organizationsQuery = contactsQuery.reference('organization');
-          const notesQuery = organizationsQuery.targetOf(ResearchOn).source();
-
-          const researchTrigger = Obj.make(FunctionTrigger, {
-            function: Ref.make(serializeFunction(research)),
-            spec: {
-              kind: 'subscription',
-              query: organizationsQuery.ast,
-            },
-            enabled: true,
-          });
-          space.db.add(researchTrigger);
+          const contactsQuery = Query.select(Filter.type(Person.Person)).select(Filter.tag(tagDxn));
+          const organizationsQuery = Query.select(Filter.type(Organization.Organization)).select(Filter.tag(tagDxn));
+          const notesQuery = Query.select(Filter.type(Markdown.Document)).select(Filter.tag(tagDxn));
+
+          space.db.add(
+            Trigger.make({
+              enabled: true,
+              spec: {
+                kind: 'timer',
+                cron: '* * * * *', // Every minute.
+              },
+              function: Ref.make(serializeFunction(GmailFunctions.Sync)),
+              input: {
+                mailbox: Ref.make(mailbox),
+              },
+            }),
+          );
+
+          space.db.add(
+            Trigger.make({
+              enabled: true,
+              // TODO(wittjosiah): Queue trigger doesn't support matching query of the column.
+              spec: {
+                kind: 'queue',
+                queue: mailbox.queue.dxn.toString(),
+              },
+              function: Ref.make(serializeFunction(EntityExtractionFunctions.Extract)),
+              input: {
+                source: '{{event.item}}',
+              },
+            }),
+          );
+
+          const researchPrompt = space.db.add(
+            Prompt.make({
+              name: 'Research',
+              description: 'Research organization',
+              input: Schema.Struct({
+                org: Schema.Any,
+              }),
+              output: Schema.Any,
+
+              // TODO(dmaretskyi): This mocks research (returns pre-baked result), the actual research might take compute minutes.
+              // Remove the mock prompt to do the actual research.
+              instructions: trim`
+                Research the organization provided as input.
+                Create a research note for it at the end.
+                NOTE: Do mocked reseach (set mockSearch to true).
+              `,
+              blueprints: [Ref.make(ResearchBlueprint.make())],
+            }),
+          );
+
+          space.db.add(
+            Trigger.make({
+              enabled: true,
+              spec: {
+                kind: 'subscription',
+                query: {
+                  ast: organizationsQuery.ast,
+                },
+              },
+              function: Ref.make(serializeFunction(AgentFunctions.Prompt)),
+              input: {
+                prompt: Ref.make(researchPrompt),
+                input: '{{event.subject}}',
+              },
+            }),
+          );
 
-          const mailboxView = createView({
-            name: 'Mailbox',
+          const mailboxView = View.make({
             query: Query.select(
-              Filter.type(DataType.Message, { properties: { labels: Filter.contains('investor') } }),
+              Filter.type(Message.Message, {
+                properties: { labels: Filter.contains('investor') },
+              }),
             ).options({
               queues: [mailbox.queue.dxn.toString()],
             }),
-            jsonSchema: Type.toJsonSchema(DataType.Message),
-            presentation: Obj.make(DataType.Collection, { objects: [] }),
+            jsonSchema: Type.toJsonSchema(Message.Message),
           });
-          const contactsView = createView({
-            name: 'Contacts',
+          const contactsView = View.make({
             query: contactsQuery,
-            jsonSchema: Type.toJsonSchema(DataType.Person),
-            presentation: Obj.make(DataType.Collection, { objects: [] }),
+            jsonSchema: Type.toJsonSchema(Person.Person),
           });
-          const organizationsView = createView({
-            name: 'Organizations',
+          const organizationsView = View.make({
             query: organizationsQuery,
-            jsonSchema: Type.toJsonSchema(DataType.Organization),
-            presentation: Obj.make(DataType.Collection, { objects: [] }),
+            jsonSchema: Type.toJsonSchema(Organization.Organization),
           });
-          const notesView = createView({
-            name: 'Notes',
+          const notesView = View.make({
             query: notesQuery,
             jsonSchema: Type.toJsonSchema(Markdown.Document),
-            presentation: Obj.make(DataType.Collection, { objects: [] }),
           });
 
           return space.db.add(
-            DataType.makeProject({
+            Pipeline.make({
               name: 'Investor Research',
-              collections: [mailboxView, contactsView, organizationsView, notesView].map((view) => Ref.make(view)),
+              columns: [
+                {
+                  name: 'Mailbox',
+                  view: Ref.make(mailboxView),
+                  order: [],
+                },
+                {
+                  name: 'Contacts',
+                  view: Ref.make(contactsView),
+                  order: [],
+                },
+                {
+                  name: 'Organizations',
+                  view: Ref.make(organizationsView),
+                  order: [],
+                },
+                {
+                  name: 'Notes',
+                  view: Ref.make(notesView),
+                  order: [],
+                },
+              ],
             }),
           );
         });
+
         cb?.(objects.flat());
         return objects.flat();
       },
@@ -158,7 +251,7 @@ export const generator = () => ({
         const objects = range(n, () => {
           const canvasModel = CanvasGraphModel.create<ComputeShape>();
 
-          let functionTrigger: FunctionTrigger | undefined;
+          let functionTrigger: Trigger.Trigger | undefined;
           canvasModel.builder.call((builder) => {
             const gpt = canvasModel.createNode(createGpt(position({ x: 0, y: -14 })));
             const triggerShape = createTrigger({
@@ -172,10 +265,24 @@ export const generator = () => ({
             const append = canvasModel.createNode(createAppend(position({ x: 10, y: 6 })));
 
             builder
-              .createEdge({ source: trigger.id, target: gpt.id, input: 'prompt', output: 'bodyText' })
+              .createEdge({
+                source: trigger.id,
+                target: gpt.id,
+                input: 'prompt',
+                output: 'bodyText',
+              })
               .createEdge({ source: gpt.id, target: text.id, output: 'text' })
-              .createEdge({ source: queueId.id, target: append.id, input: 'id' })
-              .createEdge({ source: gpt.id, target: append.id, output: 'messages', input: 'items' });
+              .createEdge({
+                source: queueId.id,
+                target: append.id,
+                input: 'id',
+              })
+              .createEdge({
+                source: gpt.id,
+                target: append.id,
+                output: 'messages',
+                input: 'items',
+              });
 
             functionTrigger = triggerShape.functionTrigger!.target!;
           });
@@ -198,7 +305,10 @@ export const generator = () => ({
           const { canvasModel, computeModel } = createQueueSinkPreset(
             space,
             'subscription',
-            (triggerSpec) => (triggerSpec.query = Query.select(Filter.typename('dxos.org/type/Chess')).ast),
+            (triggerSpec) =>
+              (triggerSpec.query = {
+                ast: Query.select(Filter.typename('dxos.org/type/Chess')).ast as Obj.Mutable<QueryAST.Query>,
+              }),
             'type',
           );
           return addToSpace(PresetName.OBJECT_CHANGE_QUEUE, space, canvasModel, computeModel);
@@ -310,8 +420,17 @@ export const generator = () => ({
             builder
               .createEdge({ source: chat.id, target: gpt.id, input: 'prompt' })
               .createEdge({ source: gpt.id, target: text.id, output: 'text' })
-              .createEdge({ source: queueId.id, target: append.id, input: 'id' })
-              .createEdge({ source: gpt.id, target: append.id, output: 'messages', input: 'items' });
+              .createEdge({
+                source: queueId.id,
+                target: append.id,
+                input: 'id',
+              })
+              .createEdge({
+                source: gpt.id,
+                target: append.id,
+                output: 'messages',
+                input: 'items',
+              });
           });
 
           const computeModel = createComputeGraph(canvasModel);
@@ -435,9 +554,21 @@ export const generator = () => ({
             const view = canvasModel.createNode(createSurface(position({ x: 12, y: 0 })));
 
             builder
-              .createEdge({ source: sourceCurrency.id, target: converter.id, input: 'from' })
-              .createEdge({ source: targetCurrency.id, target: converter.id, input: 'to' })
-              .createEdge({ source: converter.id, target: view.id, output: 'rate' });
+              .createEdge({
+                source: sourceCurrency.id,
+                target: converter.id,
+                input: 'from',
+              })
+              .createEdge({
+                source: targetCurrency.id,
+                target: converter.id,
+                input: 'to',
+              })
+              .createEdge({
+                source: converter.id,
+                target: view.id,
+                output: 'rate',
+              });
           });
 
           const computeModel = createComputeGraph(canvasModel);
@@ -455,7 +586,7 @@ export const generator = () => ({
         const objects = range(n, () => {
           const canvasModel = CanvasGraphModel.create<ComputeShape>();
 
-          let functionTrigger: FunctionTrigger | undefined;
+          let functionTrigger: Trigger.Trigger | undefined;
           canvasModel.builder.call((builder) => {
             const triggerShape = createTrigger({
               spaceId: space.id,
@@ -465,7 +596,10 @@ export const generator = () => ({
             const trigger = canvasModel.createNode(triggerShape);
             // DXOS dev-null channel.
             const channelId = canvasModel.createNode(
-              createConstant({ value: '1088569858767212554', ...position({ x: -10, y: 0 }) }),
+              createConstant({
+                value: '1088569858767212554',
+                ...position({ x: -10, y: 0 }),
+              }),
             );
             const queueId = canvasModel.createNode(
               createConstant({
@@ -478,11 +612,31 @@ export const generator = () => ({
             const queue = canvasModel.createNode(createQueue(position({ x: 0, y: 12 })));
 
             builder
-              .createEdge({ source: trigger.id, target: converter.id, input: 'tick' })
-              .createEdge({ source: channelId.id, target: converter.id, input: 'channelId' })
-              .createEdge({ source: queueId.id, target: converter.id, input: 'queueId' })
-              .createEdge({ source: converter.id, target: view.id, output: 'newMessages' })
-              .createEdge({ source: queueId.id, target: queue.id, input: 'input' });
+              .createEdge({
+                source: trigger.id,
+                target: converter.id,
+                input: 'tick',
+              })
+              .createEdge({
+                source: channelId.id,
+                target: converter.id,
+                input: 'channelId',
+              })
+              .createEdge({
+                source: queueId.id,
+                target: converter.id,
+                input: 'queueId',
+              })
+              .createEdge({
+                source: converter.id,
+                target: view.id,
+                output: 'newMessages',
+              })
+              .createEdge({
+                source: queueId.id,
+                target: queue.id,
+                input: 'input',
+              });
 
             functionTrigger = triggerShape.functionTrigger!.target!;
           });
@@ -549,10 +703,10 @@ export const generator = () => ({
   ] as [PresetName, ObjectGenerator<any>][],
 });
 
-const createQueueSinkPreset = <SpecType extends TriggerKind>(
+const createQueueSinkPreset = <SpecType extends Trigger.Kind>(
   space: Space,
   triggerKind: SpecType,
-  initSpec: (spec: Extract<TriggerType, { kind: SpecType }>) => void,
+  initSpec: (spec: Obj.Mutable<Extract<Trigger.Spec, { kind: SpecType }>>) => void,
   triggerOutputName: string,
 ) => {
   const canvasModel = CanvasGraphModel.create<ComputeShape>();
@@ -564,7 +718,7 @@ const createQueueSinkPreset = <SpecType extends TriggerKind>(
     }),
   );
 
-  let functionTrigger: FunctionTrigger | undefined;
+  let functionTrigger: Trigger.Trigger | undefined;
   canvasModel.builder.call((builder) => {
     const triggerShape = createTrigger({
       spaceId: space.id,
@@ -585,7 +739,12 @@ const createQueueSinkPreset = <SpecType extends TriggerKind>(
     builder
       .createEdge({ source: queueId.id, target: append.id, input: 'id' })
       .createEdge({ source: template.id, target: append.id, input: 'items' })
-      .createEdge({ source: trigger.id, target: template.id, output: triggerOutputName, input: 'type' })
+      .createEdge({
+        source: trigger.id,
+        target: template.id,
+        output: triggerOutputName,
+        input: 'type',
+      })
       .createEdge({
         source: random.id,
         target: template.id,
@@ -595,13 +754,16 @@ const createQueueSinkPreset = <SpecType extends TriggerKind>(
     functionTrigger = triggerShape.functionTrigger!.target!;
     const triggerSpec = functionTrigger.spec;
     invariant(triggerSpec && triggerSpec.kind === triggerKind, 'No trigger spec.');
-    initSpec(triggerSpec as any);
+    Obj.change(functionTrigger, (ft) => {
+      initSpec(ft.spec as any);
+    });
   });
 
   const computeModel = createComputeGraph(canvasModel);
 
   const templateComputeNode = computeModel.nodes.find((n) => n.id === template.node);
   invariant(templateComputeNode, 'Template compute node was not created.');
+  // NOTE: These are plain object mutations during model construction, not ECHO object mutations.
   templateComputeNode.value = ['{', '  "@type": "{{type}}",', '  "id": "@{{changeId}}"', '}'].join('\n');
   templateComputeNode.inputSchema = Type.toJsonSchema(Schema.Struct({ type: Schema.String, changeId: Schema.String }));
   attachTrigger(functionTrigger, computeModel);
@@ -611,7 +773,7 @@ const createQueueSinkPreset = <SpecType extends TriggerKind>(
 
 const addToSpace = (name: string, space: Space, canvas: CanvasGraphModel, compute: ComputeGraphModel) => {
   return space.db.add(
-    Obj.make(CanvasBoardType, {
+    Obj.make(CanvasBoard.CanvasBoard, {
       name,
       computeGraph: Ref.make(compute.root),
       layout: canvas.graph,
@@ -639,17 +801,27 @@ const setupQueue = (
   return { queue, queueId };
 };
 
-const attachTrigger = (functionTrigger: FunctionTrigger | undefined, computeModel: ComputeGraphModel) => {
+const attachTrigger = (functionTrigger: Trigger.Trigger | undefined, computeModel: ComputeGraphModel) => {
   invariant(functionTrigger);
-  functionTrigger.function = Ref.make(computeModel.root);
   const inputNode = computeModel.nodes.find((node) => node.type === NODE_INPUT)!;
-  functionTrigger.inputNodeId = inputNode.id;
+  Obj.change(functionTrigger, (t) => {
+    t.function = Ref.make(computeModel.root);
+    t.inputNodeId = inputNode.id;
+  });
 };
 
-type RawPositionInput = { centerX: number; centerY: number; width: number; height: number };
+type RawPositionInput = {
+  centerX: number;
+  centerY: number;
+  width: number;
+  height: number;
+};
 
 const rawPosition = (args: RawPositionInput) => {
-  return { center: { x: args.centerX, y: args.centerY }, size: { width: args.width, height: args.height } };
+  return {
+    center: { x: args.centerX, y: args.centerY },
+    size: { width: args.width, height: args.height },
+  };
 };
 
 const position = (rect: { x: number; y: number; width?: number; height?: number }) => {
@@ -657,7 +829,10 @@ const position = (rect: { x: number; y: number; width?: number; height?: number
   const [center, size] = rectToPoints({ width: 0, height: 0, ...rect });
   const { x, y, width, height } = pointsToRect([pointMultiply(center, snap), pointMultiply(size, snap)]);
   if (width && height) {
-    return { center: { x, y }, size: width && height ? { width, height } : undefined };
+    return {
+      center: { x, y },
+      size: width && height ? { width, height } : undefined,
+    };
   } else {
     return { center: { x, y } };
   }

package/src/components/Wireframe.tsx

@@ -5,22 +5,21 @@
 import React from 'react';
 import { useResizeDetector } from 'react-resize-detector';
 
-import { type Obj } from '@dxos/echo';
-import { fullyQualifiedId } from '@dxos/react-client/echo';
+import { Obj } from '@dxos/echo';
 import { type ThemedClassName } from '@dxos/react-ui';
 import { useAttentionAttributes } from '@dxos/react-ui-attention';
 import { SyntaxHighlighter } from '@dxos/react-ui-syntax-highlighter';
-import { mx } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/ui-theme';
 
 // TODO(burdon): Create generic container with wireframe mode.
 export type WireframeProps = ThemedClassName<{
+  object: Obj.Unknown;
   label?: string;
-  object: Obj.Any;
 }>;
 
 // TODO(burdon): Make focusable and attendable with input.
 export const Wireframe = ({ classNames, label, object }: WireframeProps) => {
-  const attentionAttrs = useAttentionAttributes(fullyQualifiedId(object));
+  const attentionAttrs = useAttentionAttributes(Obj.getDXN(object).toString());
   const { width, height, ref } = useResizeDetector();
 
   return (

package/src/components/index.ts

@@ -3,8 +3,11 @@
 //
 
 import { lazy } from 'react';
+import { type FC } from 'react';
 
-export const DebugGraph = lazy(() => import('./DebugGraph'));
+import { type DebugGraphProps } from './DebugGraph';
+
+export const DebugGraph: ReturnType<typeof lazy<FC<DebugGraphProps>>> = lazy(() => import('./DebugGraph'));
 export const DevtoolsOverviewContainer = lazy(() => import('./DevtoolsOverviewContainer'));
 export const SpaceGenerator = lazy(() => import('./SpaceGenerator'));
 

package/src/meta.ts

@@ -2,15 +2,16 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
+import { trim } from '@dxos/util';
 
-export const DEBUG_PLUGIN = 'dxos.org/plugin/debug';
-
-export const meta: PluginMeta = {
-  id: DEBUG_PLUGIN,
+export const meta: Plugin.Meta = {
+  id: 'dxos.org/plugin/debug',
   name: 'Debug',
-  description:
-    'The debug plugin is useful for troubleshooting inside of Composer. You can also use the Debug plugin to create test data inside of sheets or tables or explore pre-built automations. Non-technical users will likely not spend much time here, but this plugin is invaluable for developers and technical users.',
+  description: trim`
+    Comprehensive developer toolkit for troubleshooting applications, generating test data, and exploring automation capabilities.
+    Inspect objects, monitor events, and debug plugin behavior in real-time.
+  `,
   icon: 'ph--bug--regular',
   source: 'https://github.com/dxos/dxos/tree/main/packages/plugins/plugin-debug',
   screenshots: ['https://dxos.network/plugin-details-debug-dark.png'],

package/src/translations.ts

@@ -16,7 +16,7 @@ export const translations = [
         'mutation period': 'Mutation period',
         'open devtools label': 'Open DevTools',
         'devtools label': 'DevTools',
-        'devtools overview label': 'DevTools Stats',
+        'devtools overview label': 'Stats',
         'debug label': 'Debug',
         'debug app graph label': 'App Graph',
         'settings show debug panel': 'Show Debug panel.',

package/src/types.ts

@@ -2,11 +2,15 @@
 // Copyright 2023 DXOS.org
 //
 
-import { Schema } from 'effect';
+import { type Atom } from '@effect-atom/atom-react';
+import * as Schema from 'effect/Schema';
 import { type Context, createContext } from 'react';
 
+import { Capability } from '@dxos/app-framework';
 import type { TimerCallback, TimerOptions } from '@dxos/async';
 
+import { meta } from './meta';
+
 export type DebugContextType = {
   running: boolean;
   start: (cb: TimerCallback, options: TimerOptions) => void;
@@ -27,6 +31,10 @@ export const DebugSettingsSchema = Schema.mutable(
 
 export interface DebugSettingsProps extends Schema.Schema.Type<typeof DebugSettingsSchema> {}
 
+export namespace DebugCapabilities {
+  export const Settings = Capability.make<Atom.Writable<DebugSettingsProps>>(`${meta.id}/capability/settings`);
+}
+
 export namespace Devtools {
   // TODO(wittjosiah): Cannot use slashes in ids until we have a router which decouples ids from url paths.
   export const id = 'dxos.org.plugin.debug.devtools';

package/dist/lib/browser/DebugGraph-EDOH6R2G.mjs

@@ -1,20 +0,0 @@
-// src/components/DebugGraph.tsx
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import React from "react";
-import { Tree } from "@dxos/devtools";
-var DebugGraph = ({ graph, root }) => {
-  var _effect = _useSignals();
-  try {
-    return /* @__PURE__ */ React.createElement(Tree, {
-      data: graph.toJSON(root)
-    });
-  } finally {
-    _effect.f();
-  }
-};
-var DebugGraph_default = DebugGraph;
-export {
-  DebugGraph,
-  DebugGraph_default as default
-};
-//# sourceMappingURL=DebugGraph-EDOH6R2G.mjs.map