@dxos/plugin-script 0.8.4-main.ae835ea → 0.8.4-main.bcb3aa67d6

package/src/capabilities/index.ts

@@ -2,13 +2,15 @@
 // Copyright 2025 DXOS.org
 //
 
-import { lazy } from '@dxos/app-framework';
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
 
-export const AppGraphBuilder = lazy(() => import('./app-graph-builder'));
-export const BlueprintDefinition = lazy(() => import('./blueprint-definition'));
-export const Compiler = lazy(() => import('./compiler'));
-export const IntentResolver = lazy(() => import('./intent-resolver'));
-export const ReactSurface = lazy(() => import('./react-surface'));
-export const ScriptSettings = lazy(() => import('./settings'));
-
-export * from './capabilities';
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const BlueprintDefinition = Capability.lazy('BlueprintDefinition', () => import('./blueprint-definition'));
+export const Compiler = Capability.lazy('Compiler', () => import('./compiler'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);
+export const ReactSurface = Capability.lazy('ReactSurface', () => import('./react-surface'));
+export const ScriptSettings = Capability.lazy('ScriptSettings', () => import('./settings'));

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/operation';
+
+import { ScriptHandlers } from '../blueprints/functions';
+import { ScriptOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(
+      Capabilities.OperationHandler,
+      OperationHandlerSet.merge(ScriptOperationHandlerSet, ScriptHandlers),
+    );
+  }),
+);

package/src/capabilities/react-surface.tsx

@@ -2,101 +2,151 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import React from 'react';
 
-import { Capabilities, contributes, createSurface, useCapability } from '@dxos/app-framework';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { Surface, useAtomCapability, useSettingsState } from '@dxos/app-framework/ui';
+import { AppCapabilities } from '@dxos/app-toolkit';
 import { InvocationTraceContainer } from '@dxos/devtools';
 import { Obj } from '@dxos/echo';
 import { Script } from '@dxos/functions';
-import { SettingsStore } from '@dxos/local-storage';
+import { useClient } from '@dxos/react-client';
 import { getSpace } from '@dxos/react-client/echo';
-import { StackItem } from '@dxos/react-ui-stack';
-import { type DataType } from '@dxos/schema';
+import { Panel } from '@dxos/react-ui';
+import { type AccessToken } from '@dxos/types';
 
+import { ScriptPluginSettings } from '#components';
+import { DEPLOYMENT_DIALOG } from '../constants';
 import {
-  DEPLOYMENT_DIALOG,
   DeploymentDialog,
   NotebookContainer,
   ScriptContainer,
   ScriptObjectSettings,
-  ScriptPluginSettings,
   ScriptProperties,
   TestContainer,
-} from '../components';
-import { meta } from '../meta';
-import { Notebook, type ScriptSettings } from '../types';
+} from '#containers';
+import { useCompiler } from '#hooks';
+import { meta } from '#meta';
+import { Notebook, ScriptCapabilities, type Settings } from '#types';
+import { getAccessCredential } from '../util';
 
