@dxos/plugin-automation 0.8.4-main.f9ba587 → 0.8.4-main.fcc0d83b33

package/src/components/FunctionsRegistry/index.ts

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

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 JsonPath } from '@dxos/echo-schema';
-import { type FunctionType } from '@dxos/functions';
-import { useOnTransition } from '@dxos/react-ui';
-import { Form, type FormInputStateProps, type QueryRefOptions, useFormValues } from '@dxos/react-ui-form';
+import { type Database, JsonSchema, Obj, Ref } from '@dxos/echo';
+import { type JsonPath } from '@dxos/echo/internal';
+import { type Operation } from '@dxos/operation';
+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 = {
-  functions: FunctionType[];
-  onQueryRefOptions: QueryRefOptions;
-} & FormInputStateProps;
+  type: SchemaAST.AST;
+  functions: Operation.PersistentOperation[];
+  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);
@@ -39,22 +36,30 @@ export const FunctionInputEditor = ({
   useOnTransition(
     // Clear function parameter input when the function changes.
     selectedFunctionValue,
-    (prevValue) => prevValue !== undefined && prevValue !== selectedFunctionValue,
+    (prevValue) => {
+      if (!Ref.isRef(prevValue) || !Ref.isRef(selectedFunctionValue)) {
+        return false;
+      }
+
+      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 effectSchema = useMemo(() => (inputSchema ? JsonSchema.toEffectSchema(inputSchema) : undefined), [inputSchema]);
   const propertyCount = inputSchema?.properties ? Object.keys(inputSchema.properties).length : 0;
+  const defaultValues = useMemo(() => {
+    const raw = getValue() ?? {};
+    return Obj.isObject(raw) ? { ...Obj.getSnapshot(raw) } : { ...raw };
+  }, [getValue]);
 
-  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) {
@@ -63,16 +68,18 @@ 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
+      <Form.Label label={t('function-parameters.label')} asChild />
+      <Form.Root
+        key={selectedFunction.id}
         schema={effectSchema}
-        values={values}
+        defaultValues={defaultValues}
+        db={db}
         onValuesChanged={handleValuesChanged}
-        onQueryRefOptions={onQueryRefOptions}
-        outerSpacing={false}
-      />
+      >
+        <Form.FieldSet />
+      </Form.Root>
     </>
   );
 };
+
+FunctionInputEditor.displayName = 'AutomationTrigger.FunctionInputEditor';

package/src/components/TriggerEditor/SpecSelector.tsx

@@ -4,32 +4,33 @@
 
 import React, { useCallback, useMemo } from 'react';
 
-import { type FunctionTriggerType, TriggerKind, type TriggerType } from '@dxos/functions';
+import { Filter, Query } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
 import { useTranslation } from '@dxos/react-ui';
-import { SelectInput, type InputProps, useInputProps } from '@dxos/react-ui-form';
+import { type FormFieldComponentProps, SelectField, useFormFieldState } from '@dxos/react-ui-form';
 
-import { AUTOMATION_PLUGIN } from '../../meta';
+import { meta } from '#meta';
 
-export type SpecSelectorProps = InputProps;
+export type SpecSelectorProps = FormFieldComponentProps;
 
 export const SpecSelector = (props: SpecSelectorProps) => {
-  const { t } = useTranslation(AUTOMATION_PLUGIN);
-  const specProps = useInputProps(['spec' satisfies keyof FunctionTriggerType]);
+  const { t } = useTranslation(meta.id);
+  const specProps = useFormFieldState(SpecSelector.displayName, ['spec' satisfies keyof Trigger.Trigger]);
 
   const handleTypeChange = useCallback(
-    (_type: any, value: string): TriggerType | undefined => {
+    (_type: any, value: string): Trigger.Spec | undefined => {
       const getDefaultTriggerSpec = (kind: string) => {
         switch (kind) {
-          case TriggerKind.Timer:
-            return { kind: TriggerKind.Timer, cron: '' };
-          case TriggerKind.Subscription:
-            return { kind: TriggerKind.Subscription, filter: {} };
-          case TriggerKind.Queue:
-            return { kind: TriggerKind.Queue, queue: '' };
-          case TriggerKind.Email:
-            return { kind: TriggerKind.Email };
-          case TriggerKind.Webhook:
-            return { kind: TriggerKind.Webhook };
+          case 'timer':
+            return Trigger.specTimer('');
+          case 'subscription':
+            return Trigger.specSubscription(Query.select(Filter.nothing()));
+          case 'queue':
+            return Trigger.specQueue('dxn:queue:default');
+          case 'email':
+            return Trigger.specEmail();
+          case 'webhook':
+            return Trigger.specWebhook();
           default:
             return undefined;
         }
@@ -41,19 +42,30 @@ 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 kindLabels: Record<string, string> = {
+    timer: t('trigger-type.timer.label'),
+    webhook: t('trigger-type.webhook.label'),
+    websocket: t('trigger-type.websocket.label'),
+    subscription: t('trigger-type.subscription.label'),
+    email: t('trigger-type.email.label'),
+    queue: t('trigger-type.queue.label'),
+  };
+
   const options = useMemo(
     () =>
-      Object.values(TriggerKind).map((kind) => ({
+      Trigger.Kinds.map((kind) => ({
         value: kind,
-        label: t(`trigger type ${kind}`),
+        label: kindLabels[kind],
       })),
     [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

@@ -2,32 +2,58 @@
 // Copyright 2025 DXOS.org
 //
 
-import '@dxos-theme';
-
-import { type Meta } from '@storybook/react-vite';
-import React, { useEffect, useState } from 'react';
-
-import { Obj } from '@dxos/echo';
-import { FunctionType, FunctionTrigger, TriggerKind } from '@dxos/functions';
-import { faker } from '@dxos/random';
-import { useSpaces } from '@dxos/react-client/echo';
-import { ContactType, withClientProvider } from '@dxos/react-client/testing';
-import { withLayout, withTheme } from '@dxos/storybook-utils';
-
-import { TriggerEditor } from './TriggerEditor';
-import { functions } from '../../testing';
-import { translations } from '../../translations';
-
-const DefaultStory = () => {
-  const spaces = useSpaces();
-  const space = spaces[1];
-  const [trigger, setTrigger] = useState<FunctionTrigger>();
-  useEffect(() => {
+import { type Meta, type StoryObj } from '@storybook/react-vite';
+import React, { useState } from 'react';
+import { expect, userEvent, within } from 'storybook/test';
+
+import { Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
+import { Trigger } from '@dxos/functions';
+import { invariant } from '@dxos/invariant';
+import { Operation } from '@dxos/operation';
+import { random } from '@dxos/random';
+import { useQuery } from '@dxos/react-client/echo';
+import { TestSchema, useClientStory, withClientProvider } from '@dxos/react-client/testing';
+import { useAsyncEffect } from '@dxos/react-ui';
+import { translations as formTranslations } from '@dxos/react-ui-form/translations';
+import { withLayout, withTheme } from '@dxos/react-ui/testing';
+import { Employer, Organization, Person, Pipeline } from '@dxos/types';
+
+import { functions } from '#testing';
+import { translations } from '#translations';
+
+import { TriggerEditor, type TriggerEditorProps } from './TriggerEditor';
+
+const types = [
+  // TODO(burdon): Get label from annotation.
+  { value: Organization.Organization.typename, label: 'Organization' },
+  { value: Person.Person.typename, label: 'Person' },
+  { value: Type.getTypename(Pipeline.Pipeline), label: 'Project' },
+  { value: Employer.Employer.typename, label: 'Employer' },
+];
+
+const DefaultStory = (props: Partial<TriggerEditorProps>) => {
+  const { space } = useClientStory();
+  const [trigger, setTrigger] = useState<Trigger.Trigger>();
+  const tags = useQuery(space?.db, Filter.type(Tag.Tag));
+
+  useAsyncEffect(async () => {
     if (!space) {
       return;
     }
 
-    const trigger = space.db.add(Obj.make(FunctionTrigger, { spec: { kind: TriggerKind.Timer, cron: '' } }));
+    const functions = await space.db.query(Filter.type(Operation.PersistentOperation)).run();
+    const fn = functions.find((fn) => fn.name === 'example.com/function/forex');
+    invariant(fn);
+    const trigger = space.db.add(
+      Trigger.make({
+        function: Ref.make(fn),
+        spec: Trigger.specWebhook(),
+        input: {
+          from: 'USD',
+          to: 'JPY',
+        },
+      }),
+    );
     setTrigger(trigger);
   }, [space]);
 
@@ -36,43 +62,106 @@ const DefaultStory = () => {
   }
 
   return (
-    <div role='none' className='w-[32rem] bs-fit border border-separator rounded-sm'>
-      <TriggerEditor space={space} trigger={trigger} onSave={(values) => console.log('on save', values)} />
-    </div>
+    <TriggerEditor
+      db={space.db}
+      trigger={trigger}
+      types={types}
+      tags={tags}
+      onSave={(values) => console.log('on save', values)}
+      {...props}
+    />
   );
 };
 
-const meta: Meta = {
-  title: 'plugins/plugin-automation/TriggerEditor',
-  component: TriggerEditor,
+const meta = {
+  title: 'plugins/plugin-automation/components/TriggerEditor',
+  component: TriggerEditor as any,
   render: DefaultStory,
   decorators: [
+    withTheme(),
+    withLayout({ layout: 'column' }),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [FunctionType, FunctionTrigger, ContactType],
-      onSpaceCreated: ({ space }) => {
-        for (const fn of functions) {
-          space.db.add(Obj.make(FunctionType, fn));
-        }
+      types: [Tag.Tag, Operation.PersistentOperation, Trigger.Trigger, TestSchema.ContactType],
+      onCreateSpace: ({ space }) => {
+        // Tags.
+        ['Important', 'Investor', 'New'].forEach((label) => {
+          space.db.add(Tag.make({ label }));
+        });
+
+        // Functions.
+        functions.forEach((fn) => {
+          space.db.add(Obj.make(Operation.PersistentOperation, { ...fn, version: fn.version ?? '0.1.0' }));
+        });
+
+        // Objects.
         Array.from({ length: 10 }).map(() => {
           return space.db.add(
-            Obj.make(ContactType, {
-              name: faker.person.fullName(),
+            Obj.make(TestSchema.ContactType, {
+              name: random.person.fullName(),
               identifiers: [],
             }),
           );
         });
       },
     }),
-    withLayout({ fullscreen: true, classNames: 'flex justify-center m-2' }),
-    withTheme,
   ],
   parameters: {
-    translations,
+    layout: 'fullscreen',
+    translations: [...formTranslations, ...translations],
   },
-};
+} satisfies Meta<typeof DefaultStory>;
 
 export default meta;
 
-export const Default = {};
+type Story = StoryObj<typeof meta>;
+
+export const Default: Story = {};
+
+export const ReadonlySpec: Story = {
+  args: {
+    readonlySpec: true,
+  },
+};
+
+export const Spec: Story = {
+  play: async ({ canvasElement }) => {
+    const canvas = within(canvasElement);
+    const webhookText = await canvas.findByText('Webhook', {}, { timeout: 10_000 });
+    const combobox = webhookText.closest('[role="combobox"]') as HTMLElement;
+    await expect(combobox).not.toBeDisabled();
+
+    // Helper to switch to a kind via keyboard.
+    // TODO(wittjosiah): Radix Select in popper mode doesn't close on click.
+    //   Use keyboard navigation: open, type first letter to jump, Enter to select.
+    const selectKind = async (combobox: HTMLElement, firstLetter: string) => {
+      combobox.focus();
+      await userEvent.keyboard('{Enter}');
+      await userEvent.keyboard(firstLetter);
+      await userEvent.keyboard('{Enter}');
+    };
+
+    // Timer — should show "Cron" field.
+    await selectKind(combobox, 't');
+    await expect(canvas.findByLabelText('Cron')).resolves.toBeInTheDocument();
+
+    // Email — no extra fields; Cron should be gone.
+    await selectKind(combobox, 'e');
+    await expect(combobox).not.toBeDisabled();
+    await expect(canvas.queryByLabelText('Cron')).not.toBeInTheDocument();
+
+    // Webhook — should show "Method" field.
+    await selectKind(combobox, 'w');
+    await expect(canvas.findByLabelText('Method')).resolves.toBeInTheDocument();
+
+    // Subscription — should show query editor.
+    await selectKind(combobox, 's');
+    await expect(combobox).not.toBeDisabled();
+    await expect(canvas.queryByLabelText('Method')).not.toBeInTheDocument();
+
+    // Feed — should show DXN field (the queue address). DXN is a combobox, not an input, so use getByText.
+    await selectKind(combobox, 'f');
+    await expect(canvas.findByText('DXN')).resolves.toBeInTheDocument();
+  },
+};

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -5,57 +5,89 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { ComputeGraph } from '@dxos/conductor';
-import { Type } from '@dxos/echo';
+import { DXN, type Database, Entity, Feed, Obj, type Query } from '@dxos/echo';
+import { Script, Trigger } from '@dxos/functions';
+import { Operation } from '@dxos/operation';
+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 {
-  FunctionType,
-  FunctionTriggerSchema,
-  type FunctionTriggerType,
-  type FunctionTrigger,
-  ScriptType,
-} from '@dxos/functions';
-import { Filter, Ref, useQuery, type Space } from '@dxos/react-client/echo';
-import { type CustomInputMap, Form, SelectInput, useRefQueryLookupHandler } from '@dxos/react-ui-form';
-
-import { FunctionInputEditor, type FunctionInputEditorProps } from './FunctionInputEditor';
+  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;
-  trigger: FunctionTriggerType;
-  onSave?: (trigger: Omit<FunctionTrigger, 'id'>) => void;
-  onCancel?: () => void;
-};
+  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;
+} &
+  // 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 });
 
-export const TriggerEditor = ({ space, trigger, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = (values: FunctionTriggerType) => {
-    onSave?.(values);
-  };
+  const handleValuesChanged = useCallback(
+    (newValues: Partial<TriggerFormSchema>) => {
+      Obj.update(trigger, (trigger) => {
+        Object.assign(trigger, newValues);
+      });
+    },
+    [trigger],
+  );
 
-  const handleRefQueryLookup = useRefQueryLookupHandler({ space });
-  const Custom = useCustomInputs(space, handleRefQueryLookup);
+  const triggerSchema = useMemo(() => omitId(Trigger.Trigger), []);
+  const defaultValues = useMemo(() => {
+    const { id: _, ...values } = trigger;
+    return values;
+  }, [trigger]);
 
   return (
-    <Form
-      outerSpacing={false}
-      Custom={Custom}
-      schema={FunctionTriggerSchema}
-      values={trigger}
-      onSave={handleSave}
-      onCancel={onCancel}
-      onQueryRefOptions={handleRefQueryLookup}
-    />
+    <Form.Root<TriggerFormSchema>
+      {...formProps}
+      db={db}
+      schema={triggerSchema}
+      defaultValues={defaultValues}
+      fieldMap={fieldMap}
+      onValuesChanged={handleValuesChanged}
+    >
+      <Form.Viewport>
+        <Form.Content>
+          <Form.FieldSet />
+          <Form.Actions />
+        </Form.Content>
+      </Form.Viewport>
+    </Form.Root>
   );
 };
 
-const useCustomInputs = (space: Space, onQueryRefOptions: FunctionInputEditorProps['onQueryRefOptions']) => {
-  const functions = useQuery(space, Filter.type(FunctionType));
-  const workflows = useQuery(space, Filter.type(ComputeGraph));
-  const scripts = useQuery(space, Filter.type(ScriptType));
+type UseCustomInputsProps = {
+  db: Database.Database;
+  readonlySpec?: boolean;
+} & Pick<QueryFormProps, 'types' | 'tags'>;
+
+const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps): FormFieldMap => {
+  const functions = useQuery(db, Filter.type(Operation.PersistentOperation));
+  const workflows = useQuery(db, Filter.type(ComputeGraph));
+  const scripts = useQuery(db, Filter.type(Script.Script));
+  const feeds = useQuery(db, Filter.type(Feed.Feed));
 
   return useMemo(
-    (): CustomInputMap => ({
+    (): FormFieldMap => ({
       // Function selector.
-      ['function' satisfies keyof FunctionTriggerType]: (props) => {
+      ['function' satisfies keyof Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
           const formValue = props.getValue();
           if (Ref.isRef(formValue)) {
@@ -66,17 +98,17 @@ const useCustomInputs = (space: Space, onQueryRefOptions: FunctionInputEditorPro
 
         const handleOnValueChange = useCallback(
           (_type: any, dxnString: string) => {
-            const dxn = Type.DXN.parse(dxnString);
+            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}
@@ -86,14 +118,31 @@ const useCustomInputs = (space: Space, onQueryRefOptions: FunctionInputEditorPro
       },
 
       // Spec selector.
-      ['spec.kind' as const]: SpecSelector,
+      'spec.kind': (props) => <SpecSelector {...props} readonly={readonlySpec} />,
+
+      // Queue feed selector with parent labels.
+      'spec.queue': (props) => <SelectField {...props} options={getFeedQueueOptions(feeds)} />,
+
+      // TODO(wittjosiah): Copied from ViewEditor.
+      // Query input editor.
+      'spec.query': (props) => {
+        const handleChange = useCallback(
+          (query: Query.Any) => props.onValueChange(props.type, { ast: query.ast }),
+          [props.type, props.onValueChange],
+        );
+
+        return (
+          <Input.Root>
+            <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: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
     }),
-    [workflows, scripts, functions],
+    [workflows, scripts, functions, feeds, readonlySpec],
   );
 };
 
@@ -101,7 +150,20 @@ const getWorkflowOptions = (graphs: ComputeGraph[]) => {
   return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
 };
 
-const getFunctionOptions = (scripts: ScriptType[], functions: FunctionType[]) => {
-  const getLabel = (fn: FunctionType) => scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
+const getFunctionOptions = (scripts: Script.Script[], functions: Operation.PersistentOperation[]) => {
+  const getLabel = (fn: Operation.PersistentOperation) =>
+    scripts.find((s) => fn.source?.target?.id === s.id)?.name ?? fn.name;
   return functions.map((fn) => ({ label: getLabel(fn), value: `dxn:echo:@:${fn.id}` }));
 };
+
+const getFeedQueueOptions = (feeds: Feed.Feed[]) => {
+  return feeds.flatMap((feed) => {
+    const queueDxn = Feed.getQueueDxn(feed);
+    if (!queueDxn) {
+      return [];
+    }
+    const parent = Obj.getParent(feed);
+    const label = parent ? Entity.getLabel(parent) : Entity.getLabel(feed);
+    return [{ label: label ?? feed.id, value: queueDxn.toString() }];
+  });
+};

package/src/components/index.ts

@@ -6,7 +6,6 @@ import { lazy } from 'react';
 
 export * from './TriggerEditor';
 
-export const AutomationContainer = lazy(() => import('./AutomationContainer'));
 export const AutomationPanel = lazy(() => import('./AutomationPanel'));
-export const FunctionsContainer = lazy(() => import('./FunctionsContainer'));
 export const FunctionsPanel = lazy(() => import('./FunctionsPanel'));
+export const FunctionsRegistry = lazy(() => import('./FunctionsRegistry'));

package/src/containers/AutomationSettings/AutomationSettings.tsx

@@ -0,0 +1,31 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { AppSurface } from '@dxos/app-toolkit/ui';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+
+import { AutomationPanel, type AutomationPanelProps } from '../../components/AutomationPanel';
+import { TriggersSettings } from '../TriggerSettings';
+
+export type AutomationSettingsProps = AppSurface.SpaceArticleProps<Omit<AutomationPanelProps, 'space'>>;
+
+export const AutomationSettings = (props: AutomationSettingsProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <Settings.Viewport>
+      <Settings.Section
+        title={t('automation-verbose.label', { ns: meta.id })}
+        description={t('automation.description', { ns: meta.id })}
+      >
+        <AutomationPanel {...props} />
+        <TriggersSettings space={props.space} />
+      </Settings.Section>
+    </Settings.Viewport>
+  );
+};