@dxos/plugin-automation 0.8.4-main.406dc2a → 0.8.4-main.43cb759274

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

@@ -4,47 +4,49 @@
 
 import { type Meta, type StoryObj } from '@storybook/react-vite';
 import React, { useState } from 'react';
+import { expect, userEvent, within } from 'storybook/test';
 
+import { Operation, Trigger } from '@dxos/compute';
 import { Filter, Obj, Ref, Tag, Type } from '@dxos/echo';
-import { FunctionTrigger, FunctionType } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { faker } from '@dxos/random';
+import { random } from '@dxos/random';
 import { useQuery } from '@dxos/react-client/echo';
-import { ContactType, useClientProvider, withClientProvider } from '@dxos/react-client/testing';
+import { TestSchema, useClientStory, withClientProvider } from '@dxos/react-client/testing';
 import { useAsyncEffect } from '@dxos/react-ui';
-import { withTheme } from '@dxos/react-ui/testing';
-import { DataType } from '@dxos/schema';
+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 { functions, registryFunctions } from '#testing';
+import { translations } from '#translations';
 
 import { TriggerEditor, type TriggerEditorProps } from './TriggerEditor';
 
 const types = [
   // TODO(burdon): Get label from annotation.
-  { value: Type.getTypename(DataType.Organization), label: 'Organization' },
-  { value: Type.getTypename(DataType.Person), label: 'Person' },
-  { value: Type.getTypename(DataType.Project), label: 'Project' },
-  { value: Type.getTypename(DataType.Employer), label: 'Employer' },
+  { value: Type.getTypename(Organization.Organization), label: 'Organization' },
+  { value: Type.getTypename(Person.Person), label: 'Person' },
+  { value: Type.getTypename(Pipeline.Pipeline), label: 'Project' },
+  { value: Type.getTypename(Employer.Employer), label: 'Employer' },
 ];
 
 const DefaultStory = (props: Partial<TriggerEditorProps>) => {
-  const { space } = useClientProvider();
-  const [trigger, setTrigger] = useState<FunctionTrigger>();
-  const tags = useQuery(space, Filter.type(Tag.Tag));
+  const { space } = useClientStory();
+  const [trigger, setTrigger] = useState<Trigger.Trigger>();
+  const tags = useQuery(space?.db, Filter.type(Tag.Tag));
 
   useAsyncEffect(async () => {
     if (!space) {
       return;
     }
 
-    const result = await space.db.query(Filter.type(FunctionType)).run();
-    const fn = result.objects.find((fn) => fn.name === 'example.com/function/forex');
+    const functions = await space.db.query(Filter.type(Operation.PersistentOperation)).run();
+    const fn = functions.find((fn) => fn.name === 'com.example.function.forex');
     invariant(fn);
     const trigger = space.db.add(
-      Obj.make(FunctionTrigger, {
+      Trigger.make({
         function: Ref.make(fn),
-        spec: { kind: 'webhook' },
+        spec: Trigger.specWebhook(),
         input: {
           from: 'USD',
           to: 'JPY',
@@ -59,41 +61,60 @@ const DefaultStory = (props: Partial<TriggerEditorProps>) => {
   }
 
   return (
-    <div role='none' className='w-[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}
+    />
   );
 };
 
 const meta = {
-  title: 'plugins/plugin-automation/TriggerEditor',
+  title: 'plugins/plugin-automation/components/TriggerEditor',
   component: TriggerEditor as any,
   render: DefaultStory,
   decorators: [
-    withTheme,
+    withTheme(),
+    withLayout({ layout: 'column' }),
     withClientProvider({
       createIdentity: true,
       createSpace: true,
-      types: [Tag.Tag, FunctionType, FunctionTrigger, ContactType],
+      types: [Tag.Tag, Operation.PersistentOperation, 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 }));
+        });
+
+        // Functions in the local space.
+        functions.forEach((fn) => {
+          const { key, version, ...data } = fn;
+          space.db.add(
+            Obj.make(Operation.PersistentOperation, {
+              [Obj.Meta]: { key, version: version ?? '0.1.0' },
+              ...data,
+            }),
+          );
+        });
 
-        for (const fn of functions) {
-          space.db.add(Obj.make(FunctionType, fn));
-        }
+        // Functions in the registry (simulate built-in / plugin-provided operations).
+        space.db.registry.add(
+          registryFunctions.map(({ key, version, ...data }) =>
+            Obj.make(Operation.PersistentOperation, {
+              [Obj.Meta]: { key, version: version ?? '0.1.0' },
+              ...data,
+            }),
+          ),
+        );
+
+        // 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: [],
             }),
           );
@@ -102,8 +123,8 @@ const meta = {
     }),
   ],
   parameters: {
-    layout: 'column',
-    translations,
+    layout: 'fullscreen',
+    translations: [...formTranslations, ...translations],
   },
 } satisfies Meta<typeof DefaultStory>;
 
@@ -118,3 +139,46 @@ export const ReadonlySpec: Story = {
     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 the Feed selector field (a Ref(Feed) combobox). The combobox
+    // isn't associated with its label, so match the field's <label> element directly.
+    await selectKind(combobox, 'f');
+    await expect(combobox).not.toBeDisabled();
+    await expect(await canvas.findByText('Feed', { selector: 'label' })).toBeInTheDocument();
+  },
+};

package/src/components/TriggerEditor/TriggerEditor.tsx

@@ -2,85 +2,120 @@
 // Copyright 2025 DXOS.org
 //
 
+import * as Option from 'effect/Option';
+import * as Record from 'effect/Record';
 import React, { useCallback, useMemo } from 'react';
 
+import { Operation, Script, Trigger } from '@dxos/compute';
 import { ComputeGraph } from '@dxos/conductor';
-import { type Query, Type } from '@dxos/echo';
-import { FunctionTrigger, FunctionType, ScriptType } from '@dxos/functions';
-import { Filter, Ref, type Space, useQuery } from '@dxos/react-client/echo';
+import { Annotation, type Database, Entity, Feed, Filter, Obj, Query, Ref, Scope, Type } from '@dxos/echo';
+import { DXN, EID } from '@dxos/keys';
+import { 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';
+import { getOperationUri } from './util';
+
+type TriggerFormSchema = ExcludeId<typeof Trigger.Trigger>;
 
 export type TriggerEditorProps = {
-  space: Space;
-  trigger: FunctionTrigger;
+  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<FunctionTrigger, 'id'>) => void;
-  onCancel?: () => void;
-} & Pick<QueryFormProps, 'types' | 'tags'>;
-
-export const TriggerEditor = ({ space, trigger, readonlySpec, types, tags, onSave, onCancel }: TriggerEditorProps) => {
-  const handleSave = ({ id: _, ...values }: FunctionTrigger) => {
-    onSave?.(values);
-  };
+} &
+  // 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 });
+
+  const handleValuesChanged = useCallback(
+    (newValues: Partial<TriggerFormSchema>) => {
+      Obj.update(trigger, (trigger) => {
+        Object.assign(trigger, newValues);
+      });
+    },
+    [trigger],
+  );
 
-  const handleRefQueryLookup = useRefQueryLookupHandler({ space });
-  const Custom = useCustomInputs({ space, readonlySpec, types, tags, onQueryRefOptions: handleRefQueryLookup });
+  const triggerSchema = useMemo(() => omitId(Trigger.Trigger), []);
+  const defaultValues = useMemo(() => {
+    const { id: _, ...values } = trigger;
+    return values;
+  }, [trigger]);
 
   return (
-    <Form
-      outerSpacing={false}
-      Custom={Custom}
-      schema={FunctionTrigger}
-      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>
   );
 };
 
 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(FunctionType));
