@dxos/functions 0.5.3-main.d7fe7b5 → 0.5.3-main.eb56347

package/src/testing/functions-integration.test.ts

@@ -13,7 +13,7 @@ import { Invitation } from '@dxos/protocols/proto/dxos/client/services';
 import { describe, test } from '@dxos/test';
 
 import { setTestCallHandler } from './test/handler';
-import { FunctionRegistry } from '../registry';
+import { FunctionRegistry } from '../function';
 import { DevServer, Scheduler } from '../runtime';
 import { createFunctionRuntime, createInitializedClients, TestType } from '../testing';
 import { TriggerRegistry } from '../trigger';

package/src/testing/setup.ts

@@ -10,7 +10,7 @@ import { range } from '@dxos/util';
 import { TestType } from './types';
 import { FunctionDef, FunctionTrigger } from '../types';
 
-// TODO(burdon): Create TestBuilder.
+// TODO(burdon): Create new or extend existing TestBuilder.
 
 export const createInitializedClients = async (testBuilder: TestBuilder, count: number = 1, config?: Config) => {
   const clients = range(count).map(() => new Client({ config, services: testBuilder.createLocalClientServices() }));

package/src/trigger/trigger-registry.test.ts

@@ -11,7 +11,7 @@ import { type Space } from '@dxos/client/echo';
 import { TestBuilder } from '@dxos/client/testing';
 import { Context } from '@dxos/context';
 import { Filter } from '@dxos/echo-db';
-import { create } from '@dxos/echo-schema';
+import { create, splitMeta } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 import { range } from '@dxos/util';
 
@@ -19,9 +19,17 @@ import { TriggerRegistry } from './trigger-registry';
 import { createInitializedClients, TestType, triggerWebhook } from '../testing';
 import { type FunctionManifest, FunctionTrigger } from '../types';
 
-const testManifest: FunctionManifest = {
+const manifest: FunctionManifest = {
   triggers: [
     {
+      '@meta': {
+        keys: [
+          {
+            source: 'example.com',
+            id: 'trigger-1',
+          },
+        ],
+      },
       function: 'example.com/function/webhook-test',
       spec: {
         type: 'webhook',
@@ -29,10 +37,22 @@ const testManifest: FunctionManifest = {
       },
     },
     {
+      '@meta': {
+        keys: [
+          {
+            source: 'example.com',
+            id: 'trigger-2',
+          },
+        ],
+      },
       function: 'example.com/function/subscription-test',
       spec: {
         type: 'subscription',
-        filter: [{ type: TestType.typename }],
+        filter: [
+          {
+            type: TestType.typename,
+          },
+        ],
       },
     },
   ],
@@ -57,11 +77,12 @@ describe('trigger registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       const { objects } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      expect(objects.length).to.eq(testManifest.triggers?.length);
-      const expected = testManifest.triggers?.map((t) => t.function).sort();
-      expect(objects.map((o: FunctionTrigger) => o.function).sort()).to.deep.eq(expected);
+      expect(objects.length).to.eq(manifest.triggers?.length);
+
+      const expected = manifest.triggers?.map((trigger) => trigger.function).sort();
+      expect(objects.map((object: FunctionTrigger) => object.function).sort()).to.deep.eq(expected);
     });
   });
 
@@ -70,13 +91,13 @@ describe('trigger registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const callbackInvoked = new Trigger();
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const webhookTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'webhook')!;
+      const webhookTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'webhook')!;
       await registry.activate({ space }, webhookTrigger, async () => {
         callbackInvoked.wake();
         return 200;
@@ -90,15 +111,16 @@ describe('trigger registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const inactiveTrigger = registry.getInactiveTriggers(space)[0];
       await registry.activate({ space }, inactiveTrigger, async () => 200);
 
       const updatedInactiveList = registry.getInactiveTriggers(space);
-      expect(updatedInactiveList.find((t: FunctionTrigger) => t.function === inactiveTrigger.function)).to.be.undefined;
+      expect(updatedInactiveList.find((trigger: FunctionTrigger) => trigger.function === inactiveTrigger.function)).to
+        .be.undefined;
     });
   });
 
