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

package/src/hooks/deploy.ts

@@ -4,15 +4,17 @@
 
 import { useEffect, useMemo } from 'react';
 
-import { Function, type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { Obj, Query, Ref } from '@dxos/echo';
+import { type Script, getUserFunctionIdInMetadata } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
 import { log } from '@dxos/log';
 import { type Client, useClient } from '@dxos/react-client';
-import { Query, Ref, type Space, getMeta, getSpace, useQuery } from '@dxos/react-client/echo';
+import { type Space, getSpace, useQuery } from '@dxos/react-client/echo';
 import { type TFunction } from '@dxos/react-ui';
 import { createMenuAction } from '@dxos/react-ui-menu';
-import { errorMessageColors } from '@dxos/react-ui-theme';
+import { messageValence } from '@dxos/ui-theme';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 import { deployScript, getFunctionUrl, isScriptDeployed } from '../util';
 
 export type DeployActionProperties = { type: 'deploy' } | { type: 'copy' };
@@ -24,10 +26,12 @@ export type DeployState = {
   error: string;
 };
 
+import { type ScriptToolbarStateStore } from './useToolbarState';
+
 export type CreateDeployOptions = {
-  state: Partial<DeployState>;
+  state: ScriptToolbarStateStore;
   script: Script.Script;
-  fn: Function.Function;
+  fn: Operation.PersistentOperation;
   space?: Space;
   existingFunctionId?: string;
   client: Client;
@@ -35,12 +39,14 @@ export type CreateDeployOptions = {
 };
 
 export const createDeploy = ({ state, script, space, fn, client, existingFunctionId, t }: CreateDeployOptions) => {
+  const { value } = state;
+
   // TODO(wittjosiah): Should this be an action?
   const errorItem = createMenuAction('error', () => {}, {
-    label: state.error ?? ['no error label', { ns: meta.id }],
+    label: value.error ?? ['no-error.label', { ns: meta.id }],
     icon: 'ph--warning-circle--regular',
-    hidden: !state.error,
-    classNames: state.error && errorMessageColors,
+    hidden: !value.error,
+    classNames: value.error && messageValence('error'),
   });
 
   const deployAction = createMenuAction<DeployActionProperties>(
@@ -50,75 +56,78 @@ export const createDeploy = ({ state, script, space, fn, client, existingFunctio
         return;
       }
 
-      state.error = undefined;
-      state.deploying = true;
+      state.set('error', undefined);
+      state.set('deploying', true);
 
       const result = await deployScript({ script, client, space, fn, existingFunctionId });
 
       if (!result.success) {
         log.catch(result.error);
-        state.error = t('upload failed label');
+        state.set('error', t('upload-failed.label'));
       }
 
-      state.deploying = false;
+      state.set('deploying', false);
     },
     {
       type: 'deploy',
-      label: [state.deploying ? 'publishing label' : 'deploy label', { ns: meta.id }],
-      icon: state.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
-      disabled: state.deploying,
-      classNames: state.deploying ? '[&_svg]:animate-spin' : '',
+      label: [value.deploying ? 'publishing.label' : 'deploy.label', { ns: meta.id }],
+      icon: value.deploying ? 'ph--spinner-gap--regular' : 'ph--cloud-arrow-up--regular',
+      disabled: value.deploying,
+      classNames: value.deploying ? '[&_svg]:animate-spin' : '',
     },
   );
 
   const copyAction = createMenuAction<DeployActionProperties>(
     'copy',
     async () => {
-      if (state.functionUrl) {
-        await navigator.clipboard.writeText(state.functionUrl);
+      if (value.functionUrl) {
+        await navigator.clipboard.writeText(value.functionUrl);
       }
     },
     {
       type: 'copy',
-      label: ['copy link label', { ns: meta.id }],
+      label: ['copy-link.label', { ns: meta.id }],
       icon: 'ph--link--regular',
-      disabled: !state.functionUrl,
+      disabled: !value.functionUrl,
     },
   );
 
   return {
     nodes: [errorItem, deployAction, copyAction],
     edges: [
-      { source: 'root', target: 'error' },
-      { source: 'root', target: 'deploy' },
-      { source: 'root', target: 'copy' },
+      { source: 'root', target: 'error', relation: 'child' },
+      { source: 'root', target: 'deploy', relation: 'child' },
+      { source: 'root', target: 'copy', relation: 'child' },
     ],
   };
 };
 
-export const useDeployState = ({ state, script }: { state: Partial<DeployState>; script: Script.Script }) => {
+export const useDeployState = ({ state, script }: { state: ScriptToolbarStateStore; script: Script.Script }) => {
   const { space, client, fn, existingFunctionId } = useDeployDeps({ script });
   useEffect(() => {
     if (!existingFunctionId) {
       return;
     }
 
-    state.functionUrl = getFunctionUrl({
-      script,
-      fn,
-      edgeUrl: client.config.values.runtime?.services?.edge?.url ?? '',
-    });
-  }, [existingFunctionId, space, fn, script, client.config.values.runtime?.services?.edge?.url]);
+    state.set(
+      'functionUrl',
+      getFunctionUrl({
+        script,
+        fn,
+        edgeUrl: client.config.values.runtime?.services?.edge?.url ?? '',
+      }),
+    );
+  }, [existingFunctionId, space, fn, script, client.config.values.runtime?.services?.edge?.url, state]);
 
   useEffect(() => {
-    state.deployed = isScriptDeployed({ script, fn });
-  }, [script.changed, existingFunctionId, fn, script]);
+    state.set('deployed', isScriptDeployed({ script, fn }));
+  }, [script.changed, existingFunctionId, fn, script, state]);
 };
 
 export const useDeployDeps = ({ script }: { script: Script.Script }) => {
   const client = useClient();
   const space = getSpace(script);
-  const [fn] = useQuery(space, Query.type(Function.Function, { source: Ref.make(script) }));
-  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(getMeta(fn)), [fn]);
+  const [fn] = useQuery(space?.db, Query.type(Operation.PersistentOperation, { source: Ref.make(script) }));
+  const existingFunctionId = useMemo(() => fn && getUserFunctionIdInMetadata(Obj.getMeta(fn)), [fn]);
   return { client, space, fn, existingFunctionId };
 };