-  const workflows = useQuery(space, Filter.type(ComputeGraph));
-  const scripts = useQuery(space, Filter.type(ScriptType));
+const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps): FormFieldMap => {
+  const functions = useQuery(
+    db,
+    Query.select(Filter.type(Operation.PersistentOperation)).from(Scope.space(), Scope.registry()),
+  );
+
+  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 FunctionTrigger]: (props) => {
+      ['function' satisfies keyof Trigger.Trigger]: (props) => {
         const getValue = useCallback(() => {
           const formValue = props.getValue();
           if (Ref.isRef(formValue)) {
-            return formValue.dxn.toString() as string;
+            return formValue.uri;
           }
           return undefined;
         }, [props]);
 
         const handleOnValueChange = useCallback(
-          (_type: any, dxnString: string) => {
-            const dxn = Type.DXN.parse(dxnString);
-            if (dxn) {
-              const ref = Ref.fromDXN(dxn);
-              props.onValueChange('object', ref);
+          (_type: any, uriString: string) => {
+            // Function references are either an EID (space-resident) or a key DXN (registry).
+            const uri = EID.tryParse(uriString) ?? (DXN.isDXN(uriString) ? uriString : undefined);
+            if (uri) {
+              props.onValueChange(props.type, Ref.fromURI(uri));
             }
           },
-          [props.onValueChange],
+          [props.type, props.onValueChange],
         );
 
         return (
-          <SelectInput
+          <SelectField
             {...props}
             getValue={getValue as any}
             onValueChange={handleOnValueChange}
@@ -90,38 +125,126 @@ const useCustomInputs = ({ space, readonlySpec, types, tags, onQueryRefOptions }
       },
 
       // Spec selector.
-      ['spec.kind' as const]: (props) => <SpecSelector {...props} readonly={readonlySpec ? 'disabled-input' : false} />,
+      'spec.kind': (props) => <SpecSelector {...props} readonly={readonlySpec} />,
+
+      // Feed selector with parent labels.
+      'spec.feed': (props) => {
+        const getValue = useCallback(() => {
+          const formValue = props.getValue();
+          if (Ref.isRef(formValue)) {
+            return formValue.uri.toString() as string;
+          }
+          return undefined;
+        }, [props]);
+
+        const handleOnValueChange = useCallback(
+          (_type: any, dxnString: string) => {
+            const uri = EID.tryParse(dxnString);
+            if (uri) {
+              props.onValueChange(props.type, Ref.fromURI(uri));
+            }
+          },
+          [props.type, props.onValueChange],
+        );
+
+        return (
+          <SelectField
+            {...props}
+            getValue={getValue as any}
+            onValueChange={handleOnValueChange}
+            options={getFeedOptions(feeds)}
+          />
+        );
+      },
 
       // TODO(wittjosiah): Copied from ViewEditor.
       // Query input editor.
-      ['spec.query' as const]: (props) => {
+      'spec.query': (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: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
     }),
-    [workflows, scripts, functions, readonlySpec],
+    [workflows, scripts, functions, feeds, readonlySpec],
   );
 };
 
+const getObjectIconProps = (object: Entity.Unknown): { icon?: string; iconHue?: string } => {
+  const type = Entity.getType(object);
+  const schema = type ? Type.getSchema(type) : undefined;
+  const annotation = schema ? Option.getOrUndefined(Annotation.IconAnnotation.get(schema)) : undefined;
+  return annotation ? { icon: annotation.icon, iconHue: annotation.hue } : {};
+};
+
 const getWorkflowOptions = (graphs: ComputeGraph[]) => {
-  return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
+  return graphs.map((graph) => ({
+    label: `compute-${graph.id}`,
+    value: Obj.getURI(graph),
+    ...getObjectIconProps(graph),
+  }));
+};
+
+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) => {
+    const { icon: schemaIcon, iconHue } = getObjectIconProps(fn);
+    return {
+      label: getLabel(fn),
+      value: getOperationUri(fn),
+      icon: fn.icon ?? schemaIcon,
+      iconHue,
+    };
+  });
+};
+
+const getFeedDisplayName = (feed: Feed.Feed): string =>
+  Entity.getLabel(feed) ?? feed.name ?? Entity.getTypename(feed) ?? 'Feed';
+
+const computeRefRole = (entity: Feed.Feed): string | undefined => {
+  const parent = Obj.getParent(entity);
+  if (!parent) {
+    return undefined;
+  }
+  for (const key of Record.keys(parent)) {
+    if (Ref.isRef(parent[key]) && parent[key].target?.id === entity.id) {
+      return `$.${key}`;
+    }
+  }
+  return undefined;
 };
 
