@dxos/plugin-routine 0.10.0 → 0.11.0

package/dist/types/src/types/Routine.d.ts

@@ -1,55 +0,0 @@
-import * as Schema from 'effect/Schema';
-import { Instructions, Runnable, Trigger } from '@dxos/compute';
-import { Operation } from '@dxos/compute';
-import { Obj, Ref, Type } from '@dxos/echo';
-declare const Kinds: readonly ['runnable', 'instructions'];
-export declare const Kind: Schema.Literal<["runnable", "instructions"]>;
-export type Kind = (typeof Kinds)[number];
-declare const Routine_base: Type.ObjClass<Routine, {
-    readonly name?: string | undefined;
-    readonly description?: string | undefined;
-    readonly spec?: {
-        readonly kind: "runnable";
-        readonly runnable: import("@dxos/echo/internal").Ref<Operation.PersistentOperation & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-    } | {
-        readonly kind: "instructions";
-        readonly instructions: import("@dxos/echo/internal").Ref<Instructions.Instructions & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>;
-    } | undefined;
-    readonly triggers: readonly import("@dxos/echo/internal").Ref<Trigger.Trigger & import("@dxos/echo/Entity").OfKind<import("@dxos/echo/internal").EntityKind.Object> & Obj.Unknown>[];
-}, {}>;
-/**
- * User-facing routine: a thin aggregate of an action (`runnable`) and the triggers that fire it.
- * App-level only — EDGE stays unaware of it (triggers point directly at the runnable).
- */
-export declare class Routine extends Routine_base {
-}
-/** Returns true when value is a Routine object. */
-export declare const instanceOf: (value: unknown) => value is Routine;
-/**
- * The owned Instructions ref of an instructions-action routine, or undefined for an operation action.
- * Classification is explicit in `spec.kind`, so this needs no `.target` dereference; callers resolve the ref
- * reactively (`useObject`) or asynchronously (`Database.load`) as appropriate.
- */
-export declare const instructionsRef: (routine: Pick<Routine, 'spec'>) => Ref.Ref<Instructions.Instructions> | undefined;
-/** The Operation (runnable) ref of an operation-action routine, or undefined for an instructions action. */
-export declare const runnableRef: (routine: Pick<Routine, 'spec'>) => Ref.Ref<Runnable.Runnable> | undefined;
-/**
- * Wire the routine's owned triggers to dispatch its current action (`spec`): an instructions action sets each
- * trigger's `runnable` to RunInstructions with the owned instructions bound into `input`; an operation action
- * binds the operation directly and drops any stale instructions binding. Call after the action (`spec`) changes
- * so a trigger never keeps a binding for the previous action.
- */
-export declare const wireTriggers: (routine: Routine) => void;
-/**
- * Creates a fully-wired in-memory routine graph. `instructions` and `trigger` are optional extras beyond the
- * schema fields: when provided they are parented under the routine and wired together (runnable, trigger
- * runnable, the trigger's instructions input binding, and the `triggers` ref) so that a single `Database.add`
- * cascades the whole graph. `triggers` defaults to `[]` so callers that supply a `trigger` need not provide it.
- */
-export declare const make: ({ instructions, trigger, triggers, ...props }: Omit<Obj.MakeProps<typeof Routine>, 'triggers'> & {
-    triggers?: ReadonlyArray<Ref.Ref<Trigger.Trigger>>;
-    instructions?: Instructions.Instructions;
-    trigger?: Trigger.Trigger;
-}) => Routine;
-export {};
-//# sourceMappingURL=Routine.d.ts.map

package/dist/types/src/types/Routine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Routine.d.ts","sourceRoot":"","sources":["../../../../src/types/Routine.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIhE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAmB,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAK7D,QAAA,MAAM,KAAK,YAAI,UAAU,EAAE,cAAc,CAAU,CAAC;AACpD,eAAO,MAAM,IAAI,8CAA2B,CAAC;AAC7C,MAAM,MAAM,IAAI,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;AAc1C;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,YAyB5B;CAAG;AAEJ,mDAAmD;AACnD,eAAO,MAAM,UAAU,UAAW,OAAO,KAAG,KAAK,IAAI,OAAyC,CAAC;AAE/F;;;;GAIG;AACH,eAAO,MAAM,eAAe,YAAa,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,KAAG,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,YAAY,CAAC,GAAG,SACvB,CAAC;AAEhF,4GAA4G;AAC5G,eAAO,MAAM,WAAW,YAAa,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,KAAG,GAAG,CAAC,GAAG,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,SACnB,CAAC;AAWxE;;;;;GAKG;AACH,eAAO,MAAM,YAAY,YAAa,OAAO,KAAG,IAc/C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI,kDAKd,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,OAAO,OAAO,CAAC,EAAE,UAAU,CAAC,GAAG;IACnD,QAAQ,CAAC,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC;IACnD,YAAY,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC;IACzC,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAC;CAC3B,KAAG,OAiBH,CAAC"}