package/src/hooks/format.ts

@@ -6,11 +6,12 @@ import { format } from 'prettier';
 import prettierPluginEstree from 'prettier/plugins/estree';
 import prettierPluginTypescript from 'prettier/plugins/typescript';
 
+import { Obj } from '@dxos/echo';
 import { type Script } from '@dxos/functions';
 import { log } from '@dxos/log';
 import { createMenuAction } from '@dxos/react-ui-menu';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
 export type FormatActionProperties = { type: 'format' };
 
@@ -23,19 +24,22 @@ export const createFormat = (script: Script.Script) => {
       }
 
       try {
-        script.source.target!.content = await format(script.source.target!.content, {
+        const formatted = await format(script.source.target!.content, {
           parser: 'typescript',
           plugins: [prettierPluginEstree, prettierPluginTypescript],
           semi: true,
           singleQuote: true,
         });
+        Obj.change(script.source.target!, (obj) => {
+          obj.content = formatted;
+        });
       } catch (err: any) {
         // TODO(wittjosiah): Show error in UI.
         log.catch(err);
       }
     },
     {
-      label: ['format label', { ns: meta.id }],
+      label: ['format.label', { ns: meta.id }],
       icon: 'ph--magic-wand--regular',
     },
   );
@@ -46,6 +50,7 @@ export const createFormat = (script: Script.Script) => {
       {
         source: 'root',
         target: 'format',
+        relation: 'child',
       },
     ],
   };

package/src/hooks/index.ts

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

package/src/hooks/template.ts