@@ -107,12 +129,12 @@ describe('trigger registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'subscription')!;
+      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
       let count = 0;
       await registry.activate({ space }, echoTrigger, async () => {
         count++;
@@ -124,7 +146,6 @@ describe('trigger registry', () => {
       expect(count).to.eq(1);
 
       space.db.remove(echoTrigger);
-
       space.db.add(create(TestType, { title: '2' }));
       await sleep(20);
       expect(count).to.eq(1);
@@ -134,12 +155,12 @@ describe('trigger registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const space = await client.spaces.create();
       const registry = createRegistry(client);
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
-      await waitHasInactiveTriggers(registry, space);
+      await waitForInactiveTriggers(registry, space);
 
       const { objects: allTriggers } = await space.db.query(Filter.schema(FunctionTrigger)).run();
-      const echoTrigger = allTriggers.find((t: FunctionTrigger) => t.spec.type === 'subscription')!;
+      const echoTrigger = allTriggers.find((trigger: FunctionTrigger) => trigger.spec.type === 'subscription')!;
       let count = 0;
       await registry.activate({ space }, echoTrigger, async () => {
         count++;
@@ -155,19 +176,20 @@ describe('trigger registry', () => {
   });
 
   describe('trigger events', () => {
-    test('event fired when all registered when opened', async () => {
+    test.only('event fired when all registered when opened', async () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const registry = createRegistry(client);
-      const triggers = createTriggersInSpace(client.spaces.default, 3);
+      const triggers = createTriggers(client.spaces.default, 3);
 
       const triggersRegistered = new Trigger<FunctionTrigger[]>();
       registry.registered.on((fn) => {
         expect(fn.space.key.toHex()).to.eq(client.spaces.default.key.toHex());
         triggersRegistered.wake(fn.triggers);
       });
+
       void registry.open(ctx);
       const functions = await triggersRegistered.wait();
-      const expected = triggers.map((obj) => obj.id).sort();
+      const expected = triggers.map((object) => object.id).sort();
       expect(functions.map((fn) => fn.id).sort()).to.deep.eq(expected);
     });
 
@@ -182,16 +204,16 @@ describe('trigger registry', () => {
         triggerRegistered.wake(fn.triggers[0]);
       });
       await registry.open(ctx);
-      await registry.register(space, { triggers: testManifest?.triggers?.slice(0, 1) });
+      await registry.register(space, { triggers: manifest?.triggers?.slice(0, 1) });
       const registered = await triggerRegistered.wait();
-      expect(registered.function).to.eq(testManifest.triggers![0].function);
+      expect(registered.function).to.eq(manifest.triggers![0].function);
     });
 
     test('event fired when a new trigger is removed', async () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      const triggers = createTriggersInSpace(space, 3);
+      const triggers = createTriggers(space, 3);
 
       const triggerLoaded = new Trigger();
       registry.registered.on((fn) => triggerLoaded.wake());
@@ -201,7 +223,7 @@ describe('trigger registry', () => {
         expect(fn.triggers.length).to.eq(1);
         triggerRemoved.wake(fn.triggers[0]);
       });
-      await registry.register(space, testManifest);
+      await registry.register(space, manifest);
       await registry.open(ctx);
       await triggerLoaded.wait();
 
@@ -211,19 +233,23 @@ describe('trigger registry', () => {
     });
   });
 
-  const waitHasInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
-    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
-  };
-
   const createRegistry = (client: Client) => {
     const registry = new TriggerRegistry(client);
     ctx.onDispose(() => registry.close());
     return registry;
   };
 
-  const createTriggersInSpace = (space: Space, count: number) => {
-    const triggers = range(count, () => create(FunctionTrigger, { ...testManifest.triggers![0] }));
-    triggers.forEach((def) => space.db.add(def));
+  const createTriggers = (space: Space, count: number) => {
+    const triggers = range(count, () => {
+      const { meta, object } = splitMeta(manifest.triggers![0]);
+      return create(FunctionTrigger, object, meta);
+    });
+
+    triggers.forEach((trigger) => space.db.add(trigger));
     return triggers;
   };
+
+  const waitForInactiveTriggers = async (registry: TriggerRegistry, space: Space) => {
+    await waitForCondition({ condition: () => registry.getInactiveTriggers(space).length > 0 });
+  };
 });

package/src/trigger/trigger-registry.ts

@@ -4,12 +4,13 @@
 
 import { Event } from '@dxos/async';
 import { type Client } from '@dxos/client';
-import { create, Filter, type Space } from '@dxos/client/echo';
+import { create, Filter, getMeta, type Space } from '@dxos/client/echo';
 import { Context, Resource } from '@dxos/context';
+import { ECHO_ATTR_META, foreignKey, foreignKeyEquals, splitMeta } from '@dxos/echo-schema';
 import { invariant } from '@dxos/invariant';
 import { PublicKey } from '@dxos/keys';
 import { log } from '@dxos/log';
-import { ComplexMap } from '@dxos/util';
+import { ComplexMap, diff, intersection } from '@dxos/util';
 
 import { createSubscriptionTrigger, createTimerTrigger, createWebhookTrigger, createWebsocketTrigger } from './type';
 import { type FunctionManifest, FunctionTrigger, type FunctionTriggerType, type TriggerSpec } from '../types';
@@ -96,17 +97,28 @@ export class TriggerRegistry extends Resource {
     if (!manifest.triggers?.length) {
       return;
     }
-    if (!space.db.graph.runtimeSchemaRegistry.isSchemaRegistered(FunctionTrigger)) {
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
       space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
     }
 
-    const reactiveObjects = manifest.triggers.map((template: Omit<FunctionTrigger, 'id'>) =>
-      create(FunctionTrigger, { ...template }),
-    );
-    reactiveObjects.forEach((obj) => space.db.add(obj));
+    // Sync triggers.
+    const { objects: existing } = await space.db.query(Filter.schema(FunctionTrigger)).run();
+    const { added } = diff(existing, manifest.triggers, (a, b) => {
+      // Create FK to enable syncing if none are set.
+      // TODO(burdon): Warn if not unique.
+      const keys = b[ECHO_ATTR_META]?.keys ?? [foreignKey('manifest', [b.function, b.spec.type].join('-'))];
+      return intersection(getMeta(a)?.keys ?? [], keys, foreignKeyEquals).length > 0;
+    });
+
+    // TODO(burdon): Update existing.
+    added.forEach((trigger) => {
+      const { meta, object } = splitMeta(trigger);
+      space.db.add(create(FunctionTrigger, object, meta));
+    });
   }
 
   protected override async _open(): Promise<void> {
+    log.info('open...');
     const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
       for (const space of spaces) {
         if (this._triggersBySpaceKey.has(space.key)) {
@@ -119,12 +131,15 @@ export class TriggerRegistry extends Resource {
         if (this._ctx.disposed) {
           break;
         }
-        const functionsSubscription = space.db.query(Filter.schema(FunctionTrigger)).subscribe(async (triggers) => {
-          await this._handleRemovedTriggers(space, triggers.objects, registered);
-          this._handleNewTriggers(space, triggers.objects, registered);
-        });
 
-        this._ctx.onDispose(functionsSubscription);
+        // Subscribe to updates.
+        this._ctx.onDispose(
+          space.db.query(Filter.schema(FunctionTrigger)).subscribe(async (triggers) => {
+            log.info('update', { space: space.key, triggers: triggers.objects.length });
+            await this._handleRemovedTriggers(space, triggers.objects, registered);
+            this._handleNewTriggers(space, triggers.objects, registered);
+          }),
+        );
       }
     });
 
@@ -132,6 +147,7 @@ export class TriggerRegistry extends Resource {
   }
 
   protected override async _close(_: Context): Promise<void> {
+    log.info('close...');
     this._triggersBySpaceKey.clear();
   }
 
@@ -143,7 +159,10 @@ export class TriggerRegistry extends Resource {
     if (newTriggers.length > 0) {
       const newRegisteredTriggers: RegisteredTrigger[] = newTriggers.map((trigger) => ({ trigger }));
       registered.push(...newRegisteredTriggers);
-      log('registered new triggers', () => ({ spaceKey: space.key, functions: newTriggers.map((t) => t.function) }));
+      log.info('added', () => ({
+        spaceKey: space.key,
+        triggers: newTriggers.map((trigger) => trigger.function),
+      }));
       this.registered.emit({ space, triggers: newTriggers });
     }
   }
@@ -158,6 +177,12 @@ export class TriggerRegistry extends Resource {
       const wasRemoved =
         allTriggers.find((trigger: FunctionTrigger) => trigger.id === registered[i].trigger.id) == null;
       if (wasRemoved) {
+        if (removed.length) {
+          log.info('removed', () => ({
+            spaceKey: space.key,
+            triggers: removed.map((trigger) => trigger.function),
+          }));
+        }
         const unregistered = registered.splice(i, 1)[0];
         await unregistered.activationCtx?.dispose();
         removed.push(unregistered.trigger);

package/src/trigger/type/subscription-trigger.ts

@@ -3,7 +3,7 @@
 //
 
 import { TextV0Type } from '@braneframe/types';
-import { debounce, DeferredTask } from '@dxos/async';
+import { debounce, UpdateScheduler } from '@dxos/async';
 import { type Context } from '@dxos/context';
 import { createSubscription, Filter, getAutomergeObjectCore, type Query } from '@dxos/echo-db';
 import { log } from '@dxos/log';
@@ -18,26 +18,33 @@ export const createSubscriptionTrigger: TriggerFactory<SubscriptionTrigger> = as
   callback: TriggerCallback,
 ) => {
   const objectIds = new Set<string>();
-  const task = new DeferredTask(ctx, async () => {
-    if (objectIds.size > 0) {
-      await callback({ objects: Array.from(objectIds) });
-      objectIds.clear();
-    }
-  });
+  const task = new UpdateScheduler(
+    ctx,
+    async () => {
+      if (objectIds.size > 0) {
+        const objects = Array.from(objectIds);
+        objectIds.clear();
+        await callback({ objects });
+      }
+    },
+    { maxFrequency: 4 },
+  );
 
   // TODO(burdon): Don't fire initially?
   // TODO(burdon): Create queue. Only allow one invocation per trigger at a time?
   const subscriptions: (() => void)[] = [];
   const subscription = createSubscription(({ added, updated }) => {
-    log.info('updated', { added: added.length, updated: updated.length });
+    const sizeBefore = objectIds.size;
     for (const object of added) {
       objectIds.add(object.id);
     }
     for (const object of updated) {
       objectIds.add(object.id);
     }
-
-    task.schedule();
+    if (objectIds.size > sizeBefore) {
+      log.info('updated', { added: added.length, updated: updated.length });
+      task.trigger();
+    }
   });
 
   subscriptions.push(() => subscription.unsubscribe());

package/src/types.ts

@@ -2,10 +2,7 @@
 // Copyright 2023 DXOS.org
 //
 
-import { AST, S, TypedObject } from '@dxos/echo-schema';
-
-// TODO(burdon): Factor out.
-const omitEchoId = <T>(schema: S.Schema<T>): S.Schema<Omit<T, 'id'>> => S.make(AST.omit(schema.ast, ['id']));
+import { RawObject, S, TypedObject } from '@dxos/echo-schema';
 
 /**
  * Type discriminator for TriggerSpec.
@@ -15,30 +12,36 @@ const omitEchoId = <T>(schema: S.Schema<T>): S.Schema<Omit<T, 'id'>> => S.make(A
  */
 export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
 
-const SubscriptionTriggerSchema = S.struct({
-  type: S.literal('subscription'),
-  // TODO(burdon): Define query DSL.
-  filter: S.array(
-    S.struct({
-      type: S.string,
-      props: S.optional(S.record(S.string, S.any)),
-    }),
-  ),
-  options: S.optional(
-    S.struct({
-      // Watch changes to object (not just creation).
-      deep: S.optional(S.boolean),
-      // Debounce changes (delay in ms).
-      delay: S.optional(S.number),
-    }),
-  ),
-});
+const SubscriptionTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('subscription'),
+    // TODO(burdon): Define query DSL (from ECHO).
+    filter: S.array(
+      S.struct({
+        type: S.string,
+        props: S.optional(S.record(S.string, S.any)),
+      }),
+    ),
+    options: S.optional(
+      S.struct({
+        // Watch changes to object (not just creation).
+        deep: S.optional(S.boolean),
+        // Debounce changes (delay in ms).
+        delay: S.optional(S.number),
+      }),
+    ),
+  }),
+);
+
 export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
 
-const TimerTriggerSchema = S.struct({
-  type: S.literal('timer'),
-  cron: S.string,
-});
+const TimerTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('timer'),
+    cron: S.string,
+  }),
+);
+
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 
 const WebhookTriggerSchema = S.mutable(
@@ -49,13 +52,17 @@ const WebhookTriggerSchema = S.mutable(
     port: S.optional(S.number),
   }),
 );
+
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
 
-const WebsocketTriggerSchema = S.struct({
-  type: S.literal('websocket'),
-  url: S.string,
-  init: S.optional(S.record(S.string, S.any)),
-});
+const WebsocketTriggerSchema = S.mutable(
+  S.struct({
+    type: S.literal('websocket'),
+    url: S.string,
+    init: S.optional(S.record(S.string, S.any)),
+  }),
+);
+
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
 
 const TriggerSpecSchema = S.union(
@@ -64,6 +71,7 @@ const TriggerSpecSchema = S.union(
   WebsocketTriggerSchema,
   SubscriptionTriggerSchema,
 );
+
 export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
 
 /**
@@ -84,9 +92,9 @@ export class FunctionTrigger extends TypedObject({
   typename: 'dxos.org/type/FunctionTrigger',
   version: '0.1.0',
 })({
-  function: S.string.pipe(S.description('Function ID/URI.')),
-  // Context passed to a function.
-  meta: S.optional(S.record(S.string, S.any)),
+  function: S.string.pipe(S.description('Function URI.')),
+  // Context is merged into the event data passed to the function.
+  meta: S.optional(S.object),
   spec: TriggerSpecSchema,
 }) {}
 
@@ -94,8 +102,11 @@ export class FunctionTrigger extends TypedObject({
  * Function manifest file.
  */
 export const FunctionManifestSchema = S.struct({
-  functions: S.optional(S.mutable(S.array(omitEchoId(FunctionDef)))),
-  triggers: S.optional(S.mutable(S.array(omitEchoId(FunctionTrigger)))),
+  functions: S.optional(S.mutable(S.array(RawObject(FunctionDef)))),
+  triggers: S.optional(S.mutable(S.array(RawObject(FunctionTrigger)))),
 });
 
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
+
+// TODO(burdon): Standards?
+export const FUNCTION_SCHEMA = [FunctionDef, FunctionTrigger];

package/dist/types/src/registry/function-registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"function-registry.d.ts","sourceRoot":"","sources":["../../../../src/registry/function-registry.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,cAAc,CAAC;AAC3C,OAAO,EAAkB,KAAK,KAAK,EAAE,MAAM,mBAAmB,CAAC;AAC/D,OAAO,EAAE,KAAK,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAIvD,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAE9D,MAAM,MAAM,wBAAwB,GAAG;IACrC,KAAK,EAAE,KAAK,CAAC;IACb,YAAY,EAAE,WAAW,EAAE,CAAC;CAC7B,CAAC;AAEF,qBAAa,gBAAiB,SAAQ,QAAQ;IAKhC,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAA4D;IAEhG,SAAgB,qBAAqB,kCAAyC;gBAEjD,OAAO,EAAE,MAAM;IAIrC,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,WAAW,EAAE;IAIhD;;;OAGG;IAEU,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;cAcrD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;cA0BtB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3D"}

package/dist/types/src/registry/function-registry.test.d.ts.map

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

package/dist/types/src/registry/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/registry/index.ts"],"names":[],"mappings":"AAIA,cAAc,qBAAqB,CAAC"}

package/src/registry/function-registry.ts

@@ -1,84 +0,0 @@
-//
-// Copyright 2024 DXOS.org
-//
-
-import { Event } from '@dxos/async';
-import { type Client } from '@dxos/client';
-import { create, Filter, type Space } from '@dxos/client/echo';
-import { type Context, Resource } from '@dxos/context';
-import { PublicKey } from '@dxos/keys';
-import { ComplexMap } from '@dxos/util';
-
-import { FunctionDef, type FunctionManifest } from '../types';
-
-export type FunctionsRegisteredEvent = {
-  space: Space;
-  newFunctions: FunctionDef[];
-};
-
-export class FunctionRegistry extends Resource {
-  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
-
-  public readonly onFunctionsRegistered = new Event<FunctionsRegisteredEvent>();
-
-  constructor(private readonly _client: Client) {
-    super();
-  }
-
-  public getFunctions(space: Space): FunctionDef[] {
-    return this._functionBySpaceKey.get(space.key) ?? [];
-  }
-
-  /**
-   * The method loads function definitions from the manifest into the space.
-   * We first load all the definitions from the space to deduplicate by functionId.
-   */
-  // TODO(burdon): This should not be space specific (they are static for the agent).
-  public async register(space: Space, manifest: FunctionManifest): Promise<void> {
-    if (!manifest.functions?.length) {
-      return;
-    }
-    if (!space.db.graph.runtimeSchemaRegistry.isSchemaRegistered(FunctionDef)) {
-      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionDef);
-    }
-
-    const { objects: existingDefinitions } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const newDefinitions = getNewDefinitions(manifest.functions, existingDefinitions);
-    const reactiveObjects = newDefinitions.map((template) => create(FunctionDef, { ...template }));
-    reactiveObjects.forEach((obj) => space.db.add(obj));
-  }
-
-  protected override async _open(): Promise<void> {
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._functionBySpaceKey.has(space.key)) {
-          continue;
-        }
-        const registered: FunctionDef[] = [];
-        this._functionBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
-        }
-
-        const functionsSubscription = space.db.query(Filter.schema(FunctionDef)).subscribe((definitions) => {
-          const newFunctions = getNewDefinitions(definitions.objects, registered);
-          if (newFunctions.length > 0) {
-            registered.push(...newFunctions);
-            this.onFunctionsRegistered.emit({ space, newFunctions });
-          }
-        });
-        this._ctx.onDispose(functionsSubscription);
-      }
-    });
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
-  }
-
-  protected override async _close(_: Context): Promise<void> {
-    this._functionBySpaceKey.clear();
-  }
-}
-
-const getNewDefinitions = <T extends { uri: string }>(candidateList: T[], existing: FunctionDef[]): T[] => {
-  return candidateList.filter((candidate) => existing.find((def) => def.uri === candidate.uri) == null);
-};