@dxos/plugin-script 0.8.4-main.2c6827d → 0.8.4-main.3c1ae3b

package/src/components/QueryEditor/QueryEditor.stories.tsx

@@ -0,0 +1,89 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useCallback, useMemo, useState } from 'react';
+
+import { createDocAccessor } from '@dxos/echo-db';
+import { QuerySandbox } from '@dxos/echo-query';
+import { createObject } from '@dxos/react-client/echo';
+import { Toolbar, useAsyncEffect } from '@dxos/react-ui';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { createDataExtensions } from '@dxos/react-ui-editor';
+import { StackItem } from '@dxos/react-ui-stack';
+import { Json } from '@dxos/react-ui-syntax-highlighter';
+import { trim } from '@dxos/util';
+
+import { QueryEditor, type QueryEditorProps } from './QueryEditor';
+
+const SCRIPT = trim`
+  Query.select(Filter.type('dxos.org/type/Person'))
+`;
+
+const DefaultStory = (props: QueryEditorProps) => {
+  const object = useMemo(() => createObject({ content: SCRIPT }), []);
+  const [result, setResult] = useState<object | undefined>({});
+  const [sandbox, setSandbox] = useState<QuerySandbox>();
+
+  useAsyncEffect(async () => {
+    const sandbox = new QuerySandbox();
+    await sandbox.open();
+    setSandbox(sandbox);
+
+    return () => {
+      void sandbox.close();
+    };
+  }, []);
+
+  const extensions = useMemo(
+    () => [createDataExtensions({ id: object.id, text: createDocAccessor(object, ['content']) })],
+    [],
+  );
+
+  const handleRun = useCallback(async () => {
+    try {
+      const result = sandbox?.eval(object.content);
+
+      setResult({
+        timestamp: Date.now(),
+        result,
+      });
+    } catch (err) {
+      setResult({
+        timestamp: Date.now(),
+        error: String(err),
+      });
+    }
+  }, [object, sandbox]);
+
+  return (
+    <StackItem.Content toolbar>
+      {/* <ScriptToolbar script={script} state={{}} /> */}
+      <Toolbar.Root>
+        <Toolbar.Button onClick={handleRun}>Run</Toolbar.Button>
+      </Toolbar.Root>
+      <div role='none' className='grid grid-rows-[1fr_min-content] bs-full overflow-hidden text-sm'>
+        <QueryEditor {...props} initialValue={object.content} extensions={extensions} />
+        <Json data={result} classNames='shrink-0 p-2 border-t border-subduedSeparator' />
+      </div>
+    </StackItem.Content>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-script/QueryEditor',
+  component: QueryEditor,
+  render: DefaultStory,
+  decorators: [withTheme, withLayout({ container: 'column', classNames: 'is-prose' })],
+} satisfies Meta<typeof DefaultStory>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    id: 'test',
+  },
+};

package/src/components/QueryEditor/QueryEditor.tsx

@@ -0,0 +1,47 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useState } from 'react';
+import { ScriptTarget } from 'typescript';
+
+import queryApi from '@dxos/echo-query/api.d.ts?raw';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { Compiler } from '../../compiler';
+import { TypescriptEditor, type TypescriptEditorProps } from '../TypescriptEditor';
+
+const GLOBALS = `
+  namespace QueryAPI {
+    ${queryApi}
+  }
+
+  declare global {
+    const Query: typeof QueryAPI.Query;
+    const Filter: typeof QueryAPI.Filter;
+    const Order: typeof QueryAPI.Order;
+  }
+
+  export {};
+`;
+
+export type QueryEditorProps = Omit<TypescriptEditorProps, 'env'>;
+
+export const QueryEditor = (props: QueryEditorProps) => {
+  const [compiler, setCompiler] = useState<Compiler>();
+
+  useAsyncEffect(async () => {
+    const compiler = new Compiler({
+      lib: ['ES5'],
+      target: ScriptTarget.ES2022,
+    });
+    await compiler.initialize(GLOBALS);
+    setCompiler(compiler);
+  }, []);
+
+  if (!compiler) {
+    return null;
+  }
+
+  return <TypescriptEditor {...props} env={compiler.environment} />;
+};