-import { ScriptCapabilities } from './capabilities';
+export default Capability.makeModule(() =>
+  Effect.succeed(
+    Capability.contributes(Capabilities.ReactSurface, [
+      Surface.create({
+        id: `${meta.id}.plugin-settings`,
+        role: 'article',
+        filter: (data): data is { subject: AppCapabilities.Settings } =>
+          AppCapabilities.isSettings(data.subject) && data.subject.prefix === meta.id,
+        component: ({ data: { subject } }) => {
+          const { settings, updateSettings } = useSettingsState<Settings.Settings>(subject.atom);
+          const client = useClient();
+          // TODO(burdon): Check token.
+          const handleAuthenticate = async () => {
+            const { identityKey } = client.halo.identity.get()!;
+            await client.halo.writeCredentials([getAccessCredential(identityKey)]);
+          };
+          return (
+            <ScriptPluginSettings
+              settings={settings}
+              onSettingsChange={updateSettings}
+              onAuthenticate={handleAuthenticate}
+            />
+          );
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.script.article`,
+        role: ['article', 'section'],
+        filter: (data): data is { subject: Script.Script; attendableId: string } =>
+          Obj.instanceOf(Script.Script, data.subject),
+        component: ({ data, role }) => {
+          const compiler = useCompiler();
+          const settings = useAtomCapability(ScriptCapabilities.Settings);
+          // TODO(wittjosiah): Why? The editor should be allow to render even if the environment is not ready.
+          if (!compiler?.environment) {
+            return null;
+          }
 
-export default () =>
-  contributes(Capabilities.ReactSurface, [
-    createSurface({
-      id: `${meta.id}/plugin-settings`,
-      role: 'article',
-      filter: (data): data is { subject: SettingsStore<ScriptSettings> } =>
-        data.subject instanceof SettingsStore && data.subject.prefix === meta.id,
-      component: ({ data: { subject } }) => <ScriptPluginSettings settings={subject.value} />,
-    }),
-    createSurface({
-      id: `${meta.id}/script/article`,
-      role: ['article', 'section'],
-      filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
-      component: ({ data, role }) => {
-        const compiler = useCapability(ScriptCapabilities.Compiler);
-        // TODO(dmaretskyi): Since settings store is not reactive, this would break on the script plugin being enabled without a page reload.
-        const settings = useCapability(Capabilities.SettingsStore).getStore<ScriptSettings>(meta.id)?.value;
-        return <ScriptContainer role={role} script={data.subject} settings={settings} env={compiler.environment} />;
-      },
-    }),
-    createSurface({
-      id: `${meta.id}/notebook/article`,
-      role: 'article',
-      filter: (data): data is { subject: Notebook.Notebook } => Obj.instanceOf(Notebook.Notebook, data.subject),
-      component: ({ data, role }) => {
-        const compiler = useCapability(ScriptCapabilities.Compiler);
-        return <NotebookContainer role={role} notebook={data.subject} env={compiler.environment} />;
-      },
-    }),
-    // TODO(burdon): Standardize PluginSettings vs ObjectSettings.
-    // TODO(burdon): Why is ScriptProperties different from ScriptObjectSettings?
-    createSurface({
-      id: `${meta.id}/companion/base-settings`,
-      role: 'base-object-settings',
-      filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
-      component: ({ data }) => <ScriptProperties object={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion/settings`,
-      role: 'object-settings',
-      filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
-      component: ({ data }) => <ScriptObjectSettings object={data.subject} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion/execute`,
-      role: 'article',
-      filter: (data): data is { companionTo: Script.Script } =>
-        Obj.instanceOf(Script.Script, data.companionTo) && data.subject === 'execute',
-      component: ({ data, role }) => <TestContainer script={data.companionTo} role={role} />,
-    }),
-    createSurface({
-      id: `${meta.id}/companion/logs`,
-      role: 'article',
-      filter: (data): data is { companionTo: Script.Script } =>
-        Obj.instanceOf(Script.Script, data.companionTo) && data.subject === 'logs',
-      component: ({ data, role }) => {
-        const space = getSpace(data.companionTo);
-        return (
-          <StackItem.Content>
-            <InvocationTraceContainer space={space} target={data.companionTo} detailAxis='block' />
-          </StackItem.Content>
-        );
-      },
-    }),
-    createSurface({
-      id: DEPLOYMENT_DIALOG,
-      role: 'dialog',
-      filter: (data): data is { props: { accessToken: DataType.AccessToken; scriptTemplates: any } } =>
-        data.component === DEPLOYMENT_DIALOG,
-      component: ({ data }) => <DeploymentDialog {...data.props} />,
-    }),
-  ]);
+          return (
+            <ScriptContainer
+              role={role}
+              subject={data.subject}
+              attendableId={data.attendableId}
+              settings={settings}
+              env={compiler?.environment}
+            />
+          );
+        },
+      }),
+      Surface.create({
+        id: `${meta.id}.notebook.article`,
+        role: 'article',
+        filter: (data): data is { subject: Notebook.Notebook; attendableId: string } =>
+          typeof data.attendableId === 'string' && Obj.instanceOf(Notebook.Notebook, data.subject),
+        component: ({ data, role }) => {
+          const compiler = useCompiler();
+          return (
+            <NotebookContainer
+              role={role}
+              subject={data.subject}
+              attendableId={data.attendableId}
+              env={compiler?.environment}
+            />
+          );
+        },
+      }),
+      // TODO(burdon): Standardize PluginSettings vs ObjectSettings.
+      // TODO(burdon): Why is ScriptProperties different from ScriptObjectSettings?
+      Surface.create({
+        id: `${meta.id}.companion.base-settings`,
+        role: 'base-object-settings',
+        filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
+        component: ({ data }) => <ScriptProperties object={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.companion.settings`,
+        role: 'object-settings',
+        filter: (data): data is { subject: Script.Script } => Obj.instanceOf(Script.Script, data.subject),
+        component: ({ data }) => <ScriptObjectSettings object={data.subject} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.companion.execute`,
+        role: 'article',
+        filter: (data): data is { companionTo: Script.Script } =>
+          Obj.instanceOf(Script.Script, data.companionTo) && data.subject === 'execute',
+        component: ({ data, role }) => <TestContainer script={data.companionTo} role={role} />,
+      }),
+      Surface.create({
+        id: `${meta.id}.companion.logs`,
+        role: 'article',
+        filter: (data): data is { companionTo: Script.Script } =>
+          Obj.instanceOf(Script.Script, data.companionTo) && data.subject === 'logs',
+        component: ({ data, role }) => {
+          const space = getSpace(data.companionTo);
+          const queueDxn = space?.properties.invocationTraceQueue?.dxn;
+          return (
+            <Panel.Root role={role}>
+              <Panel.Content asChild>
+                <InvocationTraceContainer
+                  db={space?.db}
+                  queueDxn={queueDxn}
+                  target={data.companionTo}
+                  detailAxis='block'
+                />
+              </Panel.Content>
+            </Panel.Root>
+          );
+        },
+      }),
+      Surface.create({
+        id: DEPLOYMENT_DIALOG,
+        role: 'dialog',
+        filter: (data): data is { props: { accessToken: AccessToken.AccessToken; scriptTemplates: any } } =>
+          data.component === DEPLOYMENT_DIALOG,
+        component: ({ data }) => <DeploymentDialog {...data.props} />,
+      }),
+    ]),
+  ),
+);

package/src/capabilities/settings.ts

@@ -2,20 +2,32 @@
 // Copyright 2025 DXOS.org
 //
 
-import { Capabilities, contributes } from '@dxos/app-framework';
-import { live } from '@dxos/live-object';
+import * as Effect from 'effect/Effect';
 
-import { meta } from '../meta';
-import { ScriptSettings } from '../types';
+import { Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { createKvsStore } from '@dxos/effect';
 
-export default () => {
-  const settings = live<ScriptSettings>({
-    editorInputMode: 'vscode',
-  });
+import { meta } from '#meta';
+import { ScriptCapabilities, Settings } from '#types';
 
-  return contributes(Capabilities.Settings, {
-    prefix: meta.id,
-    schema: ScriptSettings,
-    value: settings,
-  });
-};
+export default Capability.makeModule(() =>
+  Effect.sync(() => {
+    const settingsAtom = createKvsStore({
+      key: meta.id,
+      schema: Settings.Settings,
+      defaultValue: () => ({
+        editorInputMode: 'vscode' as const,
+      }),
+    });
+
+    return [
+      Capability.contributes(ScriptCapabilities.Settings, settingsAtom),
+      Capability.contributes(AppCapabilities.Settings, {
+        prefix: meta.id,
+        schema: Settings.Settings,
+        atom: settingsAtom,
+      }),
+    ];
+  }),
+);

package/src/compiler/compiler.ts

@@ -12,6 +12,8 @@ import ts from 'typescript';
 
 import { invariant } from '@dxos/invariant';
 
+const GLOBALS = 'globals.d.ts';
+
 const defaultOptions: ts.CompilerOptions = {
   lib: ['DOM', 'es2022'],
   target: ts.ScriptTarget.ES2022,
@@ -23,16 +25,21 @@ export class Compiler {
 
   constructor(private readonly _options: ts.CompilerOptions = defaultOptions) {}
 
-  async initialize(): Promise<void> {
+  async initialize(globals?: string): Promise<void> {
     if (this._env) {
       return;
     }
 
     // TODO(wittjosiah): Figure out how to get workers working in plugin packages.
     //   https://github.com/val-town/codemirror-ts?tab=readme-ov-file#setup-worker
-    this._fsMap = await createDefaultMapFromCDN(this._options, '5.5.4', true, ts);
+    this._fsMap = await createDefaultMapFromCDN(this._options, '5.7.2', true, ts);
+    if (globals) {
+      this._fsMap.set(GLOBALS, globals);
+    }
+
+    const rootFiles = globals ? [GLOBALS] : [];
     const system = createSystem(this._fsMap);
-    this._env = createVirtualTypeScriptEnvironment(system, [], ts, this._options);
+    this._env = createVirtualTypeScriptEnvironment(system, rootFiles, ts, this._options);
   }
 
   get environment() {

package/src/components/{FrameContainer/FrameContainer.tsx → FramePanel/FramePanel.tsx}

@@ -5,15 +5,15 @@
 import React, { useEffect, useRef } from 'react';
 
 import { clientServiceBundle } from '@dxos/client-protocol';
-import { type BundleResult } from '@dxos/functions/bundler';
+import { type BundleResult } from '@dxos/functions-runtime/bundler';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 import { useClient } from '@dxos/react-client';
-import { baseSurface, mx } from '@dxos/react-ui-theme';
 import { createProtoRpcPeer } from '@dxos/rpc';
 import { createIFramePort } from '@dxos/rpc-tunnel';
+import { mx } from '@dxos/ui-theme';
 
-export type FrameContainerProps = {
+export type FramePanelProps = {
   containerUrl: string;
   result: BundleResult;
   debug?: boolean;
@@ -22,7 +22,7 @@ export type FrameContainerProps = {
 /**
  * IFrame container for the compiled script.
  */
-export const FrameContainer = ({ containerUrl, result, debug = true }: FrameContainerProps) => {
+export const FramePanel = ({ containerUrl, result, debug = true }: FramePanelProps) => {
   const client = useClient();
   const iframeRef = useRef<HTMLIFrameElement>(null);
   useEffect(() => {
@@ -49,7 +49,9 @@ export const FrameContainer = ({ containerUrl, result, debug = true }: FrameCont
   invariant(result.sourceHash, 'Source hash is required.');
   const sourceHash = Buffer.from(result.sourceHash).toString('hex');
   const src =
-    'bundle' in result ? `${containerUrl}?ts=${sourceHash}#code=${encodeURIComponent(result.bundle)}` : undefined;
+    'bundle' in result
+      ? `${containerUrl}?ts=${sourceHash}#code=${encodeURIComponent(new TextDecoder().decode(Object.values(result.bundle as any)[0] as Uint8Array))}`
+      : undefined;
 
   return (
     <>
@@ -59,8 +61,7 @@ export const FrameContainer = ({ containerUrl, result, debug = true }: FrameCont
         <div className='relative'>
           <div
             className={mx(
-              baseSurface,
-              'flex absolute right-2 bottom-2 w-[30rem] h-[200px] ring rounded',
+              'flex absolute right-2 bottom-2 w-[30rem] h-[200px] bg-base-surface ring rounded-sm',
               'z-20 overflow-x-hidden overflow-y-auto',
             )}
           >

package/src/components/{FrameContainer → FramePanel}/index.ts

@@ -2,4 +2,4 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './FrameContainer';
+export * from './FramePanel';

package/src/components/NotebookStack/NotebookCell.tsx

@@ -4,38 +4,37 @@
 
 import React, { useCallback, useMemo } from 'react';
 
-import { Surface } from '@dxos/app-framework';
+import { Surface } from '@dxos/app-framework/ui';
+import { type Database, Obj } from '@dxos/echo';
+import { createDocAccessor } from '@dxos/echo-db';
 import { invariant } from '@dxos/invariant';
 import { TemplateEditor } from '@dxos/plugin-assistant';
-import { createDocAccessor } from '@dxos/react-client/echo';
-import { type Space } from '@dxos/react-client/echo';
 import { useThemeContext, useTranslation } from '@dxos/react-ui';
 import { QueryEditor, type QueryEditorProps } from '@dxos/react-ui-components';
+import { EditorContent, type EditorContentProps } from '@dxos/react-ui-editor';
 import {
   type BasicExtensionsOptions,
-  Editor,
-  type EditorProps,
   createBasicExtensions,
   createDataExtensions,
   createMarkdownExtensions,
   createThemeExtensions,
   decorateMarkdown,
-} from '@dxos/react-ui-editor';
-import { mx } from '@dxos/react-ui-theme';
+} from '@dxos/ui-editor';
+import { mx } from '@dxos/ui-theme';
 import { isNonNullable } from '@dxos/util';
 
-import { meta } from '../../meta';
+import { meta } from '#meta';
 import { type ComputeGraph } from '../../notebook';
-import { type Notebook } from '../../types';
+import { type Notebook } from '#types';
 import { TypescriptEditor, type TypescriptEditorProps } from '../TypescriptEditor';
 
 import { type NotebookMenuProps } from './NotebookMenu';
 
-const editorStyles = 'p-2 pis-3';
-const valueStyles = 'p-1 pis-3';
+const editorStyles = 'p-2 ps-3';
+const valueStyles = 'p-1 ps-3';
 
 export type NotebookCellProps = {
-  space?: Space;
+  db?: Database.Database;
   graph?: ComputeGraph;
   dragging?: boolean;
   cell: Notebook.Cell;
@@ -43,23 +42,28 @@ export type NotebookCellProps = {
 } & (Pick<NotebookMenuProps, 'onCellInsert' | 'onCellDelete'> & Pick<TypescriptEditorProps, 'env'>);
 
 // TODO(burdon): Show evaluation errors.
-export const NotebookCell = ({ space, graph, dragging, cell, promptResults, env }: NotebookCellProps) => {
+export const NotebookCell = ({ db, graph, dragging, cell, promptResults, env }: NotebookCellProps) => {
   const { t } = useTranslation(meta.id);
 
   const extensions = useMemo(() => {
     return cell.source?.target
-      ? [createDataExtensions({ id: cell.id, text: createDocAccessor(cell.source.target, ['content']) })].filter(
-          isNonNullable,
-        )
+      ? [
+          createDataExtensions({
+            id: cell.id,
+            text: createDocAccessor(cell.source.target, ['content']),
+          }),
+        ].filter(isNonNullable)
       : [];
   }, [cell.source?.target]);
 
-  const view = cell.view?.target;
+  const explorerGraph = cell.graph?.target;
 
   const handleQueryChange = useCallback<NonNullable<QueryEditorProps['onChange']>>(
     (value: string) => {
       invariant(cell.source?.target);
-      cell.source.target.content = value;
+      Obj.change(cell.source.target, (obj) => {
+        obj.content = value;
+      });
     },
     [cell],
   );
@@ -94,7 +98,7 @@ export const NotebookCell = ({ space, graph, dragging, cell, promptResults, env
             extensions={extensions}
             env={env}
             options={{
-              placeholder: t('notebook cell placeholder'),
+              placeholder: t('notebook-cell.placeholder'),
               highlightActiveLine: false,
               lineNumbers: false,
             }}
@@ -110,15 +114,15 @@ export const NotebookCell = ({ space, graph, dragging, cell, promptResults, env
 
       // TODO(burdon): Remove app-framework deps (via render prop).
       return (
-        <div className={mx('bs-full overflow-hidden grid', view && !dragging && 'grid-rows-[min-content_1fr]')}>
+        <div className={mx('h-full overflow-hidden grid', explorerGraph && !dragging && 'grid-rows-[min-content_1fr]')}>
           <QueryEditor
             id={cell.id}
-            classNames={[editorStyles, 'border-b border-subduedSeparator']}
-            db={space?.db}
+            classNames={[editorStyles, 'border-b border-subdued-separator']}
+            db={db}
             value={cell.source.target.content}
             onChange={handleQueryChange}
           />
-          {view && !dragging && <Surface role='section' limit={1} data={{ subject: view }} />}
+          {explorerGraph && !dragging && <Surface.Surface role='section' limit={1} data={{ subject: explorerGraph }} />}
         </div>
       );
 
@@ -146,7 +150,7 @@ export const NotebookCell = ({ space, graph, dragging, cell, promptResults, env
 };
 
 const NotebookCellValue = ({ cell, graph }: NotebookCellProps) => {
-  const name = graph?.expressions.value[cell.id]?.name;
+  const name = graph?.getExpressions()[cell.id]?.name;
   const value = graph?.getValue(cell.id);
   if (value == null) {
     return null;
@@ -155,13 +159,13 @@ const NotebookCellValue = ({ cell, graph }: NotebookCellProps) => {
   return (
     <div
       className={mx(
-        'flex is-full bg-groupSurface border-t border-subduedSeparator text-description font-mono',
+        'flex w-full bg-group-surface border-y border-subdued-separator text-description font-mono',
         valueStyles,
       )}
     >
       {name && (
         <>
-          <span className='text-successText'>{name}</span>
+          <span className='text-success-text'>{name}</span>
           <span className='text-description'>&nbsp;=&nbsp;</span>
         </>
       )}
@@ -181,28 +185,31 @@ const NotebookPromptResult = ({ cell, promptResults }: NotebookCellProps) => {
   }
 
   return (
-    <div className={mx('flex is-full bg-groupSurface text-description border-t border-subduedSeparator', valueStyles)}>
+    <div className={mx('flex w-full bg-group-surface text-description border-y border-subdued-separator', valueStyles)}>
       <NotebookTextEditor readOnly value={value} />
     </div>
   );
 };
 
 const NotebookTextEditor = ({
-  extensions: extensionsParam,
+  extensions: extensionsProp,
   readOnly,
   ...props
-}: EditorProps & Pick<BasicExtensionsOptions, 'readOnly'>) => {
+}: EditorContentProps & Pick<BasicExtensionsOptions, 'readOnly'>) => {
   const { t } = useTranslation(meta.id);
   const { themeMode } = useThemeContext();
   const extensions = useMemo(() => {
     return [
-      createBasicExtensions({ placeholder: t('notebook markdown placeholder'), readOnly }),
+      createBasicExtensions({
+        placeholder: t('notebook-markdown.placeholder'),
+        readOnly,
+      }),
       createThemeExtensions({ themeMode, syntaxHighlighting: true }),
       createMarkdownExtensions(),
       decorateMarkdown(),
-      extensionsParam,
+      extensionsProp,
     ].filter(isNonNullable);
-  }, [extensionsParam]);
+  }, [extensionsProp]);
 
-  return <Editor {...props} extensions={extensions} moveToEnd />;
+  return <EditorContent {...props} extensions={extensions} selectionEnd />;
 };

package/src/components/NotebookStack/NotebookMenu.tsx

@@ -6,8 +6,8 @@ import React from 'react';
 
 import { DropdownMenu, useTranslation } from '@dxos/react-ui';
 
-import { meta } from '../../meta';
-import { type Notebook } from '../../types';
+import { meta } from '#meta';
+import { type Notebook } from '#types';
 
 export type NotebookMenuProps = {
   cell?: Notebook.Cell;
@@ -23,20 +23,20 @@ export const NotebookMenu = ({ cell, onCellInsert, onCellDelete }: NotebookMenuP
       <DropdownMenu.Content>
         <DropdownMenu.Viewport>
           <DropdownMenu.Item onClick={() => onCellInsert?.('script', cell?.id)}>
-            {t('notebook cell insert script label')}
+            {t('notebook-cell-insert-script.label')}
           </DropdownMenu.Item>
           <DropdownMenu.Item onClick={() => onCellInsert?.('prompt', cell?.id)}>
-            {t('notebook cell insert prompt label')}
+            {t('notebook-cell-insert-prompt.label')}
           </DropdownMenu.Item>
           <DropdownMenu.Item onClick={() => onCellInsert?.('query', cell?.id)}>
-            {t('notebook cell insert query label')}
+            {t('notebook-cell-insert-query.label')}
           </DropdownMenu.Item>
           <DropdownMenu.Item onClick={() => onCellInsert?.('markdown', cell?.id)}>
-            {t('notebook cell insert markdown label')}
+            {t('notebook-cell-insert-markdown.label')}
           </DropdownMenu.Item>
           {cell && onCellDelete && (
             <DropdownMenu.Item onClick={() => onCellDelete?.(cell.id)}>
-              {t('notebook cell delete label')}
+              {t('notebook-cell-delete.label')}
             </DropdownMenu.Item>
           )}
         </DropdownMenu.Viewport>