-const getFunctionOptions = (scripts: ScriptType[], functions: FunctionType[]) => {
-  const getLabel = (fn: FunctionType) => 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 getFeedOptions = (feeds: Feed.Feed[]) => {
+  return feeds.map((feed) => {
+    const parent = Obj.getParent(feed);
+    const displayObject = parent ?? feed;
+    const role = computeRefRole(feed);
+
+    if (parent) {
+      return {
+        label: Entity.getLabel(parent) ?? Entity.getTypename(parent) ?? 'Parent',
+        secondaryLabel: role ?? getFeedDisplayName(feed),
+        value: Obj.getURI(feed),
+        ...getObjectIconProps(displayObject),
+      };
+    }
+
+    return {
+      label: getFeedDisplayName(feed),
+      secondaryLabel: role,
+      value: Obj.getURI(feed),
+      ...getObjectIconProps(displayObject),
+    };
+  });
 };

package/src/components/TriggerEditor/util.ts

@@ -0,0 +1,51 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Operation } from '@dxos/compute';
+import { Obj } from '@dxos/echo';
+import { DXN, EID, type URI } from '@dxos/keys';
+
+/**
+ * Reference URI for an operation. Registry operations (no owning database) are referenced by
+ * their versioned key DXN so they resolve via the operation registry; space-resident operations
+ * are referenced by their EID.
+ */
+// TODO(wittjosiah): There should be a generic & consistent way to get the dxn uri for entities if its available.
+export const getOperationUri = (fn: Operation.PersistentOperation): URI.URI => {
+  if (Obj.getDatabase(fn) === undefined) {
+    const key = Operation.getKey(fn);
+    const version = Operation.getVersion(fn);
+    const dxn = key ? DXN.tryMake(version ? `dxn:${key}:${version}` : `dxn:${key}`) : undefined;
+    if (dxn) {
+      return dxn;
+    }
+  }
+
+  return Obj.getURI(fn);
+};
+
+/**
+ * Resolve an operation from a list by its reference URI (an EID for space-resident operations,
+ * or a versioned key DXN for registry operations).
+ */
+export const findOperationByUri = (
+  functions: readonly Operation.PersistentOperation[],
+  uri: URI.URI,
+): Operation.PersistentOperation | undefined => {
+  const eid = EID.tryParse(uri);
+  if (eid) {
+    const entityId = EID.getEntityId(eid);
+    return entityId ? functions.find((fn) => fn.id === entityId) : undefined;
+  }
+
+  if (DXN.isDXN(uri)) {
+    const key = DXN.getName(uri);
+    const version = DXN.getVersion(uri);
+    return functions.find(
+      (fn) => Operation.getKey(fn) === key && (version === undefined || Operation.getVersion(fn) === version),
+    );
+  }
+
+  return undefined;
+};

