@dxos/plugin-automation 0.8.4-main.fffef41 → 0.8.4-staging.60fe92afc8

package/src/testing/test-functions.ts

@@ -4,14 +4,18 @@
 
 import * as Schema from 'effect/Schema';
 
-import { ContactType } from '@dxos/client/testing';
-import { Type } from '@dxos/echo';
+import { TestSchema } from '@dxos/client/testing';
+import { JsonSchema, Ref, DXN } from '@dxos/echo';
 
+/**
+ * Operations seeded into the local space in stories.
+ */
 export const functions = [
   {
-    name: 'example.com/function/chess',
+    key: DXN.make('com.example.function.chess'),
+    name: 'com.example.function.chess',
     version: '0.1.0',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
         level: Schema.Number.annotations({
           title: 'Level',
@@ -20,10 +24,11 @@ export const functions = [
     ),
   },
   {
-    name: 'example.com/function/forex',
+    key: DXN.make('com.example.function.forex'),
+    name: 'com.example.function.forex',
     version: '0.1.0',
     binding: 'FOREX',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
         from: Schema.String.annotations({ title: 'Currency from' }),
         to: Schema.String.annotations({ title: 'Currency to' }),
@@ -31,11 +36,40 @@ export const functions = [
     ),
   },
   {
-    name: 'example.com/function/ping-contact',
+    key: DXN.make('com.example.function.pingContact'),
+    name: 'com.example.function.ping-contact',
     version: '0.0.1',
-    inputSchema: Type.toJsonSchema(
+    inputSchema: JsonSchema.toJsonSchema(
       Schema.Struct({
-        contact: Type.Ref(ContactType).annotations({ title: 'Contact' }),
+        contact: Ref.Ref(TestSchema.ContactType).annotations({ title: 'Contact' }),
+      }),
+    ),
+  },
+];
+
+/**
+ * Operations seeded into the registry (not the local space) in stories.
+ * Simulates built-in or plugin-provided operations available globally.
+ */
+export const registryFunctions = [
+  {
+    key: 'com.example.function.translate',
+    name: 'com.example.function.translate',
+    version: '0.1.0',
+    inputSchema: JsonSchema.toJsonSchema(
+      Schema.Struct({
+        text: Schema.String.annotations({ title: 'Text' }),
+        targetLanguage: Schema.String.annotations({ title: 'Target language' }),
+      }),
+    ),
+  },
+  {
+    key: 'com.example.function.summarize',
+    name: 'com.example.function.summarize',
+    version: '0.1.0',
+    inputSchema: JsonSchema.toJsonSchema(
+      Schema.Struct({
+        content: Schema.String.annotations({ title: 'Content' }),
       }),
     ),
   },

package/src/testing.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// Eager re-export of `AutomationPlugin`. See `@dxos/plugin-testing/src/core.ts`
+// for the rationale.
+export * from './AutomationPlugin';

package/src/translations.ts

@@ -2,49 +2,65 @@
 // Copyright 2023 DXOS.org
 //
 
+import { Type } from '@dxos/echo';
 import { type Resource } from '@dxos/react-ui';
 
-import { meta } from './meta';
+import { meta } from '#meta';
+import { Automation } from '#types';
 
 export const translations = [
   {
     'en-US': {
+      [Type.getTypename(Automation.Automation)]: {
+        'typename.label': 'Automation',
+        'typename.label_zero': 'Automations',
+        'typename.label_one': 'Automation',
+        'typename.label_other': 'Automations',
+        'object-name.placeholder': 'New automation',
+        'add-object.label': 'Add automation',
+        'rename-object.label': 'Rename automation',
+        'delete-object.label': 'Delete automation',
+      },
       [meta.id]: {
-        'plugin name': 'Automation',
-        'automation panel label': 'Automations',
-        'script automation label': 'Automation',
-        'automation verbose label': 'Manage automations',
-        'automation description': 'You can manage all the triggers which automate your space here.',
-
-        'runtime label': 'Enable Local Runtime',
-        'runtime description':
-          'This will start a trigger dispatcher locally for this space to run triggers on your device while Composer is running.',
-
-        'functions panel label': 'Functions',
-        'functions verbose label': 'Manage deployed functions',
-        'functions registry verbose label': 'Functions registry',
-        'functions registry description': 'Import functions from the registry',
-        'functions description': 'You can manage all the functions deployed from your space on EDGE here.',
-        'function copy id': 'Copy Function ID',
-        'no functions found': 'No functions found',
-        'go to function source button label': 'Show function source',
-        'delete function button label': 'Delete function',
+        'plugin.name': 'Automation',
+        'automation-panel.label': 'Automations',
+        'create-panel.template.placeholder': 'Search templates...',
 
-        'trigger editor title': 'Configure Trigger',
-        'new trigger label': 'Add Trigger',
-        'trigger type timer': 'Timer',
-        'trigger type webhook': 'Webhook',
-        'trigger type websocket': 'Websocket',
-        'trigger type subscription': 'Subscription',
-        'trigger type email': 'Email',
-        'trigger type queue': 'Queue',
+        'automation-name.label': 'Name',
+        'general.title': 'General',
+        'general.description': 'Name and status.',
+        'action.title': 'Action',
+        'action.description': 'What this automation runs.',
+        'action.placeholder': 'Select an operation or routine',
+        'action-input.label': 'Input',
+        'action-kind.operation.label': 'Operation',
+        'action-kind.routine.label': 'Routine',
+        'trigger-picker.title': 'Trigger',
+        'trigger-picker.description': 'When this automation runs.',
+        'trigger-kind.placeholder': 'Select trigger type',
+        'trigger-kind.timer.label': 'Schedule (cron)',
+        'trigger-kind.feed.label': 'Feed',
+        'cron.placeholder': '0 0 * * *',
+        'feed.placeholder': 'Select a feed',
+        'enabled.label': 'Enabled',
+        'enabled.description': 'Turn this automation on or off.',
+        'add-trigger.label': 'Add trigger',
+        'add-trigger-first.message': 'Add a trigger to enable.',
+        'remove-trigger.label': 'Remove',
+        'select-action-first.message': 'Select an action first.',
+        'automation-companion.label': 'Automation',
+        'no-automations.message': 'No automations for this object.',
+        'automation-not-associated.message': 'Not yet associated with this object.',
+        'automation-detached.message': 'No longer associated with this object.',
 
-        'trigger copy url': 'Copy URL',
-        'trigger copy email': 'Copy Email',
+        'automation-verbose.label': 'Manage automations',
+        'automation.description': 'Manage where automations in this space run.',
 
-        'trigger payload add': 'Add',
-        'trigger payload remove': 'Remove',
-        'trigger payload prop name placeholder': 'New payload property name',
+        'runtime.label': 'Runtime location',
+        'runtime.description': 'Determines where automations in this space run.',
+        'runtime.disabled.label': 'Disabled',
+        'runtime.local.label': 'Local',
+        'runtime.edge.label': 'EDGE (experimental)',
       },
     },
   },

package/src/types/Automation.test.ts

@@ -0,0 +1,37 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { describe, test } from 'vitest';
+
+import { Operation } from '@dxos/compute';
+import { Obj, Type } from '@dxos/echo';
+
+import { blank } from '../templates';
+import * as Automation from './Automation';
+import * as Runnable from './Runnable';
+
+describe('Automation', () => {
+  test('make produces a typed Automation', ({ expect }) => {
+    const automation = Automation.make({ name: 'Test', triggers: [] });
+    expect(Automation.instanceOf(automation)).toBe(true);
+    expect(Obj.instanceOf(Automation.Automation, automation)).toBe(true);
+    expect(Type.getTypename(Automation.Automation)).toBe('org.dxos.type.automation');
+    expect(Obj.getLabel(automation)).toBe('Test');
+    expect(automation.triggers).toEqual([]);
+    expect(automation.runnable).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);
+  });
+
+  describe('blank template', () => {
+    test('is the default no-op template', ({ expect }) => {
+      expect(blank.id).toBe('org.dxos.automation.blank');
+      expect(blank.label).toBe('Blank');
+      expect(typeof blank.scaffold).toBe('function');
+    });
+  });
+});

package/src/types/Automation.ts

@@ -0,0 +1,45 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { DXN, Annotation, Obj, Ref, Type } from '@dxos/echo';
+import { LabelAnnotation } from '@dxos/echo/internal';
+
+import * as Runnable from './Runnable';
+
+/**
+ * User-facing automation: 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 const Automation = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
+  /**
+   * The action to run. A trigger's `function` Ref points directly at this (so EDGE/the dispatcher can run
+   * it). `Runnable` is the type seam — currently just Operation; see Runnable.ts.
+   */
+  runnable: Ref.Ref(Runnable.Runnable).pipe(Schema.optional),
+  /**
+   * Explicit membership, bi-directional with `trigger.function → 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.
+   *
+   * Typed as `Obj.Unknown` (not `Trigger`) to avoid pulling query-AST types into the emitted declaration —
+   * the same reason `Trigger.function` uses `Obj.Unknown`. Resolve and narrow with `Obj.instanceOf(Trigger)`.
+   */
+  triggers: Schema.Array(Ref.Ref(Obj.Unknown)),
+}).pipe(
+  LabelAnnotation.set(['name']),
+  Annotation.IconAnnotation.set({ icon: 'ph--lightning--regular', hue: 'amber' }),
+  Type.makeObject(DXN.make('org.dxos.type.automation', '0.1.0')),
+);
+
+export type Automation = Type.InstanceType<typeof Automation>;
+
+export const instanceOf = (value: unknown): value is Automation => Obj.instanceOf(Automation, value);
+
+export const make = (props: Obj.MakeProps<typeof Automation>) => Obj.make(Automation, props);

package/src/types/AutomationCapabilities.ts

@@ -0,0 +1,52 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import type * as Effect from 'effect/Effect';
+
+import { Capability } from '@dxos/app-framework';
+import type { Database, Obj } from '@dxos/echo';
+import { type DelegationStrategy } from '@dxos/functions-runtime';
+
+import * as Automation from './Automation';
+
+/**
+ * Optional supervisor strategy for the agent chat service. When contributed (by a plugin that knows
+ * the agent/plan model, e.g. plugin-assistant), the conversational agent delegates outstanding work
+ * to sub-agents and folds their results back into the conversation. Consumed by the AgentService
+ * LayerSpec; absent by default (a plain conversational agent).
+ */
+export const AgentDelegationStrategy = Capability.make<DelegationStrategy>(
+  'org.dxos.plugin.automation.capability.agentDelegationStrategy',
+);
+
+/**
+ * An automation template contributed by a plugin. The create dialog and the per-object "Automations"
+ * companion list contributed templates (`Capability.getAll(AutomationCapabilities.Template)`) and run the
+ * chosen template's `scaffold` to build the automation.
+ */
+export type Template = {
+  /** Stable id (e.g. 'org.dxos.automation.blank'). */
+  id: string;
+  /** Human-readable label shown in the picker. */
+  label: string;
+  /** Optional Phosphor icon name. */
+  icon?: string;
+  /**
+   * Whether this template applies to the given companion subject. The subject is the object whose
+   * "Automations" companion is open, or undefined in the global create dialog. Templates that need a
+   * specific subject (e.g. a feed-bearing Mailbox) gate themselves here. Defaults to always-applies.
+   */
+  appliesTo?: (subject?: Obj.Unknown) => boolean;
+  /**
+   * Build the Automation from the user's input. The returned Automation is added to the database by the
+   * create flow; any auxiliary objects (runnable, triggers) must be added by the scaffold itself via
+   * Database.Service. `subject` is set when scaffolding from an object's companion.
+   */
+  scaffold: (ctx: {
+    name?: string;
+    subject?: Obj.Unknown;
+  }) => Effect.Effect<Automation.Automation, Error, Database.Service>;
+};
+
+export const Template = Capability.make<Template>('org.dxos.plugin.automation.capability.template');

package/src/types/AutomationOperation.ts

@@ -0,0 +1,61 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+// @import-as-namespace
+
+import * as Schema from 'effect/Schema';
+
+import { Capability } from '@dxos/app-framework';
+import { Operation } from '@dxos/compute';
+import { Database, DXN, Obj } from '@dxos/echo';
+// Value-side `EID` import keeps TS declaration emit portable — `TriggerTemplate`
+// references `EID.Schema` and the inferred `CreateTriggerFromTemplate` type
+// otherwise needs a transitive `@dxos/keys` import that's hard for d.ts emit to surface.
+import { EID as _EchoURIReference } from '@dxos/keys';
+
+import { meta } from '#meta';
+
+import { TriggerTemplate } from './schema';
+export { _EchoURIReference };
+
+const makeKey = (name: string) => DXN.make(`${meta.id}.operation.${name}`);
+
+export const CreateTriggerFromTemplate = Operation.make({
+  meta: {
+    key: makeKey('createTriggerFromTemplate'),
+    name: 'Create Trigger From Template',
+    icon: 'ph--lightning--regular',
+  },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    db: Database.Database,
+    template: TriggerTemplate,
+    enabled: Schema.optional(Schema.Boolean),
+    scriptName: Schema.optional(Schema.String),
+    input: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
+  }),
+  output: Schema.Void,
+});
+
+// The single creation entrypoint for every path (create dialog, companion, sidebar) so placement and
+// ownership are established in one place. Output mirrors `SpaceCapabilities.CreateObjectResult`.
+export const CreateAutomation = Operation.make({
+  meta: {
+    key: makeKey('createAutomation'),
+    name: 'Create Automation',
+    icon: 'ph--lightning--regular',
+  },
+  services: [Capability.Service],
+  input: Schema.Struct({
+    db: Database.Database,
+    templateId: Schema.String,
+    name: Schema.optional(Schema.String),
+    subject: Schema.optional(Obj.Unknown),
+  }),
+  output: Schema.Struct({
+    id: Schema.String,
+    subject: Schema.Array(Schema.String),
+    object: Obj.Unknown,
+  }),
+});

