@dxos/plugin-automation 0.8.4-main.9735255 → 0.8.4-main.9be5663bfe

package/src/components/TriggerEditor/FunctionInputEditor.tsx

@@ -5,17 +5,17 @@
 import type * as SchemaAST from 'effect/SchemaAST';
 import React, { useCallback, useMemo } from 'react';
 
-import { type Database, Ref, Type } from '@dxos/echo';
+import { type Database, JsonSchema, Obj, Ref } from '@dxos/echo';
 import { type JsonPath } from '@dxos/echo/internal';
-import { type Function } from '@dxos/functions';
+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';
+import { meta } from '#meta';
 
 export type FunctionInputEditorProps = {
   type: SchemaAST.AST;
-  functions: Function.Function[];
+  functions: Operation.PersistentOperation[];
   db?: Database.Database;
 } & FormFieldStateProps;
 
@@ -48,9 +48,12 @@ export const FunctionInputEditor = ({ type, functions, db, getValue, onValueChan
   );
 
   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 values = useMemo(() => getValue() ?? {}, [getValue]);
+  const defaultValues = useMemo(() => {
+    const raw = getValue() ?? {};
+    return Obj.isObject(raw) ? { ...Obj.getSnapshot(raw) } : { ...raw };
+  }, [getValue]);
 
   const handleValuesChanged = useCallback<NonNullable<FormRootProps['onValuesChanged']>>(
     (values) => {
@@ -65,8 +68,14 @@ export const FunctionInputEditor = ({ type, functions, db, getValue, onValueChan
 
   return (
     <>
-      <Form.Label label={t('function parameters label')} asChild />
-      <Form.Root schema={effectSchema} values={values} db={db} onValuesChanged={handleValuesChanged}>
+      <Form.Label label={t('function-parameters.label')} asChild />
+      <Form.Root
+        key={selectedFunction.id}
+        schema={effectSchema}
+        defaultValues={defaultValues}
+        db={db}
+        onValuesChanged={handleValuesChanged}
+      >
         <Form.FieldSet />
       </Form.Root>
     </>

package/src/components/TriggerEditor/SpecSelector.tsx

@@ -9,7 +9,7 @@ import { Trigger } from '@dxos/functions';
 import { useTranslation } from '@dxos/react-ui';
 import { type FormFieldComponentProps, SelectField, useFormFieldState } from '@dxos/react-ui-form';
 
-import { meta } from '../../meta';
+import { meta } from '#meta';
 
 export type SpecSelectorProps = FormFieldComponentProps;
 
@@ -31,7 +31,7 @@ export const SpecSelector = (props: SpecSelectorProps) => {
               },
             };
           case 'queue':
-            return { kind: 'queue', queue: 'dxn:' };
+            return { kind: 'queue', queue: 'dxn:queue:default' };
           case 'email':
             return { kind: 'email' };
           case 'webhook':
@@ -52,11 +52,20 @@ export const SpecSelector = (props: SpecSelectorProps) => {
     [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(
     () =>
       Trigger.Kinds.map((kind) => ({
         value: kind,
-        label: t(`trigger type ${kind}`),
+        label: kindLabels[kind],
       })),
     [t],
   );

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

@@ -4,28 +4,30 @@
 
 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 { Function, Trigger } from '@dxos/functions';
+import { Trigger } from '@dxos/functions';
 import { invariant } from '@dxos/invariant';
-import { faker } from '@dxos/random';
+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 { 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 { 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 } 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(Project.Project), label: 'Project' },
+  { value: Type.getTypename(Pipeline.Pipeline), label: 'Project' },
   { value: Employer.Employer.typename, label: 'Employer' },
 ];
 
@@ -39,7 +41,7 @@ const DefaultStory = (props: Partial<TriggerEditorProps>) => {
       return;
     }
 
-    const functions = await space.db.query(Filter.type(Function.Function)).run();
+    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(
@@ -72,16 +74,16 @@ const DefaultStory = (props: Partial<TriggerEditorProps>) => {
 };
 
 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, Function.Function, Trigger.Trigger, TestSchema.ContactType],
+      types: [Tag.Tag, Operation.PersistentOperation, Trigger.Trigger, TestSchema.ContactType],
       onCreateSpace: ({ space }) => {
         // Tags.
         ['Important', 'Investor', 'New'].forEach((label) => {
@@ -90,14 +92,14 @@ const meta = {
 
         // Functions.
         functions.forEach((fn) => {
-          space.db.add(Function.make(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(TestSchema.ContactType, {
-              name: faker.person.fullName(),
+              name: random.person.fullName(),
               identifiers: [],
             }),
           );
@@ -122,3 +124,44 @@ 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 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,8 +5,9 @@
 import React, { useCallback, useMemo } from 'react';
 
 import { ComputeGraph } from '@dxos/conductor';
-import { DXN, type Database, type Query } from '@dxos/echo';
-import { Function, Script, Trigger } from '@dxos/functions';
+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';
@@ -36,20 +37,31 @@ export type TriggerEditorProps = {
   Pick<FormRootProps<TriggerFormSchema>, 'onSave' | 'onCancel'>;
 
 export const TriggerEditor = ({ db, types, tags, readonlySpec, trigger, ...formProps }: TriggerEditorProps) => {
-  const fieldMap = useCustomInputs({
-    db,
-    types,
-    tags,
-    readonlySpec,
-  });
+  const fieldMap = useCustomInputs({ db, types, tags, readonlySpec });
+
+  const handleValuesChanged = useCallback(
+    (newValues: Partial<TriggerFormSchema>) => {
+      Obj.change(trigger, (trigger) => {
+        Object.assign(trigger, newValues);
+      });
+    },
+    [trigger],
+  );
+
+  const triggerSchema = useMemo(() => omitId(Trigger.Trigger), []);
+  const defaultValues = useMemo(() => {
+    const { id: _, ...values } = trigger;
+    return values;
+  }, [trigger]);
 
   return (
     <Form.Root<TriggerFormSchema>
       {...formProps}
-      schema={omitId(Trigger.Trigger)}
-      values={trigger}
       db={db}
+      schema={triggerSchema}
+      defaultValues={defaultValues}
       fieldMap={fieldMap}
+      onValuesChanged={handleValuesChanged}
     >
       <Form.Viewport>
         <Form.Content>
@@ -67,9 +79,10 @@ type UseCustomInputsProps = {
 } & Pick<QueryFormProps, 'types' | 'tags'>;
 
 const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps): FormFieldMap => {
-  const functions = useQuery(db, Filter.type(Function.Function));
+  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(
     (): FormFieldMap => ({
@@ -105,11 +118,14 @@ const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps
       },
 
       // Spec selector.
-      ['spec.kind' as const]: (props) => <SpecSelector {...props} readonly={readonlySpec} />,
+      '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' as const]: (props) => {
+      'spec.query': (props) => {
         const handleChange = useCallback(
           (query: Query.Any) => props.onValueChange(props.type, { ast: query.ast }),
           [props.type, props.onValueChange],
@@ -124,9 +140,9 @@ const useCustomInputs = ({ db, readonlySpec, types, tags }: UseCustomInputsProps
       },
 
       // Function input editor.
-      ['input' as const]: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
+      input: (props) => <FunctionInputEditor {...props} functions={functions} db={db} />,
     }),
-    [workflows, scripts, functions, readonlySpec],
+    [workflows, scripts, functions, feeds, readonlySpec],
   );
 };
 
@@ -134,7 +150,20 @@ const getWorkflowOptions = (graphs: ComputeGraph[]) => {
   return graphs.map((graph) => ({ label: `compute-${graph.id}`, value: `dxn:echo:@:${graph.id}` }));
 };
 
-const getFunctionOptions = (scripts: Script.Script[], functions: Function.Function[]) => {
-  const getLabel = (fn: Function.Function) => 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

@@ -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,28 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+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 const AutomationSettings = (props: AutomationPanelProps) => {
+  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 db={props.space.db} />
+      </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,34 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import React from 'react';
+
+import { type Space } from '@dxos/react-client/echo';
+import { useTranslation } from '@dxos/react-ui';
+import { Settings } from '@dxos/react-ui-form';
+
+import { meta } from '#meta';
+
+import { FunctionsPanel } from '../../components/FunctionsPanel';
+import { FunctionsRegistry } from '../../components/FunctionsRegistry';
+
+export const FunctionsContainer = ({ space }: { space: Space }) => {
+  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';

package/src/{components → containers/TriggerSettings}/TriggerSettings.tsx

@@ -6,20 +6,21 @@ import React from 'react';
 
 import { type Database } from '@dxos/echo';
 import { Input, useTranslation } from '@dxos/react-ui';
-import { ControlItemInput } from '@dxos/react-ui-form';
+import { Settings } from '@dxos/react-ui-form';
 
-import { useTriggerRuntimeControls } from '../hooks';
-import { meta } from '../meta';
+import { useTriggerRuntimeControls } from '#hooks';
+import { meta } from '#meta';
 
 export const TriggersSettings = ({ db }: { db: Database.Database }) => {
-  const { triggers, isRunning, start, stop } = useTriggerRuntimeControls(db);
+  const { state, start, stop } = useTriggerRuntimeControls(db);
+  const isRunning = state?.enabled ?? false;
   const { t } = useTranslation(meta.id);
 
   return (
-    <div className='container-max-width grid grid-cols-1 md:grid-cols-[1fr_min-content]'>
-      <ControlItemInput title={t('runtime label')} description={t('runtime description')}>
+    <div className='grid grid-cols-1 md:grid-cols-[1fr_min-content]'>
+      <Settings.Item title={t('runtime.label')} description={t('runtime.description')}>
         <Input.Switch classNames='justify-self-end' checked={isRunning} onCheckedChange={isRunning ? stop : start} />
-      </ControlItemInput>
+      </Settings.Item>
     </div>
   );
 };

package/src/containers/TriggerSettings/index.ts

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

package/src/containers/index.ts

@@ -0,0 +1,9 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { type ComponentType, lazy } from 'react';
+
+export const AutomationSettings: ComponentType<any> = lazy(() => import('./AutomationSettings'));
+export const FunctionsContainer: ComponentType<any> = lazy(() => import('./FunctionsContainer'));
+export const TriggerSettings: ComponentType<any> = lazy(() => import('./TriggerSettings'));

package/src/hooks/index.ts

@@ -2,5 +2,8 @@
 // Copyright 2025 DXOS.org
 //
 
+// TODO(wittjosiah): Factor out.
 export * from './useComputeRuntimeCallback';
 export * from './useTriggerRuntimeControls';
+export * from './useComputeRuntime';
+export * from './useComputeRuntimeService';

package/src/hooks/useComputeRuntime.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCapability } from '@dxos/app-framework/ui';
+import { SpaceId } from '@dxos/keys';
+
+import { AutomationCapabilities } from '../types';
+
+/**
+ * Resolves the compute runtime for a space.
+ */
+export const useComputeRuntime = (id: SpaceId | undefined): AutomationCapabilities.ComputeRuntime | undefined => {
+  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
+  return id !== undefined ? computeRuntime.getRuntime(id) : undefined;
+};

package/src/hooks/useComputeRuntimeCallback.ts

@@ -2,17 +2,14 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Cause from 'effect/Cause';
 import * as Effect from 'effect/Effect';
-import * as Exit from 'effect/Exit';
 import { type DependencyList, useCallback } from 'react';
 
-import { useCapability } from '@dxos/app-framework/react';
 import { type Key } from '@dxos/echo';
-import { type FunctionDefinition, FunctionInvocationService, TracingService } from '@dxos/functions';
-import { log } from '@dxos/log';
 
-import { AutomationCapabilities } from '../types';
+import { AutomationCapabilities } from '#types';
+
+import { useComputeRuntime } from './useComputeRuntime';
 
 /**
  * Create an effectful function that has access to compute services
@@ -23,8 +20,7 @@ export const useComputeRuntimeCallback = <T>(
   fn: () => Effect.Effect<T, any, AutomationCapabilities.ComputeServices>,
   deps?: DependencyList,
 ): (() => Promise<T>) => {
-  const computeRuntime = useCapability(AutomationCapabilities.ComputeRuntime);
-  const runtime = id !== undefined ? computeRuntime.getRuntime(id) : undefined;
+  const runtime = useComputeRuntime(id);
 
   return useCallback(() => {
     if (!runtime) {
@@ -34,34 +30,3 @@ export const useComputeRuntimeCallback = <T>(
     return runtime.runPromise(fn());
   }, [runtime, ...(deps ?? [])]);
 };
-
-// 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* TracingService;
-    const trace = yield* tracer.traceInvocationStart({
-      target: undefined,
-      payload: {
-        data: {},
-      },
-    });
-
-    // Invoke the function.
-    const result = yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(
-      Effect.provide(trace.invocationTraceQueue ? TracingService.layerInvocation(trace) : TracingService.layerNoop),
-      Effect.exit,
-    );
-
-    if (Exit.isFailure(result)) {
-      const error = Cause.prettyErrors(result.cause)[0];
-      log.error(error.message, error.cause ?? error.stack);
-    }
-
-    yield* tracer.traceInvocationEnd({
-      trace,
-      // TODO(dmaretskyi): Might miss errors.
-      exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : undefined,
-    });
-
-    return result;
-  });

package/src/hooks/useComputeRuntimeService.ts

@@ -0,0 +1,24 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Context from 'effect/Context';
+import { use } from 'react';
+import { useMemo } from 'react';
+
+import { unwrapExit } from '@dxos/effect';
+import { SpaceId } from '@dxos/keys';
+
+import { AutomationCapabilities } from '../types';
+import { useComputeRuntime } from './useComputeRuntime';
+
+export const useComputeRuntimeService = <T extends Context.Tag<any, any>>(
+  tag: T,
+  spaceId?: SpaceId,
+): (Context.Tag.Service<T> & AutomationCapabilities.ComputeRuntime) | undefined => {
+  const runtime = useComputeRuntime(spaceId);
+  if (!runtime) {
+    return undefined;
+  }
+  return unwrapExit(use(useMemo(() => runtime.runPromiseExit(tag), [runtime, tag])));
+};

package/src/hooks/useTriggerRuntimeControls.ts

@@ -2,19 +2,23 @@
 // Copyright 2025 DXOS.org
 //
 
+import { Atom, useAtomValue } from '@effect-atom/atom-react';
+import type * as Context from 'effect/Context';
 import * as Effect from 'effect/Effect';
+import { useEffect, useState } from 'react';
 
 import { type Database, Filter } from '@dxos/echo';
 import { Trigger } from '@dxos/functions';
-import { TriggerDispatcher } from '@dxos/functions-runtime';
+import { TriggerDispatcher, type TriggerDispatcherState } from '@dxos/functions-runtime';
 import { useQuery } from '@dxos/react-client/echo';
-import { useAsyncState } from '@dxos/react-ui';
 
 import { useComputeRuntimeCallback } from './useComputeRuntimeCallback';
 
 interface TriggerRuntimeControls {
   triggers: Trigger.Trigger[];
-  isRunning: boolean;
+
+  state: TriggerDispatcherState | undefined;
+
   start: () => void;
   stop: () => void;
 }
@@ -22,16 +26,27 @@ interface TriggerRuntimeControls {
 export const useTriggerRuntimeControls = (db: Database.Database | undefined): TriggerRuntimeControls => {
   const triggers = useQuery(db, Filter.type(Trigger.Trigger));
 
-  const [isRunningState, setIsRunningState] = useAsyncState(
-    useComputeRuntimeCallback(db?.spaceId, () => TriggerDispatcher.pipe(Effect.map((t) => t.running))),
+  const [dispatcher, setDispatcher] = useState<Context.Tag.Service<TriggerDispatcher> | undefined>(undefined);
+
+  const init = useComputeRuntimeCallback(
+    db?.spaceId,
+    Effect.fnUntraced(function* () {
+      const dispatcher = yield* TriggerDispatcher;
+      setDispatcher(dispatcher);
+    }),
   );
 
+  useEffect(() => {
+    void init();
+  }, []);
+
+  const state = useAtomValue(dispatcher?.state ?? Atom.make(undefined));
+
   const start = useComputeRuntimeCallback(
     db?.spaceId,
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.start();
-      setIsRunningState(true);
     }),
   );
 
@@ -40,13 +55,12 @@ export const useTriggerRuntimeControls = (db: Database.Database | undefined): Tr
     Effect.fnUntraced(function* () {
       const dispatcher = yield* TriggerDispatcher;
       yield* dispatcher.stop();
-      setIsRunningState(false);
     }),
   );
 
   return {
     triggers,
-    isRunning: isRunningState ?? false,
+    state,
     start: () => void start(),
     stop: () => void stop(),
   };