@dxos/plugin-script 0.8.4-main.c85a9c8dae → 0.8.4-main.d9fc60f731

package/src/containers/NotebookArticle/NotebookArticle.stories.tsx

@@ -0,0 +1,85 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Operation } from '@dxos/compute';
+import { Filter } from '@dxos/echo';
+import { AssistantPlugin } from '@dxos/plugin-assistant/testing';
+import { AutomationPlugin } from '@dxos/plugin-automation/testing';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { ExplorerPlugin } from '@dxos/plugin-explorer/testing';
+import { Markdown } from '@dxos/plugin-markdown';
+import { MarkdownPlugin } from '@dxos/plugin-markdown/testing';
+import { corePlugins } from '@dxos/plugin-testing';
+import { Config, useClient } from '@dxos/react-client';
+import { useQuery } from '@dxos/react-client/echo';
+import { withLayout } from '@dxos/react-ui/testing';
+import { DataTypes } from '@dxos/schema';
+
+import { createNotebook } from '#testing';
+import { translations } from '#translations';
+import { Notebook } from '#types';
+
+import { NotebookArticle } from './NotebookArticle';
+
+const meta: Meta<typeof NotebookArticle> = {
+  title: 'plugins/plugin-script/containers/NotebookArticle',
+  component: NotebookArticle,
+  render: (args) => {
+    const client = useClient();
+    const space = client.spaces.get()[0];
+    const notebooks = useQuery(space?.db, Filter.type(Notebook.Notebook));
+    return <NotebookArticle {...args} subject={notebooks[0]} attendableId='test' />;
+  },
+  decorators: [
+    withLayout({ layout: 'column', classNames: 'w-document-max-width' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          // TODO(wittjosiah): ComputeRuntime requires edge to be configured or it will throw.
+          config: new Config({
+            runtime: {
+              services: SERVICES_CONFIG.REMOTE,
+            },
+          }),
+          types: [...DataTypes, Notebook.Notebook, Operation.PersistentOperation, Markdown.Document],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              const { personalSpace } = yield* initializeIdentity(client);
+
+              personalSpace.db.add(createNotebook());
+              personalSpace.db.add(Markdown.make({ content: '# Hello World' }));
+              personalSpace.db.add(Operation.serialize(AgentPrompt));
+            }),
+        }),
+        AssistantPlugin(),
+        AutomationPlugin(),
+        ExplorerPlugin(),
+        MarkdownPlugin(),
+      ],
+    }),
+  ],
+  parameters: {
+    translations,
+  },
+};
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {
+  args: {
+    role: 'article',
+    subject: undefined as any,
+  },
+};

package/src/containers/{NotebookContainer/NotebookContainer.tsx → NotebookArticle/NotebookArticle.tsx}

@@ -9,41 +9,41 @@ import * as Exit from 'effect/Exit';
 import type * as Types from 'effect/Types';
 import React, { useCallback, useContext, useMemo, useState } from 'react';
 
-import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
-import { AgentFunctions } from '@dxos/assistant-toolkit';
-import { Blueprint, Prompt } from '@dxos/blueprints';
+import { useSpaceCallback } from '@dxos/app-framework/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { AgentPrompt } from '@dxos/assistant-toolkit';
+import { Blueprint, Routine } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
 import { Filter, Obj, Query, Ref } from '@dxos/echo';
 import { QueryBuilder } from '@dxos/echo-query';
-import { type FunctionDefinition, FunctionInvocationService, TracingService } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
-import { useComputeRuntimeCallback } from '@dxos/plugin-automation';
-import { Graph } from '@dxos/plugin-explorer/types';
+import { Graph } from '@dxos/plugin-explorer';
 import { DropdownMenu, IconButton, Panel, Toolbar, useTranslation } from '@dxos/react-ui';
 import { useAttention } from '@dxos/react-ui-attention';
 import { Text, ViewModel } from '@dxos/schema';
 import { isNonNullable } from '@dxos/util';
 
