@dxos/plugin-automation 0.8.4-main.8360d9e660 → 0.8.4-main.8baae0fced

package/src/capabilities/layer-specs.ts

@@ -0,0 +1,231 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Registry } from '@effect-atom/atom';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+
+import { OpaqueToolkit } from '@dxos/ai';
+import { Capabilities, Capability } from '@dxos/app-framework';
+import { AppCapabilities } from '@dxos/app-toolkit';
+import { ClientService } from '@dxos/client';
+import { Blueprint, LayerSpec, OperationHandlerSet, OperationRegistry } from '@dxos/compute';
+import { ProcessManager } from '@dxos/compute-runtime';
+import { Database, Feed } from '@dxos/echo';
+import { QueueService } from '@dxos/functions';
+import {
+  AgentService,
+  FeedTraceSink,
+  RemoteFunctionExecutionService,
+  TriggerDispatcher,
+  TriggerStateStore,
+} from '@dxos/functions-runtime';
+import { invariant } from '@dxos/invariant';
+import { ClientCapabilities } from '@dxos/plugin-client';
+
+//
+// Capability Module
+//
+// Contributes application- and space-affinity `Capabilities.LayerSpec` entries
+// that together replace the former monolithic `AutomationCapabilities.ComputeRuntime`.
+//
+// Specs are declared at module level; runtime state (the `Client`, contributed
+// capability lists, etc.) is resolved via Effect-level requirements rather
+// than captured from an outer scope.
+//
+
+/**
+ * Default application-affinity `RemoteFunctionExecutionService`. Space specs
+ * (see {@link RemoteFunctionExecutionOverrideSpec}) can override this with a
+ * space-scoped client.
+ */
+const RemoteFunctionExecutionSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [ClientService],
+    provides: [RemoteFunctionExecutionService],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const client = yield* ClientService;
+        return RemoteFunctionExecutionService.fromClient(client);
+      }),
+    ),
+);
+
+/**
+ * Gathers contributed {@link Capabilities.OperationHandler} sets from the
+ * {@link Capability.Service} and exposes them through the
+ * {@link OperationHandlerSet.OperationHandlerProvider} tag so space-affinity
+ * specs (e.g. {@link OperationRegistrySpec}) can consume them through the
+ * normal LayerStack resolution path.
+ */
+const OperationHandlerProviderSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [OperationHandlerSet.OperationHandlerProvider],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const operationHandlerSets = yield* Capability.getAll(Capabilities.OperationHandler);
+        const mergedOperationHandlers =
+          operationHandlerSets.length === 0
+            ? OperationHandlerSet.empty
+            : OperationHandlerSet.merge(...operationHandlerSets);
+        return OperationHandlerSet.provide(mergedOperationHandlers);
+      }),
+    ),
+);
+
+const BlueprintRegistrySpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [Blueprint.RegistryService],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const capabilities = yield* Capability.Service;
+        const blueprints = capabilities
+          .getAll(AppCapabilities.BlueprintDefinition)
+          .flatMap((blueprint) => blueprint.make());
+        return Layer.succeed(Blueprint.RegistryService, new Blueprint.Registry(blueprints));
+      }),
+    ),
+);
+
+const OpaqueToolkitSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [Capability.Service],
+    provides: [OpaqueToolkit.OpaqueToolkitProvider],
+  },
+  () =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        const capabilities = yield* Capability.Service;
+        return Layer.succeed(OpaqueToolkit.OpaqueToolkitProvider, {
+          getToolkit: () => {
+            const toolkits = capabilities.getAll(AppCapabilities.Toolkit);
+            return OpaqueToolkit.merge(...toolkits);
+          },
+        });
+      }),
+    ),
+);
+
+const AgentServiceSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [ProcessManager.ProcessManagerService],
+    provides: [AgentService.AgentService],
+  },
+  () => AgentService.layer(),
+);
+
+const OperationRegistrySpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [Database.Service, OperationHandlerSet.OperationHandlerProvider],
+    provides: [OperationRegistry.Service],
+  },
+  () => OperationRegistry.layer,
+);
+
+/**
+ * In-memory trigger state. Loses state across restarts but works in both
+ * browser and CLI/Node contexts. Hosts that need durable storage should
+ * contribute a replacement LayerSpec that provides {@link TriggerStateStore}
+ * backed by a persistent `KeyValueStore` (e.g. `BrowserKeyValueStore` or
+ * `BunKeyValueStore`).
+ */
+const TriggerStateStoreSpec = LayerSpec.make(
+  {
+    affinity: 'application',
+    requires: [],
+    provides: [TriggerStateStore],
+  },
+  () => TriggerStateStore.layerMemory,
+);
+
+//
+// Space-affinity specs.
+//
+
+const FeedTraceSinkSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [Database.Service, Feed.FeedService],
+    provides: [FeedTraceSink.FeedTraceSink],
+  },
+  () => FeedTraceSink.layerLive,
+);
+
+/**
+ * Space-scoped override of {@link RemoteFunctionExecutionService}. Activated
+ * only when the client's `runtime.client.edgeFeatures.agents` config is set;
+ * falls back to the application-level spec otherwise.
+ */
+const RemoteFunctionExecutionOverrideSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [ClientService],
+    provides: [RemoteFunctionExecutionService],
+  },
+  (context) =>
+    Layer.unwrapEffect(
+      Effect.gen(function* () {
+        invariant(context.space, 'space context required for RemoteFunctionExecutionService override');
+        const client = yield* ClientService;
+        return RemoteFunctionExecutionService.fromClient(client, context.space);
+      }),
+    ),
+);
+
+const TriggerDispatcherSpec = LayerSpec.make(
+  {
+    affinity: 'space',
+    requires: [
+      Database.Service,
+      QueueService,
+      TriggerStateStore,
+      ProcessManager.ProcessManagerService,
+      Registry.AtomRegistry,
+    ],
+    provides: [TriggerDispatcher],
+  },
+  () => TriggerDispatcher.layer({ timeControl: 'natural' }),
+);
+
+export default Capability.makeModule(
+  Effect.fnUntraced(function* () {
+    const client = yield* Capability.get(ClientCapabilities.Client);
+
+    const contributions: Capability.Any[] = [
+      Capability.contributes(Capabilities.LayerSpec, OperationHandlerProviderSpec),
+      Capability.contributes(Capabilities.LayerSpec, BlueprintRegistrySpec),
+      Capability.contributes(Capabilities.LayerSpec, OpaqueToolkitSpec),
+      Capability.contributes(Capabilities.LayerSpec, AgentServiceSpec),
+      Capability.contributes(Capabilities.LayerSpec, OperationRegistrySpec),
+      Capability.contributes(Capabilities.LayerSpec, TriggerStateStoreSpec),
+      Capability.contributes(Capabilities.LayerSpec, FeedTraceSinkSpec),
+      Capability.contributes(Capabilities.LayerSpec, TriggerDispatcherSpec),
+      Capability.contributes(Capabilities.TraceSink, ({ resolver }) => FeedTraceSink.makeRoutingSink({ resolver })),
+      // Edge-mode override is conditional on runtime config, so it stays in the
+      // activation block.
+      Capability.contributes(
+        Capabilities.LayerSpec,
+        client.config.get('runtime.client.edgeFeatures.agents')
+          ? RemoteFunctionExecutionSpec
+          : RemoteFunctionExecutionOverrideSpec,
+      ),
+    ];
+
+    return contributions;
+  }),
+);