package/src/components/QueryEditor/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from './QueryEditor';

package/src/components/ScriptContainer.tsx

@@ -4,8 +4,9 @@
 
 import React, { useMemo } from 'react';
 
+import { createDocAccessor } from '@dxos/echo-db';
 import { type Script } from '@dxos/functions';
-import { createDocAccessor, getSpace } from '@dxos/react-client/echo';
+import { getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { createDataExtensions, listener, stackItemContentEditorClassNames } from '@dxos/react-ui-editor';
 import { StackItem } from '@dxos/react-ui-stack';
@@ -42,7 +43,7 @@ export const ScriptContainer = ({ role, script, settings = { editorInputMode: 'v
             createDataExtensions({
               id: script.id,
               text: createDocAccessor(script.source.target, ['content']),
-              space,
+              messenger: space,
               identity,
             }),
           ]

package/src/components/Settings/ScriptObjectSettings.tsx

@@ -9,11 +9,12 @@ import { ToolId } from '@dxos/ai';
 import { SettingsAction, createIntent } from '@dxos/app-framework';
 import { useIntentDispatcher } from '@dxos/app-framework/react';
 import { Blueprint, Template } from '@dxos/blueprints';
+import { Filter, Obj, Ref } from '@dxos/echo';
 import { Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
 import { getInvocationUrl } from '@dxos/functions-runtime';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
-import { Filter, Ref, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
+import { getSpace, useQuery } from '@dxos/react-client/echo';
 import { Button, Clipboard, Input, useAsyncEffect, useControlledState, useTranslation } from '@dxos/react-ui';
 import { AccessToken } from '@dxos/types';
 import { kebabize } from '@dxos/util';
@@ -144,7 +145,7 @@ const Binding = ({ object }: ScriptObjectSettingsProps) => {
   const space = getSpace(object);
   const [fn] = useQuery(space, Filter.type(Function.Function, { source: Ref.make(object) }));
 
-  const functionId = fn && getUserFunctionIdInMetadata(getMeta(fn));
+  const functionId = fn && getUserFunctionIdInMetadata(Obj.getMeta(fn));
   const functionUrl =
     functionId &&
     getInvocationUrl(functionId, client.config.values.runtime?.services?.edge?.url ?? '', {
@@ -207,7 +208,7 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
   const { dispatchPromise: dispatch } = useIntentDispatcher();
   const space = getSpace(object);
   const [githubToken] = useQuery(space, Filter.type(AccessToken.AccessToken, { source: 'github.com' }));
-  const gistKey = getMeta(object).keys.find(({ source }) => source === 'github.com');
+  const gistKey = Obj.getMeta(object).keys.find(({ source }) => source === 'github.com');
   const [gistUrl, setGistUrl] = useState<string | undefined>();
 
   useAsyncEffect(async () => {
@@ -250,7 +251,7 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
 
     try {
       // TODO(wittjosiah): Factor out to intent.
-      const meta = getMeta(object);
+      const meta = Obj.getMeta(object);
       const githubKey = meta.keys.find(({ source }) => source === 'github.com');
       const gistId = githubKey?.id;
       if (gistId) {

package/src/components/TypescriptEditor/TypescriptEditor.stories.tsx

@@ -5,7 +5,7 @@
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useCallback, useMemo, useState } from 'react';
 
-import { createDocAccessor } from '@dxos/react-client/echo';
+import { createDocAccessor } from '@dxos/echo-db';
 import { createObject } from '@dxos/react-client/echo';
 import { Toolbar } from '@dxos/react-ui';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';

package/src/components/TypescriptEditor/TypescriptEditor.tsx

@@ -86,14 +86,14 @@ export const TypescriptEditor = ({
 
         // https://github.com/val-town/codemirror-ts
         env && [
-          tsFacet.of({ env, path: `/src/${id}.ts` }),
+          tsFacet.of({ env, path: `./src/${id}.ts` }),
           tsSync(),
           tsLinter(),
           tsHover({ renderTooltip: createTooltipRenderer(themeMode) }),
         ],
       ].filter(isNonNullable),
     }),
-    [id, extensions, themeMode, inputMode, selection, scrollTo],
+    [id, extensions, themeMode, inputMode, selection, scrollTo, env],
   );
 
   // TODO(brudon): Use react-ui-editor's Editor component.

package/src/e2e/deploy.test.ts

@@ -0,0 +1,64 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { readFile } from 'node:fs/promises';
+
+import { describe, expect, test } from 'vitest';
+
+import { Client, type Config } from '@dxos/client';
+import { createEdgeIdentity } from '@dxos/client/edge';
+import { configPreset } from '@dxos/config';
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { invariant } from '@dxos/invariant';
+import { log } from '@dxos/log';
+
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('Functions deployment', () => {
+  test('deploys FOREX (effect) function and invokes it via EDGE (main)', { timeout: 120_000 }, async () => {
+    const config = configPreset({ edge: 'main' });
+    await testDeploy(config);
+  });
+
+  test('deploys FOREX (effect) function and invokes it via EDGE (production)', { timeout: 120_000 }, async () => {
+    const config = configPreset({ edge: 'production' });
+    await testDeploy(config);
+  });
+
+  const testDeploy = async (config: Config) => {
+    await using client = await new Client({ config }).initialize();
+    await client.halo.createIdentity();
+
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+
+    // Inline echo function source.
+    const source = await readFile(new URL('../templates/forex-effect.ts', import.meta.url), 'utf-8');
+
+    // Bundle and upload.
+    const buildResult = await bundleFunction({ source });
+    if ('error' in buildResult) {
+      throw buildResult.error ?? new Error('Bundle creation failed');
+    }
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+
+    const func = await functionsServiceClient.deploy({
+      ownerPublicKey: space.key,
+      version: '0.0.1',
+      entryPoint: buildResult.entryPoint,
+      assets: buildResult.assets,
+    });
+
+    // Invoke deployed function via EDGE directly.
+    const edgeClient = client.edge;
+    invariant(edgeClient, 'edgeClient is required');
+    edgeClient.setIdentity(createEdgeIdentity(client));
+
+    const input = { from: 'USD', to: 'EUR' };
+    const result = await functionsServiceClient.invoke(func, input);
+    log.info('>>> result', { result, func });
+    const resultNumber = Number(result);
+    expect(resultNumber).toBeGreaterThan(0);
+    expect(resultNumber).toBeLessThan(100);
+  };
+});

package/src/hooks/deploy.ts

@@ -4,10 +4,11 @@
 
 import { useEffect, useMemo } from 'react';
 
+import { Obj, Query, Ref } from '@dxos/echo';
 import { Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { type Client, useClient } from '@dxos/react-client';
-import { Query, Ref, type Space, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
+import { type Space, getSpace, useQuery } from '@dxos/react-client/echo';
 import { type TFunction } from '@dxos/react-ui';
 import { createMenuAction } from '@dxos/react-ui-menu';
 import { errorMessageColors } from '@dxos/react-ui-theme';
@@ -119,6 +120,6 @@ export const useDeployDeps = ({ script }: { script: Script.Script }) => {
   const client = useClient();
   const space = getSpace(script);
   const [fn] = useQuery(space, Query.type(Function.Function, { source: Ref.make(script) }));
-  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(getMeta(fn)), [fn]);
+  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(Obj.getMeta(fn)), [fn]);
   return { client, space, fn, existingFunctionId };
 };

package/src/hooks/index.ts

@@ -8,3 +8,4 @@ export * from './template';
 
 export * from './useCreateAndDeployScriptTemplates';
 export * from './useToolbarState';
+export * from './useCompiler';

package/src/hooks/useCompiler.ts

@@ -0,0 +1,23 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCapabilities, usePluginManager } from '@dxos/app-framework/react';
+import { useAsyncEffect } from '@dxos/react-ui';
+
+import { ScriptCapabilities } from '../capabilities';
+import type { Compiler } from '../compiler';
+import { ScriptEvents } from '../events';
+
+/**
+ * Asynchronously sets up the compiler and returns it.
+ * @returns The compiler instance or undefined if it is not ready.
+ */
+export const useCompiler = (): Compiler | undefined => {
+  const manager = usePluginManager();
+  useAsyncEffect(async () => {
+    await manager.activate(ScriptEvents.SetupCompiler);
+  }, [manager]);
+  const [compiler] = useCapabilities(ScriptCapabilities.Compiler);
+  return compiler;
+};

package/src/templates/chess.ts

@@ -2,27 +2,28 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-// @ts-ignore
+import * as Schema from 'effect/Schema';
 import { Chess } from 'https://esm.sh/chess.js@0.13.1?bundle=false';
 
+import { defineFunction } from '@dxos/functions';
+
 export default defineFunction({
   key: 'dxos.org/script/chess',
   name: 'Chess',
   description: 'Plays a random move in a chess game.',
 
-  inputSchema: S.Struct({
-    changedObjectId: S.String.annotations({
+  inputSchema: Schema.Struct({
+    changedObjectId: Schema.String.annotations({
       description: 'The objects to play the game on.',
     }),
-    player: S.optional(S.Literal('w', 'b')).annotations({
+    player: Schema.optional(Schema.Literal('w', 'b')).annotations({
       description: 'The player to play the game as.',
     }),
   }),
 
-  outputSchema: S.Struct({
-    state: S.String.annotations({
+  // @ts-expect-error
+  outputSchema: Schema.Struct({
+    state: Schema.String.annotations({
       description: 'The state of the game as an ASCII art board.',
     }),
   }),

package/src/templates/data-generator.ts

@@ -23,7 +23,7 @@ export default defineFunction({
     data: { documentAmount = 1, textSize = 10, mutationAmount = 0, waitAfterCreation = 10_000 },
     context: { space },
   }: any) => {
-    await space.db.graph.schemaRegistry.addSchema([Expando]);
+    await space.db.graph.schemaRegistry.register([Expando]);
     const result: Record<string, any> = {};
     const objects: Expando[] = [];
 

package/src/templates/forex-effect.ts

@@ -2,41 +2,36 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
-import {
-  FetchHttpClient,
-  HttpClient,
-  HttpClientRequest,
-  // @ts-ignore
-} from 'https://esm.sh/@effect/platform@0.89.0?deps=effect@3.17.0&bundle=false';
-// @ts-ignore
-import * as Effect from 'https://esm.sh/effect@3.17.0/Effect?bundle=false';
-// @ts-ignore
-import * as Schedule from 'https://esm.sh/effect@3.17.0/Schedule?bundle=false';
+import * as FetchHttpClient from '@effect/platform/FetchHttpClient';
+import * as HttpClient from '@effect/platform/HttpClient';
+import * as HttpClientRequest from '@effect/platform/HttpClientRequest';
+import * as Effect from 'effect/Effect';
+import * as Schedule from 'effect/Schedule';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
 
 export default defineFunction({
   key: 'dxos.org/script/forex-effect',
   name: 'Forex Effect',
   description: 'Returns the exchange rate between two currencies.',
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
 
-  outputSchema: S.String.annotations({ description: 'The exchange rate between the two currencies' }),
+  outputSchema: Schema.String.annotations({ description: 'The exchange rate between the two currencies' }),
 
-  handler: async ({ data: { from, to } }: any) =>
-    Effect.gen(function* () {
-      const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
-        HttpClient.execute,
-        Effect.flatMap((res: any) => res.json),
-        Effect.timeout('1 second'),
-        Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
-        Effect.scoped,
-      );
+  handler: Effect.fnUntraced(function* ({ data: { from, to } }) {
+    const res = yield* HttpClientRequest.get(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`).pipe(
+      HttpClient.execute,
+      Effect.flatMap((res: any) => res.json),
+      Effect.timeout('1 second'),
+      Effect.retry(Schedule.exponential(1_000).pipe(Schedule.compose(Schedule.recurs(3)))),
+      Effect.scoped,
+    );
 
-      return res.data.rates[to].toString();
-    }).pipe(Effect.provide(FetchHttpClient.layer)),
+    return (res as any).data.rates[to].toString();
+  }, Effect.provide(FetchHttpClient.layer)),
 });

package/src/templates/forex.ts

@@ -2,20 +2,21 @@
 // Copyright 2025 DXOS.org
 //
 
-// @ts-ignore
-import { S, defineFunction } from 'dxos:functions';
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
 
 export default defineFunction({
   key: 'dxos.org/script/forex',
   name: 'Forex',
   description: 'Returns the exchange rate between two currencies.',
 
-  inputSchema: S.Struct({
-    from: S.String.annotations({ description: 'The source currency' }),
-    to: S.String.annotations({ description: 'The target currency' }),
+  inputSchema: Schema.Struct({
+    from: Schema.String.annotations({ description: 'The source currency' }),
+    to: Schema.String.annotations({ description: 'The target currency' }),
   }),
 
-  handler: async ({ data: { from, to } }: any) => {
+  handler: async ({ data: { from, to } }) => {
     const res = await fetch(`https://free.ratesdb.com/v1/rates?from=${from}&to=${to}`);
     const {
       data: { rates },

package/src/testing/deploy.test.ts

@@ -0,0 +1,63 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { readFile } from 'node:fs/promises';
+
+import { describe, expect, test } from 'vitest';
+
+import { Client } from '@dxos/client';
+import { configPreset } from '@dxos/config';
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionsServiceClient } from '@dxos/functions-runtime/edge';
+import { FunctionRuntimeKind } from '@dxos/protocols';
+
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('Script deployment', () => {
+  test('deploys FOREX (effect) function and invokes it via EDGE (main)', { timeout: 120_000 }, async () => {
+    const config = configPreset({
+      edge: 'dev',
+    });
+    await using client = await new Client({ config }).initialize();
+    await client.halo.createIdentity();
+
+    const space = await client.spaces.create();
+    await space.waitUntilReady();
+
+    // Inline echo function source.
+    const source = await readFile(new URL('../templates/forex-effect.ts', import.meta.url), 'utf-8');
+
+    // Bundle and upload.
+    const buildResult = await bundleFunction({ source });
+    if ('error' in buildResult) {
+      throw buildResult.error ?? new Error('Bundle creation failed');
+    }
+    // for (const [key, value] of Object.entries(buildResult.assets)) {
+    //   await writeFile(key, value);
+    //   console.log(resolve(key));
+    // }
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+    const newFunction = await functionsServiceClient.deploy({
+      // TODO(dmaretskyi): Space key or identity key.
+      ownerPublicKey: space.key,
+      version: '0.0.1',
+      entryPoint: buildResult.entryPoint,
+      assets: buildResult.assets,
+      runtime: FunctionRuntimeKind.enums.WORKER_LOADER,
+    });
+    console.log(newFunction);
+
+    expect(newFunction.id).toBeDefined();
+
+    // // Invoke deployed function via EDGE directly.
+    // const edgeClient = client.edge;
+    // invariant(edgeClient, 'edgeClient is required');
+    // edgeClient.setIdentity(createEdgeIdentity(client));
+
+    // const input = { from: 'USD', to: 'EUR' };
+    // const result = await edgeClient.invokeFunction({ functionId }, input);
+    // log.info('>>> result', { result, functionId });
+    // const resultNumber = Number(result);
+    // expect(resultNumber).toBeGreaterThan(0);
+    // expect(resultNumber).toBeLessThan(100);
+  });
+});

package/src/testing/simulator.test.ts

@@ -0,0 +1,40 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { readFile } from 'node:fs/promises';
+
+import * as Record from 'effect/Record';
+import { describe, expect, test } from 'vitest';
+
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionWorker } from '@dxos/functions-simulator-cloudflare';
+import { ErrorCodec } from '@dxos/protocols';
+
+// Requires downloading assets from R2
+describe.runIf(process.env.DX_TEST_TAGS?.includes('functions-e2e'))('Run script in sumulator', () => {
+  test('forex-effect', { timeout: 120_000 }, async () => {
+    const source = await readFile(new URL('../templates/forex-effect.ts', import.meta.url), 'utf-8');
+
+    // Bundle and upload.
+    const buildResult = await bundleFunction({ source });
+    if ('error' in buildResult) {
+      throw buildResult.error ?? new Error('Bundle creation failed');
+    }
+
+    const worker = new FunctionWorker({
+      mainModule: buildResult.entryPoint,
+      modules: Record.map(buildResult.assets, (contents, filename) => ({
+        contents: contents as Uint8Array<ArrayBuffer>,
+        contentType: filename.endsWith('.wasm') ? 'application/wasm' : 'application/javascript',
+      })),
+    });
+
+    const result = await worker.invoke({ from: 'USD', to: 'EUR' });
+    console.log(result);
+    if (result._kind === 'error') {
+      throw ErrorCodec.decode(result.error);
+    }
+    expect(Number(result.result)).toBeGreaterThan(0);
+  });
+});

package/src/translations.ts

@@ -19,6 +19,7 @@ export const translations = [
         'object name placeholder': 'New script',
         'rename object label': 'Rename script',
         'delete object label': 'Delete script',
+        'object deleted label': 'Script deleted',
       },
       [Notebook.Notebook.typename]: {
         'typename label': 'Notebook',
@@ -28,6 +29,7 @@ export const translations = [
         'object name placeholder': 'New notebook',
         'rename object label': 'Rename notebook',
         'delete object label': 'Delete notebook',
+        'object deleted label': 'Notebook deleted',
       },
       [meta.id]: {
         'plugin name': 'Scripts',

package/src/types/Notebook.ts

@@ -6,9 +6,10 @@ import * as Schema from 'effect/Schema';
 
 import { Prompt } from '@dxos/blueprints';
 import { Obj, Type } from '@dxos/echo';
-import { FormAnnotation } from '@dxos/echo/internal';
+import { FormInputAnnotation } from '@dxos/echo/internal';
 import { LabelAnnotation } from '@dxos/echo/internal';
-import { Text, View } from '@dxos/schema';
+import { Graph } from '@dxos/plugin-explorer/types';
+import { Text } from '@dxos/schema';
 
 export type CellType = 'markdown' | 'script' | 'query' | 'prompt' | 'view';
 
@@ -19,7 +20,7 @@ const Cell_ = Schema.Struct({
   // TODO(burdon): Union type.
   source: Schema.optional(Type.Ref(Text.Text)),
   prompt: Schema.optional(Type.Ref(Prompt.Prompt)),
-  view: Schema.optional(Type.Ref(View.View)),
+  graph: Schema.optional(Type.Ref(Graph.Graph)),
 }).pipe(Schema.mutable);
 export interface Cell extends Schema.Schema.Type<typeof Cell_> {}
 export interface Cell_Encoded extends Schema.Schema.Encoded<typeof Cell_> {}
@@ -27,7 +28,7 @@ export const Cell: Schema.Schema<Cell, Cell_Encoded> = Cell_;
 
 export const Notebook = Schema.Struct({
   name: Schema.String.pipe(Schema.optional),
-  cells: Cell.pipe(Schema.Array, Schema.mutable, FormAnnotation.set(false)),
+  cells: Cell.pipe(Schema.Array, Schema.mutable, FormInputAnnotation.set(false)),
 }).pipe(
   Type.Obj({
     typename: 'dxos.org/type/Notebook',