package/src/types/Runnable.ts

@@ -0,0 +1,14 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+// @import-as-namespace
+
+import { Operation } from '@dxos/compute';
+
+// TODO(wittjosiah): Currently just Operation. Widen to a union (Operation | ComputeGraph | …) once the
+// dispatcher/EDGE can run non-Operation runnables as a Process; factor down to @dxos/compute once
+// ComputeGraph's type moves there. Routines are NOT a direct member — they run via the AgentPrompt
+// operation (bound as input).
+export type Runnable = Operation.PersistentOperation;
+export const Runnable = Operation.PersistentOperation;

package/src/types/index.ts

@@ -3,3 +3,8 @@
 //
 
 export * from './schema';
+
+export * as Automation from './Automation';
+export * as AutomationCapabilities from './AutomationCapabilities';
+export * as AutomationOperation from './AutomationOperation';
+export * as Runnable from './Runnable';

package/src/types/schema.ts

@@ -4,21 +4,21 @@
 
 import * as Schema from 'effect/Schema';
 
-import { SpaceSchema } from '@dxos/react-client/echo';
+import { Database } from '@dxos/echo';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
-const TriggerTemplate = Schema.Union(
+export const TriggerTemplate = Schema.Union(
   Schema.Struct({ type: Schema.Literal('timer'), cron: Schema.String }),
-  Schema.Struct({ type: Schema.Literal('queue'), queueDXN: Schema.Any }),
+  Schema.Struct({ type: Schema.Literal('feed'), feed: Schema.Any }),
 );
 
 export namespace AutomationAction {
   export class CreateTriggerFromTemplate extends Schema.TaggedClass<CreateTriggerFromTemplate>()(
-    `${meta.id}/action/create-trigger-from-template`,
+    `${meta.id}.action.create-trigger-from-template`,
     {
       input: Schema.Struct({
-        space: SpaceSchema,
+        db: Database.Database,
         template: TriggerTemplate,
         enabled: Schema.optional(Schema.Boolean),
         // TODO(wittjosiah): Improve how this lookup is done.

package/src/util/automations-for-object.test.ts

@@ -0,0 +1,86 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { describe, test } from 'vitest';
+
+import { Trigger } from '@dxos/compute';
+import { type Database, DXN, Feed, Obj, Ref, Type } from '@dxos/echo';
+import { EffectEx } from '@dxos/effect';
+import { EID, URI } from '@dxos/keys';
+import { ClientCapabilities, ClientEvents } from '@dxos/plugin-client';
+import { ClientPlugin, initializeIdentity } from '@dxos/plugin-client/testing';
+import { createComposerTestApp } from '@dxos/plugin-testing/harness';
+
+import { Automation } from '#types';
+
+import { automationsForObject, connectedAutomationsQuery } from './automations-for-object';
+
+// A minimal feed-annotated host (like a mailbox): an object holding a `feed` ref.
+const FeedHost = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  feed: Ref.Ref(Feed.Feed),
+}).pipe(Type.makeObject(DXN.make('org.dxos.test.feedHost', '0.1.0')));
+
+const types = [Automation.Automation, Trigger.Trigger, Feed.Feed, FeedHost];
+
+const initSpace = async (harness: Awaited<ReturnType<typeof createComposerTestApp>>) => {
+  const { personalSpace } = await EffectEx.runAndForwardErrors(
+    initializeIdentity(harness.get(ClientCapabilities.Client)),
+  );
+  await harness.waitForEvent(ClientEvents.SpacesReady);
+  return personalSpace.db;
+};
+
+const connectedIds = (db: Database.Database, object: Obj.Unknown) =>
+  db
+    .query(connectedAutomationsQuery(object))
+    .run()
+    .then((automations) => automations.map((automation) => automation.id).sort());
+
+// Build a space-qualified ref like the RefField object picker does (from the entity's fully-qualified URI),
+// rather than the bare ref `Ref.make` produces — this is the encoding real triggers carry, and it exercises
+// the reverse-ref EID normalization that lets qualified refs match a space-less anchor.
+const qualifiedRef = (db: Database.Database, object: Obj.Unknown) =>
+  Ref.fromURI(URI.make(EID.make({ spaceId: db.spaceId, entityId: object.id })));
+
+describe('automations connected to an object', () => {
+  test('input-ref: trigger whose nested input references the object', async ({ expect }) => {
+    await using harness = await createComposerTestApp({ plugins: [ClientPlugin({ types })] });
+    const db = await initSpace(harness);
+
+    const target = db.add(Automation.make({ name: 'target', triggers: [] }));
+    const other = db.add(Automation.make({ name: 'other', triggers: [] }));
+    // The target ref is nested in the trigger's untyped `input` record, and is space-qualified like a
+    // picker-created ref.
+    const trigger = db.add(Trigger.make({ input: { subject: qualifiedRef(db, target) } }));
+    const owner = db.add(Automation.make({ name: 'owner', triggers: [Ref.make(trigger)] }));
+    await db.flush();
+
+    expect(automationsForObject(target, [owner, other]).map((automation) => automation.id)).toEqual([owner.id]);
+    expect(automationsForObject(other, [owner])).toEqual([]);
+
+    // Poll to absorb index latency; the query resolves via the reverse-ref index.
+    await expect.poll(() => connectedIds(db, target), { timeout: 5_000 }).toEqual([owner.id]);
+    await expect.poll(() => connectedIds(db, other), { timeout: 5_000 }).toEqual([]);
+  });
+
+  test('feed-ref: feed trigger bound to the object’s feed', async ({ expect }) => {
+    await using harness = await createComposerTestApp({ plugins: [ClientPlugin({ types })] });
+    const db = await initSpace(harness);
+
+    const feed = db.add(Feed.make());
+    const host = db.add(Obj.make(FeedHost, { name: 'mailbox', feed: Ref.make(feed) }));
+    const other = db.add(Automation.make({ name: 'other', triggers: [] }));
+    // Picker-created feed refs are space-qualified (unlike `Trigger.specFeed`'s bare `Ref.make`); the host's
+    // own feed ref is bare (code-created). They must still match through the reverse-ref index.
+    const feedTrigger = db.add(Trigger.make({ spec: { kind: 'feed', feed: qualifiedRef(db, feed) } }));
+    const owner = db.add(Automation.make({ name: 'feed-owner', triggers: [Ref.make(feedTrigger)] }));
+    await db.flush();
+
+    expect(automationsForObject(host, [owner, other]).map((automation) => automation.id)).toEqual([owner.id]);
+
+    await expect.poll(() => connectedIds(db, host), { timeout: 5_000 }).toEqual([owner.id]);
+  });
+});

package/src/util/automations-for-object.ts

@@ -0,0 +1,72 @@
+//
+// Copyright 2026 DXOS.org
+//
+
+import { Trigger } from '@dxos/compute';
+import { Filter, Obj, Query, Ref } from '@dxos/echo';
+
+import { Automation } from '#types';
+
+/**
+ * Reactive query for the automations connected to an object O — without a stored association field.
+ *
+ * Association is derived: an automation is connected when one of its triggers references O, either via a
+ * `Ref` anywhere in the trigger's `input` (e.g. a magazine passed into AgentPrompt's input) or via a feed
+ * trigger whose `spec.feed` resolves to `O.feed` (feed-annotated hosts like mailboxes). Both are reachable
+ * by reverse-reference traversal because ECHO's reverse-ref index is structural — it records every ref in a
+ * document regardless of schema path (incl. untyped records and union-nested fields). The traversal is two
+ * hops: O ← Trigger ← Automation.
+ */
+export const connectedAutomationsQuery = (object: Obj.Unknown): Query.Query<Automation.Automation> => {
+  // Triggers referencing O directly (any path, incl. nested in the untyped `input` record).
+  const byInput = Query.select(Filter.id(object.id)).referencedBy(Trigger.Trigger);
+  // Triggers referencing O's feed; `.reference('feed')` reads the path structurally and is empty for objects
+  // without a feed prop, so this branch contributes nothing for non-feed objects.
+  const byFeed = Query.select(Filter.id(object.id)).reference('feed').referencedBy(Trigger.Trigger);
+  return Query.all(byInput, byFeed).referencedBy(Automation.Automation, 'triggers');
+};
+
+/**
+ * Pure predicate equivalent of {@link connectedAutomationsQuery}, over a pre-queried list of automations.
+ * Kept for unit tests (asserting the query and predicate agree) and the deferred quick-association check.
+ */
+export const automationsForObject = (
+  object: Obj.Unknown,
+  automations: Automation.Automation[],
+): Automation.Automation[] => automations.filter((automation) => automationReferencesObject(automation, object));
+
+export const automationReferencesObject = (automation: Automation.Automation, object: Obj.Unknown): boolean => {
+  const objectFeedId = getFeedId(object);
+  return automation.triggers.some((ref) => {
+    const trigger = ref.target;
+    if (!Obj.instanceOf(Trigger.Trigger, trigger)) {
+      return false;
+    }
+
+    if (trigger.spec?.kind === 'feed' && objectFeedId && trigger.spec.feed?.target?.id === objectFeedId) {
+      return true;
+    }
+
+    return trigger.input != null && referencesId(trigger.input, object.id);
+  });
+};
+
+/** The feed id a feed-annotated object points at (e.g. `mailbox.feed`), if any. */
+const getFeedId = (object: Obj.Unknown): string | undefined => {
+  const feedRef = (object as { feed?: Ref.Ref<unknown> }).feed;
+  return Ref.isRef(feedRef) ? feedRef.target?.id : undefined;
+};
+
+/** Recursively scan a value for a Ref whose target is the given object id. */
+const referencesId = (value: unknown, id: string): boolean => {
+  if (Ref.isRef(value)) {
+    return value.target?.id === id;
+  }
+  if (Array.isArray(value)) {
+    return value.some((entry) => referencesId(entry, id));
+  }
+  if (value && typeof value === 'object') {
+    return Object.values(value).some((entry) => referencesId(entry, id));
+  }
+  return false;
+};

package/src/vite-env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+//
+// Copyright 2026 DXOS.org
+//
+
+declare module '*.mdl?raw' {
+  const content: string;
+  export default content;
+}

package/dist/lib/browser/AutomationPanel-7OECLR5N.mjs

@@ -1,11 +0,0 @@
-import {
-  AutomationPanel,
-  AutomationPanel_default
-} from "./chunk-QKFBHAGN.mjs";
-import "./chunk-JW7XSPYW.mjs";
-import "./chunk-LZQFZO3B.mjs";
-export {
-  AutomationPanel,
-  AutomationPanel_default as default
-};
-//# sourceMappingURL=AutomationPanel-7OECLR5N.mjs.map