package/src/capabilities/node.ts

@@ -0,0 +1,13 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { Capability } from '@dxos/app-framework';
+import { OperationHandlerSet } from '@dxos/compute';
+
+export const AppGraphBuilder = Capability.lazy('AppGraphBuilder', () => import('./app-graph-builder'));
+export const LayerSpecs = Capability.lazy<void, Capability.Any[]>('LayerSpecs', () => import('./layer-specs'));
+export const OperationHandler = Capability.lazy<OperationHandlerSet.OperationHandlerSet>(
+  'OperationHandler',
+  () => import('./operation-handler'),
+);

package/src/capabilities/operation-handler.ts

@@ -0,0 +1,16 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Effect from 'effect/Effect';
+
+import { Capabilities, Capability } from '@dxos/app-framework';
+import type { OperationHandlerSet } from '@dxos/compute';
+
+import { AutomationOperationHandlerSet } from '#operations';
+
+export default Capability.makeModule<OperationHandlerSet.OperationHandlerSet>(
+  Effect.fnUntraced(function* () {
+    return Capability.contributes(Capabilities.OperationHandler, AutomationOperationHandlerSet);
+  }),
+);

package/src/capabilities/{react-surface/react-surface.tsx → react-surface.tsx}

@@ -7,20 +7,18 @@ import React from 'react';
 
 import { Capabilities, Capability } from '@dxos/app-framework';
 import { Surface } from '@dxos/app-framework/ui';
