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

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

@@ -6,7 +6,7 @@ import { S } from '@dxos/echo-schema';
  * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions
  */
 export type FunctionTriggerType = 'subscription' | 'timer' | 'webhook' | 'websocket';
-declare const SubscriptionTriggerSchema: S.struct<{
+declare const SubscriptionTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["subscription"]>;
     filter: S.array<S.struct<{
         type: S.$string;
@@ -23,12 +23,12 @@ declare const SubscriptionTriggerSchema: S.struct<{
         readonly deep?: boolean | undefined;
         readonly delay?: number | undefined;
     } | undefined, never>;
-}>;
+}>>;
 export type SubscriptionTrigger = S.Schema.Type<typeof SubscriptionTriggerSchema>;
-declare const TimerTriggerSchema: S.struct<{
+declare const TimerTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["timer"]>;
     cron: S.$string;
-}>;
+}>>;
 export type TimerTrigger = S.Schema.Type<typeof TimerTriggerSchema>;
 declare const WebhookTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["webhook"]>;
@@ -36,7 +36,7 @@ declare const WebhookTriggerSchema: S.mutable<S.struct<{
     port: S.PropertySignature<"?:", number | undefined, never, "?:", number | undefined, never>;
 }>>;
 export type WebhookTrigger = S.Schema.Type<typeof WebhookTriggerSchema>;
