@dxos/plugin-script 0.8.4-main.406dc2a → 0.8.4-main.4a85c3132b

package/src/templates/ping.ts

@@ -1,8 +1,17 @@
 //
-// Copyright 2024 DXOS.org
+// Copyright 2025 DXOS.org
 //
 
-/**
- * Echos the request data.
- */
-export default async ({ data }: any) => data;
+import * as Schema from 'effect/Schema';
+
+import { defineFunction } from '@dxos/functions';
+
+export default defineFunction({
+  key: 'dxos.org/script/ping',
+  name: 'Ping',
+  inputSchema: Schema.Any,
+
+  handler: async ({ data }) => {
+    return data;
+  },
+});

package/src/testing/data.ts

@@ -2,46 +2,71 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Prompt } from '@dxos/blueprints';
 import { Ref } from '@dxos/echo';
 import { createObject } from '@dxos/echo-db';
 import { PublicKey } from '@dxos/keys';
-import { DataType } from '@dxos/schema';
+import { Markdown } from '@dxos/plugin-markdown/types';
+import { Text } from '@dxos/schema';
 
 import { Notebook } from '../types';
 
-// NOTE: createObject(DataType.makeText is required to make codemirror work.
-export const createNotebook = () =>
+// TODO(burdon): NOTE: createObject is required for tests.
+
+export const createNotebook = (): Notebook.Notebook =>
   Notebook.make({
     cells: [
       {
         id: PublicKey.random().toString(),
         type: 'script',
-        script: Ref.make(createObject(DataType.makeText(['c = a() + b', '', ''].join('\n')))),
+        source: Ref.make(createObject(Text.make('c = a() + b'))),
       },
       {
         id: PublicKey.random().toString(),
         type: 'script',
-        script: Ref.make(createObject(DataType.makeText(['a = () => 100', ''].join('\n')))),
+        source: Ref.make(createObject(Text.make('a = () => 100'))),
       },
       {
         id: PublicKey.random().toString(),
         type: 'script',
-        script: Ref.make(createObject(DataType.makeText(['b = 200'].join('\n')))),
+        source: Ref.make(createObject(Text.make('b = 200'))),
       },
       {
         id: PublicKey.random().toString(),
         type: 'script',
-        script: Ref.make(createObject(DataType.makeText(['d = a() * 2'].join('\n')))),
+        source: Ref.make(createObject(Text.make('d = a() * 2'))),
       },
       {
         id: PublicKey.random().toString(),
         type: 'script',
-        script: Ref.make(createObject(DataType.makeText(['c + d', '', '', ''].join('\n')))),
+        source: Ref.make(createObject(Text.make('c + d'))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'prompt',
+        prompt: Ref.make(
+          createObject(
+            Prompt.make({
+              instructions: 'Very briefly, what colors are associated with the numbers {{a}} and {{b}}.',
+            }),
+          ),
+        ),
       },
       {
         id: PublicKey.random().toString(),
         type: 'query',
-        script: Ref.make(createObject(DataType.makeText('#test'))),
+        source: Ref.make(createObject(Text.make(`docs = (type: ${Markdown.Document.typename})`))),
+      },
+      {
+        id: PublicKey.random().toString(),
+        type: 'prompt',
+        prompt: Ref.make(
+          createObject(
+            Prompt.make({
+              instructions: 'Very briefly, summarize the documents: {{docs}}',
+            }),
+          ),
+        ),
       },
     ],
   });

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

@@ -2,7 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { ScriptType } from '@dxos/functions';
+import { Script } from '@dxos/functions';
 import { type Resource } from '@dxos/react-ui';
 
 import { meta } from './meta';
@@ -11,7 +11,7 @@ import { Notebook } from './types';
 export const translations = [
   {
     'en-US': {
-      [ScriptType.typename]: {
+      [Script.Script.typename]: {
         'typename label': 'Script',
         'typename label_zero': 'Scripts',
         'typename label_one': 'Script',
@@ -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',
@@ -66,7 +68,6 @@ export const translations = [
         'settings editor input mode default label': 'Default',
         'settings editor input mode vim label': 'Vim',
         'settings editor input mode vscode label': 'VS Code',
-        'template select group label': 'Select template',
         'function panel label': 'Debug Function',
         'script test label': 'Test',
         'script logs label': 'Logs',

package/src/types/Notebook.ts

@@ -0,0 +1,41 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { Prompt } from '@dxos/blueprints';
+import { Obj, Ref, Type } from '@dxos/echo';
+import { FormInputAnnotation } from '@dxos/echo/internal';
+import { LabelAnnotation } from '@dxos/echo/internal';
+import { Graph } from '@dxos/plugin-explorer/types';
+import { Text } from '@dxos/schema';
+
+export type CellType = 'markdown' | 'script' | 'query' | 'prompt' | 'view';
+
+export const Cell = Schema.Struct({
+  id: Schema.String,
+  type: Schema.String,
+  name: Schema.optional(Schema.String),
+  // TODO(burdon): Union type.
+  source: Schema.optional(Ref.Ref(Text.Text)),
+  prompt: Schema.optional(Ref.Ref(Prompt.Prompt)),
+  graph: Schema.optional(Ref.Ref(Graph.Graph)),
+});
+
+export interface Cell extends Schema.Schema.Type<typeof Cell> {}
+
+export const Notebook = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  cells: Cell.pipe(Schema.Array, FormInputAnnotation.set(false)),
+}).pipe(
+  Type.object({
+    typename: 'dxos.org/type/Notebook',
+    version: '0.1.0',
+  }),
+  LabelAnnotation.set(['name']),
+);
+
+export type Notebook = Schema.Schema.Type<typeof Notebook>;
+
+export const make = (props: Obj.MakeProps<typeof Notebook> = { cells: [] }): Notebook => Obj.make(Notebook, props);

package/src/types/actions.ts

@@ -4,15 +4,16 @@
 
 import * as Schema from 'effect/Schema';
 
-import { SpaceSchema } from '@dxos/client/echo';
-import { ScriptType } from '@dxos/functions';
+import { Database } from '@dxos/echo';
+import { Script } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 
 import { meta } from '../meta';
 import { templates } from '../templates';
 
-import { Notebook } from './schema';
+const SCRIPT_OPERATION = `${meta.id}/operation`;
 
-export namespace ScriptAction {
+export namespace ScriptOperation {
   export const ScriptProps = Schema.Struct({
     name: Schema.optional(Schema.String),
     // TODO(wittjosiah): Placeholder annotation?
@@ -23,31 +24,22 @@ export namespace ScriptAction {
     ),
   });
 
-  export class CreateScript extends Schema.TaggedClass<CreateScript>()(`${meta.id}/action/create-script`, {
-    input: Schema.extend(
-      ScriptProps,
-      Schema.Struct({
-        space: SpaceSchema,
-      }),
-    ),
-    output: Schema.Struct({
-      object: ScriptType,
-    }),
-  }) {}
-
   export const NotebookProps = Schema.Struct({
     name: Schema.optional(Schema.String),
   });
 
-  export class CreateNotebook extends Schema.TaggedClass<CreateNotebook>()(`${meta.id}/action/create-notebook`, {
-    input: Schema.extend(
-      NotebookProps,
-      Schema.Struct({
-        space: SpaceSchema,
+  export const CreateScript = Operation.make({
+    meta: { key: `${SCRIPT_OPERATION}/create-script`, name: 'Create Script' },
+    schema: {
+      input: Schema.extend(
+        ScriptProps,
+        Schema.Struct({
+          db: Database.Database,
+        }),
+      ),
+      output: Schema.Struct({
+        object: Script.Script,
       }),
-    ),
-    output: Schema.Struct({
-      object: Notebook.Notebook,
-    }),
-  }) {}
+    },
+  });
 }

package/src/types/capabilities.ts

@@ -0,0 +1,17 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type Atom } from '@effect-atom/atom-react';
+
+import { Capability } from '@dxos/app-framework';
+
+import { type Compiler } from '../compiler';
+import { meta } from '../meta';
+
+import { type ScriptSettings } from './types';
+
+export namespace ScriptCapabilities {
+  export const Settings = Capability.make<Atom.Writable<ScriptSettings>>(`${meta.id}/capability/settings`);
+  export const Compiler = Capability.make<Compiler>(`${meta.id}/capability/compiler`);
+}

package/src/types/events.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { ActivationEvent } from '@dxos/app-framework';
+
+import { meta } from '../meta';
+
+export namespace ScriptEvents {
+  export const SetupCompiler = ActivationEvent.make(`${meta.id}/event/setup-compiler`);
+}

package/src/types/index.ts

@@ -3,4 +3,7 @@
 //
 
 export * from './actions';
-export * from './schema';
+export * from './capabilities';
+export * from './events';
+export * as Notebook from './Notebook';
+export * from './types';

package/src/types/types.ts

@@ -0,0 +1,15 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+
+import { EditorInputMode } from '@dxos/ui-editor';
+
+export const ScriptSettings = Schema.mutable(
+  Schema.Struct({
+    editorInputMode: EditorInputMode,
+  }),
+);
+
+export type ScriptSettings = Schema.Schema.Type<typeof ScriptSettings>;

package/src/util/deploy.ts

@@ -4,29 +4,23 @@
 
 import { type Client } from '@dxos/client';
 import { Obj, Ref } from '@dxos/echo';
-import {
-  FunctionType,
-  type ScriptType,
-  getUserFunctionIdInMetadata,
-  setUserFunctionIdInMetadata,
-} from '@dxos/functions';
-import { Bundler } from '@dxos/functions/bundler';
-import { incrementSemverPatch, uploadWorkerFunction } from '@dxos/functions/edge';
+import { Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { bundleFunction } from '@dxos/functions-runtime/bundler';
+import { FunctionsServiceClient, incrementSemverPatch } from '@dxos/functions-runtime/edge';
 import { log } from '@dxos/log';
+import { FunctionRuntimeKind } from '@dxos/protocols';
 import { type Space } from '@dxos/react-client/echo';
 
-import { updateFunctionMetadata } from './functions';
-
-export const isScriptDeployed = ({ script, fn }: { script: ScriptType; fn: any }): boolean => {
+export const isScriptDeployed = ({ script, fn }: { script: Script.Script; fn: any }): boolean => {
   const existingFunctionId = fn && getUserFunctionIdInMetadata(Obj.getMeta(fn));
   return Boolean(existingFunctionId) && !script.changed;
 };
 
 type DeployScriptProps = {
-  script: ScriptType;
+  script: Script.Script;
   client: Client;
   space: Space;
-  fn?: FunctionType;
+  fn?: Function.Function;
   existingFunctionId?: string;
 };
 
@@ -48,32 +42,30 @@ export const deployScript = async ({
   }
 
   try {
-    const bundler = new Bundler({ platform: 'browser', sandboxedModules: [], remoteModules: {} });
-    const buildResult = await bundler.bundle({ source: script.source!.target!.content });
+    const buildResult = await bundleFunction({
+      source: script.source!.target!.content,
+    });
     if ('error' in buildResult) {
       throw buildResult.error || new Error('Bundle creation failed');
     }
 
-    const { functionId, version, meta } = await uploadWorkerFunction({
-      client,
+    const functionsServiceClient = FunctionsServiceClient.fromClient(client);
+    const newFunction = await functionsServiceClient.deploy({
+      // TODO(dmaretskyi): Space key or identity key.
       ownerPublicKey: space.key,
       version: fn ? incrementSemverPatch(fn.version) : '0.0.1',
       functionId: existingFunctionId,
       entryPoint: buildResult.entryPoint,
-      assets: { [buildResult.entryPoint]: buildResult.asset },
+      assets: buildResult.assets,
+      runtime: FunctionRuntimeKind.enums.WORKER_LOADER,
     });
 
-    if (functionId === undefined || version === undefined) {
-      throw new Error(`Upload didn't return expected data: ${JSON.stringify({ functionId, version })}`);
-    }
-
-    const storedFunction = createOrUpdateFunctionInSpace(space, fn, script, functionId, version);
-    script.changed = false;
-    updateFunctionMetadata(script, storedFunction, meta, functionId);
-
-    setUserFunctionIdInMetadata(Obj.getMeta(storedFunction), functionId);
+    const storedFunction = createOrUpdateFunctionInSpace(space, fn, script, newFunction);
+    Obj.change(script, (s) => {
+      s.changed = false;
+    });
 
-    return { success: true, functionId };
+    return { success: true, functionId: getUserFunctionIdInMetadata(Obj.getMeta(storedFunction)) };
   } catch (err: any) {
     log.catch(err);
     return { success: false, error: err };
@@ -83,7 +75,7 @@ export const deployScript = async ({
 /**
  * Validate inputs for script deployment.
  */
-const validateDeployInputs = (script: ScriptType, space: Space): Error | null => {
+const validateDeployInputs = (script: Script.Script, space: Space): Error | null => {
   if (!script.source || !space) {
     return new Error('Script source or space not available');
   }
@@ -92,19 +84,17 @@ const validateDeployInputs = (script: ScriptType, space: Space): Error | null =>
 
 const createOrUpdateFunctionInSpace = (
   space: Space,
-  fn: FunctionType | undefined,
-  script: ScriptType,
-  functionId: string,
-  version: string,
-): FunctionType => {
+  fn: Function.Function | undefined,
+  script: Script.Script,
+  newFunction: Function.Function,
+): Function.Function => {
   if (fn) {
-    fn.name = script.name ?? 'New Function';
-    fn.version = version;
+    Function.setFrom(fn, newFunction);
     return fn;
   } else {
-    const fn = Obj.make(FunctionType, { name: script.name ?? 'New Function', version, source: Ref.make(script) });
-    space.db.add(fn);
-    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionId);
-    return fn;
+    Obj.change(newFunction, (f) => {
+      f.source = Ref.make(script);
+    });
+    return space.db.add(newFunction);
   }
 };

package/src/util/functions.ts

@@ -2,11 +2,13 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type FunctionType, type ScriptType, getInvocationUrl, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { Obj } from '@dxos/echo';
+import { type Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { getInvocationUrl } from '@dxos/functions-runtime';
 import { type PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
 import { type Credential } from '@dxos/protocols/proto/dxos/halo/credentials';
-import { getMeta, getSpace } from '@dxos/react-client/echo';
+import { getSpace } from '@dxos/react-client/echo';
 /**
  * Get the function URL for a given script and client configuration
  */
@@ -15,12 +17,12 @@ export const getFunctionUrl = ({
   fn,
   edgeUrl,
 }: {
-  script: ScriptType;
+  script: Script.Script;
   fn: any;
   edgeUrl: string;
 }): string | undefined => {
   const space = getSpace(script);
-  const existingFunctionId = fn && getUserFunctionIdInMetadata(getMeta(fn));
+  const existingFunctionId = fn && getUserFunctionIdInMetadata(Obj.getMeta(fn));
 
   if (!existingFunctionId) {
     return undefined;
@@ -32,36 +34,38 @@ export const getFunctionUrl = ({
 };
 
 export const updateFunctionMetadata = (
-  script: ScriptType,
-  storedFunction: FunctionType,
+  script: Script.Script,
+  storedFunction: Function.Function,
   meta: any,
   functionId: string,
 ) => {
-  if (script.description !== undefined && script.description.trim() !== '') {
-    storedFunction.description = script.description;
-  } else if (meta.description) {
-    storedFunction.description = meta.description;
-  } else {
-    log.verbose('no description in function metadata', { functionId });
-  }
+  Obj.change(storedFunction, (f) => {
+    if (script.description !== undefined && script.description.trim() !== '') {
+      f.description = script.description;
+    } else if (meta.description) {
+      f.description = meta.description;
+    } else {
+      log.verbose('no description in function metadata', { functionId });
+    }
 
-  if (meta.inputSchema) {
-    storedFunction.inputSchema = meta.inputSchema;
-  } else {
-    log.verbose('no input schema in function metadata', { functionId });
-  }
+    if (meta.inputSchema) {
+      f.inputSchema = meta.inputSchema;
+    } else {
+      log.verbose('no input schema in function metadata', { functionId });
+    }
 
-  if (meta.outputSchema) {
-    storedFunction.outputSchema = meta.outputSchema;
-  } else {
-    log.verbose('no output schema in function metadata', { functionId });
-  }
+    if (meta.outputSchema) {
+      f.outputSchema = meta.outputSchema;
+    } else {
+      log.verbose('no output schema in function metadata', { functionId });
+    }
 
-  if (meta.key) {
-    storedFunction.key = meta.key;
-  } else {
-    log.verbose('no key in function metadata', { functionId });
-  }
+    if (meta.key) {
+      f.key = meta.key;
+    } else {
+      log.verbose('no key in function metadata', { functionId });
+    }
+  });
 };
 
 export const getAccessCredential = (identityKey: PublicKey): Credential => {

package/src/vite-env.d.ts

@@ -18,3 +18,5 @@ declare module '*?raw' {
   const content: string;
   export default content;
 }
+
+declare module 'https://*';

package/dist/lib/browser/DeploymentDialog-65TWT6S5.mjs

@@ -1,13 +0,0 @@
-import {
-  DEPLOYMENT_DIALOG,
-  DeploymentDialog_default
-} from "./chunk-NM4WQS4F.mjs";
-import "./chunk-JO2O7W6J.mjs";
-import "./chunk-5CYLWXRH.mjs";
-import "./chunk-ST3ACVUC.mjs";
-import "./chunk-EZVXV6DA.mjs";
-export {
-  DEPLOYMENT_DIALOG,
-  DeploymentDialog_default as default
-};
-//# sourceMappingURL=DeploymentDialog-65TWT6S5.mjs.map