@dxos/react-ui-canvas-compute 0.8.2-main.fbd8ed0 → 0.8.2-staging.7ac8446

package/src/shapes/Logic.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React from 'react';
 
 import { IfElseInput, IfElseOutput, IfInput, IfOutput } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 
 import { createFunctionAnchors, FunctionBody, getHeight } from './common';
@@ -15,23 +15,23 @@ import { ComputeShape, createShape, type CreateShapeProps } from './defs';
 // Data
 //
 
-export const IfShape = Schema.extend(
+export const IfShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('if'),
+  S.Struct({
+    type: S.Literal('if'),
   }),
 );
 
-export type IfShape = Schema.Schema.Type<typeof IfShape>;
+export type IfShape = S.Schema.Type<typeof IfShape>;
 
-export const IfElseShape = Schema.extend(
+export const IfElseShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('if-else'),
+  S.Struct({
+    type: S.Literal('if-else'),
   }),
 );
 
-export type IfElseShape = Schema.Schema.Type<typeof IfElseShape>;
+export type IfElseShape = S.Schema.Type<typeof IfElseShape>;
 
 //
 // Components

package/src/shapes/Queue.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React, { Fragment } from 'react';
 
 import { DEFAULT_OUTPUT, QueueInput, QueueOutput } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 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';
@@ -15,14 +15,14 @@ import { Box, type BoxActionHandler } from './common';
 import { ComputeShape, createShape, type CreateShapeProps } from './defs';
 import { useComputeNodeState } from '../hooks';
 
-export const QueueShape = Schema.extend(
+export const QueueShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('queue'),
+  S.Struct({
+    type: S.Literal('queue'),
   }),
 );
 
-export type QueueShape = Schema.Schema.Type<typeof QueueShape>;
+export type QueueShape = S.Schema.Type<typeof QueueShape>;
 
 export type CreateQueueProps = CreateShapeProps<QueueShape>;
 