-declare const WebsocketTriggerSchema: S.struct<{
+declare const WebsocketTriggerSchema: S.mutable<S.struct<{
     type: S.literal<["websocket"]>;
     url: S.$string;
     init: S.PropertySignature<"?:", {
@@ -44,7 +44,7 @@ declare const WebsocketTriggerSchema: S.struct<{
     } | undefined, never, "?:", {
         readonly [x: string]: any;
     } | undefined, never>;
-}>;
+}>>;
 export type WebsocketTrigger = S.Schema.Type<typeof WebsocketTriggerSchema>;
 export type TriggerSpec = TimerTrigger | WebhookTrigger | WebsocketTrigger | SubscriptionTrigger;
 declare const FunctionDef_base: import("@dxos/echo-schema").EchoSchemaClass<{
@@ -62,32 +62,30 @@ 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 {
+        filter: readonly {
             readonly type: string;
             readonly props?: {
                 readonly [x: string]: any;
             } | undefined;
         }[];
-        readonly type: "subscription";
-        readonly options?: {
+        type: "subscription";
+        options?: {
             readonly deep?: boolean | undefined;
             readonly delay?: number | undefined;
         } | undefined;
     } | {
-        readonly type: "timer";
-        readonly cron: string;
+        type: "timer";
+        cron: string;
     } | {
         port?: number | undefined;
         type: "webhook";
         method: string;
     } | {
-        readonly type: "websocket";
-        readonly url: string;
-        readonly init?: {
+        type: "websocket";
+        url: string;
+        init?: {
             readonly [x: string]: any;
         } | undefined;
     };
@@ -100,89 +98,106 @@ 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 {
+            filter: readonly {
                 readonly type: string;
                 readonly props?: {
                     readonly [x: string]: any;
                 } | undefined;
             }[];
-            readonly type: "subscription";
-            readonly options?: {
+            type: "subscription";
+            options?: {
                 readonly deep?: boolean | undefined;
                 readonly delay?: number | undefined;
             } | undefined;
         } | {
-            readonly type: "timer";
-            readonly cron: string;
+            type: "timer";
+            cron: string;
         } | {
             port?: number | undefined;
             type: "webhook";
             method: string;
         } | {
-            readonly type: "websocket";
-            readonly url: string;
-            readonly init?: {
+            type: "websocket";
+            url: string;
+            init?: {
                 readonly [x: string]: any;
             } | 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 {
+            filter: readonly {
                 readonly type: string;
                 readonly props?: {
                     readonly [x: string]: any;
                 } | undefined;
             }[];
-            readonly type: "subscription";
-            readonly options?: {
+            type: "subscription";
+            options?: {
                 readonly deep?: boolean | undefined;
                 readonly delay?: number | undefined;
             } | undefined;
         } | {
-            readonly type: "timer";
-            readonly cron: string;
+            type: "timer";
+            cron: string;
         } | {
             port?: number | undefined;
             type: "webhook";
             method: string;
         } | {
-            readonly type: "websocket";
-            readonly url: string;
-            readonly init?: {
+            type: "websocket";
+            url: string;
+            init?: {
                 readonly [x: string]: any;
             } | 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 declare const FUNCTION_SCHEMA: (typeof FunctionDef | typeof FunctionTrigger)[];
 export {};
 //# sourceMappingURL=types.d.ts.map

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;;;;;;;;;;;;;;;;;GAmB9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF,QAAA,MAAM,kBAAkB;;;GAKvB,CAAC;AAEF,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;;;;;;;;GAM3B,CAAC;AAEF,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;AAG5E,eAAO,MAAM,eAAe,iDAAiC,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dxos/functions",
-  "version": "0.5.3-main.d7fe7b5",
-  "description": "Functions SDK and runtime.",
+  "version": "0.5.3-main.eb56347",
+  "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.d7fe7b5",
-    "@dxos/async": "0.5.3-main.d7fe7b5",
-    "@dxos/context": "0.5.3-main.d7fe7b5",
-    "@dxos/client": "0.5.3-main.d7fe7b5",
-    "@dxos/echo-db": "0.5.3-main.d7fe7b5",
-    "@dxos/invariant": "0.5.3-main.d7fe7b5",
-    "@dxos/keys": "0.5.3-main.d7fe7b5",
-    "@dxos/echo-schema": "0.5.3-main.d7fe7b5",
-    "@dxos/log": "0.5.3-main.d7fe7b5",
-    "@dxos/node-std": "0.5.3-main.d7fe7b5",
-    "@dxos/util": "0.5.3-main.d7fe7b5",
-    "@dxos/protocols": "0.5.3-main.d7fe7b5"
+    "@braneframe/types": "0.5.3-main.eb56347",
+    "@dxos/client": "0.5.3-main.eb56347",
+    "@dxos/async": "0.5.3-main.eb56347",
+    "@dxos/context": "0.5.3-main.eb56347",
+    "@dxos/echo-db": "0.5.3-main.eb56347",
+    "@dxos/echo-schema": "0.5.3-main.eb56347",
+    "@dxos/invariant": "0.5.3-main.eb56347",
+    "@dxos/keys": "0.5.3-main.eb56347",
+    "@dxos/log": "0.5.3-main.eb56347",
+    "@dxos/node-std": "0.5.3-main.eb56347",
+    "@dxos/protocols": "0.5.3-main.eb56347",
+    "@dxos/util": "0.5.3-main.eb56347"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.5.3-main.d7fe7b5"
+    "@dxos/agent": "0.5.3-main.eb56347"
   },
   "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/browser/index.ts

@@ -0,0 +1,5 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+export * from '../types';

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/function/function-registry.ts

@@ -0,0 +1,90 @@
+//
+// 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 { log } from '@dxos/log';
+import { ComplexMap, diff } from '@dxos/util';
+
+import { FunctionDef, type FunctionManifest } from '../types';
+
+export type FunctionsRegisteredEvent = {
+  space: Space;
+  added: FunctionDef[];
+};
+
+export class FunctionRegistry extends Resource {
+  private readonly _functionBySpaceKey = new ComplexMap<PublicKey, FunctionDef[]>(PublicKey.hash);
+
+  public readonly registered = new Event<FunctionsRegisteredEvent>();
+
+  constructor(private readonly _client: Client) {
+    super();
+  }
+
+  public getFunctions(space: Space): FunctionDef[] {
+    return this._functionBySpaceKey.get(space.key) ?? [];
+  }
+
+  /**
+   * Loads function definitions from the manifest into the space.
+   * We first load all the definitions from the space to deduplicate by functionId.
+   */
+  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);
+    }
+
+    // Sync definitions.
+    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
+    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
+    // TODO(burdon): Update existing templates.
+    added.forEach((def) => space.db.add(create(FunctionDef, def)));
+  }
+
+  protected override async _open(): Promise<void> {
+    log.info('opening...');
+    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();
+        if (this._ctx.disposed) {
+          break;
+        }
+
+        // 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 });
+            }
+          }),
+        );
+      }
+    });
+
+    // TODO(burdon): API: Normalize unsubscribe methods.
+    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
+  }
+
+  protected override async _close(_: Context): Promise<void> {
+    log.info('closing...');
+    this._functionBySpaceKey.clear();
+  }
+}

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 _functionUriToCallMutex = new Map<string, 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,25 @@ export class Scheduler {
     }
 
     await this.triggers.activate({ space }, fnTrigger, async (args) => {
-      return this._execFunction(definition, {
-        meta: fnTrigger.meta,
-        data: { ...args, spaceKey: space.key },
+      const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new Mutex();
+      this._functionUriToCallMutex.set(definition.uri, mutex);
+
+      log.info('function triggered, waiting for mutex', { uri: definition.uri });
+      return mutex.executeSynchronized(() => {
+        log.info('mutex acquired', { uri: definition.uri });
+        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 +110,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: {