package/dist/types/src/types/Routine.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=Routine.test.d.ts.map

package/dist/types/src/types/Routine.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Routine.test.d.ts","sourceRoot":"","sources":["../../../../src/types/Routine.test.ts"],"names":[],"mappings":""}

package/src/capabilities/navigation-resolver.ts

@@ -1,21 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import * as Effect from 'effect/Effect';
-
-import { Capability } from '@dxos/app-framework';
-import { AppCapabilities, Paths, TypeSection } from '@dxos/app-toolkit';
-
-import { Routine } from '#types';
-
-export default Capability.makeModule(
-  Effect.fnUntraced(function* () {
-    return [
-      Capability.contributes(
-        AppCapabilities.NavigationPathResolver,
-        TypeSection.createTypeSectionPathResolver(Routine.Routine, { groupId: Paths.GroupSegments.ai }),
-      ),
-    ];
-  }),
-);

package/src/components/MasterDetail/MasterDetail.stories.tsx

@@ -1,100 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import { type Atom } from '@effect-atom/atom-react';
-import { type Meta, type StoryObj } from '@storybook/react-vite';
-import * as Schema from 'effect/Schema';
-import React, { useState } from 'react';
-
-import { Panel, ScrollArea } from '@dxos/react-ui';
-import { Form } from '@dxos/react-ui-form';
-import { withLayout, withTheme } from '@dxos/react-ui/testing';
-
-import { translations } from '#translations';
-
-import { MasterDetail, type MasterDetailIcon } from './MasterDetail';
-
-type Row = { id: string; label: string };
-
-const ROWS: Row[] = [
-  { id: '1', label: 'Daily digest' },
-  { id: '2', label: 'Sync inbox' },
-  { id: '3', label: 'Weekly report' },
-];
-
-const DetailSchema = Schema.Struct({
-  name: Schema.String.annotations({ title: 'Name' }),
-  description: Schema.optional(Schema.String).annotations({ title: 'Description' }),
-});
-
-// Mirrors RoutineForm's gutter (Form.Viewport owns a `Column.Root` gutter); used to check list/detail alignment.
-const MockDetail = ({ row }: { row: Row }) => (
-  <Form.Root schema={DetailSchema} values={{ name: row.label, description: '' }}>
-    <Form.Viewport>
-      <Form.Content>
-        <Form.FieldSet />
-      </Form.Content>
-    </Form.Viewport>
-  </Form.Root>
-);
-
-const getIcon = (_get: Atom.Context): MasterDetailIcon => ({ icon: 'ph--lightning--regular' });
-
-const DefaultStory = () => {
-  const [selectedId, setSelectedId] = useState<string | undefined>('1');
-  const selected = ROWS.find((row) => row.id === selectedId);
-
-  return (
-    <Panel.Root>
-      <Panel.Content asChild className='pt-trim-md'>
-        <ScrollArea.Root orientation='vertical'>
-          <ScrollArea.Viewport>
-            <MasterDetail<Row>
-              classNames='dx-document'
-              items={ROWS}
-              selectedId={selectedId}
-              onSelect={setSelectedId}
-              getLabel={(_get, row) => row.label}
-              getIcon={getIcon}
-              detail={selected ? <MockDetail row={selected} /> : null}
-              emptyLabel='No items'
-            />
-          </ScrollArea.Viewport>
-        </ScrollArea.Root>
-      </Panel.Content>
-    </Panel.Root>
-  );
-};
-
-const meta = {
-  title: 'plugins/plugin-routine/components/MasterDetail',
-  render: DefaultStory,
-  decorators: [withTheme(), withLayout({ layout: 'column' })],
-  parameters: { layout: 'fullscreen', translations },
-} satisfies Meta<typeof DefaultStory>;
-
-export default meta;
-
-type Story = StoryObj<typeof meta>;
-
-export const Default: Story = {};
-
-export const Empty: Story = {
-  render: () => (
-    <Panel.Root>
-      <Panel.Content asChild className='pt-trim-md'>
-        <ScrollArea.Root orientation='vertical'>
-          <ScrollArea.Viewport>
-            <MasterDetail<Row>
-              classNames='dx-document'
-              items={[]}
-              getLabel={(_get, row) => row.label}
-              emptyLabel='No items'
-            />
-          </ScrollArea.Viewport>
-        </ScrollArea.Root>
-      </Panel.Content>
-    </Panel.Root>
-  ),
-};