package/src/shapes/RNG.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React, { useEffect, useState } from 'react';
 
 import { DEFAULT_OUTPUT } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { Icon, type IconProps } from '@dxos/react-ui';
 import { createAnchorMap, type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 import { mx } from '@dxos/react-ui-theme';
@@ -13,16 +13,16 @@ import { mx } from '@dxos/react-ui-theme';
 import { ComputeShape, createAnchorId, createShape, type CreateShapeProps } from './defs';
 import { useComputeNodeState } from '../hooks';
 
-export const RandomShape = Schema.extend(
+export const RandomShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('rng'),
-    min: Schema.optional(Schema.Number),
-    max: Schema.optional(Schema.Number),
+  S.Struct({
+    type: S.Literal('rng'),
+    min: S.optional(S.Number),
+    max: S.optional(S.Number),
   }),
 );
 
-export type RandomShape = Schema.Schema.Type<typeof RandomShape>;
+export type RandomShape = S.Schema.Type<typeof RandomShape>;
 
 export type CreateRandomProps = CreateShapeProps<RandomShape>;
 

package/src/shapes/Scope.tsx

@@ -2,24 +2,24 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React from 'react';
 
 import { DEFAULT_INPUT } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { createAnchorMap, type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 import { useAudioStream, Chaos, shaderPresets } from '@dxos/react-ui-sfx';
 
 import { ComputeShape, createAnchorId, createShape, type CreateShapeProps } from './defs';
 import { useComputeNodeState } from '../hooks';
 
-export const ScopeShape = Schema.extend(
+export const ScopeShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('scope'),
+  S.Struct({
+    type: S.Literal('scope'),
   }),
 );
 
-export type ScopeShape = Schema.Schema.Type<typeof ScopeShape>;
+export type ScopeShape = S.Schema.Type<typeof ScopeShape>;
 
 export type CreateScopeProps = CreateShapeProps<ScopeShape>;
 

package/src/shapes/Surface.tsx

@@ -2,11 +2,11 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React from 'react';
 
 import { Surface } from '@dxos/app-framework';
 import { DEFAULT_INPUT } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 import { createAnchorMap } from '@dxos/react-ui-canvas-editor';
 
@@ -14,14 +14,14 @@ import { Box, type BoxActionHandler } from './common';
 import { ComputeShape, createAnchorId, createShape, type CreateShapeProps } from './defs';
 import { useComputeNodeState } from '../hooks';
 
-export const SurfaceShape = Schema.extend(
+export const SurfaceShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('surface'),
+  S.Struct({
+    type: S.Literal('surface'),
   }),
 );
 
-export type SurfaceShape = Schema.Schema.Type<typeof SurfaceShape>;
+export type SurfaceShape = S.Schema.Type<typeof SurfaceShape>;
 
 export type CreateSurfaceProps = CreateShapeProps<SurfaceShape>;
 

package/src/shapes/Switch.tsx

@@ -2,24 +2,24 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React, { useEffect, useState } from 'react';
 
 import { DEFAULT_OUTPUT } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { Input } from '@dxos/react-ui';
 import { createAnchorMap, type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 
 import { ComputeShape, createAnchorId, createShape, type CreateShapeProps } from './defs';
 import { useComputeNodeState } from '../hooks';
 
-export const SwitchShape = Schema.extend(
+export const SwitchShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('switch'),
+  S.Struct({
+    type: S.Literal('switch'),
   }),
 );
 
-export type SwitchShape = Schema.Schema.Type<typeof SwitchShape>;
+export type SwitchShape = S.Schema.Type<typeof SwitchShape>;
 
 export type CreateSwitchProps = CreateShapeProps<SwitchShape>;
 

package/src/shapes/Table.tsx

@@ -2,26 +2,26 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React from 'react';
 
 import { createInputSchema, createOutputSchema, GptMessage } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 
 import { createFunctionAnchors, Box } from './common';
 import { ComputeShape, createShape, type CreateShapeProps } from './defs';
 
 const InputSchema = createInputSchema(GptMessage);
-const OutputSchema = createOutputSchema(Schema.mutable(Schema.Array(GptMessage)));
+const OutputSchema = createOutputSchema(S.mutable(S.Array(GptMessage)));
 
-export const TableShape = Schema.extend(
+export const TableShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('table'),
+  S.Struct({
+    type: S.Literal('table'),
   }),
 );
 
-export type TableShape = Schema.Schema.Type<typeof TableShape>;
+export type TableShape = S.Schema.Type<typeof TableShape>;
 
 export type CreateTableProps = CreateShapeProps<TableShape>;
 

package/src/shapes/Template.tsx

@@ -2,11 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React, { useRef } from 'react';
 
 import { ComputeValueType, getTemplateInputSchema, TemplateOutput, VoidInput } from '@dxos/conductor';
-import { toJsonSchema } from '@dxos/echo-schema';
+import { S, toJsonSchema } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import {
   type ShapeComponentProps,
@@ -24,15 +23,15 @@ import { useComputeNodeState } from '../hooks';
 // Data
 //
 
-export const TemplateShape = Schema.extend(
+export const TemplateShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('template'),
-    valueType: Schema.optional(ComputeValueType),
+  S.Struct({
+    type: S.Literal('template'),
+    valueType: S.optional(ComputeValueType),
   }),
 );
 
-export type TemplateShape = Schema.Schema.Type<typeof TemplateShape>;
+export type TemplateShape = S.Schema.Type<typeof TemplateShape>;
 
 //
 // Component
@@ -55,7 +54,7 @@ const TextInputComponent = ({ shape, title, ...props }: TextInputComponentProps)
   };
 
   const handleTypeChange = (newType: string) => {
-    invariant(Schema.is(ComputeValueType)(newType), 'Invalid type');
+    invariant(S.is(ComputeValueType)(newType), 'Invalid type');
 
     node.valueType = newType;
     node.inputSchema = toJsonSchema(getTemplateInputSchema(node));

package/src/shapes/Text.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React from 'react';
 
 import { DEFAULT_INPUT } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 import { TextBox, type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 import { createAnchorMap } from '@dxos/react-ui-canvas-editor';
 
@@ -13,14 +13,14 @@ import { Box, type BoxActionHandler } from './common';
 import { ComputeShape, createAnchorId, createShape, type CreateShapeProps } from './defs';
 import { useComputeNodeState } from '../hooks';
 
-export const TextShape = Schema.extend(
+export const TextShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('text'),
+  S.Struct({
+    type: S.Literal('text'),
   }),
 );
 
-export type TextShape = Schema.Schema.Type<typeof TextShape>;
+export type TextShape = S.Schema.Type<typeof TextShape>;
 
 export type CreateTextProps = CreateShapeProps<TextShape>;
 

package/src/shapes/TextToImage.tsx

@@ -2,23 +2,23 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React from 'react';
 
+import { S } from '@dxos/echo-schema';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 import { createAnchorMap } from '@dxos/react-ui-canvas-editor';
 
 import { Box } from './common';
 import { ComputeShape, createAnchorId, createShape, type CreateShapeProps } from './defs';
 
-export const TextToImageShape = Schema.extend(
+export const TextToImageShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('text-to-image'),
+  S.Struct({
+    type: S.Literal('text-to-image'),
   }),
 );
 
-export type TextToImageShape = Schema.Schema.Type<typeof TextToImageShape>;
+export type TextToImageShape = S.Schema.Type<typeof TextToImageShape>;
 
 export type CreateTextToImageProps = CreateShapeProps<TextToImageShape>;
 

package/src/shapes/Thread.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React, { useEffect, useRef } from 'react';
 
 import { createInputSchema, createOutputSchema, GptMessage } from '@dxos/conductor';
+import { S } from '@dxos/echo-schema';
 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';
@@ -14,16 +14,16 @@ import { createFunctionAnchors, Box } from './common';
 import { ComputeShape, createShape, type CreateShapeProps } from './defs';
 
 const InputSchema = createInputSchema(GptMessage);
-const OutputSchema = createOutputSchema(Schema.mutable(Schema.Array(GptMessage)));
+const OutputSchema = createOutputSchema(S.mutable(S.Array(GptMessage)));
 
-export const ThreadShape = Schema.extend(
+export const ThreadShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('thread'),
+  S.Struct({
+    type: S.Literal('thread'),
   }),
 );
 
-export type ThreadShape = Schema.Schema.Type<typeof ThreadShape>;
+export type ThreadShape = S.Schema.Type<typeof ThreadShape>;
 
 export type CreateThreadProps = CreateShapeProps<ThreadShape>;
 

package/src/shapes/Trigger.tsx

@@ -2,11 +2,17 @@
 // Copyright 2024 DXOS.org
 //
 
-import { Schema } from 'effect';
 import React, { useEffect } from 'react';
 
-import { VoidInput } from '@dxos/conductor';
-import { ObjectId, Ref } from '@dxos/echo-schema';
+import {
+  EmailTriggerOutput,
+  QueueTriggerOutput,
+  SubscriptionTriggerOutput,
+  TimerTriggerOutput,
+  VoidInput,
+  WebhookTriggerOutput,
+} from '@dxos/conductor';
+import { ObjectId, Ref, S } from '@dxos/echo-schema';
 import {
   type EmailTrigger,
   FunctionTrigger,
@@ -16,28 +22,23 @@ import {
   TriggerKind,
   type TriggerType,
   type WebhookTrigger,
-  EmailTriggerOutput,
-  QueueTriggerOutput,
-  SubscriptionTriggerOutput,
-  TimerTriggerOutput,
-  WebhookTriggerOutput,
-} from '@dxos/functions';
+} from '@dxos/functions/types';
 import { DXN, SpaceId } from '@dxos/keys';
-import { live, makeRef, useSpace } from '@dxos/react-client/echo';
+import { create, makeRef, useSpace } from '@dxos/react-client/echo';
 import { Select, type SelectRootProps } from '@dxos/react-ui';
 import { type ShapeComponentProps, type ShapeDef } from '@dxos/react-ui-canvas-editor';
 
 import { createFunctionAnchors, FunctionBody, getHeight } from './common';
 import { ComputeShape, createShape, type CreateShapeProps } from './defs';
 
-export const TriggerShape = Schema.extend(
+export const TriggerShape = S.extend(
   ComputeShape,
-  Schema.Struct({
-    type: Schema.Literal('trigger'),
-    functionTrigger: Schema.optional(Ref(FunctionTrigger)),
+  S.Struct({
+    type: S.Literal('trigger'),
+    functionTrigger: S.optional(Ref(FunctionTrigger)),
   }),
 );
-export type TriggerShape = Schema.Schema.Type<typeof TriggerShape>;
+export type TriggerShape = S.Schema.Type<typeof TriggerShape>;
 
 export type CreateTriggerProps = CreateShapeProps<Omit<TriggerShape, 'functionTrigger'>> & {
   spaceId?: SpaceId;
@@ -45,7 +46,7 @@ export type CreateTriggerProps = CreateShapeProps<Omit<TriggerShape, 'functionTr
 };
 
 export const createTrigger = (props: CreateTriggerProps): TriggerShape => {
-  const functionTrigger = live(FunctionTrigger, {
+  const functionTrigger = create(FunctionTrigger, {
     enabled: true,
     spec: createTriggerSpec(props),
   });
@@ -70,12 +71,12 @@ export const TriggerComponent = ({ shape }: TriggerComponentProps) => {
   }, [functionTrigger, functionTrigger?.spec]);
 
   useEffect(() => {
-    shape.size.height = getHeight(getOutputSchema(functionTrigger?.spec?.kind ?? TriggerKind.Email));
-  }, [functionTrigger?.spec?.kind]);
+    shape.size.height = getHeight(getOutputSchema(functionTrigger?.spec?.type ?? TriggerKind.Email));
+  }, [functionTrigger?.spec?.type]);
 
   const setKind = (kind: TriggerKind) => {
-    if (functionTrigger?.spec?.kind !== kind) {
-      functionTrigger!.spec = createTriggerSpec({ triggerKind: kind, spaceId: space?.id });
+    if (functionTrigger?.spec?.type !== kind) {
+      functionTrigger!.spec = createTriggerSpec({ triggerKind: TriggerKind.Email, spaceId: space?.id });
     }
   };
 
@@ -87,10 +88,10 @@ export const TriggerComponent = ({ shape }: TriggerComponentProps) => {
     <FunctionBody
       shape={shape}
       status={
-        <TriggerKindSelect value={functionTrigger.spec?.kind} onValueChange={(kind) => setKind(kind as TriggerKind)} />
+        <TriggerKindSelect value={functionTrigger.spec?.type} onValueChange={(kind) => setKind(kind as TriggerKind)} />
       }
       inputSchema={VoidInput}
-      outputSchema={getOutputSchema(functionTrigger.spec!.kind!)}
+      outputSchema={getOutputSchema(functionTrigger.spec!.type!)}
     />
   );
 };
@@ -104,9 +105,9 @@ const TriggerKindSelect = ({ value, onValueChange }: Pick<SelectRootProps, 'valu
         <Select.Content>
           <Select.ScrollUpButton />
           <Select.Viewport>
-            {Object.values(TriggerKind).map((kind) => (
-              <Select.Option key={kind} value={kind}>
-                {kind}
+            {Object.values(TriggerKind).map((type) => (
+              <Select.Option key={type} value={type}>
+                {type}
               </Select.Option>
             ))}
           </Select.Viewport>
@@ -122,22 +123,22 @@ const createTriggerSpec = (props: { triggerKind?: TriggerKind; spaceId?: SpaceId
   const kind = props.triggerKind ?? TriggerKind.Email;
   switch (kind) {
     case TriggerKind.Timer:
-      return { kind: TriggerKind.Timer, cron: '*/10 * * * * *' } satisfies TimerTrigger;
+      return { type: TriggerKind.Timer, cron: '*/10 * * * * *' } satisfies TimerTrigger;
     case TriggerKind.Webhook:
-      return { kind: TriggerKind.Webhook, method: 'POST' } satisfies WebhookTrigger;
+      return { type: TriggerKind.Webhook, method: 'POST' } satisfies WebhookTrigger;
     case TriggerKind.Subscription:
-      return { kind: TriggerKind.Subscription, filter: {} } satisfies SubscriptionTrigger;
+      return { type: TriggerKind.Subscription, filter: {} } satisfies SubscriptionTrigger;
     case TriggerKind.Email:
-      return { kind: TriggerKind.Email } satisfies EmailTrigger;
+      return { type: TriggerKind.Email } satisfies EmailTrigger;
     case TriggerKind.Queue: {
       const dxn = new DXN(DXN.kind.QUEUE, ['data', props.spaceId ?? SpaceId.random(), ObjectId.random()]).toString();
-      return { kind: TriggerKind.Queue, queue: dxn } satisfies QueueTrigger;
+      return { type: TriggerKind.Queue, queue: dxn } satisfies QueueTrigger;
     }
   }
 };
 
 const getOutputSchema = (kind: TriggerKind) => {
-  const kindToSchema: Record<TriggerKind, Schema.Schema<any>> = {
+  const kindToSchema: Record<TriggerKind, S.Schema<any>> = {
     [TriggerKind.Email]: EmailTriggerOutput,
     [TriggerKind.Subscription]: SubscriptionTriggerOutput,
     [TriggerKind.Timer]: TimerTriggerOutput,
@@ -157,6 +158,6 @@ export const triggerShape: ShapeDef<TriggerShape> = {
     createFunctionAnchors(
       shape,
       VoidInput,
-      getOutputSchema(shape.functionTrigger?.target?.spec?.kind ?? TriggerKind.Email),
+      getOutputSchema(shape.functionTrigger?.target?.spec?.type ?? TriggerKind.Email),
     ),
 };

package/src/shapes/common/FunctionBody.tsx

@@ -2,10 +2,10 @@
 // Copyright 2024 DXOS.org
 //
 
-import { type Schema, SchemaAST } from 'effect';
 import React, { type JSX, useRef, useState } from 'react';
 
 import { VoidInput, VoidOutput } from '@dxos/conductor';
+import { AST, type S } from '@dxos/echo-schema';
 import { useCanvasContext } from '@dxos/react-ui-canvas';
 import { type Polygon, type Shape } from '@dxos/react-ui-canvas-editor';
 import { getParentShapeElement, createAnchors, rowHeight } from '@dxos/react-ui-canvas-editor';
@@ -20,8 +20,8 @@ export type FunctionBodyProps = {
   shape: Shape;
   name?: string;
   content?: JSX.Element;
-  inputSchema?: Schema.Schema.Any;
-  outputSchema?: Schema.Schema.Any;
+  inputSchema?: S.Schema.Any;
+  outputSchema?: S.Schema.Any;
 } & Pick<BoxProps, 'status'>;
 
 // TODO(wittjosiah): Rename, not used for functions.
@@ -106,20 +106,18 @@ export const FunctionBody = ({
   );
 };
 
-export const getHeight = (input: Schema.Schema<any>) => {
-  const properties = SchemaAST.getPropertySignatures(input.ast);
+export const getHeight = (input: S.Schema<any>) => {
+  const properties = AST.getPropertySignatures(input.ast);
   return headerHeight + footerHeight + bodyPadding * 2 + properties.length * rowHeight + 2; // Incl. borders.
 };
 
 export const createFunctionAnchors = (
   shape: Polygon,
-  input: Schema.Schema<any> = VoidInput,
-  output: Schema.Schema<any> = VoidOutput,
+  input: S.Schema<any> = VoidInput,
+  output: S.Schema<any> = VoidOutput,
 ) => {
   // TODO(burdon): Set type.
-  const inputs = SchemaAST.getPropertySignatures(input.ast).map(({ name }) => createAnchorId('input', name.toString()));
-  const outputs = SchemaAST.getPropertySignatures(output.ast).map(({ name }) =>
-    createAnchorId('output', name.toString()),
-  );
+  const inputs = AST.getPropertySignatures(input.ast).map(({ name }) => createAnchorId('input', name.toString()));
+  const outputs = AST.getPropertySignatures(output.ast).map(({ name }) => createAnchorId('output', name.toString()));
   return createAnchors({ shape, inputs, outputs, center: { x: 0, y: (headerHeight - footerHeight) / 2 + 1 } });
 };

package/src/shapes/defs.ts

@@ -2,10 +2,10 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Schema, SchemaAST } from 'effect';
+import { SchemaAST as AST } from 'effect';
 
 import { DEFAULT_INPUT, DEFAULT_OUTPUT } from '@dxos/conductor';
-import { ObjectId } from '@dxos/echo-schema';
+import { ObjectId, S } from '@dxos/echo-schema';
 import { Polygon } from '@dxos/react-ui-canvas-editor';
 import { type MakeOptional } from '@dxos/util';
 
@@ -15,8 +15,8 @@ import { type MakeOptional } from '@dxos/util';
 
 export type PropertyKind = 'input' | 'output';
 
-export const getProperties = (ast: SchemaAST.AST) =>
-  SchemaAST.getPropertySignatures(ast).map(({ name }) => ({ name: name.toString() }));
+export const getProperties = (ast: AST.AST) =>
+  AST.getPropertySignatures(ast).map(({ name }) => ({ name: name.toString() }));
 
 export const createAnchorId = (kind: PropertyKind, property = kind === 'input' ? DEFAULT_INPUT : DEFAULT_OUTPUT) =>
   [kind, property].join('.');
@@ -32,15 +32,15 @@ export const parseAnchorId = (id: string): [PropertyKind | undefined, string] =>
 
 export type CreateShapeProps<S extends Polygon> = Omit<MakeOptional<S, 'id' | 'size'>, 'type' | 'node'>;
 
-export const ComputeShape = Schema.extend(
+export const ComputeShape = S.extend(
   Polygon,
-  Schema.Struct({
+  S.Struct({
     // TODO(burdon): Rename computeNode?
-    node: Schema.optional(ObjectId.annotations({ [SchemaAST.DescriptionAnnotationId]: 'Compute node id' })),
-  }).pipe(Schema.mutable),
+    node: S.optional(ObjectId.annotations({ [AST.DescriptionAnnotationId]: 'Compute node id' })),
+  }).pipe(S.mutable),
 );
 
-export type ComputeShape = Schema.Schema.Type<typeof ComputeShape>;
+export type ComputeShape = S.Schema.Type<typeof ComputeShape>;
 
 export const createShape = <S extends ComputeShape>({ id, ...rest }: CreateShapeProps<S> & { type: string }): S => {
   return {