@dxos/plugin-automation 0.8.4-main.7ace549 → 0.8.4-main.937b3ca

package/src/components/FunctionsRegistry/FunctionsRegistry.tsx

@@ -2,9 +2,6 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Array from 'effect/Array';
-import * as EffectFunction from 'effect/Function';
-import * as Order from 'effect/Order';
 import * as Schema from 'effect/Schema';
 import { useState } from 'react';
 import React, { useCallback } from 'react';
@@ -17,7 +14,7 @@ import { useAsyncEffect } from '@dxos/react-ui';
 import { IconButton, useTranslation } from '@dxos/react-ui';
 import { controlItemClasses } from '@dxos/react-ui-form';
 import { List } from '@dxos/react-ui-list';
-import { ghostHover, mx } from '@dxos/react-ui-theme';
+import { ghostHover, mx } from '@dxos/ui-theme';
 
 import { meta } from '../../meta';
 
@@ -33,7 +30,7 @@ export const FunctionsRegistry = ({ space }: FunctionsRegistryProps) => {
   const [functions, setFunctions] = useState<Function.Function[]>([]);
   const { t } = useTranslation(meta.id);
 
-  const dbFunctions = useQuery(space, Filter.type(Function.Function));
+  const dbFunctions = useQuery(space.db, Filter.type(Function.Function));
 
   const state = (func: Function.Function) => {
     const dbFunction = dbFunctions.find((f) => f.key === func.key);
@@ -48,24 +45,15 @@ export const FunctionsRegistry = ({ space }: FunctionsRegistryProps) => {
 
   useAsyncEffect(async () => {
     setLoading(true);
-    const functions = await getDeployedFunctions(client);
+    const functions = await getDeployedFunctions(client, true);
     setFunctions(functions);
     setLoading(false);
   }, []);
 
-  const dedupedFunctions = EffectFunction.pipe(
-    functions,
-    Array.filter((_) => _.key !== undefined),
-    Array.sort(Order.reverse(Order.mapInput(Order.string, (_: Function.Function) => _.updated ?? ''))),
-    Array.dedupeWith((self, that) => self.key === that.key),
-    Array.sort(Order.mapInput(Order.string, (_: Function.Function) => _.key ?? '')),
-  );
-
   const hanleImportOrUpdate = useCallback(
     async (func: Function.Function) => {
-      const {
-        objects: [existingFunc],
-      } = await space.db.query(Query.type(Function.Function, { key: func.key })).run();
+      const functions = await space.db.query(Query.type(Function.Function, { key: func.key })).run();
+      const [existingFunc] = functions;
       if (!existingFunc) {
         space.db.add(func);
         return;
@@ -77,12 +65,8 @@ export const FunctionsRegistry = ({ space }: FunctionsRegistryProps) => {
 
   return (
     <div role='none' className={mx(controlItemClasses)}>
-      {dedupedFunctions.length > 0 && (
-        <List.Root<Function.Function>
-          items={dedupedFunctions}
-          isItem={Schema.is(Function.Function)}
-          getId={(func) => func.id}
-        >
+      {functions.length > 0 && (
+        <List.Root<Function.Function> items={functions} isItem={Schema.is(Function.Function)} getId={(func) => func.id}>
           {({ items }) => (
             <div role='list' className='flex flex-col is-full'>
               {items?.map((func) => (
@@ -118,7 +102,7 @@ export const FunctionsRegistry = ({ space }: FunctionsRegistryProps) => {
         </List.Root>
       )}
 
-      {dedupedFunctions.length === 0 && !loading && (
+      {functions.length === 0 && !loading && (
         <div className='text-center plb-4 text-gray-500'>{t('no functions found')}</div>
       )}
       {loading && <div className='text-center plb-4 text-gray-500'>{t('loading functions')}</div>}

package/src/components/TriggerEditor/FunctionInputEditor.tsx

@@ -2,29 +2,26 @@
 // Copyright 2025 DXOS.org
 //
 
+import type * as SchemaAST from 'effect/SchemaAST';
 import React, { useCallback, useMemo } from 'react';
 
-import { Ref, Type } from '@dxos/echo';
+import { type Database, Ref, Type } from '@dxos/echo';
 import { type JsonPath } from '@dxos/echo/internal';
 import { type Function } from '@dxos/functions';
-import { useOnTransition } from '@dxos/react-ui';
-import { Form, type FormInputStateProps, type QueryRefOptions, useFormValues } from '@dxos/react-ui-form';
+import { useOnTransition, useTranslation } from '@dxos/react-ui';
+import { Form, type FormFieldStateProps, type FormRootProps, useFormValues } from '@dxos/react-ui-form';
+
+import { meta } from '../../meta';
 
 export type FunctionInputEditorProps = {
+  type: SchemaAST.AST;
   functions: Function.Function[];
-  onQueryRefOptions: QueryRefOptions;
-} & FormInputStateProps;
+  db?: Database.Database;
+} & FormFieldStateProps;
 
-/**
- * Editor component for function input parameters.
- */
-export const FunctionInputEditor = ({
-  functions,
-  getValue,
-  onValueChange,
-  onQueryRefOptions,
-}: FunctionInputEditorProps) => {
-  const selectedFunctionValue = useFormValues(['function' as JsonPath]);
+export const FunctionInputEditor = ({ type, functions, db, getValue, onValueChange }: FunctionInputEditorProps) => {
+  const { t } = useTranslation(meta.id);
+  const selectedFunctionValue = useFormValues(FunctionInputEditor.displayName, ['function' as JsonPath]);
   const selectedFunctionId = useMemo(() => {
     if (Ref.isRef(selectedFunctionValue)) {
       return selectedFunctionValue.dxn.toString().split('dxn:echo:@:').at(1);
@@ -47,20 +44,19 @@ export const FunctionInputEditor = ({
       return prevValue.dxn.toString() !== selectedFunctionValue.dxn.toString();
     },
     (currValue) => currValue !== undefined,
-    () => onValueChange('object', {}),
+    () => onValueChange(type, {}),
   );
 
   const inputSchema = useMemo(() => selectedFunction?.inputSchema, [selectedFunction]);
   const effectSchema = useMemo(() => (inputSchema ? Type.toEffectSchema(inputSchema) : undefined), [inputSchema]);
   const propertyCount = inputSchema?.properties ? Object.keys(inputSchema.properties).length : 0;
-
   const values = useMemo(() => getValue() ?? {}, [getValue]);
 
-  const handleValuesChanged = useCallback(
-    (values: any) => {
-      onValueChange('object', values);
+  const handleValuesChanged = useCallback<NonNullable<FormRootProps['onValuesChanged']>>(
+    (values) => {
+      onValueChange(type, values);
     },
-    [onValueChange],
+    [type, onValueChange],
   );
 
   if (selectedFunction === undefined || effectSchema === undefined || propertyCount === 0) {
@@ -69,16 +65,12 @@ export const FunctionInputEditor = ({
 
   return (
     <>
-      <h3 className='text-md'>Function parameters</h3>
-      {/* TODO(ZaymonFC): Try using <FormFields /> internal component for this nesting.
-                          This would allow errors to flow up to the root context. */}
-      <Form
-        schema={effectSchema}
-        values={values}
-        onValuesChanged={handleValuesChanged}
-        onQueryRefOptions={onQueryRefOptions}
-        outerSpacing={false}
-      />
+      <Form.Label label={t('function parameters label')} asChild />
+      <Form.Root schema={effectSchema} values={values} db={db} onValuesChanged={handleValuesChanged}>
+        <Form.FieldSet />
+      </Form.Root>
     </>
   );
 };
+
+FunctionInputEditor.displayName = 'AutomationTrigger.FunctionInputEditor';

package/src/components/TriggerEditor/SpecSelector.tsx

@@ -7,15 +7,15 @@ import React, { useCallback, useMemo } from 'react';
 import { Filter, Query } from '@dxos/echo';
 import { Trigger } from '@dxos/functions';
 import { useTranslation } from '@dxos/react-ui';
-import { type InputProps, SelectInput, useInputProps } from '@dxos/react-ui-form';
+import { type FormFieldComponentProps, SelectField, useFormFieldState } from '@dxos/react-ui-form';
 
 import { meta } from '../../meta';
 
-export type SpecSelectorProps = InputProps;
+export type SpecSelectorProps = FormFieldComponentProps;
 
 export const SpecSelector = (props: SpecSelectorProps) => {
   const { t } = useTranslation(meta.id);
-  const specProps = useInputProps(['spec' satisfies keyof Trigger.Trigger]);
+  const specProps = useFormFieldState(SpecSelector.displayName, ['spec' satisfies keyof Trigger.Trigger]);
 
   const handleTypeChange = useCallback(
     (_type: any, value: string): Trigger.Spec | undefined => {
@@ -47,9 +47,9 @@ export const SpecSelector = (props: SpecSelectorProps) => {
       }
 
       // Update the entire spec object, not just the `spec.kind`.
-      specProps.onValueChange('object', defaultSpec);
+      specProps.onValueChange(props.type, defaultSpec);
     },
-    [specProps],
+    [props.type, specProps],
   );
 
   const options = useMemo(
@@ -61,5 +61,7 @@ export const SpecSelector = (props: SpecSelectorProps) => {
     [t],
   );
 
-  return <SelectInput {...props} options={options} onValueChange={handleTypeChange} />;
+  return <SelectField {...props} options={options} onValueChange={handleTypeChange} />;
 };
+
+SpecSelector.displayName = 'Form.SpecSelector';

package/src/components/TriggerEditor/TriggerEditor.stories.tsx

@@ -6,14 +6,14 @@ import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useState } from 'react';
 
 import { Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
-import { Function } from '@dxos/functions';
-import { Trigger } from '@dxos/functions';
+import { Function, Trigger } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
 import { faker } from '@dxos/random';
 import { useQuery } from '@dxos/react-client/echo';
-import { TestSchema, useClientProvider, withClientProvider } from '@dxos/react-client/testing';
+import { TestSchema, useClientStory, withClientProvider } from '@dxos/react-client/testing';
 import { useAsyncEffect } from '@dxos/react-ui';
 import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { translations as formTranslations } from '@dxos/react-ui-form';
 import { Employer, Organization, Person, Project } from '@dxos/types';
 
 import { functions } from '../../testing';
@@ -30,17 +30,17 @@ const types = [
 ];
 
 const DefaultStory = (props: Partial<TriggerEditorProps>) => {
-  const { space } = useClientProvider();
+  const { space } = useClientStory();
   const [trigger, setTrigger] = useState<Trigger.Trigger>();
-  const tags = useQuery(space, Filter.type(Tag.Tag));
+  const tags = useQuery(space?.db, Filter.type(Tag.Tag));
 
   useAsyncEffect(async () => {
     if (!space) {
       return;
     }
 
-    const result = await space.db.query(Filter.type(Function.Function)).run();
-    const fn = result.objects.find((fn) => fn.name === 'example.com/function/forex');
+    const functions = await space.db.query(Filter.type(Function.Function)).run();
+    const fn = functions.find((fn) => fn.name === 'example.com/function/forex');
     invariant(fn);
     const trigger = space.db.add(
       Trigger.make({
@@ -60,16 +60,14 @@ const DefaultStory = (props: Partial<TriggerEditorProps>) => {
   }
 
   return (
-    <div role='none' className='is-[32rem] bs-fit border border-separator rounded-sm'>
-      <TriggerEditor
-        space={space}
-        trigger={trigger}
-        types={types}
-        tags={tags}
-        onSave={(values) => console.log('on save', values)}
-        {...props}
-      />
-    </div>
+    <TriggerEditor
+      db={space.db}
+      trigger={trigger}
+      types={types}
+      tags={tags}
+      onSave={(values) => console.log('on save', values)}
+      {...props}
+    />
   );
 };
 
@@ -79,19 +77,23 @@ const meta = {
   render: DefaultStory,
   decorators: [
     withTheme,
-    withLayout({ container: 'column' }),
+    withLayout({ layout: 'column' }),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
       types: [Tag.Tag, Function.Function, Trigger.Trigger, TestSchema.ContactType],
       onCreateSpace: ({ space }) => {
-        space.db.add(Tag.make({ label: 'Important' }));
-        space.db.add(Tag.make({ label: 'Investor' }));
-        space.db.add(Tag.make({ label: 'New' }));
+        // Tags.
+        ['Important', 'Investor', 'New'].forEach((label) => {
+          space.db.add(Tag.make({ label }));
+        });
 
-        for (const fn of functions) {
+        // Functions.
+        functions.forEach((fn) => {
           space.db.add(Function.make(fn));
-        }
+        });
+
+        // Objects.
         Array.from({ length: 10 }).map(() => {
           return space.db.add(
             Obj.make(TestSchema.ContactType, {
@@ -104,7 +106,8 @@ const meta = {
     }),
   ],
   parameters: {
-    translations,
+    layout: 'fullscreen',
+    translations: [...formTranslations, ...translations],
   },
 } satisfies Meta<typeof DefaultStory>;
 

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -5,59 +5,74 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { ComputeGraph } from '@dxos/conductor';
-import { DXN, type Query } from '@dxos/echo';
+import { DXN, type Database, type Query } from '@dxos/echo';
 import { Function, Script, Trigger } from '@dxos/functions';
-import { Filter, Ref, type Space, useQuery } from '@dxos/react-client/echo';
+import { Filter, Ref, useQuery } from '@dxos/react-client/echo';
 import { Input } from '@dxos/react-ui';
 import { QueryForm, type QueryFormProps } from '@dxos/react-ui-components';
-import { type CustomInputMap, Form, InputHeader, SelectInput, useRefQueryLookupHandler } from '@dxos/react-ui-form';
-
-import { FunctionInputEditor, type FunctionInputEditorProps } from './FunctionInputEditor';
+import {
+  type ExcludeId,
+  Form,
+  FormFieldLabel,
+  type FormFieldMap,
+  type FormRootProps,
+  SelectField,
+  omitId,
+} from '@dxos/react-ui-form';
+
+import { FunctionInputEditor } from './FunctionInputEditor';
 import { SpecSelector } from './SpecSelector';
 
+type TriggerFormSchema = ExcludeId<typeof Trigger.Trigger>;
+
 export type TriggerEditorProps = {
-  space: Space;
+  db: Database.Database;
   trigger: Trigger.Trigger;
   // TODO(wittjosiah): This needs to apply to whole spec but currently only applies to spec.kind & spec.query.
   readonlySpec?: boolean;
-  onSave?: (trigger: Omit<Trigger.Trigger, 'id'>) => void;
-  onCancel?: () => void;
-} & Pick<QueryFormProps, 'types' | 'tags'>;
-
-export const TriggerEditor = ({ space, trigger, readonlySpec, types, tags, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = ({ id: _, ...values }: Trigger.Trigger) => {
-    onSave?.(values);
-  };
-
-  const handleRefQueryLookup = useRefQueryLookupHandler({ space });
-  const Custom = useCustomInputs({ space, readonlySpec, types, tags, onQueryRefOptions: handleRefQueryLookup });
+} &
+  // prettier-ignore
+  Pick<QueryFormProps, 'types' | 'tags'> &
+  Pick<FormRootProps<TriggerFormSchema>, 'onSave' | 'onCancel'>;
+
+export const TriggerEditor = ({ db, types, tags, readonlySpec, trigger, ...formProps }: TriggerEditorProps) => {
+  const fieldMap = useCustomInputs({
+    db,
+    types,
+    tags,
+    readonlySpec,
+  });
 
   return (
-    <Form
-      outerSpacing={false}
-      Custom={Custom}
-      schema={Trigger.Trigger}
+    <Form.Root<TriggerFormSchema>
+      {...formProps}
+      schema={omitId(Trigger.Trigger)}
       values={trigger}
-      onSave={handleSave}
-      onCancel={onCancel}
-      onQueryRefOptions={handleRefQueryLookup}
-    />
+      db={db}
+      fieldMap={fieldMap}
+    >
+      <Form.Viewport>
+        <Form.Content>
+          <Form.FieldSet />
+          <Form.Actions />
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
   );
 };
 
 type UseCustomInputsProps = {
-  space: Space;
+  db: Database.Database;
   readonlySpec?: boolean;
-  onQueryRefOptions: FunctionInputEditorProps['onQueryRefOptions'];
 } & Pick<QueryFormProps, 'types' | 'tags'>;
 
-const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }: UseCustomInputsProps) => {
-  const functions = useQuery(space, Filter.type(Function.Function));
-  const workflows = useQuery(space, Filter.type(ComputeGraph));
-  const scripts = useQuery(space, Filter.type(Script.Script));
+const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps): FormFieldMap => {
+  const functions = useQuery(db, Filter.type(Function.Function));
+  const workflows = useQuery(db, Filter.type(ComputeGraph));
+  const scripts = useQuery(db, Filter.type(Script.Script));
 
   return useMemo(
-    (): CustomInputMap => ({
+    (): FormFieldMap => ({
       // Function selector.
       ['function' satisfies keyof Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
@@ -73,14 +88,14 @@ const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }
             const dxn = DXN.parse(dxnString);
             if (dxn) {
               const ref = Ref.fromDXN(dxn);
-              props.onValueChange('object', ref);
+              props.onValueChange(props.type, ref);
             }
           },
-          [props.onValueChange],
+          [props.type, props.onValueChange],
         );
 
         return (
-          <SelectInput
+          <SelectField
             {...props}
             getValue={getValue as any}
             onValueChange={handleOnValueChange}
@@ -90,28 +105,26 @@ const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }
       },
 
       // Spec selector.
-      ['spec.kind' as const]: (props) => <SpecSelector {...props} readonly={readonlySpec ? 'disabled-input' : false} />,
+      ['spec.kind' as const]: (props) => <SpecSelector {...props} readonly={readonlySpec} />,
 
       // TODO(wittjosiah): Copied from ViewEditor.
       // Query input editor.
       ['spec.query' as const]: (props) => {
         const handleChange = useCallback(
-          (query: Query.Any) => props.onValueChange('object', { ast: query.ast }),
-          [props.onValueChange],
+          (query: Query.Any) => props.onValueChange(props.type, { ast: query.ast }),
+          [props.type, props.onValueChange],
         );
 
         return (
           <Input.Root>
-            <InputHeader label={props.label} />
+            <FormFieldLabel label={props.label} asChild />
             <QueryForm initialQuery={(props.getValue() as any).ast} types={types} tags={tags} onChange={handleChange} />
           </Input.Root>
         );
       },
 
       // Function input editor.
-      ['input' as const]: (props) => (
-        <FunctionInputEditor {...props} functions={functions} onQueryRefOptions={onQueryRefOptions} />
-      ),
+      ['input' as const]: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
     }),
     [workflows, scripts, functions, readonlySpec],
   );

package/src/components/TriggerSettings.tsx

@@ -4,15 +4,15 @@
 
 import React from 'react';
 
-import { type Space } from '@dxos/react-client/echo';
+import { type Database } from '@dxos/echo';
 import { Input, useTranslation } from '@dxos/react-ui';
 import { ControlItemInput } from '@dxos/react-ui-form';
 
 import { useTriggerRuntimeControls } from '../hooks';
 import { meta } from '../meta';
 
-export const TriggersSettings = ({ space }: { space: Space }) => {
-  const { triggers, isRunning, start, stop } = useTriggerRuntimeControls(space);
+export const TriggersSettings = ({ db }: { db: Database.Database }) => {
+  const { triggers, isRunning, start, stop } = useTriggerRuntimeControls(db);
   const { t } = useTranslation(meta.id);
 
   return (

package/src/hooks/useComputeRuntimeCallback.ts

@@ -5,27 +5,26 @@
 import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
 import * as Exit from 'effect/Exit';
-import { useCallback } from 'react';
+import { type DependencyList, useCallback } from 'react';
 
 import { useCapability } from '@dxos/app-framework/react';
-import { type FunctionDefinition, FunctionInvocationService } from '@dxos/functions';
-import { InvocationTracer, TracingServiceExt } from '@dxos/functions-runtime';
+import { type Key } from '@dxos/echo';
+import { type FunctionDefinition, FunctionInvocationService, TracingService } from '@dxos/functions';
 import { log } from '@dxos/log';
-import type { Space } from '@dxos/react-client/echo';
 
-import { AutomationCapabilities } from '../capabilities';
+import { AutomationCapabilities } from '../types';
 
 /**
  * Create an effectful function that has access to compute services
  */
 // TODO(burdon): Factor out (figure out cross-plugin capabilities dependencies).
 export const useComputeRuntimeCallback = <T>(
-  space: Space | undefined,
+  id: Key.SpaceId | undefined,
   fn: () => Effect.Effect<T, any, AutomationCapabilities.ComputeServices>,
-  deps?: React.DependencyList,
+  deps?: DependencyList,
 ): (() => Promise<T>) => {
   const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
-  const runtime = space !== undefined ? computeRuntime.getRuntime(space.id) : undefined;
+  const runtime = id !== undefined ? computeRuntime.getRuntime(id) : undefined;
 
   return useCallback(() => {
     if (!runtime) {
@@ -39,7 +38,7 @@ export const useComputeRuntimeCallback = <T>(
 // TODO(wittjosiah): Function invoking should automatically be traced (DX-647).
 export const invokeFunctionWithTracing = <I, O>(functionDef: FunctionDefinition<I, O>, inputData: I) =>
   Effect.gen(function* () {
-    const tracer = yield* InvocationTracer;
+    const tracer = yield* TracingService;
     const trace = yield* tracer.traceInvocationStart({
       target: undefined,
       payload: {
@@ -49,7 +48,7 @@ export const invokeFunctionWithTracing = <I, O>(functionDef: FunctionDefinition<
 
     // Invoke the function.
     const result = yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(
-      Effect.provide(TracingServiceExt.layerQueue(trace.invocationTraceQueue)),
+      Effect.provide(trace.invocationTraceQueue ? TracingService.layerInvocation(trace) : TracingService.layerNoop),
       Effect.exit,
     );
 

package/src/hooks/useTriggerRuntimeControls.ts

@@ -4,10 +4,10 @@
 
 import * as Effect from 'effect/Effect';
 
-import { Filter } from '@dxos/echo';
+import { type Database, Filter } from '@dxos/echo';
 import { Trigger } from '@dxos/functions';
 import { TriggerDispatcher } from '@dxos/functions-runtime';
-import { type Space, useQuery } from '@dxos/react-client/echo';
+import { useQuery } from '@dxos/react-client/echo';
 import { useAsyncState } from '@dxos/react-ui';
 
 import { useComputeRuntimeCallback } from './useComputeRuntimeCallback';
@@ -19,15 +19,15 @@ interface TriggerRuntimeControls {
   stop: () => void;
 }
 
-export const useTriggerRuntimeControls = (space: Space | undefined): TriggerRuntimeControls => {
-  const triggers = useQuery(space, Filter.type(Trigger.Trigger));
+export const useTriggerRuntimeControls = (db: Database.Database | undefined): TriggerRuntimeControls => {
+  const triggers = useQuery(db, Filter.type(Trigger.Trigger));
 
   const [isRunningState, setIsRunningState] = useAsyncState(
-    useComputeRuntimeCallback(space, () => TriggerDispatcher.pipe(Effect.map((t) => t.running))),
+    useComputeRuntimeCallback(db?.spaceId, () => TriggerDispatcher.pipe(Effect.map((t) => t.running))),
   );
 
   const start = useComputeRuntimeCallback(
-    space,
+    db?.spaceId,
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.start();
@@ -36,7 +36,7 @@ export const useTriggerRuntimeControls = (space: Space | undefined): TriggerRunt
   );
 
   const stop = useComputeRuntimeCallback(
-    space,
+    db?.spaceId,
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.stop();

package/src/index.ts

@@ -2,10 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-export { AutomationCapabilities } from './capabilities';
 export * from './components';
 export * from './meta';
-export * from './events';
 export * from './hooks';
+export * from './types';
 
 export * from './AutomationPlugin';

package/src/meta.ts

@@ -2,10 +2,10 @@
 // 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 = {
+export const meta: Plugin.Meta = {
   id: 'dxos.org/plugin/automation',
   name: 'Automation',
   description: trim`

package/src/translations.ts

@@ -30,6 +30,8 @@ export const translations = [
         'go to function source button label': 'Show function source',
         'delete function button label': 'Delete function',
 
+        'function parameters label': 'Function parameters',
+
         'trigger editor title': 'Configure Trigger',
         'new trigger label': 'Add Trigger',
         'trigger type timer': 'Timer',