package/src/components/MasterDetail/MasterDetail.tsx

@@ -1,175 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import { Atom, useAtomValue } from '@effect-atom/atom-react';
-import React, { type ReactNode, useMemo } from 'react';
-
-import { Column, Icon, IconBlock, IconButton, type ThemedClassName, Tooltip, useTranslation } from '@dxos/react-ui';
-import { Empty, OrderedList } from '@dxos/react-ui-list';
-import { type ActionGraphProps, Menu, useMenuBuilder } from '@dxos/react-ui-menu';
-import { getStyles } from '@dxos/ui-theme';
-
-import { meta } from '#meta';
-
-// Prototype master-detail layout, candidate to push down into @dxos/react-ui-list as a reusable
-// component. Presentation-only: a selectable list (master) on top of a single detail pane, with an
-// optional empty state. The parent owns the detail content (the selected item's form, a draft form,
-// etc.) and the selection state.
-
-export type MasterDetailRecord = { id: string };
-
-/** A row's leading icon: same shape as {@link Obj.getIcon} — a Phosphor icon name and an optional hue. */
-export type MasterDetailIcon = { icon: string; hue?: string };
-
-/** A row's trailing adornment: a status icon with a tooltip label (e.g. a 'detached' warning badge). */
-export type MasterDetailAdornment = { icon: string; label: string };
-
-const EMPTY_MENU: ActionGraphProps = { nodes: [], edges: [] };
-
-export type MasterDetailProps<T extends MasterDetailRecord> = ThemedClassName<{
-  items: readonly T[];
-  /** Currently highlighted row; `undefined` clears the selection (e.g. while a draft is active). */
-  selectedId?: string;
-  onSelect?: (id: string | undefined) => void;
-  /**
-   * Build the row's label reactively. Run inside an atom so it can subscribe to the item's state via `get`
-   * (e.g. the object's name) and update live when it changes.
-   */
-  getLabel: (get: Atom.Context, item: T) => string;
-  /**
-   * Build the row's leading icon reactively. Run inside an atom so it can subscribe to the item's state via
-   * `get` (e.g. colour the icon by an `enabled` flag); returns the icon name and optional colour classes.
-   */
-  getIcon?: (get: Atom.Context, item: T) => MasterDetailIcon | undefined;
-  /**
-   * Build the row's trailing adornment reactively (e.g. a status badge). Run inside an atom so it can subscribe
-   * to the item's state via `get`; returns a Phosphor icon name and a tooltip label, or `undefined` for none.
-   */
-  getAdornment?: (get: Atom.Context, item: T) => MasterDetailAdornment | undefined;
-  /**
-   * Build the per-row overflow (three-dots) menu. Run inside each row's `useMenuBuilder`, so it should
-   * subscribe to that item's reactive state via `get` (e.g. an `enabled` flag) — the menu then updates live
-   * without re-rendering the whole list.
-   */
-  getMenu?: (get: Atom.Context, item: T) => ActionGraphProps;
-  /** Message shown when there are no items. */
-  emptyLabel?: string;
-  /** Detail pane content (selected item's form, draft form, …); rendered below the list. */
-  detail?: ReactNode;
-}>;
-
-/** Selectable master list (with an optional per-row overflow menu) above a parent-supplied detail pane. */
-export const MasterDetail = <T extends MasterDetailRecord>({
-  classNames,
-  items,
-  selectedId,
-  onSelect,
-  getLabel,
-  getIcon,
-  getAdornment,
-  getMenu,
-  emptyLabel,
-  detail,
-}: MasterDetailProps<T>) => {
-  // The gutter is owned by a `Column.Root` (not an ad-hoc wrapper) so the list aligns to the surface's
-  // column system: rows and their selection highlight sit in the centre track (`Column.Center`), matching
-  // the inset of the detail's form. The detail bleeds the full width since its own `Form` owns its gutter.
-  return (
-    <Column.Root gutter='sm' classNames={classNames}>
-      <Column.Center>
-        {(items.length === 0 && <Empty label={emptyLabel} />) || (
-          <OrderedList.Root<T> items={items}>
-            {({ items }) => (
-              <OrderedList.Content>
-                {items.map((item) => (
-                  <MasterDetailRow
-                    key={item.id}
-                    item={item}
-                    selected={item.id === selectedId}
-                    getLabel={getLabel}
-                    getIcon={getIcon}
-                    getAdornment={getAdornment}
-                    getMenu={getMenu}
-                    onSelect={onSelect}
-                  />
-                ))}
-              </OrderedList.Content>
-            )}
-          </OrderedList.Root>
-        )}
-      </Column.Center>
-
-      <div className='col-span-full pt-trim-md'>{detail}</div>
-    </Column.Root>
-  );
-};
-
-type MasterDetailRowProps<T extends MasterDetailRecord> = {
-  item: T;
-  selected: boolean;
-  getLabel: (get: Atom.Context, item: T) => string;
-  getIcon?: (get: Atom.Context, item: T) => MasterDetailIcon | undefined;
-  getAdornment?: (get: Atom.Context, item: T) => MasterDetailAdornment | undefined;
-  getMenu?: (get: Atom.Context, item: T) => ActionGraphProps;
-  onSelect?: (id: string | undefined) => void;
-};
-
-const MasterDetailRow = <T extends MasterDetailRecord>({
-  item,
-  selected,
-  getLabel,
-  getIcon,
-  getAdornment,
-  getMenu,
-  onSelect,
-}: MasterDetailRowProps<T>) => {
-  const { t } = useTranslation(meta.profile.key);
-  // Resolve the label, icon, adornment, and actions reactively per row — each subscribes (via `get`) only to
-  // this item's state, so a change (rename, toggling enabled) updates just this row.
-  const label = useAtomValue(useMemo(() => Atom.make((get) => getLabel(get, item)), [getLabel, item]));
-  const icon = useAtomValue(useMemo(() => Atom.make((get) => getIcon?.(get, item)), [getIcon, item]));
-  const adornment = useAtomValue(useMemo(() => Atom.make((get) => getAdornment?.(get, item)), [getAdornment, item]));
-  const menu = useMenuBuilder((get) => getMenu?.(get, item) ?? EMPTY_MENU, [getMenu, item]);
-
-  return (
-    <OrderedList.Item
-      id={item.id}
-      item={item}
-      canDrag={false}
-      hover
-      selected={selected}
-      classNames='flex items-center cursor-pointer p-1'
-      onClick={() => onSelect?.(selected ? undefined : item.id)}
-    >
-      {icon && (
-        <IconBlock>
-          <Icon icon={icon.icon} classNames={icon.hue ? getStyles(icon.hue).text : undefined} />
-        </IconBlock>
-      )}
-      <span className='grow truncate'>{label}</span>
-      {adornment && (
-        <Tooltip.Provider>
-          <Tooltip.Trigger asChild side='bottom' content={adornment.label}>
-            <Icon icon={adornment.icon} />
-          </Tooltip.Trigger>
-        </Tooltip.Provider>
-      )}
-      {getMenu && (
-        <Menu.Root {...menu}>
-          <Menu.Trigger asChild>
-            <IconButton
-              iconOnly
-              variant='ghost'
-              icon='ph--dots-three-vertical--regular'
-              label={t('routine-actions.label')}
-              // Open the menu without toggling row selection.
-              onClick={(event) => event.stopPropagation()}
-            />
-          </Menu.Trigger>
-          <Menu.Content />
-        </Menu.Root>
-      )}
-    </OrderedList.Item>
-  );
-};

