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

package/src/containers/NotebookContainer/NotebookContainer.tsx

@@ -0,0 +1,268 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { RegistryContext } from '@effect-atom/atom-react';
+import * as Cause from 'effect/Cause';
+import * as Effect from 'effect/Effect';
+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 { 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 { 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 { ComputeGraph } from '../../notebook';
+import { type Notebook } from '../../types';
+
+const INCLUDE_BLUEPRINTS = [
+  'dxos.org/blueprint/assistant',
+  'dxos.org/blueprint/database',
+  'dxos.org/blueprint/markdown',
+];
+
+// TODO(burdon): Support calling named deployed functions (as with sheet).
+
+export type NotebookContainerProps = SurfaceComponentProps<Notebook.Notebook, Pick<TypescriptEditorProps, 'env'>>;
+
+export const NotebookContainer = ({ role, subject: notebook, env }: NotebookContainerProps) => {
+  const { t } = useTranslation(meta.id);
+  const registry = useContext(RegistryContext);
+  const db = notebook && Obj.getDatabase(notebook);
+  const attendableId = notebook ? Obj.getDXN(notebook).toString() : '';
+  const { hasAttention } = useAttention(attendableId);
+
+  // TODO(burdon): Consolidate execution and state (with graph).
+  //  Generalize ComputeGraph evaluation function (using effects).
+  const graph = useMemo(() => notebook && new ComputeGraph(notebook, registry), [notebook, registry]);
+
+  const [queryValues, setQueryValues] = useState<Record<string, any>>({});
+  const handleExecQueries = useCallback(async () => {
+    invariant(db);
+
+    const builder = new QueryBuilder();
+    for (const cell of notebook?.cells ?? []) {
+      if (cell.type === 'query') {
+        if (cell.source?.target) {
+          const source = cell.source.target.content;
+          const { name, filter } = builder.build(source);
+          if (filter) {
+            const ast = Query.select(filter).ast;
+            const graph = cell.graph?.target;
+            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);
+                if (c) {
+                  c.graph = Ref.make(newGraph);
+                  c.name = name;
+                }
+              });
+            } else {
+              Obj.change(graph, (g) => {
+                g.query.ast = ast as Obj.Mutable<typeof ast>;
+              });
+            }
+          }
+        }
+
+        if (cell.name && cell.graph?.target) {
+          const graph = Obj.getSnapshot(cell.graph?.target);
+          const query = Query.fromAst(graph.query.ast);
+          const objects = await db.query(query).run();
+          const objectIds = objects?.map((obj) => obj.id);
+          setQueryValues((prev) => ({ ...prev, [cell.name!]: objectIds }));
+        }
+      }
+    }
+  }, [db, notebook, graph]);
+
+  const [promptResults, setPromptResults] = useState<Record<string, string>>({});
+  const handleExecPrompts = useComputeRuntimeCallback(
+    db?.spaceId,
+    Effect.fnUntraced(function* () {
+      invariant(graph);
+
+      const prompts =
+        notebook?.cells
+          .filter((cell) => cell.type === 'prompt')
+          .map((cell) => cell.prompt)
+          .filter(isNonNullable) ?? [];
+
+      for (const prompt of prompts) {
+        yield* runPrompt({
+          prompt,
+          input: { ...queryValues, ...graph.getValuesByName() },
+          onResult: (result) =>
+            setPromptResults((prev) => ({
+              ...prev,
+              [prompt.dxn.toString()]: result,
+            })),
+        });
+      }
+    }),
+    [notebook, graph, queryValues],
+  );
+
+  // TODO(burdon): Cache values in context (preserve when switched).
+  const handleCompute = useCallback(async () => {
+    // TODO(burdon): Generalize executors (dependencies).
+    await graph?.evaluate();
+    await handleExecQueries();
+    await handleExecPrompts();
+  }, [graph, handleExecQueries, handleExecPrompts]);
+
+  const handleRearrange = useCallback<NonNullable<NotebookStackProps['onRearrange']>>(
+    (source, target) => {
+      invariant(notebook);
+      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];
+          if (cell) {
+            n.cells.splice(to, 0, cell);
+          }
+        });
+      }
+    },
+    [notebook],
+  );
+
+  const handleCellInsert = useCallback<NonNullable<NotebookStackProps['onCellInsert']>>(
+    async (type, after) => {
+      invariant(notebook);
+      const cell: Types.Mutable<Notebook.Cell> = { id: crypto.randomUUID(), type };
+      switch (type) {
+        case 'markdown':
+        case 'script':
+        case 'query': {
+          cell.source = Ref.make(Text.make());
+          break;
+        }
+
+        case 'prompt': {
+          if (db) {
+            const objects = await db.query(Query.select(Filter.type(Blueprint.Blueprint))).run();
+            const blueprints = objects
+              .filter((blueprint) => INCLUDE_BLUEPRINTS.includes(blueprint.key))
+              .map((blueprint) => Ref.make(blueprint));
+            cell.prompt = Ref.make(Prompt.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);
+      });
+    },
+    [db, notebook],
+  );
+
+  const handleCellDelete = useCallback<NonNullable<NotebookStackProps['onCellDelete']>>(
+    (id) => {
+      invariant(notebook);
+      const idx = notebook.cells.findIndex((cell) => cell.id === id);
+      if (idx !== -1) {
+        Obj.change(notebook, (n) => {
+          n.cells.splice(idx, 1);
+        });
+      }
+    },
+    [notebook],
+  );
+
+  return (
+    <Panel.Root role={role} className='dx-article'>
+      <Panel.Toolbar asChild>
+        <Toolbar.Root disabled={!hasAttention} textBlockWidth>
+          <DropdownMenu.Root>
+            <DropdownMenu.Trigger asChild>
+              <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'
+            onClick={handleCompute}
+          />
+        </Toolbar.Root>
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <NotebookStack
+          db={db}
+          notebook={notebook}
+          graph={graph}
+          env={env}
+          promptResults={promptResults}
+          onRearrange={handleRearrange}
+          onCellInsert={handleCellInsert}
+          onCellDelete={handleCellDelete}
+        />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};
+
+// TODO(wittjosiah): Factor out. Copied from PromptArticle in plugin-assistant.
+const runPrompt = Effect.fn(function* ({
+  prompt,
+  input,
+  onResult,
+}: {
+  prompt: Ref.Ref<Prompt.Prompt>;
+  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: {},
+    },
+  });
+
+  // Invoke the function.
+  const result = yield* FunctionInvocationService.invokeFunction(AgentFunctions.Prompt, inputData).pipe(
+    Effect.provide(trace.invocationTraceQueue ? TracingService.layerInvocation(trace) : TracingService.layerNoop),
+    Effect.exit,
+  );
+
+  Exit.match(result, {
+    onFailure: (cause) => {
+      const error = Cause.prettyErrors(cause)[0];
+      log.error(error.message, error.cause ?? error.stack);
+      onResult(error.message);
+    },
+    onSuccess: (result: any) => {
+      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/NotebookContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { NotebookContainer } from './NotebookContainer';
+
+export default NotebookContainer;

package/src/containers/ScriptContainer/ScriptContainer.tsx

@@ -0,0 +1,84 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import React, { useMemo } from 'react';
+
+import { type SurfaceComponentProps } from '@dxos/app-toolkit/ui';
+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 { ScriptToolbar, TypescriptEditor, type TypescriptEditorProps } from '../../components';
+import { useDeployState, useToolbarState } from '../../hooks';
+import { type ScriptSettings } from '../../types';
+
+export type ScriptEditorProps = SurfaceComponentProps<
+  Script.Script,
+  {
+    settings?: ScriptSettings;
+  } & Pick<TypescriptEditorProps, 'env'>
+>;
+
+export const ScriptContainer = ({
+  role,
+  subject: script,
+  settings = { editorInputMode: 'vscode' },
+  env,
+}: ScriptEditorProps) => {
+  const identity = useIdentity();
+  const space = getSpace(script);
+  const state = useToolbarState();
+  useDeployState({ script, state });
+
+  const extensions = useMemo(() => {
+    if (!script.source.target) {
+      return [];
+    }
+
+    return [
+      createDataExtensions({
+        id: script.id,
+        text: createDocAccessor(script.source.target, ['content']),
+        messenger: space,
+        identity,
+      }),
+      listener({
+        onChange: ({ text }) => {
+          if (script.source.target?.content !== text) {
+            Obj.change(script, (s) => {
+              s.changed = true;
+            });
+          }
+        },
+      }),
+    ];
+  }, [identity, space, script, script.source.target]);
+
+  if (!extensions.length) {
+    return null;
+  }
+
+  return (
+    <Panel.Root role={role} className='dx-article'>
+      <Panel.Toolbar asChild>
+        <ScriptToolbar state={state} role={role} script={script} />
+      </Panel.Toolbar>
+      <Panel.Content asChild>
+        <TypescriptEditor
+          id={script.id}
+          env={env}
+          initialValue={script.source?.target?.content}
+          extensions={extensions}
+          classNames={stackItemContentEditorClassNames(role)}
+          inputMode={settings.editorInputMode}
+          toolbar
+        />
+      </Panel.Content>
+    </Panel.Root>
+  );
+};

package/src/containers/ScriptContainer/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { ScriptContainer } from './ScriptContainer';
+
+export default ScriptContainer;

package/src/{components/Settings → containers/ScriptObjectSettings}/ScriptObjectSettings.tsx

@@ -6,20 +6,23 @@ import { Octokit } from '@octokit/core';
 import React, { type ChangeEvent, useCallback, useState } from 'react';
 
 import { ToolId } from '@dxos/ai';
-import { SettingsAction, createIntent, useIntentDispatcher } from '@dxos/app-framework';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
+import { SettingsOperation } from '@dxos/app-toolkit';
 import { Blueprint, Template } from '@dxos/blueprints';
-import { FunctionType, type ScriptType, getInvocationUrl, getUserFunctionIdInMetadata } from '@dxos/functions';
+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 { useQuery } from '@dxos/react-client/echo';
 import { Button, Clipboard, Input, useAsyncEffect, useControlledState, useTranslation } from '@dxos/react-ui';
-import { DataType } from '@dxos/schema';
+import { AccessToken } from '@dxos/types';
 import { kebabize } from '@dxos/util';
 
 import { meta } from '../../meta';
 
 export type ScriptObjectSettingsProps = {
-  object: ScriptType;
+  object: Script.Script;
 };
 
 export const ScriptObjectSettings = ({ object }: ScriptObjectSettingsProps) => {
@@ -32,27 +35,11 @@ export const ScriptObjectSettings = ({ object }: ScriptObjectSettingsProps) => {
   );
 };
 
-export const ScriptProperties = ({ object }: ScriptObjectSettingsProps) => {
-  const { t } = useTranslation(meta.id);
-  return (
-    <Input.Root>
-      <Input.Label>{t('description label')}</Input.Label>
-      <Input.TextInput
-        placeholder={t('description placeholder')}
-        value={object.description ?? ''}
-        onChange={(event) => {
-          object.description = event.target.value;
-        }}
-      />
-    </Input.Root>
-  );
-};
-
 const BlueprintEditor = ({ object }: ScriptObjectSettingsProps) => {
   const { t } = useTranslation(meta.id);
-  const space = getSpace(object);
-  const [fn] = useQuery(space, Filter.type(FunctionType, { source: Ref.make(object) }));
-  const blueprints = useQuery(space, Filter.type(Blueprint.Blueprint));
+  const db = Obj.getDatabase(object);
+  const [fn] = useQuery(db, Filter.type(Function.Function, { source: Ref.make(object) }));
+  const blueprints = useQuery(db, Filter.type(Blueprint.Blueprint));
 
   const [creating, setCreating] = useState(false);
   const [instructions, setInstructions] = useState<string>(`You can run the script "${object.name ?? 'script'}".`);
@@ -68,7 +55,7 @@ const BlueprintEditor = ({ object }: ScriptObjectSettingsProps) => {
   }, [existingBlueprint]);
 
   const handleSave = useCallback(async () => {
-    if (!space) {
+    if (!db) {
       return;
     }
 
@@ -76,15 +63,19 @@ const BlueprintEditor = ({ object }: ScriptObjectSettingsProps) => {
     try {
       if (existingBlueprint) {
         const text = await existingBlueprint.instructions.source.load();
-        text.content = instructions;
+        Obj.change(text, (t) => {
+          t.content = instructions;
+        });
         if (fn?.key) {
           const toolId = ToolId.make(fn.key);
           if (!existingBlueprint.tools?.includes(toolId)) {
-            existingBlueprint.tools = [...(existingBlueprint.tools ?? []), toolId];
+            Obj.change(existingBlueprint, (b) => {
+              b.tools = [...(b.tools ?? []), toolId];
+            });
           }
         }
       } else if (fn?.key) {
-        space.db.add(
+        db.add(
           Blueprint.make({
             key: blueprintKey,
             name: object.name ?? 'Script',
@@ -95,25 +86,29 @@ const BlueprintEditor = ({ object }: ScriptObjectSettingsProps) => {
           }),
         );
       }
-      await space.db.flush();
+      await db.flush();
     } finally {
       setCreating(false);
     }
-  }, [space, existingBlueprint, fn, blueprintKey, object.name, instructions]);
+  }, [db, existingBlueprint, fn, blueprintKey, object.name, instructions]);
 
   return (
-    <div className='flex flex-col gap-4 mlb-cardSpacingBlock'>
+    <div className='flex flex-col gap-4 my-form-padding'>
       <div>
         <h2>{t('blueprint editor label', { default: 'Blueprint' })}</h2>
         <p className='text-description text-sm'>
-          {t('blueprint editor description', { default: 'Create a blueprint that exposes this script as a tool.' })}
+          {t('blueprint editor description', {
+            default: 'Create a blueprint that exposes this script as a tool.',
+          })}
         </p>
       </div>
       <Input.Root>
         <div role='none' className='flex flex-col gap-1'>
           <Input.Label>{t('blueprint instructions label', { default: 'Instructions' })}</Input.Label>
           <Input.TextArea
-            placeholder={t('blueprint instructions placeholder', { default: 'Describe how this tool should be used.' })}
+            placeholder={t('blueprint instructions placeholder', {
+              default: 'Describe how this tool should be used.',
+            })}
             rows={6}
             value={instructions}
             onChange={(event) => setInstructions(event.target.value)}
@@ -135,14 +130,14 @@ const BlueprintEditor = ({ object }: ScriptObjectSettingsProps) => {
 const Binding = ({ object }: ScriptObjectSettingsProps) => {
   const { t } = useTranslation(meta.id);
   const client = useClient();
-  const space = getSpace(object);
-  const [fn] = useQuery(space, Filter.type(FunctionType, { source: Ref.make(object) }));
+  const db = Obj.getDatabase(object);
+  const [fn] = useQuery(db, 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 ?? '', {
-      spaceId: space?.id,
+      spaceId: db?.spaceId,
     });
 
   const [binding, setBinding] = useControlledState(fn?.binding ?? '');
@@ -154,7 +149,9 @@ const Binding = ({ object }: ScriptObjectSettingsProps) => {
   );
 
   const handleBindingBlur = useCallback(() => {
-    fn.binding = binding;
+    Obj.change(fn, (f) => {
+      f.binding = binding;
+    });
   }, [fn, binding]);
 
   if (!fn || !functionUrl) {
@@ -163,7 +160,7 @@ const Binding = ({ object }: ScriptObjectSettingsProps) => {
 
   // TODO(burdon): Use form.
   return (
-    <div role='form' className='flex flex-col gap-2 mlb-cardSpacingBlock'>
+    <div role='form' className='flex flex-col gap-2 my-form-padding'>
       <h2>{t('remote function settings heading')}</h2>
       <Input.Root>
         <div role='none' className='flex flex-col gap-1'>
@@ -173,7 +170,9 @@ const Binding = ({ object }: ScriptObjectSettingsProps) => {
               disabled
               value={functionUrl}
               onChange={(event) => {
-                fn.name = event.target.value;
+                Obj.change(fn, (f) => {
+                  f.name = event.target.value;
+                });
               }}
             />
             <Clipboard.IconButton value={functionUrl} />
@@ -198,10 +197,10 @@ const Binding = ({ object }: ScriptObjectSettingsProps) => {
 // TODO(burdon): Move to separate tab?
 const Publishing = ({ object }: ScriptObjectSettingsProps) => {
   const { t } = useTranslation(meta.id);
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
-  const space = getSpace(object);
-  const [githubToken] = useQuery(space, Filter.type(DataType.AccessToken, { source: 'github.com' }));
-  const gistKey = getMeta(object).keys.find(({ source }) => source === 'github.com');
+  const { invokePromise } = useOperationInvoker();
+  const db = Obj.getDatabase(object);
+  const [githubToken] = useQuery(db, Filter.type(AccessToken.AccessToken, { source: 'github.com' }));
+  const gistKey = Obj.getMeta(object).keys.find(({ source }) => source === 'github.com');
   const [gistUrl, setGistUrl] = useState<string | undefined>();
 
   useAsyncEffect(async () => {
@@ -225,8 +224,11 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
   }, [githubToken, gistKey]);
 
   const handleOpenTokenManager = useCallback(
-    () => dispatch(createIntent(SettingsAction.Open, { plugin: 'dxos.org/plugin/token-manager' })),
-    [],
+    () =>
+      invokePromise(SettingsOperation.Open, {
+        plugin: 'dxos.org/plugin/token-manager',
+      }),
+    [invokePromise],
   );
 
   const [publishing, setPublishing] = useState(false);
@@ -239,7 +241,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) {
@@ -252,8 +254,11 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
           public: true,
           files,
         });
-        if (response.data.id) {
-          meta.keys.push({ source: 'github.com', id: response.data.id });
+        const gistId = response.data.id;
+        if (gistId) {
+          Obj.change(object, (obj) => {
+            Obj.getMeta(obj).keys.push({ source: 'github.com', id: gistId });
+          });
         }
       }
     } finally {
@@ -262,7 +267,7 @@ const Publishing = ({ object }: ScriptObjectSettingsProps) => {
   }, [object, githubToken]);
 
   return (
-    <div className='flex flex-col gap-4 mlb-cardSpacingBlock'>
+    <div className='flex flex-col gap-4 my-form-padding'>
       <div>
         <h2>{t('script publish settings label')}</h2>
         <p className='text-description text-sm'>{t('script publish settings description')}</p>

package/src/containers/ScriptObjectSettings/index.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { ScriptObjectSettings } from './ScriptObjectSettings';
+
+export default ScriptObjectSettings;

package/src/{components/Settings → containers/ScriptPluginSettings}/ScriptPluginSettings.tsx

@@ -6,14 +6,19 @@ import React from 'react';
 
 import { useClient } from '@dxos/react-client';
 import { Button, Select, useTranslation } from '@dxos/react-ui';
-import { type EditorInputMode, EditorInputModes } from '@dxos/react-ui-editor';
-import { ControlGroup, ControlItemInput, ControlPage, ControlSection } from '@dxos/react-ui-form';
+import { Settings } from '@dxos/react-ui-form';
+import { type EditorInputMode, EditorInputModes } from '@dxos/ui-editor';
 
 import { meta } from '../../meta';
 import { type ScriptSettings } from '../../types';
 import { getAccessCredential } from '../../util';
 
-export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings }) => {
+export type ScriptPluginSettingsComponentProps = {
+  settings: ScriptSettings;
+  onSettingsChange: (fn: (current: ScriptSettings) => ScriptSettings) => void;
+};
+
+export const ScriptPluginSettings = ({ settings, onSettingsChange }: ScriptPluginSettingsComponentProps) => {
   const { t } = useTranslation(meta.id);
   const client = useClient();
 
@@ -24,19 +29,19 @@ export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings })
   };
 
   return (
-    <ControlPage>
-      <ControlSection title={t('settings title', { ns: meta.id })}>
-        <ControlGroup>
+    <Settings.Root>
+      <Settings.Section title={t('settings title', { ns: meta.id })}>
+        <Settings.Group>
           {/* TODO(wittjosiah): Hide outside of dev environments. */}
-          <ControlItemInput title={t('authenticate action label')}>
+          <Settings.ItemInput title={t('authenticate action label')}>
             <Button onClick={handleAuthenticate}>{t('authenticate button label')}</Button>
-          </ControlItemInput>
+          </Settings.ItemInput>
 
-          <ControlItemInput title={t('editor input mode label')}>
+          <Settings.ItemInput title={t('editor input mode label')}>
             <Select.Root
               value={settings.editorInputMode ?? 'default'}
               onValueChange={(value) => {
-                settings.editorInputMode = value as EditorInputMode;
+                onSettingsChange((s) => ({ ...s, editorInputMode: value as EditorInputMode }));
               }}
             >
               <Select.TriggerButton placeholder={t('select editor input mode placeholder')} />
@@ -53,9 +58,9 @@ export const ScriptPluginSettings = ({ settings }: { settings: ScriptSettings })
                 </Select.Content>
               </Select.Portal>
             </Select.Root>
-          </ControlItemInput>
-        </ControlGroup>
-      </ControlSection>
-    </ControlPage>
+          </Settings.ItemInput>
+        </Settings.Group>
+      </Settings.Section>
+    </Settings.Root>
   );
 };