@dxos/functions 0.5.3-main.f9b873d → 0.5.3-main.fffc127

package/dist/types/src/trigger/type/timer-trigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timer-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/timer-trigger.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErG,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,YAAY,CA8B3D,CAAC"}
+{"version":3,"file":"timer-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/timer-trigger.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,YAAY,CA8B3D,CAAC"}

package/dist/types/src/trigger/type/webhook-trigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhook-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/webhook-trigger.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErG,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,cAAc,CAiC/D,CAAC"}
+{"version":3,"file":"webhook-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/webhook-trigger.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,cAAc,CAiC/D,CAAC"}

package/dist/types/src/trigger/type/websocket-trigger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"websocket-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/websocket-trigger.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAA6C,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAErG,UAAU,uBAAuB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,gBAAgB,EAAE,uBAAuB,CAoE5F,CAAC"}
+{"version":3,"file":"websocket-trigger.d.ts","sourceRoot":"","sources":["../../../../../src/trigger/type/websocket-trigger.ts"],"names":[],"mappings":"AAWA,OAAO,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAwB,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEhF,UAAU,uBAAuB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,gBAAgB,EAAE,uBAAuB,CAoE5F,CAAC"}

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,127 +62,154 @@ export declare class FunctionDef extends FunctionDef_base {
 }
 declare const FunctionTrigger_base: import("@dxos/echo-schema").EchoSchemaClass<{
     function: string;
+    enabled?: boolean | undefined;
     meta?: {
-        readonly [x: string]: any;
+        [x: string]: any;
     } | 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;
 }>;
+/**
+ * Function trigger.
+ */
 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<{
+        "@meta"?: {
+            readonly keys: {
+                readonly id: string;
+                readonly source: string;
+            }[];
+        } | undefined;
+    })[] | undefined, never>;
+    triggers: S.PropertySignature<"?:", ({
         function: string;
+        enabled?: boolean | undefined;
         meta?: {
-            readonly [x: string]: any;
+            [x: string]: any;
         } | 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<{
+        "@meta"?: {
+            readonly keys: {
+                readonly id: string;
+                readonly source: string;
+            }[];
+        } | undefined;
+    })[] | undefined, never, "?:", ({
         function: string;
+        enabled?: boolean | undefined;
         meta?: {
-            readonly [x: string]: any;
+            [x: string]: any;
         } | 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,gBAQ/B;CAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEL;;GAEG;AACH,qBAAa,eAAgB,SAAQ,oBASnC;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.f9b873d",
-  "description": "Functions SDK and runtime.",
+  "version": "0.5.3-main.fffc127",
+  "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.f9b873d",
-    "@dxos/async": "0.5.3-main.f9b873d",
-    "@dxos/client": "0.5.3-main.f9b873d",
-    "@dxos/context": "0.5.3-main.f9b873d",
-    "@dxos/echo-db": "0.5.3-main.f9b873d",
-    "@dxos/echo-schema": "0.5.3-main.f9b873d",
-    "@dxos/invariant": "0.5.3-main.f9b873d",
-    "@dxos/keys": "0.5.3-main.f9b873d",
-    "@dxos/log": "0.5.3-main.f9b873d",
-    "@dxos/node-std": "0.5.3-main.f9b873d",
-    "@dxos/util": "0.5.3-main.f9b873d",
-    "@dxos/protocols": "0.5.3-main.f9b873d"
+    "@braneframe/types": "0.5.3-main.fffc127",
+    "@dxos/async": "0.5.3-main.fffc127",
+    "@dxos/client": "0.5.3-main.fffc127",
+    "@dxos/context": "0.5.3-main.fffc127",
+    "@dxos/echo-schema": "0.5.3-main.fffc127",
+    "@dxos/invariant": "0.5.3-main.fffc127",
+    "@dxos/keys": "0.5.3-main.fffc127",
+    "@dxos/echo-db": "0.5.3-main.fffc127",
+    "@dxos/node-std": "0.5.3-main.fffc127",
+    "@dxos/log": "0.5.3-main.fffc127",
+    "@dxos/protocols": "0.5.3-main.fffc127",
+    "@dxos/util": "0.5.3-main.fffc127"
   },
   "devDependencies": {
     "@types/express": "^4.17.17",
     "@types/ws": "^7.4.0",
-    "@dxos/agent": "0.5.3-main.f9b873d"
+    "@dxos/agent": "0.5.3-main.fffc127"
   },
   "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,16 @@
         "properties": {
           "function": {
             "type": "string",
-            "description": "Function ID/URI.",
+            "description": "Function URI.",
             "title": "string"
           },
+          "enabled": {
+            "type": "boolean",
+            "description": "a boolean",
+            "title": "boolean"
+          },
           "meta": {
-            "type": "object",
-            "required": [],
-            "properties": {},
-            "additionalProperties": {
-              "$id": "/schemas/any",
-              "title": "any"
-            }
+            "$ref": "#/$defs/object"
           },
           "spec": {
             "anyOf": [
@@ -193,5 +192,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,16 @@ 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));
+    // TODO(burdon): Add/remove listener in start/stop.
+    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 +158,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 });
@@ -189,8 +189,8 @@ export class DevServer {
         registrationId: this._functionServiceRegistration,
         functions: this.functions.map(({ def: { id, route } }) => ({ id, route })),
       });
-    } catch (e) {
-      log.catch(e);
+    } catch (err) {
+      log.catch(err);
     }
   }
 
@@ -212,7 +212,6 @@ export class DevServer {
   private async _invoke(path: string, event: FunctionEvent) {
     const { handler } = this._handlers[path] ?? {};
     invariant(handler, `invalid path: ${path}`);
-
     const context: FunctionContext = {
       client: this._client,
       dataDir: this._options.dataDir,