package/src/types/Routine.test.ts

@@ -1,51 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-import { describe, test } from 'vitest';
-
-import { Instructions, Operation, Runnable, Trigger } from '@dxos/compute';
-import { Obj, Ref, Type } from '@dxos/echo';
-
-import { blank } from '../templates';
-import { isRunInstructions } from '../util';
-import * as Routine from './Routine';
-
-describe('Routine', () => {
-  test('make produces a typed Routine', ({ expect }) => {
-    const routine = Routine.make({ name: 'Test', triggers: [] });
-    expect(Routine.instanceOf(routine)).toBe(true);
-    expect(Obj.instanceOf(Routine.Routine, routine)).toBe(true);
-    expect(Type.getTypename(Routine.Routine)).toBe('org.dxos.type.routine');
-    expect(Obj.getLabel(routine)).toBe('Test');
-    expect(routine.triggers).toEqual([]);
-    expect(routine.spec).toBeUndefined();
-  });
-
-  test('Runnable seam is currently the Operation type', ({ expect }) => {
-    // MVP: Runnable === Operation. Widening this to a union is the documented next step.
-    expect(Runnable.Runnable).toBe(Operation.PersistentOperation);
-  });
-
-  test('make wires an instructions action so a single add yields a runnable routine', ({ expect }) => {
-    const instructions = Instructions.make({ name: 'Body', text: 'do something' });
-    const trigger = Trigger.make({ spec: Trigger.specTimer('0 9 * * *') });
-    const routine = Routine.make({ name: 'R', instructions, trigger });
-
-    // The routine owns the instructions, and the trigger dispatches RunInstructions with those instructions
-    // bound into the trigger input so no separate persistence step is needed.
-    expect(Routine.instructionsRef(routine)?.target?.id).toBe(instructions.id);
-    expect(routine.triggers[0]?.target?.id).toBe(trigger.id);
-    expect(isRunInstructions(trigger.runnable)).toBe(true);
-    const bound = trigger.input?.instructions;
-    expect(Ref.isRef(bound) ? bound.target?.id : undefined).toBe(instructions.id);
-  });
-
-  describe('blank template', () => {
-    test('is the default no-op template', ({ expect }) => {
-      expect(blank.id).toBe('org.dxos.routine.blank');
-      expect(blank.label).toBe('Blank');
-      expect(typeof blank.scaffold).toBe('function');
-    });
-  });
-});

