@dxos/functions 0.5.3-main.cb47aab → 0.5.3-main.d3c5e1f

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

@@ -62,9 +62,7 @@ export declare class FunctionDef extends FunctionDef_base {
 }
 declare const FunctionTrigger_base: import("@dxos/echo-schema").EchoSchemaClass<{
     function: string;
-    meta?: {
-        readonly [x: string]: any;
-    } | undefined;
+    meta?: object | undefined;
     spec: {
         readonly filter: readonly {
             readonly type: string;
@@ -100,26 +98,34 @@ export declare class FunctionTrigger extends FunctionTrigger_base {
  * Function manifest file.
  */
 export declare const FunctionManifestSchema: S.struct<{
-    functions: S.PropertySignature<"?:", Omit<{
+    functions: S.PropertySignature<"?:", ({
         handler: string;
         uri: string;
         description?: string | undefined;
         route: string;
     } & {
-        id: string;
-    }, "id">[] | undefined, never, "?:", Omit<{
+        "@meta"?: {
+            readonly keys: {
+                readonly id: string;
+                readonly source: string;
+            }[];
+        } | undefined;
+    })[] | undefined, never, "?:", ({
         handler: string;
         uri: string;
         description?: string | undefined;
         route: string;
     } & {
-        id: string;
-    }, "id">[] | undefined, never>;
-    triggers: S.PropertySignature<"?:", Omit<{
-        function: string;
-        meta?: {
-            readonly [x: string]: any;
+        "@meta"?: {
+            readonly keys: {
+                readonly id: string;
+                readonly source: string;
+            }[];
         } | undefined;
+    })[] | undefined, never>;
+    triggers: S.PropertySignature<"?:", ({
+        function: string;
+        meta?: object | undefined;
         spec: {
             readonly filter: readonly {
                 readonly type: string;
@@ -147,12 +153,15 @@ export declare const FunctionManifestSchema: S.struct<{
             } | undefined;
         };
     } & {
-        id: string;
-    }, "id">[] | undefined, never, "?:", Omit<{
-        function: string;
-        meta?: {
-            readonly [x: string]: any;
+        "@meta"?: {
+            readonly keys: {
+                readonly id: string;
+                readonly source: string;
+            }[];
         } | undefined;
+    })[] | undefined, never, "?:", ({
+        function: string;
+        meta?: object | undefined;
         spec: {
             readonly filter: readonly {
                 readonly type: string;
@@ -180,8 +189,13 @@ export declare const FunctionManifestSchema: S.struct<{
             } | undefined;
         };
     } & {
-        id: string;
-    }, "id">[] | undefined, never>;
+        "@meta"?: {
+            readonly keys: {
+                readonly id: string;
+                readonly source: string;
+            }[];
+        } | undefined;
+    })[] | undefined, never>;
 }>;
 export type FunctionManifest = S.Schema.Type<typeof FunctionManifestSchema>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAO,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAKxD;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;EAiB7B,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;EAGtB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAOzB,CAAC;AACF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;;;;;EAI1B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAQ5E,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAS/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAQnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/types.ts"],"names":[],"mappings":"AAIA,OAAO,EAAa,CAAC,EAAe,MAAM,mBAAmB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,cAAc,GAAG,OAAO,GAAG,SAAS,GAAG,WAAW,CAAC;AAErF,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;EAiB7B,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;EAGtB,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,QAAA,MAAM,oBAAoB;;;;GAOzB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAExE,QAAA,MAAM,sBAAsB;;;;;;;;EAI1B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAS5E,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,cAAc,GAAG,gBAAgB,GAAG,mBAAmB,CAAC;;;;;;;;;AAEjG;;GAEG;AACH,qBAAa,WAAY,SAAQ,gBAS/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL,qBAAa,eAAgB,SAAQ,oBAQnC;CAAG;AAEL;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjC,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

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

@@ -0,0 +1,15 @@
+export type Comparator<A, B = A> = (a: A, b: B) => boolean;
+export type DiffResult<A, B = A> = {
+    added: B[];
+    updated: A[];
+    removed: A[];
+};
+/**
+ *
+ * @param previous
+ * @param next
+ * @param comparator
+ */
+export declare const diff: <A, B = A>(previous: readonly A[], next: readonly B[], comparator: Comparator<A, B>) => DiffResult<A, B>;
+export declare const intersection: <A, B = A>(a: A[], b: B[], comparator: Comparator<A, B>) => A[];
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/util.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;AAE3D,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI;IACjC,KAAK,EAAE,CAAC,EAAE,CAAC;IACX,OAAO,EAAE,CAAC,EAAE,CAAC;IACb,OAAO,EAAE,CAAC,EAAE,CAAC;CACd,CAAC;AAEF;;;;;GAKG;AAEH,eAAO,MAAM,IAAI,0GAwBhB,CAAC;AAGF,eAAO,MAAM,YAAY,iEACuC,CAAC"}

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

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

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

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxos/functions",
-  "version": "0.5.3-main.cb47aab",
-  "description": "Functions SDK and runtime.",
+  "version": "0.5.3-main.d3c5e1f",
+  "description": "Functions API and runtime.",
   "homepage": "https://dxos.org",
   "bugs": "https://github.com/dxos/dxos/issues",
   "license": "MIT",
@@ -10,10 +10,24 @@
     ".": {
       "browser": "./dist/lib/browser/index.mjs",
       "node": "./dist/lib/node/index.cjs",
-      "default": "./dist/lib/node/index.cjs"
+      "default": "./dist/lib/node/index.cjs",
+      "types": "./dist/types/src/index.d.ts"
+    },
+    "./types": {
+      "browser": "./dist/lib/browser/types.mjs",
+      "node": "./dist/lib/node/types.cjs",
+      "default": "./dist/lib/node/types.cjs",
+      "types": "./dist/types/src/types.d.ts"
     }
   },
   "types": "dist/types/src/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "types": [
+        "dist/types/src/types.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist",
     "schema",
@@ -26,29 +40,28 @@
     "express": "^4.19.2",
     "get-port-please": "^3.1.1",
     "ws": "^8.14.2",
-    "@braneframe/types": "0.5.3-main.cb47aab",
-    "@dxos/async": "0.5.3-main.cb47aab",
-    "@dxos/client": "0.5.3-main.cb47aab",
-    "@dxos/context": "0.5.3-main.cb47aab",
-    "@dxos/echo-db": "0.5.3-main.cb47aab",
-    "@dxos/echo-schema": "0.5.3-main.cb47aab",
-    "@dxos/invariant": "0.5.3-main.cb47aab",
-    "@dxos/keys": "0.5.3-main.cb47aab",
-    "@dxos/log": "0.5.3-main.cb47aab",
-    "@dxos/node-std": "0.5.3-main.cb47aab",
-    "@dxos/protocols": "0.5.3-main.cb47aab",
-    "@dxos/util": "0.5.3-main.cb47aab"
+    "@braneframe/types": "0.5.3-main.d3c5e1f",
+    "@dxos/async": "0.5.3-main.d3c5e1f",
+    "@dxos/client": "0.5.3-main.d3c5e1f",
+    "@dxos/context": "0.5.3-main.d3c5e1f",
+    "@dxos/echo-db": "0.5.3-main.d3c5e1f",
+    "@dxos/invariant": "0.5.3-main.d3c5e1f",
+    "@dxos/keys": "0.5.3-main.d3c5e1f",
+    "@dxos/echo-schema": "0.5.3-main.d3c5e1f",
+    "@dxos/protocols": "0.5.3-main.d3c5e1f",
+    "@dxos/log": "0.5.3-main.d3c5e1f",
+    "@dxos/node-std": "0.5.3-main.d3c5e1f",
+    "@dxos/util": "0.5.3-main.d3c5e1f"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.5.3-main.cb47aab"
+    "@dxos/agent": "0.5.3-main.d3c5e1f"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "gen-schema": "ts-node ./tools/schema.ts",
-    "prebuild": "pnpm gen-schema"
+    "gen-schema": "ts-node ./tools/schema.ts"
   }
 }

package/schema/functions.json

@@ -48,17 +48,11 @@
         "properties": {
           "function": {
             "type": "string",
-            "description": "Function ID/URI.",
+            "description": "Function URI.",
             "title": "string"
           },
           "meta": {
-            "type": "object",
-            "required": [],
-            "properties": {},
-            "additionalProperties": {
-              "$id": "/schemas/any",
-              "title": "any"
-            }
+            "$ref": "#/$defs/object"
           },
           "spec": {
             "anyOf": [
@@ -193,5 +187,20 @@
       }
     }
   },
-  "additionalProperties": false
+  "additionalProperties": false,
+  "$defs": {
+    "object": {
+      "$id": "/schemas/object",
+      "oneOf": [
+        {
+          "type": "object"
+        },
+        {
+          "type": "array"
+        }
+      ],
+      "description": "an object in the TypeScript meaning, i.e. the `object` type",
+      "title": "object"
+    }
+  }
 }

package/src/{registry → function}/function-registry.test.ts

@@ -44,7 +44,7 @@ describe('function 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, testManifest.functions);
       const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
       expect(definitions.length).to.eq(1);
       expect(definitions[0].uri).to.eq(testManifest.functions?.[0]?.uri);
@@ -54,8 +54,8 @@ describe('function registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      const existing = space.db.add(create(FunctionDef, { ...testManifest.functions![0] }));
-      await registry.register(space, testManifest);
+      const existing = space.db.add(create(FunctionDef, testManifest.functions![0]));
+      await registry.register(space, testManifest.functions);
       const { objects: definitions } = await space.db.query(Filter.schema(FunctionDef)).run();
       expect(definitions.length).to.eq(1);
       expect(definitions[0].uri).to.eq(existing.uri);
@@ -67,12 +67,12 @@ describe('function registry', () => {
       const client = (await createInitializedClients(testBuilder))[0];
       const registry = createRegistry(client);
       const space = await client.spaces.create();
-      const definitions = range(3, () => create(FunctionDef, { ...testManifest.functions![0] }));
+      const definitions = range(3, () => create(FunctionDef, testManifest.functions![0]));
       definitions.forEach((def) => space.db.add(def));
 
       const functionRegistered = new Trigger<FunctionDef[]>();
-      registry.onFunctionsRegistered.on((fn) => {
-        functionRegistered.wake(fn.newFunctions);
+      registry.registered.on((fn) => {
+        functionRegistered.wake(fn.added);
       });
       void registry.open(ctx);
       const functions = await functionRegistered.wait();
@@ -86,12 +86,12 @@ describe('function registry', () => {
       const space = await client.spaces.create();
 
       const functionRegistered = new Trigger<FunctionDef>();
-      registry.onFunctionsRegistered.on((fn) => {
-        expect(fn.newFunctions.length).to.eq(1);
-        functionRegistered.wake(fn.newFunctions[0]);
+      registry.registered.on((fn) => {
+        expect(fn.added.length).to.eq(1);
+        functionRegistered.wake(fn.added[0]);
       });
       await registry.open(ctx);
-      await registry.register(space, testManifest);
+      await registry.register(space, testManifest.functions);
       const registered = await functionRegistered.wait();
       expect(registered.uri).to.eq(testManifest.functions![0].uri);
     });

package/src/{registry → function}/function-registry.ts

@@ -7,19 +7,21 @@ 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 { log } from '@dxos/log';
 import { ComplexMap } from '@dxos/util';
 
 import { FunctionDef, type FunctionManifest } from '../types';
+import { diff } from '../util';
 
 export type FunctionsRegisteredEvent = {
   space: Space;
-  newFunctions: FunctionDef[];
+  added: FunctionDef[];
 };
 
 export class FunctionRegistry extends Resource {
   private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
 
-  public readonly onFunctionsRegistered = new Event<FunctionsRegisteredEvent>();
+  public readonly registered = new Event<FunctionsRegisteredEvent>();
 
   constructor(private readonly _client: Client) {
     super();
@@ -30,30 +32,33 @@ export class FunctionRegistry extends Resource {
   }
 
   /**
-   * The method loads function definitions from the manifest into the space.
+   * 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) {
+  public async register(space: Space, functions: FunctionManifest['functions']): Promise<void> {
+    log('register', { space: space.key, functions: functions?.length ?? 0 });
+    if (!functions?.length) {
       return;
     }
     if (!space.db.graph.runtimeSchemaRegistry.hasSchema(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));
+    // Sync definitions.
+    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
+    const { added, removed } = diff(existing, functions, (a, b) => a.uri === b.uri);
+    added.forEach((def) => space.db.add(create(FunctionDef, def)));
+    // TODO(burdon): Update existing templates.
+    removed.forEach((def) => space.db.remove(def));
   }
 
   protected override async _open(): Promise<void> {
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
+    const spacesSubscription = 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();
@@ -61,24 +66,25 @@ export class FunctionRegistry extends Resource {
           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);
+        // Subscribe to updates.
+        this._ctx.onDispose(
+          space.db.query(Filter.schema(FunctionDef)).subscribe(({ objects }) => {
+            const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
+            // TODO(burdon): Update and remove.
+            if (added.length > 0) {
+              registered.push(...added);
+              this.registered.emit({ space, added });
+            }
+          }),
+        );
       }
     });
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
+
+    // TODO(burdon): API: Normalize unsubscribe methods.
+    this._ctx.onDispose(() => spacesSubscription.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);
-};

package/src/index.ts

@@ -2,8 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
+export * from './function';
 export * from './handler';
-export * from './registry';
 export * from './runtime';
 export * from './trigger';
 export * from './types';

package/src/runtime/dev-server.test.ts

@@ -11,7 +11,7 @@ import { TestBuilder } from '@dxos/client/testing';
 import { describe, test } from '@dxos/test';
 
 import { DevServer } from './dev-server';
-import { FunctionRegistry } from '../registry';
+import { FunctionRegistry } from '../function';
 import { createFunctionRuntime } from '../testing';
 import { type FunctionManifest } from '../types';
 
@@ -44,7 +44,7 @@ describe('dev server', () => {
       baseDir: path.join(__dirname, '../testing'),
     });
     const space = await client.spaces.create();
-    await registry.register(space, manifest);
+    await registry.register(space, manifest.functions);
     await server.start();
 
     // TODO(burdon): Doesn't shut down cleanly.

package/src/runtime/dev-server.ts

@@ -13,8 +13,8 @@ import { Context } from '@dxos/context';
 import { invariant } from '@dxos/invariant';
 import { log } from '@dxos/log';
 
+import { type FunctionRegistry } from '../function';
 import { type FunctionContext, type FunctionEvent, type FunctionHandler, type FunctionResponse } from '../handler';
-import { type FunctionRegistry } from '../registry';
 import { type FunctionDef } from '../types';
 
 export type DevServerOptions = {
@@ -41,16 +41,15 @@ export class DevServer {
 
   public readonly update = new Event<number>();
 
-  // prettier-ignore
   constructor(
     private readonly _client: Client,
     private readonly _functionsRegistry: FunctionRegistry,
     private readonly _options: DevServerOptions,
   ) {
-    this._functionsRegistry.onFunctionsRegistered.on(async ({ newFunctions }) => {
-      newFunctions.forEach((def) => this._load(def));
+    this._functionsRegistry.registered.on(async ({ added }) => {
+      added.forEach((def) => this._load(def));
       await this._safeUpdateRegistration();
-      log('new functions loaded', { newFunctions });
+      log('new functions loaded', { added });
     });
   }
 
@@ -158,7 +157,7 @@ export class DevServer {
   /**
    * Load function.
    */
-  private async _load(def: FunctionDef, force = false) {
+  private async _load(def: FunctionDef, force?: boolean | undefined) {
     const { uri, route, handler } = def;
     const filePath = join(this._options.baseDir, handler);
     log.info('loading', { uri, force });

package/src/runtime/scheduler.test.ts

@@ -12,7 +12,7 @@ import { create } from '@dxos/echo-schema';
 import { describe, test } from '@dxos/test';
 
 import { Scheduler, type SchedulerOptions } from './scheduler';
-import { FunctionRegistry } from '../registry';
+import { FunctionRegistry } from '../function';
 import { createInitializedClients, TestType, triggerWebhook } from '../testing';
 import { TriggerRegistry } from '../trigger';
 import { type FunctionManifest } from '../types';

package/src/runtime/scheduler.ts

@@ -4,12 +4,13 @@
 
 import path from 'node:path';
 
+import { Mutex } from '@dxos/async';
 import { type Space } from '@dxos/client/echo';
 import { Context } from '@dxos/context';
 import { log } from '@dxos/log';
 
+import { type FunctionRegistry } from '../function';
 import { type FunctionEventMeta } from '../handler';
-import { type FunctionRegistry } from '../registry';
 import { type TriggerRegistry } from '../trigger';
 import { type FunctionDef, type FunctionManifest, type FunctionTrigger } from '../types';
 
@@ -26,13 +27,15 @@ export type SchedulerOptions = {
 export class Scheduler {
   private _ctx = createContext();
 
+  private readonly _callMutex = new Mutex();
+
   constructor(
     public readonly functions: FunctionRegistry,
     public readonly triggers: TriggerRegistry,
     private readonly _options: SchedulerOptions = {},
   ) {
-    this.functions.onFunctionsRegistered.on(async ({ space, newFunctions }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), newFunctions);
+    this.functions.registered.on(async ({ space, added }) => {
+      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
     });
     this.triggers.registered.on(async ({ space, triggers }) => {
       await this._safeActivateTriggers(space, triggers, this.functions.getFunctions(space));
@@ -52,8 +55,9 @@ export class Scheduler {
     await this.triggers.close();
   }
 
+  // TODO(burdon): Remove and update registries directly.
   public async register(space: Space, manifest: FunctionManifest) {
-    await this.functions.register(space, manifest);
+    await this.functions.register(space, manifest.functions);
     await this.triggers.register(space, manifest);
   }
 
@@ -76,16 +80,20 @@ export class Scheduler {
     }
 
     await this.triggers.activate({ space }, fnTrigger, async (args) => {
-      return this._execFunction(definition, {
-        meta: fnTrigger.meta,
-        data: { ...args, spaceKey: space.key },
+      return this._callMutex.executeSynchronized(() => {
+        return this._execFunction(definition, fnTrigger, {
+          meta: fnTrigger.meta,
+          data: { ...args, spaceKey: space.key },
+        });
       });
     });
+
     log('activated trigger', { space: space.key, trigger: fnTrigger });
   }
 
   private async _execFunction<TData, TMeta>(
     def: FunctionDef,
+    trigger: FunctionTrigger,
     { data, meta }: { data: TData; meta?: TMeta },
   ): Promise<number> {
     let status = 0;
@@ -97,7 +105,7 @@ export class Scheduler {
       if (endpoint) {
         // TODO(burdon): Move out of scheduler (generalize as callback).
         const url = path.join(endpoint, def.route);
-        log.info('exec', { function: def.uri, url });
+        log.info('exec', { function: def.uri, url, triggerType: trigger.spec.type });
         const response = await fetch(url, {
           method: 'POST',
           headers: {

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() }));