@@ -15,15 +15,21 @@ const createTemplateSelectActions = (script: Script.Script) => {
     return createMenuAction<TemplateActionProperties>(
       `template--${template.id}`,
       () => {
-        script.name = template.name;
-        script.source!.target!.content = template.source;
-        const metaKeys = Obj.getMeta(script).keys;
-        const oldPresetIndex = metaKeys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
-        if (oldPresetIndex >= 0) {
-          metaKeys.splice(oldPresetIndex, 1);
-        }
-        if ('presetId' in template) {
-          metaKeys.push({ source: FUNCTIONS_PRESET_META_KEY, id: template.presetId });
+        Obj.change(script, (obj) => {
+          obj.name = template.name;
+          const meta = Obj.getMeta(obj);
+          const oldPresetIndex = meta.keys.findIndex((key) => key.source === FUNCTIONS_PRESET_META_KEY);
+          if (oldPresetIndex >= 0) {
+            meta.keys.splice(oldPresetIndex, 1);
+          }
+          if ('presetId' in template) {
+            meta.keys.push({ source: FUNCTIONS_PRESET_META_KEY, id: template.presetId });
+          }
+        });
+        if (script.source?.target) {
+          Obj.change(script.source.target, (obj) => {
+            obj.content = template.source;
+          });
         }
       },
       {
@@ -40,8 +46,8 @@ export const createTemplateSelect = (script: Script.Script) => {
   return {
     nodes: [...templateSelectActions],
     edges: [
-      { source: 'root', target: 'template-select' },
-      ...templateSelectActions.map((action) => ({ source: 'template-select', target: action.id })),
+      { source: 'root', target: 'template-select', relation: 'child' },
+      ...templateSelectActions.map((action) => ({ source: 'template-select', target: action.id, relation: 'child' })),
     ],
   };
 };

package/src/hooks/useCompiler.ts

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

package/src/hooks/useCreateAndDeployScriptTemplates.ts

@@ -2,19 +2,18 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Function from 'effect/Function';
 import { useCallback, useState } from 'react';
 
-import { chain, createIntent, useIntentDispatcher } from '@dxos/app-framework';
+import { useOperationInvoker } from '@dxos/app-framework/ui';
 import { Obj } from '@dxos/echo';
 import { Script } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { SpaceAction } from '@dxos/plugin-space/types';
+import { SpaceOperation } from '@dxos/plugin-space/operations';
 import { useClient } from '@dxos/react-client';
 import { type Space } from '@dxos/react-client/echo';
 
 import { type Template } from '../templates';
-import { ScriptAction } from '../types';
+import { ScriptOperation } from '#operations';
 import { deployScript } from '../util';
 
 type DeploymentStatus = 'idle' | 'pending' | 'success' | 'error';
@@ -27,7 +26,7 @@ type DeploymentStatus = 'idle' | 'pending' | 'success' | 'error';
  * All creation / deployment operations run concurrently for improved performance.
  */
 export const useCreateAndDeployScriptTemplates = (space: Space | undefined, scriptTemplates: Template[]) => {
-  const { dispatchPromise: dispatch } = useIntentDispatcher();
+  const { invokePromise } = useOperationInvoker();
   const client = useClient();
   const [status, setStatus] = useState<DeploymentStatus>('idle');
   const [error, setError] = useState<Error | undefined>(undefined);
@@ -39,21 +38,20 @@ export const useCreateAndDeployScriptTemplates = (space: Space | undefined, scri
 
     const deploymentResults = await Promise.all(
       scriptTemplates.map(async (template) => {
-        const result = await dispatch(
-          Function.pipe(
-            createIntent(ScriptAction.CreateScript, { space, initialTemplateId: template.id as any }),
-            chain(SpaceAction.AddObject, { target: space }),
-          ),
-        );
-        invariant(Obj.instanceOf(Script.Script, result.data?.object));
-
-        return deployScript({ space, client, script: result.data.object });
+        const createResult = await invokePromise(ScriptOperation.CreateScript, {
+          db: space.db,
+          initialTemplateId: template.id as any,
+        });
+        invariant(Obj.instanceOf(Script.Script, createResult.data?.object));
+        await invokePromise(SpaceOperation.AddObject, { target: space.db, object: createResult.data.object });
+
+        return deployScript({ space, client, script: createResult.data.object });
       }),
     );
 
     const hasErrors = deploymentResults.some((result) => !result.success);
     setStatus(hasErrors ? 'error' : 'success');
-  }, [space, dispatch, client, scriptTemplates]);
+  }, [space, invokePromise, client, scriptTemplates]);
 
   // TODO(burdon): Return onCreateAndDeployScripts.
   return { handleCreateAndDeployScripts, status, error };

package/src/hooks/useToolbarState.ts

@@ -2,15 +2,40 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom } from '@effect-atom/atom-react';
 import { useMemo } from 'react';
 
-import { live } from '@dxos/live-object';
+import { Capabilities } from '@dxos/app-framework';
+import { useCapability } from '@dxos/app-framework/ui';
 
 import { type DeployState } from './deploy';
 
 export type ScriptToolbarState = Partial<DeployState>;
 
-// TODO(burdon): Replace with context provider?
-export const useToolbarState = (initialState: ScriptToolbarState = {}) => {
-  return useMemo(() => live<ScriptToolbarState>(initialState), []);
+export type ScriptToolbarStateStore = {
+  atom: Atom.Writable<ScriptToolbarState>;
+  get value(): ScriptToolbarState;
+  update: (updater: (current: ScriptToolbarState) => ScriptToolbarState) => void;
+  set: <K extends keyof ScriptToolbarState>(key: K, value: ScriptToolbarState[K]) => void;
+};
+
+export const useToolbarState = (initialState: ScriptToolbarState = {}): ScriptToolbarStateStore => {
+  const registry = useCapability(Capabilities.AtomRegistry);
+  const atom = useMemo(() => Atom.make<ScriptToolbarState>(initialState), []);
+
+  return useMemo(
+    () => ({
+      atom,
+      get value() {
+        return registry.get(atom);
+      },
+      update: (updater: (current: ScriptToolbarState) => ScriptToolbarState) => {
+        registry.set(atom, updater(registry.get(atom)));
+      },
+      set: <K extends keyof ScriptToolbarState>(key: K, v: ScriptToolbarState[K]) => {
+        registry.set(atom, { ...registry.get(atom), [key]: v });
+      },
+    }),
+    [atom, registry],
+  );
 };

package/src/index.ts

@@ -2,8 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-export { ScriptCapabilities } from './capabilities';
+export { ScriptCapabilities, ScriptEvents } from './types';
 export * from './components';
+export * from './containers';
 export * from './meta';
 export * from './util';
 

package/src/meta.ts

@@ -2,11 +2,11 @@
 // Copyright 2023 DXOS.org
 //
 
-import { type PluginMeta } from '@dxos/app-framework';
+import { type Plugin } from '@dxos/app-framework';
 import { trim } from '@dxos/util';
 
-export const meta: PluginMeta = {
-  id: 'dxos.org/plugin/script',
+export const meta: Plugin.Meta = {
+  id: 'org.dxos.plugin.script',
   name: 'Scripts',
   description: trim`
     Write and deploy custom JavaScript functions that extend your workspace capabilities.
@@ -22,5 +22,5 @@ export const meta: PluginMeta = {
 // TODO(ZaymonFC): Configure by scopes?
 export const defaultScriptsForIntegration: Record<string, string[]> = {
   // TODO(wittjosiah): Also include content extraction scripts in the default set.
-  'gmail.com': ['dxos.org/script/gmail'],
+  'gmail.com': ['org.dxos.script.gmail'],
 };

package/src/notebook/compute-graph.test.ts

@@ -2,16 +2,20 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Registry } from '@effect-atom/atom-react';
 import { describe, expect, test } from 'vitest';
 
-import { createNotebook } from '../testing';
+import { Obj } from '@dxos/echo';
+
+import { createNotebook } from '#testing';
 
 import { ComputeGraph } from './compute-graph';
 
 describe('notebook', () => {
   test('parse dependency graph', async () => {
+    const registry = Registry.make();
     const notebook = createNotebook();
-    const graph = new ComputeGraph(notebook);
+    const graph = new ComputeGraph(notebook, registry);
     const result = graph.parse();
 
     const getId = (i: number) => notebook.cells[i].id;
@@ -34,13 +38,17 @@ describe('notebook', () => {
   });
 
   test('evalScript blocks access to window and document', async () => {
+    const registry = Registry.make();
     const notebook = createNotebook();
     // Replace one of the cells with code that tries to access window/document.
-    if (notebook.cells[2].source?.target) {
-      notebook.cells[2].source.target.content = 'b = typeof window';
+    const sourceTarget = notebook.cells[2].source?.target;
+    if (sourceTarget) {
+      Obj.change(sourceTarget, (obj) => {
+        obj.content = 'b = typeof window';
+      });
     }
 
-    const graph = new ComputeGraph(notebook);
+    const graph = new ComputeGraph(notebook, registry);
     graph.parse();
     const values = await graph.evaluate();
 
@@ -48,8 +56,10 @@ describe('notebook', () => {
     expect(values[notebook.cells[2].id]).toBe('undefined');
 
     // Test document access.
-    if (notebook.cells[2].source?.target) {
-      notebook.cells[2].source.target.content = 'b = typeof document';
+    if (sourceTarget) {
+      Obj.change(sourceTarget, (obj) => {
+        obj.content = 'b = typeof document';
+      });
     }
     graph.parse();
     const values2 = await graph.evaluate();
@@ -58,8 +68,10 @@ describe('notebook', () => {
     expect(values2[notebook.cells[2].id]).toBe('undefined');
 
     // Test that safe globals still work.
-    if (notebook.cells[2].source?.target) {
-      notebook.cells[2].source.target.content = 'b = Math.max(100, 200)';
+    if (sourceTarget) {
+      Obj.change(sourceTarget, (obj) => {
+        obj.content = 'b = Math.max(100, 200)';
+      });
     }
     graph.parse();
     const values3 = await graph.evaluate();

package/src/notebook/compute-graph.ts

@@ -2,11 +2,11 @@
 // Copyright 2025 DXOS.org
 //
 
-import { type Signal, signal } from '@preact/signals-core';
+import { Atom, type Registry } from '@effect-atom/atom-react';
 
 import { log } from '@dxos/log';
 
-import { type Notebook } from '../types';
+import { type Notebook } from '#types';
 
 import { evalScript } from './eval';
 import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
@@ -18,38 +18,62 @@ import { type ParsedExpression, VirtualTypeScriptParser } from './vfs-parser';
 export class ComputeGraph {
   private readonly _parser = new VirtualTypeScriptParser();
 
-  private _expressions = signal<Record<string, ParsedExpression>>({});
-  private _valuesByCellId = signal<Record<string, any>>({});
-  private _valuesByName = signal<Record<string, any>>({});
+  private _expressionsAtom = Atom.make<Record<string, ParsedExpression>>({});
+  private _valuesByCellIdAtom = Atom.make<Record<string, any>>({});
+  private _valuesByNameAtom = Atom.make<Record<string, any>>({});
 
-  constructor(private readonly _notebook: Notebook.Notebook) {}
+  constructor(
+    private readonly _notebook: Notebook.Notebook,
+    private readonly _registry: Registry.Registry,
+  ) {}
 
   /**
-   * Parsed expressions by cell ID.
+   * Atom for parsed expressions by cell ID.
    */
-  get expressions(): Signal<Record<string, ParsedExpression>> {
-    return this._expressions;
+  get expressions(): Atom.Atom<Record<string, ParsedExpression>> {
+    return this._expressionsAtom;
   }
 
   /**
-   * Computed values by cell ID.
+   * Get current expressions by cell ID.
    */
-  get values(): Signal<Record<string, any>> {
-    return this._valuesByCellId;
+  getExpressions(): Record<string, ParsedExpression> {
+    return this._registry.get(this._expressionsAtom);
   }
 
   /**
-   * Computed values by name.
+   * Atom for computed values by cell ID.
    */
-  get valuesByName(): Signal<Record<string, any>> {
-    return this._valuesByName;
+  get values(): Atom.Atom<Record<string, any>> {
+    return this._valuesByCellIdAtom;
+  }
+
+  /**
+   * Get computed values by cell ID.
+   */
+  getValues(): Record<string, any> {
+    return this._registry.get(this._valuesByCellIdAtom);
+  }
+
+  /**
+   * Atom for computed values by name.
+   */
+  get valuesByName(): Atom.Atom<Record<string, any>> {
+    return this._valuesByNameAtom;
+  }
+
+  /**
+   * Get current values by name.
+   */
+  getValuesByName(): Record<string, any> {
+    return this._registry.get(this._valuesByNameAtom);
   }
 
   /**
    * Get computed value by cell ID.
    */
-  getValue(cellId: string) {
-    return this._valuesByCellId.value[cellId];
+  getValue(cellId: string): any {
+    return this._registry.get(this._valuesByCellIdAtom)[cellId];
   }
 
   /**
@@ -58,8 +82,8 @@ export class ComputeGraph {
   async evaluate() {
     // Parse expressions.
     const { expressions, dependencyGraph } = this.parse();
-    this._valuesByCellId.value = {};
-    this._valuesByName.value = {};
+    this._registry.set(this._valuesByCellIdAtom, {});
+    this._registry.set(this._valuesByNameAtom, {});
 
     // Create a map of cell IDs to expressions for easy lookup.
     const cellExpressions = new Map<string, ParsedExpression>();
@@ -124,8 +148,8 @@ export class ComputeGraph {
       }
     }
 
-    this._valuesByCellId.value = valuesByCellId;
-    this._valuesByName.value = valuesByName;
+    this._registry.set(this._valuesByCellIdAtom, valuesByCellId);
+    this._registry.set(this._valuesByNameAtom, valuesByName);
     return valuesByCellId;
   }
 
@@ -151,7 +175,7 @@ export class ComputeGraph {
 
     // Build dependency graph.
     const dependencyGraph = this.buildDependencyGraph(expressions);
-    this._expressions.value = expressions;
+    this._registry.set(this._expressionsAtom, expressions);
     return { expressions, dependencyGraph };
   }
 

package/src/operations/access-token-created.ts

@@ -0,0 +1,36 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+import * as Predicate from 'effect/Predicate';
+
+import { LayoutOperation } from '@dxos/app-toolkit';
+import { Operation } from '@dxos/operation';
+import { TokenManagerOperation } from '@dxos/plugin-token-manager/operations';
+
+import { DEPLOYMENT_DIALOG } from '../constants';
+import { defaultScriptsForIntegration } from '#meta';
+import { templates } from '../templates';
+
+const handler: Operation.WithHandler<typeof TokenManagerOperation.AccessTokenCreated> =
+  TokenManagerOperation.AccessTokenCreated.pipe(
+    Operation.withHandler(
+      Effect.fnUntraced(function* ({ accessToken }) {
+        const scriptTemplates = (defaultScriptsForIntegration[accessToken.source] ?? [])
+          .map((id) => templates.find((t) => t.id === id))
+          .filter(Predicate.isNotNullable);
+
+        if (scriptTemplates.length > 0) {
+          yield* Operation.invoke(LayoutOperation.UpdateDialog, {
+            subject: DEPLOYMENT_DIALOG,
+            blockAlign: 'start',
+            state: true,
+            props: { accessToken, scriptTemplates },
+          });
+        }
+      }),
+    ),
+  );
+
+export default handler;