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

package/dist/lib/browser/index.mjs

@@ -20,16 +20,16 @@ import { log } from "@dxos/log";
 import { nonNullable } from "@dxos/util";
 var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/handler.ts";
 var subscriptionHandler = (handler) => {
-  return ({ event: { data }, context, ...rest }) => {
+  return ({ event, context, ...rest }) => {
     const { client } = context;
-    const space = data.spaceKey ? client.spaces.get(PublicKey.from(data.spaceKey)) : void 0;
-    const objects = space ? data.objects?.map((id) => space.db.getObjectById(id)).filter(nonNullable) : [];
-    if (!!data.spaceKey && !space) {
+    const space = event.space ? client.spaces.get(PublicKey.from(event.space)) : void 0;
+    const objects = space && event.objects?.map((id) => space.db.getObjectById(id)).filter(nonNullable);
+    if (!!event.space && !space) {
       log.warn("invalid space", {
-        data
+        event
       }, {
         F: __dxlog_file,
-        L: 91,
+        L: 68,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -39,18 +39,15 @@ var subscriptionHandler = (handler) => {
         objects: objects?.length
       }, {
         F: __dxlog_file,
-        L: 93,
+        L: 70,
         S: void 0,
         C: (f, a) => f(...a)
       });
     }
     return handler({
       event: {
-        data: {
-          ...data,
-          space,
-          objects
-        }
+        space,
+        objects
       },
       context,
       ...rest
@@ -58,180 +55,26 @@ var subscriptionHandler = (handler) => {
   };
 };
 
-// packages/core/functions/src/registry/function-registry.ts
-import { Event } from "@dxos/async";
-import { create, Filter } from "@dxos/client/echo";
-import { Resource } from "@dxos/context";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { ComplexMap } from "@dxos/util";
-
-// packages/core/functions/src/types.ts
-import { AST, S, TypedObject } from "@dxos/echo-schema";
-var omitEchoId = (schema) => S.make(AST.omit(schema.ast, [
-  "id"
-]));
-var 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)
-  }))
-});
-var TimerTriggerSchema = S.struct({
-  type: S.literal("timer"),
-  cron: S.string
-});
-var WebhookTriggerSchema = S.mutable(S.struct({
-  type: S.literal("webhook"),
-  method: S.string,
-  // Assigned port.
-  port: S.optional(S.number)
-}));
-var WebsocketTriggerSchema = S.struct({
-  type: S.literal("websocket"),
-  url: S.string,
-  init: S.optional(S.record(S.string, S.any))
-});
-var TriggerSpecSchema = S.union(TimerTriggerSchema, WebhookTriggerSchema, WebsocketTriggerSchema, SubscriptionTriggerSchema);
-var FunctionDef = class extends TypedObject({
-  typename: "dxos.org/type/FunctionDef",
-  version: "0.1.0"
-})({
-  uri: S.string,
-  description: S.optional(S.string),
-  route: S.string,
-  // TODO(burdon): NPM/GitHub/Docker/CF URL?
-  handler: S.string
-}) {
-};
-var FunctionTrigger = class 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)),
-  spec: TriggerSpecSchema
-}) {
-};
-var FunctionManifestSchema = S.struct({
-  functions: S.optional(S.mutable(S.array(omitEchoId(FunctionDef)))),
-  triggers: S.optional(S.mutable(S.array(omitEchoId(FunctionTrigger))))
-});
-
-// packages/core/functions/src/registry/function-registry.ts
-var FunctionRegistry = class extends Resource {
-  constructor(_client) {
-    super();
-    this._client = _client;
-    this._functionBySpaceKey = new ComplexMap(PublicKey2.hash);
-    this.onFunctionsRegistered = new Event();
-  }
-  getFunctions(space) {
-    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).
-  async register(space, manifest) {
-    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));
-  }
-  async _open() {
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._functionBySpaceKey.has(space.key)) {
-          continue;
-        }
-        const registered = [];
-        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());
-  }
-  async _close(_) {
-    this._functionBySpaceKey.clear();
-  }
-};
-var getNewDefinitions = (candidateList, existing) => {
-  return candidateList.filter((candidate) => existing.find((def) => def.uri === candidate.uri) == null);
-};
-
 // packages/core/functions/src/runtime/dev-server.ts
 import express from "express";
 import { getPort } from "get-port-please";
 import { join } from "@dxos/node-std/path";
