@dxos/react-ui-canvas-compute 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/graph/controller.ts

@@ -2,14 +2,26 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Context, Effect, Either, Exit, Scope } from 'effect';
+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 * as Scope from 'effect/Scope';
 
+import type { AiService } from '@dxos/ai';
 import { Event, synchronized } from '@dxos/async';
+import { type Credential, type Operation, Trace } from '@dxos/compute';
 import {
+  ComputeBeginEvent,
+  ComputeCustomEvent,
+  ComputeEndEvent,
+  ComputeInputEvent,
+  ComputeNodeContext,
+  ComputeOutputEvent,
   type ComputeEdge,
   type ComputeGraphModel,
-  type ComputeMeta,
   type ComputeNode,
+  type ComputeNodeMeta,
   type GptInput,
   type GptOutput,
   type GraphDiagnostic,
@@ -18,15 +30,14 @@ 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, Feed, Registry } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
 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';
-
 import { resolveComputeNode } from './node-defs';
 
 // TODO(burdon): API package for conductor.
@@ -68,17 +79,46 @@ type ComputeOutputEvent = {
   value: RuntimeValue;
 };
 
+/**
+ * Event emitted by the compute graph during execution.
+ */
+export type ComputeEvent =
+  | { type: 'begin-compute'; nodeId: string; inputs: ReadonlyArray<string> }
+  | { type: 'end-compute'; nodeId: string; outputs: ReadonlyArray<string> }
+  | { type: 'compute-input'; nodeId: string; property: string; value: any }
+  | { type: 'compute-output'; nodeId: string; property: string; value: any }
+  | { type: 'custom'; nodeId: string; event: any };
+
+// TODO(dmaretskyi): Re-use function servies definition.
+export type ComputeServices =
+  | AiService.AiService
+  | Database.Service
+  | Feed.FeedService
+  | Credential.CredentialsService
+  | Operation.Service
+  | Registry.Service;
+
 /**
  * Nodes that will automatically trigger the execution of the graph on startup.
  */
 const AUTO_TRIGGER_NODES = ['chat', 'switch', 'constant'];
 
+/**
+ * Minimal runtime interface required by the {@link ComputeGraphController}.
+ *
+ * Satisfied by both `effect/ManagedRuntime.ManagedRuntime` and ad-hoc adapters
+ * built on top of the app-framework `ProcessManagerRuntime`.
+ */
+export interface ComputeGraphRuntime {
+  runPromiseExit<A, E>(effect: Effect.Effect<A, E, ComputeServices>): Promise<Exit.Exit<A, E>>;
+}
+
 export const createComputeGraphController = (
   graph: CanvasGraphModel<ComputeShape>,
-  serviceContainer: ServiceContainer,
+  computeRuntime: ComputeGraphRuntime,
 ) => {
   const computeGraph = createComputeGraph(graph);
-  const controller = new ComputeGraphController(serviceContainer, computeGraph);
+  const controller = new ComputeGraphController(computeRuntime, computeGraph);
   return { controller, graph };
 };
 