-import { Obj } from '@dxos/echo';
-import { useActiveSpace } from '@dxos/plugin-space';
+import { AppSurface, useActiveSpace } from '@dxos/app-toolkit/ui';
 import { getSpace } from '@dxos/react-client/echo';
 
-import { AutomationSettings, FunctionsContainer } from '../../containers';
-import { meta } from '../../meta';
+import { AutomationSettings, FunctionsContainer } from '#containers';
+import { meta } from '#meta';
 
 export default Capability.makeModule(() =>
   Effect.succeed(
     Capability.contributes(Capabilities.ReactSurface, [
       Surface.create({
-        id: `${meta.id}.space-settings-functions`,
-        role: 'article',
-        filter: (data): data is { subject: string } => data.subject === `${meta.id}.space-settings-functions`,
+        id: 'space-settings-functions',
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.space-settings-functions`),
         component: () => {
           const space = useActiveSpace();
           if (!space) {
@@ -31,9 +29,8 @@ export default Capability.makeModule(() =>
         },
       }),
       Surface.create({
-        id: `${meta.id}.space-settings-automation`,
-        role: 'article',
-        filter: (data): data is { subject: string } => data.subject === `${meta.id}.space-settings-automation`,
+        id: 'space-settings-automation',
+        filter: AppSurface.literal(AppSurface.Article, `${meta.id}.space-settings-automation`),
         component: () => {
           const space = useActiveSpace();
           if (!space) {
@@ -44,12 +41,17 @@ export default Capability.makeModule(() =>
         },
       }),
       Surface.create({
-        id: `${meta.id}.companion.automation`,
-        role: 'article',
-        filter: (data): data is { companionTo: Obj.Unknown; subject: 'automation' } =>
-          Obj.isObject(data.companionTo) && data.subject === 'automation',
+        id: 'companion.automation',
+        filter: AppSurface.allOf(
+          AppSurface.literal(AppSurface.Article, 'automation'),
+          AppSurface.companion(AppSurface.Article),
+        ),
         component: ({ data }) => {
-          return <AutomationSettings space={getSpace(data.companionTo)!} object={data.companionTo} />;
+          const space = getSpace(data.companionTo);
+          if (!space) {
+            return null;
+          }
+          return <AutomationSettings space={space} object={data.companionTo} />;
         },
       }),
     ]),

package/src/{cli/commands → commands}/trigger/create/queue.ts

@@ -13,11 +13,11 @@ import * as Option from 'effect/Option';
 import { CommandConfig } from '@dxos/cli-util';
 import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
 import { Common } from '@dxos/cli-util';
+import { Operation, Trigger } from '@dxos/compute';
 import { Database, Filter, JsonSchema, Ref } from '@dxos/echo';
-import { Function, Trigger } from '@dxos/functions';
 
 import { Enabled, Input, Queue } from '../options';
-import { printTrigger, promptForSchemaInput, selectFunction, selectQueue } from '../util';
+import { printTrigger, promptForSchemaInput, selectFunction, selectFeed } from '../util';
 
 export const queue = Command.make(
   'queue',
@@ -36,14 +36,14 @@ export const queue = Command.make(
         onNone: () => selectFunction(),
         onSome: (id) => Effect.succeed(id),
       });
-      const functions = yield* Database.runQuery(Filter.type(Function.Function));
+      const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
       const fn = functions.find((fn) => fn.id === functionId);
       if (!fn) {
         return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
       }
 
-      const queueDxn = yield* Option.match(options.queue, {
-        onNone: () => selectQueue(),
+      const queueDXN = yield* Option.match(options.queue, {
+        onNone: () => selectFeed(),
         onSome: (dxn) => Effect.succeed(dxn.toString()),
       });
 
@@ -65,10 +65,7 @@ export const queue = Command.make(
       const trigger = Trigger.make({
         function: Ref.make(fn),
         enabled,
-        spec: {
-          kind: 'queue',
-          queue: queueDxn,
-        },
+        spec: Trigger.specQueue(queueDXN),
         input,
       });
 
@@ -85,5 +82,5 @@ export const queue = Command.make(
 ).pipe(
   Command.withDescription('Create a queue trigger.'),
   Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
-  Command.provideEffectDiscard(() => withTypes(Function.Function, Trigger.Trigger)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
 );

package/src/{cli/commands → commands}/trigger/create/subscription.ts

@@ -13,8 +13,8 @@ import * as Option from 'effect/Option';
 import { CommandConfig } from '@dxos/cli-util';
 import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
 import { Common } from '@dxos/cli-util';
+import { Operation, Trigger } from '@dxos/compute';
 import { Database, Filter, JsonSchema, Query, Ref } from '@dxos/echo';
-import { Function, Trigger } from '@dxos/functions';
 
 import { Deep, Delay, Enabled, Input, Typename } from '../options';
 import { printTrigger, promptForSchemaInput, selectFunction } from '../util';
@@ -38,7 +38,7 @@ export const subscription = Command.make(
         onNone: () => selectFunction(),
         onSome: (id) => Effect.succeed(id),
       });
-      const functions = yield* Database.runQuery(Filter.type(Function.Function));
+      const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
       const fn = functions.find((fn) => fn.id === functionId);
       if (!fn) {
         return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
@@ -51,7 +51,7 @@ export const subscription = Command.make(
           }).pipe(Prompt.run),
         onSome: (value) => Effect.succeed(value),
       });
-      const queryAst = Query.select(Filter.type(typename)).ast;
+      const subscriptionQuery = Query.select(Filter.type(typename));
 
       const deepOption = yield* Option.match(options.deep, {
         onNone: () =>
@@ -102,13 +102,10 @@ export const subscription = Command.make(
       const trigger = Trigger.make({
         function: Ref.make(fn),
         enabled,
-        spec: {
-          kind: 'subscription',
-          query: {
-            ast: queryAst,
-          },
-          options: Object.keys(subscriptionOptions).length > 0 ? subscriptionOptions : undefined,
-        },
+        spec: Trigger.specSubscription(
+          subscriptionQuery,
+          Object.keys(subscriptionOptions).length > 0 ? subscriptionOptions : undefined,
+        ),
         input,
       });
       yield* Database.add(trigger);
@@ -124,5 +121,5 @@ export const subscription = Command.make(
 ).pipe(
   Command.withDescription('Create a subscription trigger.'),
   Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
-  Command.provideEffectDiscard(() => withTypes(Function.Function, Trigger.Trigger)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
 );

package/src/{cli/commands → commands}/trigger/create/timer.ts

@@ -13,8 +13,8 @@ import * as Option from 'effect/Option';
 import { CommandConfig } from '@dxos/cli-util';
 import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
 import { Common } from '@dxos/cli-util';
+import { Operation, Trigger } from '@dxos/compute';
 import { Database, Filter, JsonSchema, Ref } from '@dxos/echo';
-import { Function, Trigger } from '@dxos/functions';
 
 import { Cron, Enabled, Input } from '../options';
 import { printTrigger, promptForSchemaInput, selectFunction } from '../util';
@@ -37,7 +37,7 @@ export const timer = Command.make(
         onNone: () => selectFunction(),
         onSome: (id) => Effect.succeed(id),
       });
-      const functions = yield* Database.runQuery(Filter.type(Function.Function));
+      const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
       const fn = functions.find((fn) => fn.id === functionId);
       if (!fn) {
         return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
@@ -69,10 +69,7 @@ export const timer = Command.make(
       const trigger = Trigger.make({
         function: Ref.make(fn),
         enabled,
-        spec: {
-          kind: 'timer',
-          cron,
-        },
+        spec: Trigger.specTimer(cron),
         input,
       });
 
@@ -89,5 +86,5 @@ export const timer = Command.make(
 ).pipe(
   Command.withDescription('Create a timer trigger.'),
   Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
-  Command.provideEffectDiscard(() => withTypes(Function.Function, Trigger.Trigger)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
 );

package/src/{cli/commands → commands}/trigger/list.ts

@@ -9,8 +9,9 @@ import * as Effect from 'effect/Effect';
 
 import { CommandConfig, Common, printList, spaceIdWithDefault, spaceLayer } from '@dxos/cli-util';
 import { ClientService } from '@dxos/client';
-import { Database, Filter } from '@dxos/echo';
-import { Trigger } from '@dxos/functions';
+import { Trigger } from '@dxos/compute';
+import { Context } from '@dxos/context';
+import { Database, Filter, Query } from '@dxos/echo';
 
 import { getTriggerRemoteStatus, printTrigger } from './util';
 
@@ -23,13 +24,15 @@ export const list = Command.make(
     const { json } = yield* CommandConfig;
 
     // Fetch local triggers
-    const triggers = yield* Database.runQuery(Filter.type(Trigger.Trigger));
+    const triggers = yield* Database.runQuery(
+      Query.select(Filter.type(Trigger.Trigger)).debugLabel('cli.trigger.list'),
+    );
 
     // Fetch remote cron triggers to check availability
     const remoteCronIds = yield* Effect.gen(function* () {
       const client = yield* ClientService;
       const spaceId = yield* spaceIdWithDefault(spaceIdOption);
-      const result = yield* Effect.promise(() => client.edge.http.getCronTriggers(spaceId)).pipe(
+      const result = yield* Effect.promise(() => client.edge.http.getCronTriggers(Context.default(), spaceId)).pipe(
         Effect.catchAll(() => Effect.succeed({ cronIds: [] })),
       );
       return result.cronIds;

package/src/{cli/commands → commands}/trigger/remove.ts

@@ -9,9 +9,8 @@ import * as Effect from 'effect/Effect';
 import * as Option from 'effect/Option';
 
 import { CommandConfig, Common, print, spaceLayer, withTypes } from '@dxos/cli-util';
-import { DXN } from '@dxos/echo';
-import { Database } from '@dxos/echo';
-import { Trigger } from '@dxos/functions';
+import { Trigger } from '@dxos/compute';
+import { Database, DXN } from '@dxos/echo';
 
 import { TriggerId } from './options';
 import { printTriggerRemoved, selectTrigger } from './util';

package/src/{cli/commands → commands}/trigger/update/queue.ts

@@ -12,11 +12,11 @@ import * as Option from 'effect/Option';
 import { CommandConfig } from '@dxos/cli-util';
 import { flushAndSync, print, spaceLayer, withTypes } from '@dxos/cli-util';
 import { Common } from '@dxos/cli-util';
+import { Operation, Trigger } from '@dxos/compute';
 import { DXN, Database, Filter, JsonSchema, Obj, Ref } from '@dxos/echo';
-import { Function, Trigger } from '@dxos/functions';
 
 import { Enabled, Input, Queue, TriggerId } from '../options';
-import { printTrigger, promptForSchemaInput, selectFunction, selectQueue, selectTrigger } from '../util';
+import { printTrigger, promptForSchemaInput, selectFunction, selectFeed, selectTrigger } from '../util';
 
 export const queue = Command.make(
   'queue',
@@ -31,7 +31,6 @@ export const queue = Command.make(
   (options) =>
     Effect.gen(function* () {
       const { json } = yield* CommandConfig;
-
       const triggerId = yield* Option.match(options.id, {
         onNone: () => selectTrigger('queue'),
         onSome: (id) => Effect.succeed(id),
@@ -58,7 +57,7 @@ export const queue = Command.make(
 ).pipe(
   Command.withDescription('Update a queue trigger.'),
   Command.provide(({ spaceId }) => spaceLayer(spaceId, true)),
-  Command.provideEffectDiscard(() => withTypes(Function.Function, Trigger.Trigger)),
+  Command.provideEffectDiscard(() => withTypes(Operation.PersistentOperation, Trigger.Trigger)),
 );
 
 /**
@@ -67,10 +66,10 @@ export const queue = Command.make(
  * @returns The current function (either original or newly assigned)
  */
 const updateFunction = Effect.fn(function* (trigger: Trigger.Trigger, functionIdOption: Option.Option<string>) {
-  let currentFn: Function.Function | undefined = trigger.function
+  let currentFn: Operation.PersistentOperation | undefined = trigger.function
     ? yield* Database.load(trigger.function) as any
     : undefined;
-  if (currentFn && !Obj.instanceOf(Function.Function, currentFn)) {
+  if (currentFn && !Obj.instanceOf(Operation.PersistentOperation, currentFn)) {
     currentFn = undefined;
   }
   const currentFunctionName = currentFn ? (currentFn.name ?? currentFn.id) : undefined;
@@ -87,13 +86,13 @@ const updateFunction = Effect.fn(function* (trigger: Trigger.Trigger, functionId
       onNone: () => selectFunction(),
       onSome: (id) => Effect.succeed(id),
     });
-    const functions = yield* Database.runQuery(Filter.type(Function.Function));
+    const functions = yield* Database.runQuery(Filter.type(Operation.PersistentOperation));
     const foundFn = functions.find((fn) => fn.id === functionId);
-    if (!foundFn || !Obj.instanceOf(Function.Function, foundFn)) {
+    if (!foundFn || !Obj.instanceOf(Operation.PersistentOperation, foundFn)) {
       return yield* Effect.fail(new Error(`Function not found: ${functionId}`));
     }
-    Obj.change(trigger, (mutableTrigger) => {
-      mutableTrigger.function = Ref.make(foundFn);
+    Obj.update(trigger, (trigger) => {
+      trigger.function = Ref.make(foundFn);
     });
     currentFn = foundFn;
   }
@@ -126,13 +125,13 @@ const updateQueue = Effect.fn(function* (trigger: Trigger.Trigger, queueOption:
     onSome: () => Effect.succeed(true),
   });
   if (shouldChangeQueue) {
-    const queueDxn = yield* Option.match(queueOption, {
-      onNone: () => selectQueue(),
+    const queueDXN = yield* Option.match(queueOption, {
+      onNone: () => selectFeed(),
       onSome: (dxn) => Effect.succeed(dxn.toString()),
     });
-    Obj.change(trigger, (mutableTrigger) => {
-      if (mutableTrigger.spec?.kind === 'queue') {
-        mutableTrigger.spec.queue = queueDxn;
+    Obj.update(trigger, (trigger) => {
+      if (trigger.spec?.kind === 'queue') {
+        trigger.spec.queue = queueDXN;
       }
     });
   }
@@ -144,7 +143,7 @@ const updateQueue = Effect.fn(function* (trigger: Trigger.Trigger, queueOption:
  */
 const updateInput = Effect.fn(function* (
   trigger: Trigger.Trigger,
-  fn: Function.Function,
+  fn: Operation.PersistentOperation,
   inputOption: Option.Option<Record<string, any>>,
 ) {
   const currentInput = trigger.input as Record<string, any> | undefined;
@@ -166,8 +165,8 @@ const updateInput = Effect.fn(function* (
         promptForSchemaInput(fn.inputSchema ? JsonSchema.toEffectSchema(fn.inputSchema) : undefined, currentInput),
       onSome: (value) => Effect.succeed(value as Record<string, any>),
     });
-    Obj.change(trigger, (mutableTrigger) => {
-      mutableTrigger.input = inputObj;
+    Obj.update(trigger, (trigger) => {
+      trigger.input = inputObj;
     });
   }
 });
@@ -189,7 +188,7 @@ const updateEnabled = Effect.fn(function* (
       }).pipe(Prompt.run),
     onSome: () => Effect.succeed(enabled),
   });
-  Obj.change(trigger, (mutableTrigger) => {
-    mutableTrigger.enabled = enabledValue;
+  Obj.update(trigger, (trigger) => {
+    trigger.enabled = enabledValue;
   });
 });