-import { Event as Event2, Trigger } from "@dxos/async";
-import { Context } from "@dxos/context";
+import { Trigger } from "@dxos/async";
 import { invariant } from "@dxos/invariant";
 import { log as log2 } from "@dxos/log";
 var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/dev-server.ts";
 var DevServer = class {
   // prettier-ignore
-  constructor(_client, _functionsRegistry, _options) {
+  constructor(_client, _options) {
     this._client = _client;
-    this._functionsRegistry = _functionsRegistry;
     this._options = _options;
-    this._ctx = createContext();
     this._handlers = {};
     this._seq = 0;
-    this.update = new Event2();
-    this._functionsRegistry.onFunctionsRegistered.on(async ({ newFunctions }) => {
-      newFunctions.forEach((def) => this._load(def));
-      await this._safeUpdateRegistration();
-      log2("new functions loaded", {
-        newFunctions
-      }, {
-        F: __dxlog_file2,
-        L: 53,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    });
-  }
-  get stats() {
-    return {
-      seq: this._seq
-    };
   }
   get endpoint() {
     invariant(this._port, void 0, {
       F: __dxlog_file2,
-      L: 64,
+      L: 46,
       S: this,
       A: [
         "this._port",
@@ -246,46 +89,44 @@ var DevServer = class {
   get functions() {
     return Object.values(this._handlers);
   }
+  async initialize() {
+    for (const def of this._options.manifest.functions) {
+      try {
+        await this._load(def);
+      } catch (err) {
+        log2.error("parsing function (check manifest)", err, {
+          F: __dxlog_file2,
+          L: 63,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+    }
+  }
   async start() {
-    invariant(!this._server, void 0, {
-      F: __dxlog_file2,
-      L: 77,
-      S: this,
-      A: [
-        "!this._server",
-        ""
-      ]
-    });
-    log2.info("starting...", void 0, {
-      F: __dxlog_file2,
-      L: 78,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._ctx = createContext();
     const app = express();
     app.use(express.json());
-    app.post("/:path", async (req, res) => {
-      const { path: path2 } = req.params;
+    app.post("/:name", async (req, res) => {
+      const { name } = req.params;
       try {
         log2.info("calling", {
-          path: path2
+          name
         }, {
           F: __dxlog_file2,
-          L: 88,
+          L: 75,
           S: this,
           C: (f, a) => f(...a)
         });
         if (this._options.reload) {
-          const { def } = this._handlers["/" + path2];
+          const { def } = this._handlers[name];
           await this._load(def, true);
         }
-        res.statusCode = await this.invoke("/" + path2, req.body);
+        res.statusCode = await this._invoke(name, req.body);
         res.end();
       } catch (err) {
         log2.catch(err, void 0, {
           F: __dxlog_file2,
-          L: 98,
+          L: 84,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -304,195 +145,93 @@ var DevServer = class {
     this._server = app.listen(this._port);
     try {
       const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService.register({
-        endpoint: this.endpoint
+        endpoint: this.endpoint,
+        functions: this.functions.map(({ def: { name } }) => ({
+          name
+        }))
       });
       log2.info("registered", {
+        registrationId,
         endpoint
       }, {
         F: __dxlog_file2,
-        L: 113,
+        L: 100,
         S: this,
         C: (f, a) => f(...a)
       });
+      this._registrationId = registrationId;
       this._proxy = endpoint;
-      this._functionServiceRegistration = registrationId;
-      await this._functionsRegistry.open(this._ctx);
     } catch (err) {
       await this.stop();
       throw new Error("FunctionRegistryService not available (check plugin is configured).");
     }
-    log2.info("started", {
-      port: this._port
-    }, {
-      F: __dxlog_file2,
-      L: 124,
-      S: this,
-      C: (f, a) => f(...a)
-    });
   }
   async stop() {
-    invariant(this._server, void 0, {
-      F: __dxlog_file2,
-      L: 128,
-      S: this,
-      A: [
-        "this._server",
-        ""
-      ]
-    });
-    log2.info("stopping...", void 0, {
-      F: __dxlog_file2,
-      L: 129,
-      S: this,
-      C: (f, a) => f(...a)
-    });
     const trigger = new Trigger();
-    this._server.close(async () => {
-      log2.info("server stopped", void 0, {
-        F: __dxlog_file2,
-        L: 133,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      try {
-        if (this._functionServiceRegistration) {
-          invariant(this._client.services.services.FunctionRegistryService, void 0, {
-            F: __dxlog_file2,
-            L: 136,
-            S: this,
-            A: [
-              "this._client.services.services.FunctionRegistryService",
-              ""
-            ]
-          });
-          await this._client.services.services.FunctionRegistryService.unregister({
-            registrationId: this._functionServiceRegistration
-          });
-          log2.info("unregistered", {
-            registrationId: this._functionServiceRegistration
-          }, {
-            F: __dxlog_file2,
-            L: 141,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._functionServiceRegistration = void 0;
-          this._proxy = void 0;
-        }
-        trigger.wake();
-      } catch (err) {
-        trigger.throw(err);
+    this._server?.close(async () => {
+      if (this._registrationId) {
+        await this._client.services.services.FunctionRegistryService.unregister({
+          registrationId: this._registrationId
+        });
+        log2.info("unregistered", {
+          registrationId: this._registrationId
+        }, {
+          F: __dxlog_file2,
+          L: 117,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._registrationId = void 0;
+        this._proxy = void 0;
       }
+      trigger.wake();
     });
     await trigger.wait();
     this._port = void 0;
     this._server = void 0;
-    log2.info("stopped", void 0, {
-      F: __dxlog_file2,
-      L: 155,
-      S: this,
-      C: (f, a) => f(...a)
-    });
   }
   /**
   * Load function.
   */
-  async _load(def, force = false) {
-    const { uri, route, handler } = def;
-    const filePath = join(this._options.baseDir, handler);
+  async _load(def, flush = false) {
+    const { id, name, handler } = def;
+    const path = join(this._options.directory, handler);
     log2.info("loading", {
-      uri,
-      force
+      id
     }, {
       F: __dxlog_file2,
-      L: 164,
+      L: 136,
       S: this,
       C: (f, a) => f(...a)
     });
-    if (force) {
-      Object.keys(__require.cache).filter((key) => key.startsWith(filePath)).forEach((key) => {
-        delete __require.cache[key];
-      });
+    if (flush) {
+      Object.keys(__require.cache).filter((key) => key.startsWith(path)).forEach((key) => delete __require.cache[key]);
     }
-    const module = __require(filePath);
+    const module = __require(path);
     if (typeof module.default !== "function") {
-      throw new Error(`Handler must export default function: ${uri}`);
+      throw new Error(`Handler must export default function: ${id}`);
     }
-    this._handlers[route] = {
+    this._handlers[name] = {
       def,
       handler: module.default
     };
   }
-  async _safeUpdateRegistration() {
-    invariant(this._functionServiceRegistration, void 0, {
-      F: __dxlog_file2,
-      L: 186,
-      S: this,
-      A: [
-        "this._functionServiceRegistration",
-        ""
-      ]
-    });
-    try {
-      await this._client.services.services.FunctionRegistryService.updateRegistration({
-        registrationId: this._functionServiceRegistration,
-        functions: this.functions.map(({ def: { id, route } }) => ({
-          id,
-          route
-        }))
-      });
-    } catch (e) {
-      log2.catch(e, void 0, {
-        F: __dxlog_file2,
-        L: 193,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
   /**
-  * Invoke function.
+  * Invoke function handler.
   */
-  async invoke(path2, data) {
+  async _invoke(name, event) {
     const seq = ++this._seq;
     const now = Date.now();
     log2.info("req", {
       seq,
-      path: path2
+      name
     }, {
       F: __dxlog_file2,
-      L: 204,
+      L: 161,
       S: this,
       C: (f, a) => f(...a)
     });
-    const statusCode = await this._invoke(path2, {
-      data
-    });
-    log2.info("res", {
-      seq,
-      path: path2,
-      statusCode,
-      duration: Date.now() - now
-    }, {
-      F: __dxlog_file2,
-      L: 207,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this.update.emit(statusCode);
-    return statusCode;
-  }
-  async _invoke(path2, event) {
-    const { handler } = this._handlers[path2] ?? {};
-    invariant(handler, `invalid path: ${path2}`, {
-      F: __dxlog_file2,
-      L: 214,
-      S: this,
-      A: [
-        "handler",
-        "`invalid path: ${path}`"
-      ]
-    });
+    const { handler } = this._handlers[name];
     const context = {
       client: this._client,
       dataDir: this._options.dataDir
@@ -509,565 +248,453 @@ var DevServer = class {
       event,
       response
     });
+    log2.info("res", {
+      seq,
+      name,
+      statusCode,
+      duration: Date.now() - now
+    }, {
+      F: __dxlog_file2,
+      L: 178,
+      S: this,
+      C: (f, a) => f(...a)
+    });
     return statusCode;
   }
 };
-var createContext = () => new Context({
-  name: "DevServer"
-});
 
 // packages/core/functions/src/runtime/scheduler.ts
-import path from "@dxos/node-std/path";
-import { Context as Context2 } from "@dxos/context";
+import { CronJob } from "cron";
+import http from "@dxos/node-std/http";
+import WebSocket from "ws";
+import { TextV0Type } from "@braneframe/types";
+import { debounce, DeferredTask, sleep, Trigger as Trigger2 } from "@dxos/async";
+import { createSubscription, Filter, getAutomergeObjectCore } from "@dxos/client/echo";
+import { Context } from "@dxos/context";
+import { invariant as invariant2 } from "@dxos/invariant";
 import { log as log3 } from "@dxos/log";
+import { ComplexMap } from "@dxos/util";
 var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/scheduler.ts";
 var Scheduler = class {
-  constructor(functions, triggers, _options = {}) {
-    this.functions = functions;
-    this.triggers = triggers;
+  constructor(_client, _manifest, _options = {}) {
+    this._client = _client;
+    this._manifest = _manifest;
     this._options = _options;
-    this._ctx = createContext2();
-    this.functions.onFunctionsRegistered.on(async ({ space, newFunctions }) => {
-      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), newFunctions);
-    });
-    this.triggers.registered.on(async ({ space, triggers: triggers2 }) => {
-      await this._safeActivateTriggers(space, triggers2, this.functions.getFunctions(space));
-    });
+    this._mounts = new ComplexMap(({ id, spaceKey }) => `${spaceKey.toHex()}:${id}`);
   }
   async start() {
-    await this._ctx.dispose();
-    this._ctx = createContext2();
-    await this.functions.open(this._ctx);
-    await this.triggers.open(this._ctx);
+    this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        await space.waitUntilReady();
+        for (const trigger of this._manifest.triggers ?? []) {
+          await this.mount(new Context(), space, trigger);
+        }
+      }
+    });
   }
   async stop() {
-    await this._ctx.dispose();
-    await this.functions.close();
-    await this.triggers.close();
-  }
-  async register(space, manifest) {
-    await this.functions.register(space, manifest);
-    await this.triggers.register(space, manifest);
+    for (const { id, spaceKey } of this._mounts.keys()) {
+      await this.unmount(id, spaceKey);
+    }
   }
-  async _safeActivateTriggers(space, triggers, functions) {
-    const mountTasks = triggers.map((trigger) => {
-      return this.activate(space, functions, trigger);
+  async mount(ctx, space, trigger) {
+    const key = {
+      id: trigger.function,
+      spaceKey: space.key
+    };
+    const def = this._manifest.functions.find((config) => config.id === trigger.function);
+    invariant2(def, `Function not found: ${trigger.function}`, {
+      F: __dxlog_file3,
+      L: 72,
+      S: this,
+      A: [
+        "def",
+        "`Function not found: ${trigger.function}`"
+      ]
     });
-    await Promise.all(mountTasks).catch(log3.catch);
-  }
-  async activate(space, functions, fnTrigger) {
-    const definition = functions.find((def) => def.uri === fnTrigger.function);
-    if (!definition) {
-      log3.info("function is not found for trigger", {
-        fnTrigger
+    const exists = this._mounts.get(key);
+    if (!exists) {
+      this._mounts.set(key, {
+        ctx,
+        trigger
+      });
+      log3("mount", {
+        space: space.key,
+        trigger
       }, {
         F: __dxlog_file3,
-        L: 74,
+        L: 78,
         S: this,
         C: (f, a) => f(...a)
       });
-      return;
+      if (ctx.disposed) {
+        return;
+      }
+      if (trigger.timer) {
+        await this._createTimer(ctx, space, def, trigger.timer);
+      }
+      if (trigger.webhook) {
+        await this._createWebhook(ctx, space, def, trigger.webhook);
+      }
+      if (trigger.websocket) {
+        await this._createWebsocket(ctx, space, def, trigger.websocket);
+      }
+      if (trigger.subscription) {
+        await this._createSubscription(ctx, space, def, trigger.subscription);
+      }
     }
-    await this.triggers.activate({
-      space
-    }, fnTrigger, async (args) => {
-      return this._execFunction(definition, {
-        meta: fnTrigger.meta,
-        data: {
-          ...args,
-          spaceKey: space.key
-        }
-      });
-    });
-    log3("activated trigger", {
-      space: space.key,
-      trigger: fnTrigger
-    }, {
-      F: __dxlog_file3,
-      L: 84,
-      S: this,
-      C: (f, a) => f(...a)
-    });
   }
-  async _execFunction(def, { data, meta }) {
-    let status = 0;
+  async unmount(id, spaceKey) {
+    const key = {
+      id,
+      spaceKey
+    };
+    const { ctx } = this._mounts.get(key) ?? {};
+    if (ctx) {
+      this._mounts.delete(key);
+      await ctx.dispose();
+    }
+  }
+  // TODO(burdon): Pass in Space key (common context).
+  async _execFunction(def, data) {
     try {
-      const payload = Object.assign({}, meta && {
-        meta
-      }, data);
+      log3.info("exec", {
+        function: def.id
+      }, {
+        F: __dxlog_file3,
+        L: 117,
+        S: this,
+        C: (f, a) => f(...a)
+      });
       const { endpoint, callback } = this._options;
       if (endpoint) {
-        const url = path.join(endpoint, def.route);
-        log3.info("exec", {
-          function: def.uri,
-          url
-        }, {
-          F: __dxlog_file3,
-          L: 100,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        const response = await fetch(url, {
+        await fetch(`${this._options.endpoint}/${def.name}`, {
           method: "POST",
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify(payload)
+          body: JSON.stringify(data)
         });
-        status = response.status;
       } else if (callback) {
-        log3.info("exec", {
-          function: def.uri
-        }, {
-          F: __dxlog_file3,
-          L: 111,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        status = await callback(payload) ?? 200;
-      }
-      if (status && status >= 400) {
-        throw new Error(`Response: ${status}`);
+        await callback(data);
       }
       log3.info("done", {
-        function: def.uri,
-        status
+        function: def.id
       }, {
         F: __dxlog_file3,
-        L: 121,
+        L: 133,
         S: this,
         C: (f, a) => f(...a)
       });
     } catch (err) {
       log3.error("error", {
-        function: def.uri,
+        function: def.id,
         error: err.message
       }, {
         F: __dxlog_file3,
-        L: 123,
+        L: 135,
         S: this,
         C: (f, a) => f(...a)
       });
-      status = 500;
     }
-    return status;
   }
-};
-var createContext2 = () => new Context2({
-  name: "FunctionScheduler"
-});
-
-// packages/core/functions/src/trigger/trigger-registry.ts
-import { Event as Event3 } from "@dxos/async";
-import { create as create2, Filter as Filter3 } from "@dxos/client/echo";
-import { Context as Context3, Resource as Resource2 } from "@dxos/context";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey as PublicKey3 } from "@dxos/keys";
-import { log as log8 } from "@dxos/log";
-import { ComplexMap as ComplexMap2 } from "@dxos/util";
-
-// packages/core/functions/src/trigger/type/subscription-trigger.ts
-import { TextV0Type } from "@braneframe/types";
-import { debounce, DeferredTask } from "@dxos/async";
-import { createSubscription, Filter as Filter2, getAutomergeObjectCore } from "@dxos/echo-db";
-import { log as log4 } from "@dxos/log";
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/subscription-trigger.ts";
-var createSubscriptionTrigger = async (ctx, triggerCtx, spec, callback) => {
-  const objectIds = /* @__PURE__ */ new Set();
-  const task = new DeferredTask(ctx, async () => {
-    if (objectIds.size > 0) {
-      await callback({
-        objects: Array.from(objectIds)
-      });
-      objectIds.clear();
-    }
-  });
-  const subscriptions = [];
-  const subscription = createSubscription(({ added, updated }) => {
-    log4.info("updated", {
-      added: added.length,
-      updated: updated.length
+  //
+  // Triggers
+  //
+  /**
+  * Cron timer.
+  */
+  async _createTimer(ctx, space, def, trigger) {
+    log3.info("timer", {
+      space: space.key,
+      trigger
     }, {
-      F: __dxlog_file4,
-      L: 32,
-      S: void 0,
+      F: __dxlog_file3,
+      L: 147,
+      S: this,
       C: (f, a) => f(...a)
     });
-    for (const object of added) {
-      objectIds.add(object.id);
-    }
-    for (const object of updated) {
-      objectIds.add(object.id);
-    }
-    task.schedule();
-  });
-  subscriptions.push(() => subscription.unsubscribe());
-  const { filter, options: { deep, delay } = {} } = spec;
-  const update = ({ objects }) => {
-    subscription.update(objects);
-    if (deep) {
-      log4.info("update", {
-        objects: objects.length
-      }, {
-        F: __dxlog_file4,
-        L: 52,
-        S: void 0,
-        C: (f, a) => f(...a)
+    const { cron } = trigger;
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, {
+        space: space.key
       });
-      for (const object of objects) {
-        const content = object.content;
-        if (content instanceof TextV0Type) {
-          subscriptions.push(getAutomergeObjectCore(content).updates.on(debounce(() => subscription.update([
-            object
-          ]), 1e3)));
-        }
-      }
-    }
-  };
-  const query = triggerCtx.space.db.query(Filter2.or(filter.map(({ type, props }) => Filter2.typename(type, props))));
-  subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
-  ctx.onDispose(() => {
-    subscriptions.forEach((unsubscribe) => unsubscribe());
-  });
-};
-
-// packages/core/functions/src/trigger/type/timer-trigger.ts
-import { CronJob } from "cron";
-import { DeferredTask as DeferredTask2 } from "@dxos/async";
-import { log as log5 } from "@dxos/log";
-var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/timer-trigger.ts";
-var createTimerTrigger = async (ctx, triggerContext, spec, callback) => {
-  const task = new DeferredTask2(ctx, async () => {
-    await callback({});
-  });
-  let last = 0;
-  let run = 0;
-  const job = CronJob.from({
-    cronTime: spec.cron,
-    runOnInit: false,
-    onTick: () => {
-      const now = Date.now();
-      const delta = last ? now - last : 0;
-      last = now;
-      run++;
-      log5.info("tick", {
-        space: triggerContext.space.key.truncate(),
-        count: run,
-        delta
-      }, {
-        F: __dxlog_file5,
-        L: 37,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      task.schedule();
-    }
-  });
-  job.start();
-  ctx.onDispose(() => job.stop());
-};
-
-// packages/core/functions/src/trigger/type/webhook-trigger.ts
-import { getPort as getPort2 } from "get-port-please";
-import http from "@dxos/node-std/http";
-import { log as log6 } from "@dxos/log";
-var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/webhook-trigger.ts";
-var createWebhookTrigger = async (ctx, _, spec, callback) => {
-  const server = http.createServer(async (req, res) => {
-    if (req.method !== spec.method) {
-      res.statusCode = 405;
-      return res.end();
-    }
-    res.statusCode = await callback({});
-    res.end();
-  });
-  const port = await getPort2({
-    random: true
-  });
-  server.listen(port, () => {
-    log6.info("started webhook", {
-      port
-    }, {
-      F: __dxlog_file6,
-      L: 40,
-      S: void 0,
-      C: (f, a) => f(...a)
     });
-    spec.port = port;
-  });
-  ctx.onDispose(() => {
-    server.close();
-  });
-};
-
-// packages/core/functions/src/trigger/type/websocket-trigger.ts
-import WebSocket from "ws";
-import { sleep, Trigger as Trigger2 } from "@dxos/async";
-import { log as log7 } from "@dxos/log";
-var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/websocket-trigger.ts";
-var createWebsocketTrigger = async (ctx, triggerCtx, spec, callback, options = {
-  retryDelay: 2,
-  maxAttempts: 5
-}) => {
-  const { url, init } = spec;
-  let ws;
-  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
-    const open = new Trigger2();
-    ws = new WebSocket(url);
-    Object.assign(ws, {
-      onopen: () => {
-        log7.info("opened", {
-          url
+    let last = 0;
+    let run = 0;
+    const job = CronJob.from({
+      cronTime: cron,
+      runOnInit: false,
+      onTick: () => {
+        const now = Date.now();
+        const delta = last ? now - last : 0;
+        last = now;
+        run++;
+        log3.info("tick", {
+          space: space.key.truncate(),
+          count: run,
+          delta
         }, {
-          F: __dxlog_file7,
-          L: 39,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        if (spec.init) {
-          ws.send(new TextEncoder().encode(JSON.stringify(init)));
-        }
-        open.wake(true);
-      },
-      onclose: (event) => {
-        log7.info("closed", {
-          url,
-          code: event.code
-        }, {
-          F: __dxlog_file7,
-          L: 48,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        if (event.code === 1006) {
-          setTimeout(async () => {
-            log7.info(`reconnecting in ${options.retryDelay}s...`, {
-              url
-            }, {
-              F: __dxlog_file7,
-              L: 53,
-              S: void 0,
-              C: (f, a) => f(...a)
-            });
-            await createWebsocketTrigger(ctx, triggerCtx, spec, callback, options);
-          }, options.retryDelay * 1e3);
-        }
-        open.wake(false);
-      },
-      onerror: (event) => {
-        log7.catch(event.error, {
-          url
-        }, {
-          F: __dxlog_file7,
-          L: 62,
-          S: void 0,
+          F: __dxlog_file3,
+          L: 167,
+          S: this,
           C: (f, a) => f(...a)
         });
-      },
-      onmessage: async (event) => {
-        try {
-          log7.info("message", void 0, {
-            F: __dxlog_file7,
-            L: 67,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-          const data = JSON.parse(new TextDecoder().decode(event.data));
-          await callback({
-            data
-          });
-        } catch (err) {
-          log7.catch(err, {
-            url
-          }, {
-            F: __dxlog_file7,
-            L: 71,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-        }
+        task.schedule();
       }
     });
-    const isOpen = await open.wait();
-    if (isOpen) {
-      break;
-    } else {
-      const wait = Math.pow(attempt, 2) * options.retryDelay;
-      if (attempt < options.maxAttempts) {
-        log7.warn(`failed to connect; trying again in ${wait}s`, {
-          attempt
-        }, {
-          F: __dxlog_file7,
-          L: 82,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        await sleep(wait * 1e3);
-      }
-    }
-  }
-  ctx.onDispose(() => {
-    ws?.close();
-  });
-};
-
-// packages/core/functions/src/trigger/trigger-registry.ts
-var __dxlog_file8 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/trigger-registry.ts";
-var triggerHandlers = {
-  subscription: createSubscriptionTrigger,
-  timer: createTimerTrigger,
-  webhook: createWebhookTrigger,
-  websocket: createWebsocketTrigger
-};
-var TriggerRegistry = class extends Resource2 {
-  constructor(_client, _options) {
-    super();
-    this._client = _client;
-    this._options = _options;
-    this._triggersBySpaceKey = new ComplexMap2(PublicKey3.hash);
-    this.registered = new Event3();
-    this.removed = new Event3();
+    job.start();
+    ctx.onDispose(() => job.stop());
   }
-  getActiveTriggers(space) {
-    return this._getTriggers(space, (t) => t.activationCtx != null);
-  }
-  getInactiveTriggers(space) {
-    return this._getTriggers(space, (t) => t.activationCtx == null);
-  }
-  async activate(triggerCtx, trigger, callback) {
-    log8("activate", {
-      space: triggerCtx.space.key,
+  /**
+  * Webhook.
+  */
+  async _createWebhook(ctx, space, def, trigger) {
+    log3.info("webhook", {
+      space: space.key,
       trigger
     }, {
-      F: __dxlog_file8,
-      L: 73,
+      F: __dxlog_file3,
+      L: 180,
       S: this,
       C: (f, a) => f(...a)
     });
-    const activationCtx = new Context3({
-      name: `trigger_${trigger.function}`
+    const { port } = trigger;
+    const server = http.createServer(async (req, res) => {
+      await this._execFunction(def, {
+        space: space.key
+      });
     });
-    this._ctx.onDispose(() => activationCtx.dispose());
-    const registeredTrigger = this._triggersBySpaceKey.get(triggerCtx.space.key)?.find((reg) => reg.trigger.id === trigger.id);
-    invariant2(registeredTrigger, `Trigger is not registered: ${trigger.function}`, {
-      F: __dxlog_file8,
-      L: 79,
-      S: this,
-      A: [
-        "registeredTrigger",
-        "`Trigger is not registered: ${trigger.function}`"
-      ]
+    server.listen(port, () => {
+      log3.info("started webhook", {
+        port
+      }, {
+        F: __dxlog_file3,
+        L: 189,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+    ctx.onDispose(() => {
+      server.close();
     });
-    registeredTrigger.activationCtx = activationCtx;
-    try {
-      const options = this._options?.[trigger.spec.type];
-      await triggerHandlers[trigger.spec.type](activationCtx, triggerCtx, trigger.spec, callback, options);
-    } catch (err) {
-      delete registeredTrigger.activationCtx;
-      throw err;
-    }
   }
   /**
-  * Loads triggers from the manifest into the space.
+  * Websocket.
   */
-  async register(space, manifest) {
-    log8("register", {
-      space: space.key
+  async _createWebsocket(ctx, space, def, trigger, options = {
+    retryDelay: 2,
+    maxAttempts: 5
+  }) {
+    log3.info("websocket", {
+      space: space.key,
+      trigger
     }, {
-      F: __dxlog_file8,
-      L: 95,
+      F: __dxlog_file3,
+      L: 213,
       S: this,
       C: (f, a) => f(...a)
     });
-    if (!manifest.triggers?.length) {
-      return;
-    }
-    if (!space.db.graph.runtimeSchemaRegistry.isSchemaRegistered(FunctionTrigger)) {
-      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
-    }
-    const reactiveObjects = manifest.triggers.map((template) => create2(FunctionTrigger, {
-      ...template
-    }));
-    reactiveObjects.forEach((obj) => space.db.add(obj));
-  }
-  async _open() {
-    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
-      for (const space of spaces) {
-        if (this._triggersBySpaceKey.has(space.key)) {
-          continue;
+    const { url } = trigger;
+    let ws;
+    for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
+      const open = new Trigger2();
+      ws = new WebSocket(url);
+      Object.assign(ws, {
+        onopen: () => {
+          log3.info("opened", {
+            url
+          }, {
+            F: __dxlog_file3,
+            L: 223,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          if (trigger.init) {
+            ws.send(new TextEncoder().encode(JSON.stringify(trigger.init)));
+          }
+          open.wake(true);
+        },
+        onclose: () => {
+          log3.info("closed", {
+            url
+          }, {
+            F: __dxlog_file3,
+            L: 232,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          open.wake(false);
+        },
+        onerror: (event) => {
+          log3.catch(event.error, {
+            url
+          }, {
+            F: __dxlog_file3,
+            L: 237,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        },
+        onmessage: async (event) => {
+          try {
+            const data = JSON.parse(new TextDecoder().decode(event.data));
+            await this._execFunction(def, {
+              space: space.key,
+              data
+            });
+          } catch (err) {
+            log3.catch(err, {
+              url
+            }, {
+              F: __dxlog_file3,
+              L: 245,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
         }
-        const registered = [];
-        this._triggersBySpaceKey.set(space.key, registered);
-        await space.waitUntilReady();
-        if (this._ctx.disposed) {
-          break;
+      });
+      const isOpen = await open.wait();
+      if (isOpen) {
+        break;
+      } else {
+        const wait = Math.pow(attempt, 2) * options.retryDelay;
+        if (attempt < options.maxAttempts) {
+          log3.warn(`failed to connect; trying again in ${wait}s`, {
+            attempt
+          }, {
+            F: __dxlog_file3,
+            L: 256,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          await sleep(wait * 1e3);
         }
-        const functionsSubscription = space.db.query(Filter3.schema(FunctionTrigger)).subscribe(async (triggers) => {
-          await this._handleRemovedTriggers(space, triggers.objects, registered);
-          this._handleNewTriggers(space, triggers.objects, registered);
-        });
-        this._ctx.onDispose(functionsSubscription);
       }
+    }
+    ctx.onDispose(() => {
+      ws?.close();
     });
-    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
-  }
-  async _close(_) {
-    this._triggersBySpaceKey.clear();
   }
-  _handleNewTriggers(space, allTriggers, registered) {
-    const newTriggers = allTriggers.filter((candidate) => {
-      return registered.find((reg) => reg.trigger.id === candidate.id) == null;
+  /**
+  * ECHO subscription.
+  */
+  async _createSubscription(ctx, space, def, trigger) {
+    log3.info("subscription", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file3,
+      L: 271,
+      S: this,
+      C: (f, a) => f(...a)
     });
-    if (newTriggers.length > 0) {
-      const newRegisteredTriggers = newTriggers.map((trigger) => ({
-        trigger
-      }));
-      registered.push(...newRegisteredTriggers);
-      log8("registered new triggers", () => ({
-        spaceKey: space.key,
-        functions: newTriggers.map((t) => t.function)
-      }), {
-        F: __dxlog_file8,
-        L: 146,
+    const objectIds = /* @__PURE__ */ new Set();
+    const task = new DeferredTask(ctx, async () => {
+      await this._execFunction(def, {
+        space: space.key,
+        objects: Array.from(objectIds)
+      });
+    });
+    const subscriptions = [];
+    const subscription = createSubscription(({ added, updated }) => {
+      log3.info("updated", {
+        added: added.length,
+        updated: updated.length
+      }, {
+        F: __dxlog_file3,
+        L: 281,
         S: this,
         C: (f, a) => f(...a)
       });
-      this.registered.emit({
-        space,
-        triggers: newTriggers
-      });
-    }
-  }
-  async _handleRemovedTriggers(space, allTriggers, registered) {
-    const removed = [];
-    for (let i = registered.length - 1; i >= 0; i--) {
-      const wasRemoved = allTriggers.find((trigger) => trigger.id === registered[i].trigger.id) == null;
-      if (wasRemoved) {
-        const unregistered = registered.splice(i, 1)[0];
-        await unregistered.activationCtx?.dispose();
-        removed.push(unregistered.trigger);
+      for (const object of added) {
+        objectIds.add(object.id);
       }
-    }
-    if (removed.length > 0) {
-      this.removed.emit({
-        space,
-        triggers: removed
-      });
-    }
-  }
-  _getTriggers(space, predicate) {
-    const allSpaceTriggers = this._triggersBySpaceKey.get(space.key) ?? [];
-    return allSpaceTriggers.filter(predicate).map((trigger) => trigger.trigger);
+      for (const object of updated) {
+        objectIds.add(object.id);
+      }
+      task.schedule();
+    });
+    subscriptions.push(() => subscription.unsubscribe());
+    const { filter, options: { deep, delay } = {} } = trigger;
+    const update = ({ objects }) => {
+      subscription.update(objects);
+      if (deep) {
+        log3.info("update", {
+          objects: objects.length
+        }, {
+          F: __dxlog_file3,
+          L: 301,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        for (const object of objects) {
+          const content = object.content;
+          if (content instanceof TextV0Type) {
+            subscriptions.push(getAutomergeObjectCore(content).updates.on(debounce(() => subscription.update([
+              object
+            ]), 1e3)));
+          }
+        }
+      }
+    };
+    const query = space.db.query(Filter.or(filter.map(({ type, props }) => Filter.typename(type, props))));
+    subscriptions.push(query.subscribe(delay ? debounce(update, delay) : update));
+    ctx.onDispose(() => {
+      subscriptions.forEach((unsubscribe) => unsubscribe());
+    });
   }
 };
+
+// packages/core/functions/src/types.ts
+import * as S from "@effect/schema/Schema";
+var TimerTriggerSchema = S.struct({
+  cron: S.string
+});
+var WebhookTriggerSchema = S.struct({
+  port: S.number
+});
+var WebsocketTriggerSchema = S.struct({
+  url: S.string,
+  init: S.optional(S.record(S.string, S.any))
+});
+var SubscriptionTriggerSchema = S.struct({
+  spaceKey: S.optional(S.string),
+  // 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)
+  }))
+});
+var FunctionTriggerSchema = S.struct({
+  function: S.string.pipe(S.description("Function ID/URI.")),
+  timer: S.optional(TimerTriggerSchema),
+  webhook: S.optional(WebhookTriggerSchema),
+  websocket: S.optional(WebsocketTriggerSchema),
+  subscription: S.optional(SubscriptionTriggerSchema)
+});
+var FunctionDefSchema = S.struct({
+  id: S.string,
+  description: S.optional(S.string),
+  name: S.string,
+  // TODO(burdon): NPM/GitHub URL?
+  handler: S.string
+});
+var FunctionManifestSchema = S.struct({
+  functions: S.mutable(S.array(FunctionDefSchema)),
+  triggers: S.mutable(S.array(FunctionTriggerSchema))
+});
 export {
   DevServer,
-  FunctionDef,
   FunctionManifestSchema,
-  FunctionRegistry,
-  FunctionTrigger,
   Scheduler,
-  TriggerRegistry,
   subscriptionHandler
 };
 //# sourceMappingURL=index.mjs.map