package/src/types/Routine.ts

@@ -1,144 +0,0 @@
-//
-// Copyright 2026 DXOS.org
-//
-
-// @import-as-namespace
-
-import * as Schema from 'effect/Schema';
-
-import { Instructions, Runnable, Trigger } from '@dxos/compute';
-// Operation is imported so TypeScript can name Operation.PersistentOperation in the emitted .d.ts
-// (Runnable is an alias for Operation.PersistentOperation, so Routine's class type references it).
-// eslint-disable-next-line unused-imports/no-unused-imports
-import { Operation } from '@dxos/compute';
-import { Annotation, DXN, Obj, Ref, Type } from '@dxos/echo';
-import { LabelAnnotation } from '@dxos/echo/internal';
-
-import { runInstructionsRef } from '../util/run-instructions';
-
-const Kinds = ['runnable', 'instructions'] as const;
-export const Kind = Schema.Literal(...Kinds);
-export type Kind = (typeof Kinds)[number];
-
-const RunnableSpec = Schema.Struct({
-  kind: Schema.Literal('runnable'),
-  runnable: Ref.Ref(Runnable.Runnable),
-});
-
-const InstructionsSpec = Schema.Struct({
-  kind: Schema.Literal('instructions'),
-  instructions: Ref.Ref(Instructions.Instructions),
-});
-
-const RoutineSpec = Schema.Union(RunnableSpec, InstructionsSpec);
-
-/**
- * User-facing routine: a thin aggregate of an action (`runnable`) and the triggers that fire it.
- * App-level only — EDGE stays unaware of it (triggers point directly at the runnable).
- */
-export class Routine extends Type.makeObject<Routine>(DXN.make('org.dxos.type.routine', '0.2.0'))(
-  Schema.Struct({
-    name: Schema.String.pipe(Schema.optional),
-    description: Schema.String.pipe(Schema.optional),
-
-    /**
-     * The action to run: either an Operation (`spec.runnable`, bound directly) or the routine's own owned
-     * Instructions (`spec.instructions`). For an Operation action the trigger's `runnable` points at this
-     * Operation. For an Instructions action `spec.instructions` is the owned Instructions object (the operation
-     * is implicitly the static RunInstructions, so no separate operation ref is stored), and the trigger's
-     * `runnable` is RunInstructions with this instructions bound as its input.
-     */
-    // TODO(burdon): Change to Array? Or handle that case with a ComputeGraph runnable.
-    spec: RoutineSpec.pipe(Schema.optional),
-
-    /**
-     * Explicit membership, bi-directional with `trigger.runnable → runnable`. Required (not derived by query)
-     * because the runnable may be a shared registry operation referenced by multiple automations, which would
-     * conflate triggers. MVP enforces length <= 1.
-     */
-    triggers: Schema.Array(Ref.Ref(Trigger.Trigger)),
-  }).pipe(
-    LabelAnnotation.set(['name']),
-    Annotation.IconAnnotation.set({ icon: 'ph--lightning--regular', hue: 'amber' }),
-  ),
-) {}
-
-/** Returns true when value is a Routine object. */
-export const instanceOf = (value: unknown): value is Routine => Obj.instanceOf(Routine, value);
-
-/**
- * The owned Instructions ref of an instructions-action routine, or undefined for an operation action.
- * Classification is explicit in `spec.kind`, so this needs no `.target` dereference; callers resolve the ref
- * reactively (`useObject`) or asynchronously (`Database.load`) as appropriate.
- */
-export const instructionsRef = (routine: Pick<Routine, 'spec'>): Ref.Ref<Instructions.Instructions> | undefined =>
-  routine.spec?.kind === 'instructions' ? routine.spec.instructions : undefined;
-
-/** The Operation (runnable) ref of an operation-action routine, or undefined for an instructions action. */
-export const runnableRef = (routine: Pick<Routine, 'spec'>): Ref.Ref<Runnable.Runnable> | undefined =>
-  routine.spec?.kind === 'runnable' ? routine.spec.runnable : undefined;
-
-/** Strip a stale `instructions` binding from a trigger input. */
-const withoutInstructions = (input: Record<string, unknown> | undefined): Record<string, unknown> | undefined => {
-  if (!input || !('instructions' in input)) {
-    return input;
-  }
-  const { instructions: _drop, ...rest } = input;
-  return rest;
-};
-
-/**
- * Wire the routine's owned triggers to dispatch its current action (`spec`): an instructions action sets each
- * trigger's `runnable` to RunInstructions with the owned instructions bound into `input`; an operation action
- * binds the operation directly and drops any stale instructions binding. Call after the action (`spec`) changes
- * so a trigger never keeps a binding for the previous action.
- */
-export const wireTriggers = (routine: Routine): void => {
-  const instructions = instructionsRef(routine);
-  const fn = instructions ? runInstructionsRef() : runnableRef(routine);
-  for (const ref of routine.triggers) {
-    const trigger = ref.target;
-    if (!trigger) {
-      continue;
-    }
-    Obj.update(trigger, (trigger) => {
-      trigger.runnable = fn;
-      const base = withoutInstructions(trigger.input);
-      trigger.input = instructions ? { input: {}, ...base, instructions } : base;
-    });
-  }
-};
-
-/**
- * Creates a fully-wired in-memory routine graph. `instructions` and `trigger` are optional extras beyond the
- * schema fields: when provided they are parented under the routine and wired together (runnable, trigger
- * runnable, the trigger's instructions input binding, and the `triggers` ref) so that a single `Database.add`
- * cascades the whole graph. `triggers` defaults to `[]` so callers that supply a `trigger` need not provide it.
- */
-export const make = ({
-  instructions,
-  trigger,
-  triggers = [],
-  ...props
-}: Omit<Obj.MakeProps<typeof Routine>, 'triggers'> & {
-  triggers?: ReadonlyArray<Ref.Ref<Trigger.Trigger>>;
-  instructions?: Instructions.Instructions;
-  trigger?: Trigger.Trigger;
-}): Routine => {
-  const routine = Obj.make(Routine, { ...props, triggers });
-  if (instructions) {
-    Obj.setParent(instructions, routine);
-    Obj.update(routine, (routine) => {
-      routine.spec = { kind: 'instructions', instructions: Ref.make(instructions) };
-    });
-  }
-  if (trigger) {
-    Obj.setParent(trigger, routine);
-    Obj.update(routine, (routine) => {
-      routine.triggers.push(Ref.make(trigger));
-    });
-    // Wire the trigger's `runnable`/`input` from the action (`spec`); preserves any template-provided input.
-    wireTriggers(routine);
-  }
-  return routine;
-};