package/src/components/index.ts

@@ -7,6 +7,5 @@ import { lazy } from 'react';
 export * from './TriggerEditor';
 
 export const AutomationPanel = lazy(() => import('./AutomationPanel'));
-export const AutomationSettings = lazy(() => import('./AutomationSettings'));
-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>
+  );
+};

package/src/containers/AutomationSettings/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { AutomationSettings as default } from './AutomationSettings';

package/src/containers/FunctionsContainer/FunctionsContainer.tsx

@@ -0,0 +1,33 @@
+//
+// 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 { FunctionsPanel, FunctionsRegistry } from '../../components';
+
+export const FunctionsContainer = ({ space }: AppSurface.SpaceArticleProps) => {
+  const { t } = useTranslation(meta.id);
+  return (
+    <Settings.Viewport>
+      <Settings.Section
+        title={t('functions-verbose.label', { ns: meta.id })}
+        description={t('functions.description', { ns: meta.id })}
+      >
+        <FunctionsPanel space={space} />
+      </Settings.Section>
+      <Settings.Section
+        title={t('functions-registry-verbose.label', { ns: meta.id })}
+        description={t('functions-registry.description', { ns: meta.id })}
+      >
+        <FunctionsRegistry space={space} />
+      </Settings.Section>
+    </Settings.Viewport>
+  );
+};

package/src/containers/FunctionsContainer/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export { FunctionsContainer as default } from './FunctionsContainer';