@@ -110,10 +150,10 @@ export class ComputeGraphController extends Resource {
   /** Computed result. */
   public readonly output = new Event<ComputeOutputEvent>();
 
-  public readonly events = new Event<ComputeEventPayload>();
+  public readonly events = new Event<ComputeEvent>();
 
   constructor(
-    private readonly _serviceContainer: ServiceContainer,
+    private readonly _computeRuntime: ComputeGraphRuntime,
     /** Persistent compute graph. */
     private readonly _graph: ComputeGraphModel,
   ) {
@@ -154,7 +194,14 @@ export class ComputeGraphController extends Resource {
   /**
    * Inputs and outputs for all nodes.
    */
-  get state() {
+  get state(): Record<
+    string,
+    {
+      node: ComputeNode;
+      input: Record<string, RuntimeValue>;
+      output: Record<string, RuntimeValue>;
+    }
+  > {
     const ids = [...new Set([...Object.keys(this._runtimeStateInputs), ...Object.keys(this._runtimeStateOutputs)])];
     return Object.fromEntries(
       ids.map((id) => [
@@ -201,7 +248,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;
   }
@@ -221,37 +268,42 @@ 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);
+    EffectEx.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(
+              Layer.mergeAll(
+                Layer.succeed(Trace.TraceService, this._createTraceWriter()),
+                ComputeNodeContext.layerNoop,
+              ),
+            ),
+            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();
@@ -279,59 +331,69 @@ 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);
+    EffectEx.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(
+                Layer.mergeAll(
+                  Layer.succeed(Trace.TraceService, this._createTraceWriter()),
+                  ComputeNodeContext.layerNoop,
+                ),
+              ),
+
+              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();
   }
 
-  private _createLogger(): Context.Tag.Service<ComputeEventLogger> {
+  private _createTraceWriter(): Trace.TraceWriter {
     return {
-      log: (event) => {
-        this._handleEvent(event);
+      write: (eventType, payload) => {
+        const event = traceEventToComputeEvent(eventType.key, payload);
+        if (event) {
+          this._handleEvent(event);
+        }
       },
-      nodeId: undefined, // Not in a context of a specific node.
     };
   }
 
-  private _handleEvent(event: ComputeEventPayload): void {
+  private _handleEvent(event: ComputeEvent): void {
     log('handleEvent', { event });
     switch (event.type) {
       case 'compute-input': {
@@ -361,6 +423,23 @@ export class ComputeGraphController extends Resource {
   }
 }
 
+const traceEventToComputeEvent = (key: string, payload: unknown): ComputeEvent | undefined => {
+  switch (key) {
+    case ComputeBeginEvent.key:
+      return { type: 'begin-compute', ...(payload as { nodeId: string; inputs: ReadonlyArray<string> }) };
+    case ComputeEndEvent.key:
+      return { type: 'end-compute', ...(payload as { nodeId: string; outputs: ReadonlyArray<string> }) };
+    case ComputeInputEvent.key:
+      return { type: 'compute-input', ...(payload as { nodeId: string; property: string; value: any }) };
+    case ComputeOutputEvent.key:
+      return { type: 'compute-output', ...(payload as { nodeId: string; property: string; value: any }) };
+    case ComputeCustomEvent.key:
+      return { type: 'custom', ...(payload as { nodeId: string; event: any }) };
+    default:
+      return undefined;
+  }
+};
+
 /**
  * Waits for all effects in the bag to complete and returns the `RuntimeValue` for each property.
  */

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-schema';
+import { JsonSchema, Obj } from '@dxos/echo';
 import { invariant } from '@dxos/invariant';
 
 import { type ComputeShape, type ConstantShape, type TemplateShape } from '../shapes';
@@ -39,45 +39,45 @@ const nodeFactory: Record<NodeType | 'trigger', (shape: ComputeShape) => Compute
   [NODE_OUTPUT]: () => createNode(NODE_OUTPUT),
 
   // Extensions.
-  ['text-to-image' as const]: () => createNode('text-to-image'), // TODO(burdon): Rename ai-impage-tool
-  ['and' as const]: () => createNode('and'),
-  ['append' as const]: () => createNode('append'),
-  ['audio' as const]: () => createNode('audio'),
-  ['beacon' as const]: () => createNode('beacon'),
-  ['chat' as const]: () => createNode('chat'),
-  ['constant' as const]: (shape) =>
+  'text-to-image': () => createNode('text-to-image'), // TODO(burdon): Rename ai-impage-tool
+  and: () => createNode('and'),
+  append: () => createNode('append'),
+  audio: () => createNode('audio'),
+  beacon: () => createNode('beacon'),
+  chat: () => createNode('chat'),
+  constant: (shape) =>
     createNode('constant', {
       value: (shape as ConstantShape).value,
     }),
-  ['make-queue' as const]: () => createNode('make-queue'),
-  ['database' as const]: () => createNode('database'),
-  ['gpt' as const]: () => createNode('gpt'),
-  ['gpt-realtime' as const]: () => createNode('gpt-realtime'),
-  ['if' as const]: () => createNode('if'),
-  ['if-else' as const]: () => createNode('if-else'),
-  ['function' as const]: () => createNode('function'),
-  ['json' as const]: () => createNode('json'),
-  ['json-transform' as const]: () => createNode('json-transform'),
-  ['not' as const]: () => createNode('not'),
-  ['or' as const]: () => createNode('or'),
-  ['queue' as const]: () => createNode('queue'),
-  ['rng' as const]: () => createNode('rng'),
-  ['reducer' as const]: () => createNode('reducer'),
-  ['scope' as const]: () => createNode('scope'),
-  ['surface' as const]: () => createNode('surface'),
-  ['switch' as const]: () => createNode('switch'),
-  ['template' as const]: (shape) => {
+  'make-queue': () => createNode('make-queue'),
+  database: () => createNode('database'),
+  gpt: () => createNode('gpt'),
+  'gpt-realtime': () => createNode('gpt-realtime'),
+  if: () => createNode('if'),
+  'if-else': () => createNode('if-else'),
+  function: () => createNode('function'),
+  json: () => createNode('json'),
+  'json-transform': () => createNode('json-transform'),
+  not: () => createNode('not'),
+  or: () => createNode('or'),
+  queue: () => createNode('queue'),
+  rng: () => createNode('rng'),
+  reducer: () => createNode('reducer'),
+  scope: () => createNode('scope'),
+  surface: () => createNode('surface'),
+  switch: () => createNode('switch'),
+  template: (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'),
-  ['thread' as const]: () => createNode('thread'),
-  ['trigger' as const]: () => createNode(NODE_INPUT),
+  text: () => createNode('text'),
+  thread: () => createNode('thread'),
+  trigger: () => createNode(NODE_INPUT),
 };
 
 const createNode = (type: string, props?: Partial<ComputeNode>): ComputeNode => ({
-  id: ObjectId.random(),
+  id: Obj.ID.random(),
   type,
   ...props,
 });

package/src/hooks/useComputeGraphController.ts

@@ -21,7 +21,7 @@ const combine = (...cbs: CleanupFn[]) => {
 
 export type UseComputeGraphControllerOptions = Pick<EditorRootProps<ComputeShape>, 'graph'> & {
   controller: ComputeGraphController | null;
-  editorRef: RefObject<EditorController>;
+  editorRef: RefObject<EditorController | null>;
 };
 
 export const useComputeGraphController = ({ controller, graph, editorRef }: UseComputeGraphControllerOptions) => {

package/src/hooks/useComputeNodeState.ts

@@ -2,27 +2,25 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { useCallback, useEffect, useState } from 'react';
 
-import type { ComputeMeta, ComputeNode } from '@dxos/conductor';
-import type { ComputeEventPayload } from '@dxos/functions';
+import type { ComputeNode, ComputeNodeMeta } from '@dxos/conductor';
 import { invariant } from '@dxos/invariant';
 
-import { type RuntimeValue } from '../graph';
+import { type ComputeEvent, type RuntimeValue } from '../graph';
 import { type ComputeShape } from '../shapes';
-
 import { useComputeContext } from './compute-context';
 
 export type ComputeNodeState = {
   node: ComputeNode;
-  meta: ComputeMeta;
+  meta: ComputeNodeMeta;
   runtime: {
     inputs: Record<string, RuntimeValue>;
     outputs: Record<string, RuntimeValue>;
     setOutput: (property: string, value: any) => void;
     evalNode: () => void;
-    subscribeToEventLog: (cb: (event: ComputeEventPayload) => void) => void;
+    subscribeToEventLog: (cb: (event: ComputeEvent) => void) => () => void;
   };
 };
 
@@ -33,7 +31,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 +41,7 @@ export const useComputeNodeState = (shape: ComputeShape): ComputeNodeState => {
       if (disposed) {
         return;
       }
+
       setMeta(meta);
     });
 
@@ -56,7 +55,7 @@ export const useComputeNodeState = (shape: ComputeShape): ComputeNodeState => {
   }, [shape.node]);
 
   const subscribeToEventLog = useCallback(
-    (cb: (event: ComputeEventPayload) => void) => {
+    (cb: (event: ComputeEvent) => void): (() => void) => {
       return controller.events.on((ev) => {
         if (ev.nodeId === shape.node) {
           cb(ev);

package/src/hooks/useGraphMonitor.ts

@@ -5,10 +5,9 @@
 import { useMemo } from 'react';
 
 import { type ComputeEdge, ComputeGraphModel, type ComputeNode, DEFAULT_INPUT, DEFAULT_OUTPUT } from '@dxos/conductor';
-import { ObjectId, Ref } from '@dxos/echo-schema';
+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 { type CanvasBoard, type CanvasGraphModel, type GraphMonitor } from '@dxos/react-ui-canvas-editor';
 import { isNonNullable } from '@dxos/util';
 
 import { createComputeNode, isValidComputeNode } from '../graph';
@@ -19,7 +18,7 @@ import { type ComputeShape, type TriggerShape } from '../shapes';
  */
 export const mapEdge = (
   graph: CanvasGraphModel,
-  { source, target, output = DEFAULT_OUTPUT, input = DEFAULT_INPUT }: Connection,
+  { source, target, output = DEFAULT_OUTPUT, input = DEFAULT_INPUT }: CanvasBoard.Connection,
 ): ComputeEdge => {
   const sourceNode = graph.findNode(source) as ComputeShape;
   const targetNode = graph.findNode(target) as ComputeShape;
@@ -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.update(functionTrigger, (functionTrigger) => {
+    functionTrigger.function = Ref.make(graph.root);
+    functionTrigger.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

@@ -2,15 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema } from 'effect';
+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/registry.ts

@@ -22,7 +22,7 @@ import {
   jsonTransformShape,
   notShape,
   orShape,
-  queueShape,
+  feedShape,
   randomShape,
   reducerShape,
   scopeShape,
@@ -82,7 +82,7 @@ export const computeShapes: { title: string; shapes: ShapeDef[] }[] = [
     shapes: [
       //
       jsonShape,
-      queueShape,
+      feedShape,
       threadShape,
       textShape,
       surfaceShape,

package/src/schema.test.ts

@@ -2,14 +2,14 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import { describe, test } from 'vitest';
 
-import { live } from '@dxos/client/echo';
-import { BaseGraphNode, Graph } from '@dxos/graph';
+import { Graph } from '@dxos/graph';
 import {
+  CanvasBoard,
+  CanvasGraphModel,
   Polygon,
-  Shape,
   createEllipse,
   createPath,
   createRectangle,
@@ -21,25 +21,25 @@ 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(CanvasBoard.Shape)(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));
   });
 });
 
 describe('schema', () => {
   test('basic types', ({ expect }) => {
-    const shapes: Shape[] = [];
+    const shapes: CanvasBoard.Shape[] = [];
     shapes.push(createRectangle({ id: 'shape-1', center: { x: 0, y: 0 }, size: { width: 80, height: 80 } }));
     shapes.push(createEllipse({ id: 'shape-2', center: { x: 0, y: 0 }, size: { width: 80, height: 80 } }));
     shapes.push(createFunction({ id: 'shape-3', center: { x: 0, y: 0 } }));

package/src/shapes/Append.tsx

@@ -2,7 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
+import * as Schema from 'effect/Schema';
 import React from 'react';
 
 import { AppendInput } from '@dxos/conductor';