-import { NotebookMenu, NotebookStack, type NotebookStackProps, type TypescriptEditorProps } from '../../components';
-import { meta } from '../../meta';
+import { NotebookMenu, NotebookStack, type NotebookStackProps, type TypescriptEditorProps } from '#components';
+import { meta } from '#meta';
+import { type Notebook } from '#types';
+
 import { ComputeGraph } from '../../notebook';
-import { type Notebook } from '../../types';
 
 const INCLUDE_BLUEPRINTS = [
-  'dxos.org/blueprint/assistant',
-  'dxos.org/blueprint/database',
-  'dxos.org/blueprint/markdown',
+  'org.dxos.blueprint.assistant',
+  'org.dxos.blueprint.database',
+  'org.dxos.blueprint.markdown',
 ];
 
 // TODO(burdon): Support calling named deployed functions (as with sheet).
 
-export type NotebookContainerProps = SurfaceComponentProps<Notebook.Notebook, Pick<TypescriptEditorProps, 'env'>>;
+export type NotebookArticleProps = AppSurface.ObjectArticleProps<Notebook.Notebook, Pick<TypescriptEditorProps, 'env'>>;
 
-export const NotebookContainer = ({ role, subject: notebook, env }: NotebookContainerProps) => {
+export const NotebookArticle = ({ role, subject: notebook, attendableId, env }: NotebookArticleProps) => {
   const { t } = useTranslation(meta.id);
   const registry = useContext(RegistryContext);
-  const db = notebook && Obj.getDatabase(notebook);
-  const attendableId = notebook ? Obj.getDXN(notebook).toString() : '';
+  const db = Obj.getDatabase(notebook);
   const { hasAttention } = useAttention(attendableId);
 
   // TODO(burdon): Consolidate execution and state (with graph).
@@ -66,16 +66,16 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
             if (!graph) {
               const { view } = await ViewModel.makeFromDatabase({ db });
               const newGraph = Graph.make({ query: { ast }, view });
-              Obj.change(notebook!, (n) => {
-                const c = n.cells.find((c) => c.id === cell.id);
+              Obj.update(notebook!, (obj) => {
+                const c = obj.cells.find((c) => c.id === cell.id);
                 if (c) {
                   c.graph = Ref.make(newGraph);
                   c.name = name;
                 }
               });
             } else {
-              Obj.change(graph, (g) => {
-                g.query.ast = ast as Obj.Mutable<typeof ast>;
+              Obj.update(graph, (graph) => {
+                graph.query.ast = ast as Obj.Mutable<typeof ast>;
               });
             }
           }
@@ -93,8 +93,9 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
   }, [db, notebook, graph]);
 
   const [promptResults, setPromptResults] = useState<Record<string, string>>({});
-  const handleExecPrompts = useComputeRuntimeCallback(
+  const handleExecPrompts = useSpaceCallback(
     db?.spaceId,
+    [] as const,
     Effect.fnUntraced(function* () {
       invariant(graph);
 
@@ -111,7 +112,7 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
           onResult: (result) =>
             setPromptResults((prev) => ({
               ...prev,
-              [prompt.dxn.toString()]: result,
+              [prompt.uri]: result,
             })),
         });
       }
@@ -133,10 +134,10 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
       const from = notebook.cells.findIndex((cell) => cell.id === source.id);
       const to = notebook.cells.findIndex((cell) => cell.id === target.id);
       if (from != null && to != null) {
-        Obj.change(notebook, (n) => {
-          const cell = n.cells.splice(from, 1)[0];
+        Obj.update(notebook, (notebook) => {
+          const cell = notebook.cells.splice(from, 1)[0];
           if (cell) {
-            n.cells.splice(to, 0, cell);
+            notebook.cells.splice(to, 0, cell);
           }
         });
       }
@@ -160,17 +161,20 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
           if (db) {
             const objects = await db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
             const blueprints = objects
-              .filter((blueprint) => INCLUDE_BLUEPRINTS.includes(blueprint.key))
+              .filter((blueprint) => {
+                const key = Obj.getMeta(blueprint).key;
+                return key !== undefined && INCLUDE_BLUEPRINTS.includes(key);
+              })
               .map((blueprint) => Ref.make(blueprint));
-            cell.prompt = Ref.make(Prompt.make({ instructions: '', blueprints }));
+            cell.prompt = Ref.make(Routine.make({ instructions: '', blueprints }));
           }
           break;
         }
       }
 
       const idx = after ? notebook.cells.findIndex((cell) => cell.id === after) : notebook.cells.length;
-      Obj.change(notebook, (n) => {
-        n.cells.splice(idx, 0, cell);
+      Obj.update(notebook, (notebook) => {
+        notebook.cells.splice(idx, 0, cell);
       });
     },
     [db, notebook],
@@ -181,8 +185,8 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
       invariant(notebook);
       const idx = notebook.cells.findIndex((cell) => cell.id === id);
       if (idx !== -1) {
-        Obj.change(notebook, (n) => {
-          n.cells.splice(idx, 1);
+        Obj.update(notebook, (notebook) => {
+          notebook.cells.splice(idx, 1);
         });
       }
     },
@@ -190,20 +194,20 @@ export const NotebookContainer = ({ role, subject: notebook, env }: NotebookCont
   );
 
   return (
-    <Panel.Root role={role} className='dx-article'>
+    <Panel.Root role={role} className='dx-document'>
       <Panel.Toolbar asChild>
-        <Toolbar.Root disabled={!hasAttention} textBlockWidth>
+        <Toolbar.Root disabled={!hasAttention}>
           <DropdownMenu.Root>
             <DropdownMenu.Trigger asChild>
-              <IconButton icon='ph--plus--regular' iconOnly label={t('notebook cell insert label')} />
+              <IconButton icon='ph--plus--regular' iconOnly label={t('notebook-cell-insert.label')} />
             </DropdownMenu.Trigger>
             <NotebookMenu onCellInsert={handleCellInsert} />
           </DropdownMenu.Root>
           <Toolbar.IconButton
             icon='ph--play--fill'
             iconOnly
-            label={t('compute label')}
-            classNames='text-green-500'
+            label={t('compute.label')}
+            classNames='text-success-text'
             onClick={handleCompute}
           />
         </Toolbar.Root>
@@ -230,24 +234,13 @@ const runPrompt = Effect.fn(function* ({
   input,
   onResult,
 }: {
-  prompt: Ref.Ref<Prompt.Prompt>;
+  prompt: Ref.Ref<Routine.Routine>;
   input: Record<string, any>;
   onResult: (result: string) => void;
 }) {
-  const inputData: FunctionDefinition.Input<typeof AgentFunctions.Prompt> = { prompt, input };
-  const tracer = yield* TracingService;
-  const trace = yield* tracer.traceInvocationStart({
-    target: undefined,
-    payload: {
-      data: {},
-    },
-  });
-
+  const inputData: Operation.Definition.Input<typeof AgentPrompt> = { prompt, input };
   // Invoke the function.
-  const result = yield* FunctionInvocationService.invokeFunction(AgentFunctions.Prompt, inputData).pipe(
-    Effect.provide(trace.invocationTraceQueue ? TracingService.layerInvocation(trace) : TracingService.layerNoop),
-    Effect.exit,
-  );
+  const result = yield* Operation.invoke(AgentPrompt, inputData).pipe(Effect.orDie, Effect.exit);
 
   Exit.match(result, {
     onFailure: (cause) => {
@@ -259,10 +252,4 @@ const runPrompt = Effect.fn(function* ({
       onResult(result.note);
     },
   });
-
-  yield* tracer.traceInvocationEnd({
-    trace,
-    // TODO(dmaretskyi): Might miss errors.
-    exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : undefined,
-  });
 });

package/src/containers/NotebookArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { NotebookArticle as default } from './NotebookArticle';

package/src/containers/ScriptArticle/ScriptArticle.stories.tsx

@@ -0,0 +1,107 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import * as Effect from 'effect/Effect';
+import React, { useEffect, useState } from 'react';
+
+import { SERVICES_CONFIG } from '@dxos/ai/testing';
+import { withPluginManager } from '@dxos/app-framework/testing';
+import { Blueprint } from '@dxos/compute';
+import { Script } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Filter } from '@dxos/echo';
+import { ClientPlugin } from '@dxos/plugin-client/testing';
+import { initializeIdentity } from '@dxos/plugin-client/testing';
+import { StorybookPlugin, corePlugins } from '@dxos/plugin-testing';
+import { Config } from '@dxos/react-client';
+import { useQuery, useSpaces } from '@dxos/react-client/echo';
+import { Loading, withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Text } from '@dxos/schema';
+
+import { createScript } from '#testing';
+import { translations } from '#translations';
+
+import { ScriptArticle } from './ScriptArticle';
+
+type DefaultStoryProps = {};
+
+/**
+ * Loads the script source ref so `script.source.target` is available for the editor.
+ */
+const DefaultStory = (_: DefaultStoryProps) => {
+  const [space] = useSpaces();
+  const [script] = useQuery(space?.db, Filter.type(Script.Script));
+  const [sourceReady, setSourceReady] = useState(false);
+
+  useEffect(() => {
+    if (!script) {
+      setSourceReady(false);
+      return;
+    }
+
+    let canceled = false;
+    void (async () => {
+      await script.source.load();
+      if (!canceled) {
+        setSourceReady(true);
+      }
+    })();
+
+    return () => {
+      canceled = true;
+    };
+  }, [script]);
+
+  if (!script || !sourceReady) {
+    return <Loading />;
+  }
+
+  return (
+    <div className='flex flex-col min-h-[80vh] w-document-max-width'>
+      <ScriptArticle role='article' subject={script} attendableId='story-script' />
+    </div>
+  );
+};
+
+const meta = {
+  title: 'plugins/plugin-script/containers/ScriptArticle',
+  render: DefaultStory,
+  decorators: [
+    withTheme(),
+    withLayout({ layout: 'column', classNames: 'w-document-max-width' }),
+    withPluginManager({
+      plugins: [
+        ...corePlugins(),
+        ClientPlugin({
+          config: new Config({
+            runtime: {
+              services: SERVICES_CONFIG.REMOTE,
+            },
+          }),
+          types: [Script.Script, Operation.PersistentOperation, Blueprint.Blueprint, Text.Text],
+          onClientInitialized: ({ client }) =>
+            Effect.gen(function* () {
+              yield* initializeIdentity(client);
+              const [space] = client.spaces.get();
+              yield* Effect.promise(() => space.waitUntilReady());
+
+              createScript(space);
+            }),
+        }),
+        StorybookPlugin({}),
+      ],
+    }),
+  ],
+  parameters: {
+    layout: 'fullscreen',
+    translations,
+  },
+} satisfies Meta<DefaultStoryProps>;
+
+export default meta;
+
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};

package/src/containers/{ScriptContainer/ScriptContainer.tsx → ScriptArticle/ScriptArticle.tsx}

@@ -4,28 +4,29 @@
 
 import React, { useMemo } from 'react';
 
-import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+import { type AppSurface } from '@dxos/app-toolkit/ui';
+import { type Script } from '@dxos/compute';
 import { Obj } from '@dxos/echo';
 import { createDocAccessor } from '@dxos/echo-db';
-import { type Script } from '@dxos/functions';
 import { getSpace } from '@dxos/react-client/echo';
 import { useIdentity } from '@dxos/react-client/halo';
 import { Panel } from '@dxos/react-ui';
-import { createDataExtensions, listener, stackItemContentEditorClassNames } from '@dxos/ui-editor';
+import { createDataExtensions, listener, editorClassNames } from '@dxos/ui-editor';
 
-import { ScriptToolbar, TypescriptEditor, type TypescriptEditorProps } from '../../components';
-import { useDeployState, useToolbarState } from '../../hooks';
-import { type ScriptSettings } from '../../types';
+import { ScriptToolbar, TypescriptEditor, type TypescriptEditorProps } from '#components';
+import { useDeployState, useToolbarState } from '#hooks';
+import { type Settings } from '#types';
 
-export type ScriptEditorProps = SurfaceComponentProps<
+export type ScriptEditorProps = AppSurface.ObjectArticleProps<
   Script.Script,
   {
-    settings?: ScriptSettings;
+    settings?: Settings.Settings;
   } & Pick<TypescriptEditorProps, 'env'>
 >;
 
-export const ScriptContainer = ({
+export const ScriptArticle = ({
   role,
+  attendableId,
   subject: script,
   settings = { editorInputMode: 'vscode' },
   env,
@@ -50,8 +51,8 @@ export const ScriptContainer = ({
       listener({
         onChange: ({ text }) => {
           if (script.source.target?.content !== text) {
-            Obj.change(script, (s) => {
-              s.changed = true;
+            Obj.update(script, (script) => {
+              script.changed = true;
             });
           }
         },
@@ -64,17 +65,17 @@ export const ScriptContainer = ({
   }
 
   return (
-    <Panel.Root role={role} className='dx-article'>
+    <Panel.Root role={role}>
       <Panel.Toolbar asChild>
-        <ScriptToolbar state={state} role={role} script={script} />
+        <ScriptToolbar script={script} attendableId={attendableId} state={state} role={role} />
       </Panel.Toolbar>
       <Panel.Content asChild>
         <TypescriptEditor
+          classNames={editorClassNames(role)}
           id={script.id}
           env={env}
           initialValue={script.source?.target?.content}
           extensions={extensions}
-          classNames={stackItemContentEditorClassNames(role)}
           inputMode={settings.editorInputMode}
           toolbar
         />

package/src/containers/ScriptArticle/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export { ScriptArticle as default } from './ScriptArticle';

package/src/containers/ScriptProperties/BlueprintEditor.tsx

@@ -0,0 +1,102 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { useCallback, useState } from 'react';
+
+import { ToolId } from '@dxos/ai';
+import { Blueprint, Template } from '@dxos/compute';
+import { type Script } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { useQuery } from '@dxos/react-client/echo';
+import { Button, Input, useAsyncEffect, useTranslation } from '@dxos/react-ui';
+import { Form } from '@dxos/react-ui-form';
+import { kebabize } from '@dxos/util';
+
+import { meta } from '#meta';
+
+export type BlueprintEditorProps = { object: Script.Script };
+
+export const BlueprintEditor = ({ object }: BlueprintEditorProps) => {
+  const { t } = useTranslation(meta.id);
+  const db = Obj.getDatabase(object);
+  const [fn] = useQuery(db, Filter.type(Operation.PersistentOperation, { source: Ref.make(object) }));
+  const blueprints = useQuery(db, Filter.type(Blueprint.Blueprint));
+
+  const [creating, setCreating] = useState(false);
+  // TODO(burdon): Remove?
+  const [instructions, setInstructions] = useState<string>(`You can run the script "${object.name ?? 'script'}".`);
+  const blueprintKey = `org.dxos.blueprint.${kebabize(object.name ?? 'script')}`;
+  const existingBlueprint = blueprints.find((bp) => Obj.getMeta(bp).key === blueprintKey);
+  const fnKey = fn ? Obj.getMeta(fn).key : undefined;
+
+  useAsyncEffect(async () => {
+    if (!existingBlueprint) {
+      return;
+    }
+
+    const source = await existingBlueprint.instructions.source.load();
+    setInstructions(source.content ?? '');
+  }, [existingBlueprint]);
+
+  const handleSave = useCallback(async () => {
+    if (!db) {
+      return;
+    }
+
+    setCreating(true);
+    try {
+      if (existingBlueprint) {
+        const text = await existingBlueprint.instructions.source.load();
+        Obj.update(text, (text) => {
+          text.content = instructions;
+        });
+
+        if (fnKey) {
+          const toolId = ToolId.make(fnKey);
+          if (!existingBlueprint.tools?.includes(toolId)) {
+            Obj.update(existingBlueprint, (existingBlueprint) => {
+              existingBlueprint.tools = [...(existingBlueprint.tools ?? []), toolId];
+            });
+          }
+        }
+      } else if (fnKey) {
+        db.add(
+          Blueprint.make({
+            key: blueprintKey,
+            name: object.name ?? 'Script',
+            instructions: Template.make({ source: instructions }),
+            tools: [ToolId.make(fnKey)],
+          }),
+        );
+      }
+      await db.flush();
+    } finally {
+      setCreating(false);
+    }
+  }, [db, existingBlueprint, fnKey, blueprintKey, object.name, instructions]);
+
+  return (
+    <div className='flex flex-col'>
+      <Form.Section label={t('blueprint-editor.label')} description={t('blueprint-editor.description')} />
+
+      <Input.Root>
+        <Input.Label>{t('blueprint-instructions.label')}</Input.Label>
+        <Input.TextArea
+          placeholder={t('blueprint-instructions.placeholder')}
+          rows={6}
+          value={instructions}
+          onChange={(event) => setInstructions(event.target.value)}
+          classNames='resize-y'
+        />
+      </Input.Root>
+
+      <div className='pt-2'>
+        <Button disabled={(!existingBlueprint && !fnKey) || creating} onClick={handleSave}>
+          {t(existingBlueprint ? 'update-blueprint.label' : 'create-blueprint.label')}
+        </Button>
+      </div>
+    </div>
+  );
+};

package/src/containers/ScriptProperties/FunctionBinding.tsx

@@ -0,0 +1,83 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import React, { type ChangeEvent, useCallback } from 'react';
+
+import { type Script } from '@dxos/compute';
+import { Operation } from '@dxos/compute';
+import { Filter, Obj, Ref } from '@dxos/echo';
+import { getUserFunctionIdInMetadata } from '@dxos/functions';
+import { getInvocationUrl } from '@dxos/functions-runtime';
+import { useClient } from '@dxos/react-client';
+import { useQuery } from '@dxos/react-client/echo';
+import { Clipboard, Input, useControlledState, useTranslation } from '@dxos/react-ui';
+import { Form } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+
+export type FunctionBindingProps = { object: Script.Script };
+
+export const FunctionBinding = ({ object }: FunctionBindingProps) => {
+  const { t } = useTranslation(meta.id);
+  const client = useClient();
+  const db = Obj.getDatabase(object);
+
+  const [fn] = useQuery(db, Filter.type(Operation.PersistentOperation, { source: Ref.make(object) }));
+  const functionId = fn && getUserFunctionIdInMetadata(Obj.getMeta(fn));
+  const functionUrl =
+    functionId &&
+    getInvocationUrl(functionId, client.config.values.runtime?.services?.edge?.url ?? '', {
+      spaceId: db?.spaceId,
+    });
+
+  const [binding, setBinding] = useControlledState(fn?.binding ?? '');
+  const handleBindingChange = useCallback(
+    (event: ChangeEvent<HTMLInputElement>) => setBinding(event.target.value),
+    [setBinding],
+  );
+
+  const handleBindingBlur = useCallback(() => {
+    if (fn) {
+      Obj.update(fn, (fn) => {
+        fn.binding = binding;
+      });
+    }
+  }, [fn, binding]);
+
+  if (!fn) {
+    return null;
+  }
+
+  return (
+    <div className='flex flex-col'>
+      <Form.Section label={t('remote-function-settings.heading')} />
+
+      {functionUrl && (
+        <Input.Root>
+          <Input.Label>{t('function-url.label')}</Input.Label>
+          <Input.TextInput
+            disabled
+            value={functionUrl}
+            onChange={(event) => {
+              Obj.update(fn, (fn) => {
+                fn.name = event.target.value;
+              });
+            }}
+          />
+          <Clipboard.IconButton value={functionUrl} />
+        </Input.Root>
+      )}
+
+      <Input.Root>
+        <Input.Label>{t('function-binding.label')}</Input.Label>
+        <Input.TextInput
+          placeholder={t('function-binding.placeholder')}
+          value={binding}
+          onChange={handleBindingChange}
+          onBlur={handleBindingBlur}
+        />
+      </Input.Root>
+    </div>
+  );
+};