@dxos/react-ui-canvas-compute 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/src/graph/controller.ts

@@ -6,14 +6,17 @@ import type * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
 import * as Either from 'effect/Either';
 import * as Exit from 'effect/Exit';
+import * as Layer from 'effect/Layer';
+import type * as ManagedRuntime from 'effect/ManagedRuntime';
 import * as Scope from 'effect/Scope';
 
+import type { AiService } from '@dxos/ai';
 import { Event, synchronized } from '@dxos/async';
 import {
   type ComputeEdge,
   type ComputeGraphModel,
-  type ComputeMeta,
   type ComputeNode,
+  type ComputeNodeMeta,
   type GptInput,
   type GptOutput,
   type GraphDiagnostic,
@@ -22,11 +25,19 @@ import {
   isNotExecuted,
 } from '@dxos/conductor';
 import { Resource } from '@dxos/context';
-import { type ComputeEventLogger, type ComputeEventPayload } from '@dxos/functions';
-import { type ServiceContainer } from '@dxos/functions';
+import type { Database } from '@dxos/echo';
+import { unwrapExit } from '@dxos/effect';
+import {
+  ComputeEventLogger,
+  type ComputeEventPayload,
+  type CredentialsService,
+  type FunctionInvocationService,
+  type QueueService,
+  TracingService,
+} from '@dxos/functions';
 import { log } from '@dxos/log';
 import { type CanvasGraphModel } from '@dxos/react-ui-canvas-editor';
-import { type ContentBlock } from '@dxos/schema';
+import { type ContentBlock } from '@dxos/types';
 
 import { createComputeGraph } from '../hooks';
 import { type ComputeShape } from '../shapes';
@@ -72,6 +83,14 @@ type ComputeOutputEvent = {
   value: RuntimeValue;
 };
 
+// TODO(dmaretskyi): Re-use function servies definition.
+export type ComputeServices =
+  | AiService.AiService
+  | Database.Service
+  | QueueService
+  | CredentialsService
+  | FunctionInvocationService;
+
 /**
  * Nodes that will automatically trigger the execution of the graph on startup.
  */
@@ -79,10 +98,10 @@ const AUTO_TRIGGER_NODES = ['chat', 'switch', 'constant'];
 
 export const createComputeGraphController = (
   graph: CanvasGraphModel<ComputeShape>,
-  serviceContainer: ServiceContainer,
+  computeRuntime: ManagedRuntime.ManagedRuntime<ComputeServices, never>,
 ) => {
   const computeGraph = createComputeGraph(graph);
-  const controller = new ComputeGraphController(serviceContainer, computeGraph);
+  const controller = new ComputeGraphController(computeRuntime, computeGraph);
   return { controller, graph };
 };
 
@@ -117,7 +136,7 @@ export class ComputeGraphController extends Resource {
   public readonly events = new Event<ComputeEventPayload>();
 
   constructor(
-    private readonly _serviceContainer: ServiceContainer,
+    private readonly _computeRuntime: ManagedRuntime.ManagedRuntime<ComputeServices, never>,
     /** Persistent compute graph. */
     private readonly _graph: ComputeGraphModel,
   ) {
@@ -212,7 +231,7 @@ export class ComputeGraphController extends Resource {
     });
   }
 
-  async getMeta(node: ComputeNode): Promise<ComputeMeta> {
+  async getMeta(node: ComputeNode): Promise<ComputeNodeMeta> {
     const { meta } = await resolveComputeNode(node);
     return meta;
   }
@@ -232,37 +251,41 @@ export class ComputeGraphController extends Resource {
       executor.setOutputs(nodeId, Effect.succeed(ValueBag.make(outputs)));
     }
 
-    const serviceLayer = this._serviceContainer.createLayer();
-    await Effect.runPromise(
-      Effect.gen(this, function* () {
-        const scope = yield* Scope.make();
-
-        // TODO(dmaretskyi): Code duplication.
-        const executable = yield* Effect.promise(() => resolveComputeNode(this._graph.getNode(nodeId)));
-        const computingOutputs = executable.exec != null;
-        // TODO(dmaretskyi): Check if the node has a compute function and run computeOutputs if it does.
-        const effect = (computingOutputs ? executor.computeOutputs(nodeId) : executor.computeInputs(nodeId)).pipe(
-          Effect.withSpan('runGraph'),
-          Scope.extend(scope),
-
-          Effect.flatMap(computeValueBag),
-          Effect.provide(serviceLayer),
-          Effect.withSpan('test'),
-          Effect.tap((values) => {
-            for (const [key, value] of Object.entries(values)) {
-              if (computingOutputs) {
-                this._onOutputComputed(nodeId, key, value);
-              } else {
-                this._onInputComputed(nodeId, key, value);
+    unwrapExit(
+      await this._computeRuntime.runPromiseExit(
+        Effect.gen(this, function* () {
+          const scope = yield* Scope.make();
+
+          // TODO(dmaretskyi): Code duplication.
+          const executable = yield* Effect.promise(() => resolveComputeNode(this._graph.getNode(nodeId)));
+          const computingOutputs = executable.exec != null;
+          // TODO(dmaretskyi): Check if the node has a compute function and run computeOutputs if it does.
+          const effect = (computingOutputs ? executor.computeOutputs(nodeId) : executor.computeInputs(nodeId)).pipe(
+            Effect.withSpan('runGraph'),
+            Scope.extend(scope),
+            Effect.provide(
+              ComputeEventLogger.layerFromTracing.pipe(
+                Layer.provideMerge(TracingService.layerNoop), // TODO(dmaretskyi): Plug-in tracing events to visual feedback in the compute graph editor.
+              ),
+            ),
+            Effect.flatMap(computeValueBag),
+            Effect.withSpan('test'),
+            Effect.tap((values) => {
+              for (const [key, value] of Object.entries(values)) {
+                if (computingOutputs) {
+                  this._onOutputComputed(nodeId, key, value);
+                } else {
+                  this._onInputComputed(nodeId, key, value);
+                }
               }
-            }
-          }),
-        );
+            }),
+          );
 
-        yield* effect;
+          yield* effect;
 
-        yield* Scope.close(scope, Exit.void);
-      }),
+          yield* Scope.close(scope, Exit.void);
+        }),
+      ),
     );
 
     this.update.emit();
@@ -290,44 +313,51 @@ export class ComputeGraphController extends Resource {
         : this._graph.nodes.filter((node) => node.type != null && AUTO_TRIGGER_NODES.includes(node.type));
     const allAffectedNodes = [...new Set(triggerNodes.flatMap((node) => executor.getAllDependantNodes(node.id)))];
 
-    await Effect.runPromise(
-      Effect.gen(this, function* () {
-        const scope = yield* Scope.make();
-
-        // TODO(burdon): Return map?
-        const tasks: Effect.Effect<unknown, any, never>[] = [];
-        for (const node of allAffectedNodes) {
-          // TODO(dmaretskyi): Code duplication.
-          const executable = yield* Effect.promise(() => resolveComputeNode(this._graph.getNode(node)));
-          const computingOutputs = executable.exec != null;
-
-          // TODO(dmaretskyi): Check if the node has a compute function and run computeOutputs if it does.
-          const effect = (computingOutputs ? executor.computeOutputs(node) : executor.computeInputs(node)).pipe(
-            Effect.withSpan('runGraph'),
-            Scope.extend(scope),
-            Effect.flatMap(computeValueBag),
-            Effect.provide(this._serviceContainer.createLayer()),
-            Effect.withSpan('test'),
-            Effect.tap((values) => {
-              for (const [key, value] of Object.entries(values)) {
-                if (computingOutputs) {
-                  this._onOutputComputed(node, key, value);
-                } else {
-                  this._onInputComputed(node, key, value);
+    unwrapExit(
+      await this._computeRuntime.runPromiseExit(
+        Effect.gen(this, function* () {
+          const scope = yield* Scope.make();
+
+          // TODO(burdon): Return map?
+          const tasks: Effect.Effect<unknown, any, ComputeServices>[] = [];
+          for (const node of allAffectedNodes) {
+            // TODO(dmaretskyi): Code duplication.
+            const executable = yield* Effect.promise(() => resolveComputeNode(this._graph.getNode(node)));
+            const computingOutputs = executable.exec != null;
+
+            // TODO(dmaretskyi): Check if the node has a compute function and run computeOutputs if it does.
+            const effect = (computingOutputs ? executor.computeOutputs(node) : executor.computeInputs(node)).pipe(
+              Effect.withSpan('runGraph'),
+              Scope.extend(scope),
+              Effect.flatMap(computeValueBag),
+              Effect.provide(
+                ComputeEventLogger.layerFromTracing.pipe(
+                  Layer.provideMerge(TracingService.layerNoop), // TODO(dmaretskyi): Plug-in tracing events to visual feedback in the compute graph editor.
+                ),
+              ),
+
+              Effect.withSpan('test'),
+              Effect.tap((values) => {
+                for (const [key, value] of Object.entries(values)) {
+                  if (computingOutputs) {
+                    this._onOutputComputed(node, key, value);
+                  } else {
+                    this._onInputComputed(node, key, value);
+                  }
                 }
-              }
-            }),
-          );
+              }),
+            );
 
-          tasks.push(effect);
-        }
+            tasks.push(effect);
+          }
 
-        //
-        yield* Effect.all(tasks);
+          //
+          yield* Effect.all(tasks);
 
-        //
-        yield* Scope.close(scope, Exit.void);
-      }),
+          //
+          yield* Scope.close(scope, Exit.void);
+        }),
+      ),
     );
 
     this.update.emit();

package/src/graph/node-defs.ts

@@ -12,7 +12,7 @@ import {
   registry,
 } from '@dxos/conductor';
 import { raise } from '@dxos/debug';
-import { ObjectId, toJsonSchema } from '@dxos/echo/internal';
+import { JsonSchema, Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 
 import { type ComputeShape, type ConstantShape, type TemplateShape } from '../shapes';
@@ -68,7 +68,7 @@ const nodeFactory: Record<NodeType | 'trigger', (shape: ComputeShape) => Compute
   ['switch' as const]: () => createNode('switch'),
   ['template' as const]: (shape) => {
     const node = createNode('template', { valueType: (shape as TemplateShape).valueType, value: shape.text });
-    node.inputSchema = toJsonSchema(getTemplateInputSchema(node));
+    node.inputSchema = JsonSchema.toJsonSchema(getTemplateInputSchema(node));
     return node;
   },
   ['text' as const]: () => createNode('text'),
@@ -77,7 +77,7 @@ const nodeFactory: Record<NodeType | 'trigger', (shape: ComputeShape) => Compute
 };
 
 const createNode = (type: string, props?: Partial<ComputeNode>): ComputeNode => ({
-  id: ObjectId.random(),
+  id: Obj.ID.random(),
   type,
   ...props,
 });

package/src/hooks/useComputeNodeState.ts

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import { useCallback, useEffect, useState } from 'react';
 
-import type { ComputeMeta, ComputeNode } from '@dxos/conductor';
+import type { ComputeNode, ComputeNodeMeta } from '@dxos/conductor';
 import type { ComputeEventPayload } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 
@@ -16,7 +16,7 @@ import { useComputeContext } from './compute-context';
 
 export type ComputeNodeState = {
   node: ComputeNode;
-  meta: ComputeMeta;
+  meta: ComputeNodeMeta;
   runtime: {
     inputs: Record<string, RuntimeValue>;
     outputs: Record<string, RuntimeValue>;
@@ -33,7 +33,7 @@ export const useComputeNodeState = (shape: ComputeShape): ComputeNodeState => {
   const { controller } = useComputeContext();
   invariant(controller);
 
-  const [meta, setMeta] = useState<ComputeMeta>();
+  const [meta, setMeta] = useState<ComputeNodeMeta>();
   useEffect(() => {
     let disposed = false;
     queueMicrotask(async () => {
@@ -43,6 +43,7 @@ export const useComputeNodeState = (shape: ComputeShape): ComputeNodeState => {
       if (disposed) {
         return;
       }
+
       setMeta(meta);
     });
 

package/src/hooks/useGraphMonitor.ts

@@ -5,9 +5,8 @@
 import { useMemo } from 'react';
 
 import { type ComputeEdge, ComputeGraphModel, type ComputeNode, DEFAULT_INPUT, DEFAULT_OUTPUT } from '@dxos/conductor';
-import { ObjectId, Ref } from '@dxos/echo/internal';
+import { Obj, Ref } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
-import { getSpace } from '@dxos/react-client/echo';
 import { type CanvasGraphModel, type Connection, type GraphMonitor } from '@dxos/react-ui-canvas-editor';
 import { isNonNullable } from '@dxos/util';
 
@@ -27,7 +26,7 @@ export const mapEdge = (
   invariant(targetNode?.node);
 
   return {
-    id: ObjectId.random(),
+    id: Obj.ID.random(),
     source: sourceNode.node,
     target: targetNode.node,
     output,
@@ -113,19 +112,21 @@ export const createComputeGraph = (graph?: CanvasGraphModel<ComputeShape>) => {
 const linkTriggerToCompute = (graph: ComputeGraphModel, computeNode: ComputeNode, triggerData: TriggerShape) => {
   const functionTrigger = triggerData.functionTrigger?.target;
   invariant(functionTrigger);
-  functionTrigger.function = Ref.make(graph.root);
-  functionTrigger.inputNodeId = computeNode.id;
+  Obj.change(functionTrigger, (t) => {
+    t.function = Ref.make(graph.root);
+    t.inputNodeId = computeNode.id;
+  });
 };
 
 const deleteTriggerObjects = (computeGraph: ComputeGraphModel, deleted: CanvasGraphModel) => {
-  const space = getSpace(computeGraph.root);
-  if (!space) {
+  const db = Obj.getDatabase(computeGraph.root);
+  if (!db) {
     return;
   }
   for (const node of deleted.nodes) {
     if (node.type === 'trigger') {
       const trigger = node as TriggerShape;
-      space.db.remove(trigger.functionTrigger!.target!);
+      db.remove(trigger.functionTrigger!.target!);
     }
   }
 };

package/src/json.test.ts

@@ -5,12 +5,12 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { BaseGraphEdge, BaseGraphNode } from '@dxos/graph';
+import { Graph } from '@dxos/graph';
 
 import { createGptCircuit } from './testing';
 
 export const Shape = Schema.extend(
-  BaseGraphNode,
+  Graph.Node,
   Schema.Struct({
     text: Schema.optional(Schema.String),
     guide: Schema.optional(Schema.Boolean),
@@ -19,7 +19,7 @@ export const Shape = Schema.extend(
 );
 
 export const Connection = Schema.extend(
-  BaseGraphEdge,
+  Graph.Edge,
   Schema.Struct({
     input: Schema.optional(Schema.String),
     output: Schema.optional(Schema.String),

package/src/schema.test.ts

@@ -5,9 +5,9 @@
 import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { live } from '@dxos/echo/internal';
-import { BaseGraphNode, Graph } from '@dxos/graph';
+import { Graph } from '@dxos/graph';
 import {
+  CanvasGraphModel,
   Polygon,
   Shape,
   createEllipse,
@@ -21,19 +21,19 @@ import { ComputeShape, createFunction, createSwitch } from './shapes';
 
 describe('compute', () => {
   test('model', ({ expect }) => {
-    // const model = CanvasGraphModel.create<ComputeShape>();
+    const model = CanvasGraphModel.create<ComputeShape>();
     const node = createSwitch({ id: 'x', center: { x: 0, y: 0 }, size: { width: 80, height: 80 } });
     console.log(JSON.stringify(node, null, 2));
     expect(Schema.is(ComputeShape)(node)).toBe(true);
     expect(Schema.is(Polygon)(node)).toBe(true);
     expect(Schema.is(Shape)(node)).toBe(true);
-    expect(Schema.is(BaseGraphNode)(node)).toBe(true);
+    expect(Schema.is(Graph.Node)(node)).toBe(true);
 
-    const graph = live(Graph, { nodes: [], edges: [] });
-    graph.nodes.push(node); // Throws.
+    const graph: Graph.Any = { nodes: [], edges: [] };
+    graph.nodes.push(node);
 
-    // model.createNode(node);
-    // console.log(JSON.stringify(model, null, 2));
+    model.createNode(node);
+    console.log(JSON.stringify(model, null, 2));
   });
 });
 

package/src/shapes/Audio.tsx

@@ -35,7 +35,7 @@ export const AudioComponent = ({ shape }: ShapeComponentProps<AudioShape>) => {
 
   // https://docs.pmnd.rs/react-three-fiber/api/canvas#render-props
   return (
-    <div className='flex w-full justify-center items-center'>
+    <div className='flex is-full justify-center items-center'>
       <Icon
         icon={active ? 'ph--microphone--regular' : 'ph--microphone-slash--regular'}
         classNames={['transition opacity-20 duration-1000', active && 'opacity-100 text-red-500']}

package/src/shapes/Beacon.tsx

@@ -33,7 +33,7 @@ export const BeaconComponent = ({ shape }: ShapeComponentProps<BeaconShape>) =>
   const value = input?.type === 'executed' ? input.value : false;
 
   return (
-    <div className='flex w-full justify-center items-center'>
+    <div className='flex is-full justify-center items-center'>
       <Icon
         icon='ph--sun--regular'
         classNames={['transition opacity-20 duration-1000', isTruthy(value) && 'opacity-100 text-yellow-500']}

package/src/shapes/Boolean.tsx

@@ -57,7 +57,7 @@ const defineShape = <S extends GateShape>({
   // Be careful not to name component factories with a capital letter.
   component: () => {
     return (
-      <div className='flex w-full justify-center items-center'>
+      <div className='flex is-full justify-center items-center'>
         <Symbol />
       </div>
     );
@@ -95,7 +95,7 @@ const createSymbol =
     const paths = pathConstructor({ startX, endX, height });
 
     return (
-      <svg viewBox={`0 0 ${width} ${height}`} className='w-full h-full'>
+      <svg viewBox={`0 0 ${width} ${height}`} className='is-full bs-full'>
         {/* Input line. */}
         {getAnchorPoints({ x: 0, y: centerY }, inputs).map(({ x, y }, i) => (
           <line key={i} x1={x} y1={y} x2={startX * 1.3} y2={y} strokeWidth={strokeWidth} className={className} />

package/src/shapes/Function.tsx

@@ -35,7 +35,11 @@ export type FunctionShape = Schema.Schema.Type<typeof FunctionShape>;
 export type CreateFunctionProps = CreateShapeProps<FunctionShape>;
 
 export const createFunction = (props: CreateFunctionProps) =>
-  createShape<FunctionShape>({ type: 'function', size: { width: 256, height: 192 }, ...props });
+  createShape<FunctionShape>({
+    type: 'function',
+    size: { width: 256, height: 192 },
+    ...props,
+  });
 
 //
 // Component
@@ -62,17 +66,15 @@ const TextInputComponent = ({ shape, title, ...props }: TextInputComponentProps)
         return;
       }
 
-      const {
-        objects: [fn],
-      } = await space.db.query(Filter.type(Function.Function, { source: Ref.make(object) })).run();
+      const [fn] = await space.db.query(Filter.type(Function.Function, { source: Ref.make(object) })).run();
       if (!fn) {
         return;
       }
 
       node.value = value;
       node.function = Ref.make(fn);
-      node.inputSchema = getSnapshot(fn.inputSchema);
-      node.outputSchema = getSnapshot(fn.outputSchema);
+      node.inputSchema = fn.inputSchema ? getSnapshot(fn.inputSchema) : undefined;
+      node.outputSchema = fn.outputSchema ? getSnapshot(fn.outputSchema) : undefined;
     },
     [client, node],
   );

package/src/shapes/Gpt.tsx

@@ -74,7 +74,7 @@ export const GptComponent = ({ shape }: ShapeComponentProps<GptShape>) => {
   return (
     <FunctionBody
       shape={shape}
-      content={<div className='px-2 py-1 overflow-y-scroll'>{text}</div>}
+      content={<div className='pli-2 plb-1 overflow-y-auto'>{text}</div>}
       status={`${tokens} tokens`}
       inputSchema={meta.input}
       outputSchema={meta.output}

package/src/shapes/GptRealtime.tsx

@@ -143,7 +143,7 @@ export const GptRealtimeComponent = ({ shape }: ShapeComponentProps<GptRealtimeS
   };
 
   return (
-    <div className='flex w-full justify-center items-center'>
+    <div className='flex is-full justify-center items-center'>
       <Icon
         icon={isReady ? 'ph--waveform--regular' : isLive ? 'ph--pulse--regular' : 'ph--play--regular'}
         size={16}

package/src/shapes/Queue.tsx

@@ -8,7 +8,7 @@ import React, { Fragment } from 'react';
 import { DEFAULT_OUTPUT, QueueInput, QueueOutput } from '@dxos/conductor';
 import { type ThemedClassName } from '@dxos/react-ui';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
-import { mx } from '@dxos/react-ui-theme';
+import { mx } from '@dxos/ui-theme';
 
 import { useComputeNodeState } from '../hooks';
 
@@ -28,7 +28,11 @@ export type QueueShape = Schema.Schema.Type<typeof QueueShape>;
 export type CreateQueueProps = CreateShapeProps<QueueShape>;
 
 export const createQueue = (props: CreateQueueProps) =>
-  createShape<QueueShape>({ type: 'queue', size: { width: 256, height: 512 }, ...props });
+  createShape<QueueShape>({
+    type: 'queue',
+    size: { width: 256, height: 512 },
+    ...props,
+  });
 
 export const QueueComponent = ({ shape }: ShapeComponentProps<QueueShape>) => {
   const { runtime } = useComputeNodeState(shape);
@@ -42,9 +46,9 @@ export const QueueComponent = ({ shape }: ShapeComponentProps<QueueShape>) => {
 
   return (
     <Box shape={shape} status={`${items.length} items`} onAction={handleAction}>
-      <div className='flex flex-col w-full overflow-y-scroll divide-y divide-separator'>
+      <div className='flex flex-col is-full overflow-y-auto divide-y divide-separator'>
         {[...items].map((item, i) => (
-          <QueueItem key={i} classNames='p-1 px-2' item={item} />
+          <QueueItem key={i} classNames='p-1 pli-2' item={item} />
         ))}
       </div>
     </Box>

package/src/shapes/RNG.tsx

@@ -27,7 +27,11 @@ export type RandomShape = Schema.Schema.Type<typeof RandomShape>;
 export type CreateRandomProps = CreateShapeProps<RandomShape>;
 
 export const createRandom = (props: CreateRandomProps) =>
-  createShape<RandomShape>({ type: 'rng', size: { width: 64, height: 64 }, ...props });
+  createShape<RandomShape>({
+    type: 'rng',
+    size: { width: 64, height: 64 },
+    ...props,
+  });
 
 const icons = [
   'ph--dice-one--regular',

package/src/shapes/Scope.tsx

@@ -39,7 +39,7 @@ export const ScopeComponent = ({ shape }: ShapeComponentProps<ScopeShape>) => {
   const { getAverage } = useAudioStream(active);
 
   return (
-    <div className='flex w-full justify-center items-center bg-black'>
+    <div className='flex is-full justify-center items-center bg-black'>
       <Chaos active={active} getValue={getAverage} options={{ ...shaderPresets.heptapod, zoom: 1.2 }} />
     </div>
   );

package/src/shapes/Surface.tsx

@@ -5,7 +5,7 @@
 import * as Schema from 'effect/Schema';
 import React from 'react';
 
-import { Surface } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/react';
 import { DEFAULT_INPUT } from '@dxos/conductor';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 import { createAnchorMap } from '@dxos/react-ui-canvas-editor';
@@ -27,7 +27,11 @@ export type SurfaceShape = Schema.Schema.Type<typeof SurfaceShape>;
 export type CreateSurfaceProps = CreateShapeProps<SurfaceShape>;
 
 export const createSurface = (props: CreateSurfaceProps) =>
-  createShape<SurfaceShape>({ type: 'surface', size: { width: 384, height: 384 }, ...props });
+  createShape<SurfaceShape>({
+    type: 'surface',
+    size: { width: 384, height: 384 },
+    ...props,
+  });
 
 export const SurfaceComponent = ({ shape }: ShapeComponentProps<SurfaceShape>) => {
   const { runtime } = useComputeNodeState(shape);

package/src/shapes/Switch.tsx

@@ -36,7 +36,7 @@ export const SwitchComponent = ({ shape }: ShapeComponentProps<SwitchShape>) =>
   }, [value]);
 
   return (
-    <div className='flex w-full justify-center items-center' onClick={(ev) => ev.stopPropagation()}>
+    <div className='flex is-full justify-center items-center' onClick={(ev) => ev.stopPropagation()}>
       <Input.Root>
         <Input.Switch checked={value} onCheckedChange={(value) => setValue(value)} />
       </Input.Root>

package/src/shapes/Table.tsx

@@ -7,13 +7,13 @@ import React from 'react';
 
 import { createInputSchema, createOutputSchema } from '@dxos/conductor';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
-import { DataType } from '@dxos/schema';
+import { Message } from '@dxos/types';
 
 import { Box, createFunctionAnchors } from './common';
 import { ComputeShape, type CreateShapeProps, createShape } from './defs';
 
-const InputSchema = createInputSchema(DataType.Message);
-const OutputSchema = createOutputSchema(Schema.mutable(Schema.Array(DataType.Message)));
+const InputSchema = createInputSchema(Message.Message);
+const OutputSchema = createOutputSchema(Schema.mutable(Schema.Array(Message.Message)));
 
 export const TableShape = Schema.extend(
   ComputeShape,