@dxos/functions 0.5.3-main.6f2dfea → 0.5.3-main.79e0565

package/dist/lib/node/index.cjs

@@ -29,33 +29,57 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var node_exports = {};
 __export(node_exports, {
   DevServer: () => DevServer,
+  FunctionDef: () => FunctionDef,
   FunctionManifestSchema: () => FunctionManifestSchema,
+  FunctionRegistry: () => FunctionRegistry,
+  FunctionTrigger: () => FunctionTrigger,
   Scheduler: () => Scheduler,
+  TriggerRegistry: () => TriggerRegistry,
   subscriptionHandler: () => subscriptionHandler
 });
 module.exports = __toCommonJS(node_exports);
-var import_client = require("@dxos/client");
+var import_async = require("@dxos/async");
+var import_echo = require("@dxos/client/echo");
+var import_context = require("@dxos/context");
+var import_keys = require("@dxos/keys");
 var import_log = require("@dxos/log");
 var import_util = require("@dxos/util");
+var import_echo_schema = require("@dxos/echo-schema");
+var import_client = require("@dxos/client");
+var import_log2 = require("@dxos/log");
+var import_util2 = require("@dxos/util");
 var import_express = __toESM(require("express"));
 var import_get_port_please = require("get-port-please");
 var import_node_path = require("node:path");
-var import_async = require("@dxos/async");
+var import_async2 = require("@dxos/async");
+var import_context2 = require("@dxos/context");
 var import_invariant = require("@dxos/invariant");
-var import_log2 = require("@dxos/log");
+var import_log3 = require("@dxos/log");
+var import_node_path2 = __toESM(require("node:path"));
+var import_async3 = require("@dxos/async");
+var import_context3 = require("@dxos/context");
+var import_log4 = require("@dxos/log");
+var import_async4 = require("@dxos/async");
+var import_echo2 = require("@dxos/client/echo");
+var import_context4 = require("@dxos/context");
+var import_echo_schema2 = require("@dxos/echo-schema");
+var import_invariant2 = require("@dxos/invariant");
+var import_keys2 = require("@dxos/keys");
+var import_log5 = require("@dxos/log");
+var import_util3 = require("@dxos/util");
+var import_types = require("@braneframe/types");
+var import_async5 = require("@dxos/async");
+var import_echo_db = require("@dxos/echo-db");
+var import_log6 = require("@dxos/log");
 var import_cron = require("cron");
+var import_async6 = require("@dxos/async");
+var import_log7 = require("@dxos/log");
 var import_get_port_please2 = require("get-port-please");
 var import_node_http = __toESM(require("node:http"));
-var import_node_path2 = __toESM(require("node:path"));
+var import_log8 = require("@dxos/log");
 var import_ws = __toESM(require("ws"));
-var import_types = require("@braneframe/types");
-var import_async2 = require("@dxos/async");
-var import_echo = require("@dxos/client/echo");
-var import_context = require("@dxos/context");
-var import_invariant2 = require("@dxos/invariant");
-var import_log3 = require("@dxos/log");
-var import_util2 = require("@dxos/util");
-var S = __toESM(require("@effect/schema/Schema"));
+var import_async7 = require("@dxos/async");
+var import_log9 = require("@dxos/log");
 var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
   get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
 }) : x)(function(x) {
@@ -63,51 +87,209 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/handler.ts";
+var SubscriptionTriggerSchema = import_echo_schema.S.struct({
+  type: import_echo_schema.S.literal("subscription"),
+  // TODO(burdon): Define query DSL (from ECHO).
+  filter: import_echo_schema.S.array(import_echo_schema.S.struct({
+    type: import_echo_schema.S.string,
+    props: import_echo_schema.S.optional(import_echo_schema.S.record(import_echo_schema.S.string, import_echo_schema.S.any))
+  })),
+  options: import_echo_schema.S.optional(import_echo_schema.S.struct({
+    // Watch changes to object (not just creation).
+    deep: import_echo_schema.S.optional(import_echo_schema.S.boolean),
+    // Debounce changes (delay in ms).
+    delay: import_echo_schema.S.optional(import_echo_schema.S.number)
+  }))
+});
+var TimerTriggerSchema = import_echo_schema.S.struct({
+  type: import_echo_schema.S.literal("timer"),
+  cron: import_echo_schema.S.string
+});
+var WebhookTriggerSchema = import_echo_schema.S.mutable(import_echo_schema.S.struct({
+  type: import_echo_schema.S.literal("webhook"),
+  method: import_echo_schema.S.string,
+  // Assigned port.
+  port: import_echo_schema.S.optional(import_echo_schema.S.number)
+}));
+var WebsocketTriggerSchema = import_echo_schema.S.struct({
+  type: import_echo_schema.S.literal("websocket"),
+  url: import_echo_schema.S.string,
+  init: import_echo_schema.S.optional(import_echo_schema.S.record(import_echo_schema.S.string, import_echo_schema.S.any))
+});
+var TriggerSpecSchema = import_echo_schema.S.union(TimerTriggerSchema, WebhookTriggerSchema, WebsocketTriggerSchema, SubscriptionTriggerSchema);
+var FunctionDef = class extends (0, import_echo_schema.TypedObject)({
+  typename: "dxos.org/type/FunctionDef",
+  version: "0.1.0"
+})({
+  uri: import_echo_schema.S.string,
+  description: import_echo_schema.S.optional(import_echo_schema.S.string),
+  route: import_echo_schema.S.string,
+  // TODO(burdon): NPM/GitHub/Docker/CF URL?
+  handler: import_echo_schema.S.string
+}) {
+};
+var FunctionTrigger = class extends (0, import_echo_schema.TypedObject)({
+  typename: "dxos.org/type/FunctionTrigger",
+  version: "0.1.0"
+})({
+  function: import_echo_schema.S.string.pipe(import_echo_schema.S.description("Function URI.")),
+  // Context is merged into the event data passed to the function.
+  meta: import_echo_schema.S.optional(import_echo_schema.S.object),
+  spec: TriggerSpecSchema
+}) {
+};
+var FunctionManifestSchema = import_echo_schema.S.struct({
+  functions: import_echo_schema.S.optional(import_echo_schema.S.mutable(import_echo_schema.S.array((0, import_echo_schema.RawObject)(FunctionDef)))),
+  triggers: import_echo_schema.S.optional(import_echo_schema.S.mutable(import_echo_schema.S.array((0, import_echo_schema.RawObject)(FunctionTrigger))))
+});
+var diff = (previous, next, comparator) => {
+  const remaining = [
+    ...previous
+  ];
+  const result = {
+    added: [],
+    updated: [],
+    removed: remaining
+  };
+  for (const object of next) {
+    const index = remaining.findIndex((item) => comparator(item, object));
+    if (index === -1) {
+      result.added.push(object);
+    } else {
+      result.updated.push(remaining[index]);
+      remaining.splice(index, 1);
+    }
+  }
+  return result;
+};
+var intersection = (a, b, comparator) => a.filter((a2) => b.find((b2) => comparator(a2, b2)) !== void 0);
+var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/function/function-registry.ts";
+var FunctionRegistry = class extends import_context.Resource {
+  constructor(_client) {
+    super();
+    this._client = _client;
+    this._functionBySpaceKey = new import_util.ComplexMap(import_keys.PublicKey.hash);
+    this.registered = new import_async.Event();
+  }
+  getFunctions(space) {
+    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.
+  */
+  async register(space, functions) {
+    (0, import_log.log)("register", {
+      space: space.key,
+      functions: functions?.length ?? 0
+    }, {
+      F: __dxlog_file,
+      L: 39,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (!functions?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionDef)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionDef);
+    }
+    const { objects: existing } = await space.db.query(import_echo.Filter.schema(FunctionDef)).run();
+    const { added, removed } = diff(existing, functions, (a, b) => a.uri === b.uri);
+    added.forEach((def) => space.db.add((0, import_echo.create)(FunctionDef, def)));
+    removed.forEach((def) => space.db.remove(def));
+  }
+  async _open() {
+    const spacesSubscription = 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;
+        }
+        this._ctx.onDispose(space.db.query(import_echo.Filter.schema(FunctionDef)).subscribe(({ objects }) => {
+          const { added } = diff(registered, objects, (a, b) => a.uri === b.uri);
+          if (added.length > 0) {
+            registered.push(...added);
+            this.registered.emit({
+              space,
+              added
+            });
+          }
+        }));
+      }
+    });
+    this._ctx.onDispose(() => spacesSubscription.unsubscribe());
+  }
+  async _close(_) {
+    this._functionBySpaceKey.clear();
+  }
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/handler.ts";
 var subscriptionHandler = (handler) => {
-  return ({ event, context, ...rest }) => {
+  return ({ event: { data }, context, ...rest }) => {
     const { client } = context;
-    const space = event.spaceKey ? client.spaces.get(import_client.PublicKey.from(event.spaceKey)) : void 0;
-    const objects = space && event.objects?.map((id) => space.db.getObjectById(id)).filter(import_util.nonNullable);
-    if (!!event.spaceKey && !space) {
-      import_log.log.warn("invalid space", {
-        event
+    const space = data.spaceKey ? client.spaces.get(import_client.PublicKey.from(data.spaceKey)) : void 0;
+    const objects = space ? data.objects?.map((id) => space.db.getObjectById(id)).filter(import_util2.nonNullable) : [];
+    if (!!data.spaceKey && !space) {
+      import_log2.log.warn("invalid space", {
+        data
       }, {
-        F: __dxlog_file,
-        L: 68,
+        F: __dxlog_file2,
+        L: 91,
         S: void 0,
         C: (f, a) => f(...a)
       });
     } else {
-      import_log.log.info("handler", {
+      import_log2.log.info("handler", {
         space: space?.key.truncate(),
         objects: objects?.length
       }, {
-        F: __dxlog_file,
-        L: 70,
+        F: __dxlog_file2,
+        L: 93,
         S: void 0,
         C: (f, a) => f(...a)
       });
     }
     return handler({
       event: {
-        space,
-        objects
+        data: {
+          ...data,
+          space,
+          objects
+        }
       },
       context,
       ...rest
     });
   };
 };
-var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/dev-server.ts";
+var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/dev-server.ts";
 var DevServer = class {
-  // prettier-ignore
-  constructor(_client, _options) {
+  constructor(_client, _functionsRegistry, _options) {
     this._client = _client;
+    this._functionsRegistry = _functionsRegistry;
     this._options = _options;
+    this._ctx = createContext();
     this._handlers = {};
     this._seq = 0;
-    this.update = new import_async.Event();
+    this.update = new import_async2.Event();
+    this._functionsRegistry.registered.on(async ({ added }) => {
+      added.forEach((def) => this._load(def));
+      await this._safeUpdateRegistration();
+      (0, import_log3.log)("new functions loaded", {
+        added
+      }, {
+        F: __dxlog_file3,
+        L: 52,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
   }
   get stats() {
     return {
@@ -116,8 +298,8 @@ var DevServer = class {
   }
   get endpoint() {
     (0, import_invariant.invariant)(this._port, void 0, {
-      F: __dxlog_file2,
-      L: 54,
+      F: __dxlog_file3,
+      L: 63,
       S: this,
       A: [
         "this._port",
@@ -132,45 +314,32 @@ 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) {
-        import_log2.log.error("parsing function (check manifest)", err, {
-          F: __dxlog_file2,
-          L: 71,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      }
-    }
-  }
   async start() {
     (0, import_invariant.invariant)(!this._server, void 0, {
-      F: __dxlog_file2,
-      L: 77,
+      F: __dxlog_file3,
+      L: 76,
       S: this,
       A: [
         "!this._server",
         ""
       ]
     });
-    import_log2.log.info("starting...", void 0, {
-      F: __dxlog_file2,
-      L: 78,
+    import_log3.log.info("starting...", void 0, {
+      F: __dxlog_file3,
+      L: 77,
       S: this,
       C: (f, a) => f(...a)
     });
+    this._ctx = createContext();
     const app = (0, import_express.default)();
     app.use(import_express.default.json());
     app.post("/:path", async (req, res) => {
       const { path: path2 } = req.params;
       try {
-        import_log2.log.info("calling", {
+        import_log3.log.info("calling", {
           path: path2
         }, {
-          F: __dxlog_file2,
+          F: __dxlog_file3,
           L: 87,
           S: this,
           C: (f, a) => f(...a)
@@ -182,8 +351,8 @@ var DevServer = class {
         res.statusCode = await this.invoke("/" + path2, req.body);
         res.end();
       } catch (err) {
-        import_log2.log.catch(err, void 0, {
-          F: __dxlog_file2,
+        import_log3.log.catch(err, void 0, {
+          F: __dxlog_file3,
           L: 97,
           S: this,
           C: (f, a) => f(...a)
@@ -203,64 +372,61 @@ var DevServer = class {
     this._server = app.listen(this._port);
     try {
       const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService.register({
-        endpoint: this.endpoint,
-        functions: this.functions.map(({ def: { id, path: path2 } }) => ({
-          id,
-          path: path2
-        }))
+        endpoint: this.endpoint
       });
-      import_log2.log.info("registered", {
+      import_log3.log.info("registered", {
         endpoint
       }, {
-        F: __dxlog_file2,
-        L: 113,
+        F: __dxlog_file3,
+        L: 112,
         S: this,
         C: (f, a) => f(...a)
       });
       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).");
     }
-    import_log2.log.info("started", {
+    import_log3.log.info("started", {
       port: this._port
     }, {
-      F: __dxlog_file2,
-      L: 121,
+      F: __dxlog_file3,
+      L: 123,
       S: this,
       C: (f, a) => f(...a)
     });
   }
   async stop() {
     (0, import_invariant.invariant)(this._server, void 0, {
-      F: __dxlog_file2,
-      L: 125,
+      F: __dxlog_file3,
+      L: 127,
       S: this,
       A: [
         "this._server",
         ""
       ]
     });
-    import_log2.log.info("stopping...", void 0, {
-      F: __dxlog_file2,
-      L: 126,
+    import_log3.log.info("stopping...", void 0, {
+      F: __dxlog_file3,
+      L: 128,
       S: this,
       C: (f, a) => f(...a)
     });
-    const trigger = new import_async.Trigger();
+    const trigger = new import_async2.Trigger();
     this._server.close(async () => {
-      import_log2.log.info("server stopped", void 0, {
-        F: __dxlog_file2,
-        L: 130,
+      import_log3.log.info("server stopped", void 0, {
+        F: __dxlog_file3,
+        L: 132,
         S: this,
         C: (f, a) => f(...a)
       });
       try {
         if (this._functionServiceRegistration) {
           (0, import_invariant.invariant)(this._client.services.services.FunctionRegistryService, void 0, {
-            F: __dxlog_file2,
-            L: 133,
+            F: __dxlog_file3,
+            L: 135,
             S: this,
             A: [
               "this._client.services.services.FunctionRegistryService",
@@ -270,11 +436,11 @@ var DevServer = class {
           await this._client.services.services.FunctionRegistryService.unregister({
             registrationId: this._functionServiceRegistration
           });
-          import_log2.log.info("unregistered", {
+          import_log3.log.info("unregistered", {
             registrationId: this._functionServiceRegistration
           }, {
-            F: __dxlog_file2,
-            L: 138,
+            F: __dxlog_file3,
+            L: 140,
             S: this,
             C: (f, a) => f(...a)
           });
@@ -289,9 +455,9 @@ var DevServer = class {
     await trigger.wait();
     this._port = void 0;
     this._server = void 0;
-    import_log2.log.info("stopped", void 0, {
-      F: __dxlog_file2,
-      L: 152,
+    import_log3.log.info("stopped", void 0, {
+      F: __dxlog_file3,
+      L: 154,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -300,14 +466,14 @@ var DevServer = class {
   * Load function.
   */
   async _load(def, force = false) {
-    const { id, path: path2, handler } = def;
+    const { uri, route, handler } = def;
     const filePath = (0, import_node_path.join)(this._options.baseDir, handler);
-    import_log2.log.info("loading", {
-      id,
+    import_log3.log.info("loading", {
+      uri,
       force
     }, {
-      F: __dxlog_file2,
-      L: 161,
+      F: __dxlog_file3,
+      L: 163,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -318,37 +484,66 @@ var DevServer = class {
     }
     const module2 = __require(filePath);
     if (typeof module2.default !== "function") {
-      throw new Error(`Handler must export default function: ${id}`);
+      throw new Error(`Handler must export default function: ${uri}`);
     }
-    this._handlers[path2] = {
+    this._handlers[route] = {
       def,
       handler: module2.default
     };
   }
+  async _safeUpdateRegistration() {
+    (0, import_invariant.invariant)(this._functionServiceRegistration, void 0, {
+      F: __dxlog_file3,
+      L: 185,
+      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) {
+      import_log3.log.catch(e, void 0, {
+        F: __dxlog_file3,
+        L: 192,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }
+  }
   /**
   * Invoke function.
   */
   async invoke(path2, data) {
     const seq = ++this._seq;
     const now = Date.now();
-    import_log2.log.info("req", {
+    import_log3.log.info("req", {
       seq,
       path: path2
     }, {
-      F: __dxlog_file2,
-      L: 188,
+      F: __dxlog_file3,
+      L: 203,
       S: this,
       C: (f, a) => f(...a)
     });
-    const statusCode = await this._invoke(path2, data);
-    import_log2.log.info("res", {
+    const statusCode = await this._invoke(path2, {
+      data
+    });
+    import_log3.log.info("res", {
       seq,
       path: path2,
       statusCode,
       duration: Date.now() - now
     }, {
-      F: __dxlog_file2,
-      L: 191,
+      F: __dxlog_file3,
+      L: 206,
       S: this,
       C: (f, a) => f(...a)
     });
@@ -358,8 +553,8 @@ var DevServer = class {
   async _invoke(path2, event) {
     const { handler } = this._handlers[path2] ?? {};
     (0, import_invariant.invariant)(handler, `invalid path: ${path2}`, {
-      F: __dxlog_file2,
-      L: 198,
+      F: __dxlog_file3,
+      L: 213,
       S: this,
       A: [
         "handler",
@@ -385,109 +580,98 @@ var DevServer = class {
     return statusCode;
   }
 };
-var __dxlog_file3 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/scheduler.ts";
+var createContext = () => new import_context2.Context({
+  name: "DevServer"
+});
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/scheduler.ts";
 var Scheduler = class {
-  constructor(_client, _manifest, _options = {}) {
-    this._client = _client;
-    this._manifest = _manifest;
+  constructor(functions, triggers, _options = {}) {
+    this.functions = functions;
+    this.triggers = triggers;
     this._options = _options;
-    this._mounts = new import_util2.ComplexMap(({ spaceKey, id }) => `${spaceKey.toHex()}:${id}`);
-  }
-  get mounts() {
-    return Array.from(this._mounts.values()).reduce((acc, { trigger }) => {
-      acc.push(trigger);
-      return acc;
-    }, []);
+    this._ctx = createContext2();
+    this._callMutex = new import_async3.Mutex();
+    this.functions.registered.on(async ({ space, added }) => {
+      await this._safeActivateTriggers(space, this.triggers.getInactiveTriggers(space), added);
+    });
+    this.triggers.registered.on(async ({ space, triggers: triggers2 }) => {
+      await this._safeActivateTriggers(space, triggers2, this.functions.getFunctions(space));
+    });
   }
   async start() {
-    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 import_context.Context(), space, trigger);
-        }
-      }
-    });
+    await this._ctx.dispose();
+    this._ctx = createContext2();
+    await this.functions.open(this._ctx);
+    await this.triggers.open(this._ctx);
   }
   async stop() {
-    for (const { id, spaceKey } of this._mounts.keys()) {
-      await this.unmount(id, spaceKey);
-    }
+    await this._ctx.dispose();
+    await this.functions.close();
+    await this.triggers.close();
   }
-  /**
-  * Mount trigger.
-  */
-  async mount(ctx, space, trigger) {
-    const key = {
-      spaceKey: space.key,
-      id: trigger.function
-    };
-    const def = this._manifest.functions.find((config) => config.id === trigger.function);
-    (0, import_invariant2.invariant)(def, `Function not found: ${trigger.function}`, {
-      F: __dxlog_file3,
-      L: 83,
-      S: this,
-      A: [
-        "def",
-        "`Function not found: ${trigger.function}`"
-      ]
+  // TODO(burdon): Remove and update registries directly.
+  async register(space, manifest) {
+    await this.functions.register(space, manifest.functions);
+    await this.triggers.register(space, manifest);
+  }
+  async _safeActivateTriggers(space, triggers, functions) {
+    const mountTasks = triggers.map((trigger) => {
+      return this.activate(space, functions, trigger);
     });
-    const exists = this._mounts.get(key);
-    if (!exists) {
-      this._mounts.set(key, {
-        ctx,
-        trigger
-      });
-      (0, import_log3.log)("mount", {
-        space: space.key,
-        trigger
+    await Promise.all(mountTasks).catch(import_log4.log.catch);
+  }
+  async activate(space, functions, fnTrigger) {
+    const definition = functions.find((def) => def.uri === fnTrigger.function);
+    if (!definition) {
+      import_log4.log.info("function is not found for trigger", {
+        fnTrigger
       }, {
-        F: __dxlog_file3,
-        L: 89,
+        F: __dxlog_file4,
+        L: 78,
         S: this,
         C: (f, a) => f(...a)
       });
-      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);
-      }
-    }
-  }
-  async unmount(id, spaceKey) {
-    const key = {
-      id,
-      spaceKey
-    };
-    const { ctx } = this._mounts.get(key) ?? {};
-    if (ctx) {
-      this._mounts.delete(key);
-      await ctx.dispose();
+      return;
     }
+    await this.triggers.activate({
+      space
+    }, fnTrigger, async (args) => {
+      return this._callMutex.executeSynchronized(() => {
+        return this._execFunction(definition, fnTrigger, {
+          meta: fnTrigger.meta,
+          data: {
+            ...args,
+            spaceKey: space.key
+          }
+        });
+      });
+    });
+    (0, import_log4.log)("activated trigger", {
+      space: space.key,
+      trigger: fnTrigger
+    }, {
+      F: __dxlog_file4,
+      L: 91,
+      S: this,
+      C: (f, a) => f(...a)
+    });
   }
-  // TODO(burdon): Pass in Space key (common context).
-  async _execFunction(def, data) {
+  async _execFunction(def, trigger, { data, meta }) {
+    let status = 0;
     try {
-      let status = 0;
+      const payload = Object.assign({}, meta && {
+        meta
+      }, data);
       const { endpoint, callback } = this._options;
       if (endpoint) {
-        const url = import_node_path2.default.join(endpoint, def.path);
-        import_log3.log.info("exec", {
-          function: def.id,
-          url
+        const url = import_node_path2.default.join(endpoint, def.route);
+        import_log4.log.info("exec", {
+          function: def.uri,
+          url,
+          triggerType: trigger.spec.type
         }, {
-          F: __dxlog_file3,
-          L: 133,
+          F: __dxlog_file4,
+          L: 108,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -496,358 +680,448 @@ var Scheduler = class {
           headers: {
             "Content-Type": "application/json"
           },
-          body: JSON.stringify(data)
+          body: JSON.stringify(payload)
         });
         status = response.status;
       } else if (callback) {
-        import_log3.log.info("exec", {
-          function: def.id
+        import_log4.log.info("exec", {
+          function: def.uri
         }, {
-          F: __dxlog_file3,
-          L: 144,
+          F: __dxlog_file4,
+          L: 119,
           S: this,
           C: (f, a) => f(...a)
         });
-        status = await callback(data) ?? 200;
+        status = await callback(payload) ?? 200;
       }
       if (status && status >= 400) {
         throw new Error(`Response: ${status}`);
       }
-      import_log3.log.info("done", {
-        function: def.id,
+      import_log4.log.info("done", {
+        function: def.uri,
         status
       }, {
-        F: __dxlog_file3,
-        L: 154,
+        F: __dxlog_file4,
+        L: 129,
         S: this,
         C: (f, a) => f(...a)
       });
-      return status;
     } catch (err) {
-      import_log3.log.error("error", {
-        function: def.id,
+      import_log4.log.error("error", {
+        function: def.uri,
         error: err.message
       }, {
-        F: __dxlog_file3,
-        L: 157,
+        F: __dxlog_file4,
+        L: 131,
         S: this,
         C: (f, a) => f(...a)
       });
-      return 500;
+      status = 500;
     }
+    return status;
   }
-  //
-  // Triggers
-  //
-  /**
-  * Cron timer.
-  */
-  async _createTimer(ctx, space, def, trigger) {
-    import_log3.log.info("timer", {
-      space: space.key,
-      trigger
+};
+var createContext2 = () => new import_context3.Context({
+  name: "FunctionScheduler"
+});
+var __dxlog_file5 = "/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 import_async5.UpdateScheduler(ctx, async () => {
+    if (objectIds.size > 0) {
+      const objects = Array.from(objectIds);
+      objectIds.clear();
+      await callback({
+        objects
+      });
+    }
+  }, {
+    maxFrequency: 4
+  });
+  const subscriptions = [];
+  const subscription = (0, import_echo_db.createSubscription)(({ added, updated }) => {
+    const sizeBefore = objectIds.size;
+    for (const object of added) {
+      objectIds.add(object.id);
+    }
+    for (const object of updated) {
+      objectIds.add(object.id);
+    }
+    if (objectIds.size > sizeBefore) {
+      import_log6.log.info("updated", {
+        added: added.length,
+        updated: updated.length
+      }, {
+        F: __dxlog_file5,
+        L: 45,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      task.trigger();
+    }
+  });
+  subscriptions.push(() => subscription.unsubscribe());
+  const { filter, options: { deep, delay } = {} } = spec;
+  const update = ({ objects }) => {
+    subscription.update(objects);
+    if (deep) {
+      import_log6.log.info("update", {
+        objects: objects.length
+      }, {
+        F: __dxlog_file5,
+        L: 59,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      for (const object of objects) {
+        const content = object.content;
+        if (content instanceof import_types.TextV0Type) {
+          subscriptions.push((0, import_echo_db.getAutomergeObjectCore)(content).updates.on((0, import_async5.debounce)(() => subscription.update([
+            object
+          ]), 1e3)));
+        }
+      }
+    }
+  };
+  const query = triggerCtx.space.db.query(import_echo_db.Filter.or(filter.map(({ type, props }) => import_echo_db.Filter.typename(type, props))));
+  subscriptions.push(query.subscribe(delay ? (0, import_async5.debounce)(update, delay) : update));
+  ctx.onDispose(() => {
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+  });
+};
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/timer-trigger.ts";
+var createTimerTrigger = async (ctx, triggerContext, spec, callback) => {
+  const task = new import_async6.DeferredTask(ctx, async () => {
+    await callback({});
+  });
+  let last = 0;
+  let run = 0;
+  const job = import_cron.CronJob.from({
+    cronTime: spec.cron,
+    runOnInit: false,
+    onTick: () => {
+      const now = Date.now();
+      const delta = last ? now - last : 0;
+      last = now;
+      run++;
+      import_log7.log.info("tick", {
+        space: triggerContext.space.key.truncate(),
+        count: run,
+        delta
+      }, {
+        F: __dxlog_file6,
+        L: 37,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      task.schedule();
+    }
+  });
+  job.start();
+  ctx.onDispose(() => job.stop());
+};
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/webhook-trigger.ts";
+var createWebhookTrigger = async (ctx, _, spec, callback) => {
+  const server = import_node_http.default.createServer(async (req, res) => {
+    if (req.method !== spec.method) {
+      res.statusCode = 405;
+      return res.end();
+    }
+    res.statusCode = await callback({});
+    res.end();
+  });
+  const port = await (0, import_get_port_please2.getPort)({
+    random: true
+  });
+  server.listen(port, () => {
+    import_log8.log.info("started webhook", {
+      port
     }, {
-      F: __dxlog_file3,
-      L: 170,
-      S: this,
+      F: __dxlog_file7,
+      L: 40,
+      S: void 0,
       C: (f, a) => f(...a)
     });
-    const { cron } = trigger;
-    const task = new import_async2.DeferredTask(ctx, async () => {
-      await this._execFunction(def, {
-        spaceKey: space.key
-      });
-    });
-    let last = 0;
-    let run = 0;
-    const job = import_cron.CronJob.from({
-      cronTime: cron,
-      runOnInit: false,
-      onTick: () => {
-        const now = Date.now();
-        const delta = last ? now - last : 0;
-        last = now;
-        run++;
-        import_log3.log.info("tick", {
-          space: space.key.truncate(),
-          count: run,
-          delta
+    spec.port = port;
+  });
+  ctx.onDispose(() => {
+    server.close();
+  });
+};
+var __dxlog_file8 = "/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 import_async7.Trigger();
+    ws = new import_ws.default(url);
+    Object.assign(ws, {
+      onopen: () => {
+        import_log9.log.info("opened", {
+          url
         }, {
-          F: __dxlog_file3,
-          L: 190,
-          S: this,
+          F: __dxlog_file8,
+          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) => {
+        import_log9.log.info("closed", {
+          url,
+          code: event.code
+        }, {
+          F: __dxlog_file8,
+          L: 48,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        if (event.code === 1006) {
+          setTimeout(async () => {
+            import_log9.log.info(`reconnecting in ${options.retryDelay}s...`, {
+              url
+            }, {
+              F: __dxlog_file8,
+              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) => {
+        import_log9.log.catch(event.error, {
+          url
+        }, {
+          F: __dxlog_file8,
+          L: 62,
+          S: void 0,
           C: (f, a) => f(...a)
         });
-        task.schedule();
+      },
+      onmessage: async (event) => {
+        try {
+          import_log9.log.info("message", void 0, {
+            F: __dxlog_file8,
+            L: 67,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const data = JSON.parse(new TextDecoder().decode(event.data));
+          await callback({
+            data
+          });
+        } catch (err) {
+          import_log9.log.catch(err, {
+            url
+          }, {
+            F: __dxlog_file8,
+            L: 71,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
       }
     });
-    job.start();
-    ctx.onDispose(() => job.stop());
+    const isOpen = await open.wait();
+    if (isOpen) {
+      break;
+    } else {
+      const wait = Math.pow(attempt, 2) * options.retryDelay;
+      if (attempt < options.maxAttempts) {
+        import_log9.log.warn(`failed to connect; trying again in ${wait}s`, {
+          attempt
+        }, {
+          F: __dxlog_file8,
+          L: 82,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        await (0, import_async7.sleep)(wait * 1e3);
+      }
+    }
   }
-  /**
-  * Webhook.
-  */
-  async _createWebhook(ctx, space, def, trigger) {
-    import_log3.log.info("webhook", {
-      space: space.key,
+  ctx.onDispose(() => {
+    ws?.close();
+  });
+};
+var __dxlog_file9 = "/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 import_context4.Resource {
+  constructor(_client, _options) {
+    super();
+    this._client = _client;
+    this._options = _options;
+    this._triggersBySpaceKey = new import_util3.ComplexMap(import_keys2.PublicKey.hash);
+    this.registered = new import_async4.Event();
+    this.removed = new import_async4.Event();
+  }
+  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) {
+    (0, import_log5.log)("activate", {
+      space: triggerCtx.space.key,
       trigger
     }, {
-      F: __dxlog_file3,
-      L: 203,
+      F: __dxlog_file9,
+      L: 75,
       S: this,
       C: (f, a) => f(...a)
     });
-    const server = import_node_http.default.createServer(async (req, res) => {
-      if (req.method !== trigger.method) {
-        res.statusCode = 405;
-        return res.end();
-      }
-      res.statusCode = await this._execFunction(def, {
-        spaceKey: space.key
-      });
-      res.end();
-    });
-    const port = await (0, import_get_port_please2.getPort)({
-      random: true
+    const activationCtx = new import_context4.Context({
+      name: `trigger_${trigger.function}`
     });
-    server.listen(port, () => {
-      import_log3.log.info("started webhook", {
-        port
-      }, {
-        F: __dxlog_file3,
-        L: 226,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      trigger.port = port;
-    });
-    ctx.onDispose(() => {
-      server.close();
+    this._ctx.onDispose(() => activationCtx.dispose());
+    const registeredTrigger = this._triggersBySpaceKey.get(triggerCtx.space.key)?.find((reg) => reg.trigger.id === trigger.id);
+    (0, import_invariant2.invariant)(registeredTrigger, `Trigger is not registered: ${trigger.function}`, {
+      F: __dxlog_file9,
+      L: 81,
+      S: this,
+      A: [
+        "registeredTrigger",
+        "`Trigger is not registered: ${trigger.function}`"
+      ]
     });
+    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;
+    }
   }
   /**
-  * Websocket.
-  * NOTE: The port must be unique, so the same hook cannot be used for multiple spaces.
+  * Loads triggers from the manifest into the space.
   */
-  async _createWebsocket(ctx, space, def, trigger, options = {
-    retryDelay: 2,
-    maxAttempts: 5
-  }) {
-    import_log3.log.info("websocket", {
-      space: space.key,
-      trigger
+  async register(space, manifest) {
+    (0, import_log5.log)("register", {
+      space: space.key
     }, {
-      F: __dxlog_file3,
-      L: 252,
+      F: __dxlog_file9,
+      L: 97,
       S: this,
       C: (f, a) => f(...a)
     });
-    const { url } = trigger;
-    let ws;
-    for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
-      const open = new import_async2.Trigger();
-      ws = new import_ws.default(url);
-      Object.assign(ws, {
-        onopen: () => {
-          import_log3.log.info("opened", {
-            url
-          }, {
-            F: __dxlog_file3,
-            L: 262,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          if (trigger.init) {
-            ws.send(new TextEncoder().encode(JSON.stringify(trigger.init)));
-          }
-          open.wake(true);
-        },
-        // TODO(burdon): Config retry if server closes?
-        onclose: (event) => {
-          import_log3.log.info("closed", {
-            url,
-            code: event.code
-          }, {
-            F: __dxlog_file3,
-            L: 272,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          open.wake(false);
-        },
-        onerror: (event) => {
-          import_log3.log.catch(event.error, {
-            url
-          }, {
-            F: __dxlog_file3,
-            L: 277,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-        },
-        onmessage: async (event) => {
-          try {
-            const data = JSON.parse(new TextDecoder().decode(event.data));
-            await this._execFunction(def, {
-              spaceKey: space.key,
-              data
-            });
-          } catch (err) {
-            import_log3.log.catch(err, {
-              url
-            }, {
-              F: __dxlog_file3,
-              L: 285,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
+    if (!manifest.triggers?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(FunctionTrigger)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(FunctionTrigger);
+    }
+    const { objects: existing } = await space.db.query(import_echo2.Filter.schema(FunctionTrigger)).run();
+    const { added, removed } = diff(existing, manifest.triggers, (a, b) => {
+      const keys = b[import_echo_schema2.ECHO_ATTR_META]?.keys ?? [
+        (0, import_echo_schema2.foreignKey)("manifest", [
+          b.function,
+          b.spec.type
+        ].join("-"))
+      ];
+      return intersection((0, import_echo2.getMeta)(a)?.keys ?? [], keys, import_echo_schema2.foreignKeyEquals).length > 0;
+    });
+    added.forEach((trigger) => {
+      const { meta, object } = (0, import_echo_schema2.splitMeta)(trigger);
+      space.db.add((0, import_echo2.create)(FunctionTrigger, object, meta));
+    });
+    removed.forEach((trigger) => space.db.remove(trigger));
+  }
+  async _open() {
+    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        if (this._triggersBySpaceKey.has(space.key)) {
+          continue;
         }
-      });
-      const isOpen = await open.wait();
-      if (isOpen) {
-        break;
-      } else {
-        const wait = Math.pow(attempt, 2) * options.retryDelay;
-        if (attempt < options.maxAttempts) {
-          import_log3.log.warn(`failed to connect; trying again in ${wait}s`, {
-            attempt
-          }, {
-            F: __dxlog_file3,
-            L: 296,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          await (0, import_async2.sleep)(wait * 1e3);
+        const registered = [];
+        this._triggersBySpaceKey.set(space.key, registered);
+        await space.waitUntilReady();
+        if (this._ctx.disposed) {
+          break;
         }
+        const functionsSubscription = space.db.query(import_echo2.Filter.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());
   }
-  /**
-  * ECHO subscription.
-  */
-  async _createSubscription(ctx, space, def, trigger) {
-    import_log3.log.info("subscription", {
-      space: space.key,
-      trigger
-    }, {
-      F: __dxlog_file3,
-      L: 311,
-      S: this,
-      C: (f, a) => f(...a)
+  async _close(_) {
+    this._triggersBySpaceKey.clear();
+  }
+  _handleNewTriggers(space, allTriggers, registered) {
+    const newTriggers = allTriggers.filter((candidate) => {
+      return registered.find((reg) => reg.trigger.id === candidate.id) == null;
     });
-    const objectIds = /* @__PURE__ */ new Set();
-    const task = new import_async2.DeferredTask(ctx, async () => {
-      await this._execFunction(def, {
+    if (newTriggers.length > 0) {
+      const newRegisteredTriggers = newTriggers.map((trigger) => ({
+        trigger
+      }));
+      registered.push(...newRegisteredTriggers);
+      (0, import_log5.log)("registered new triggers", () => ({
         spaceKey: space.key,
-        objects: Array.from(objectIds)
-      });
-    });
-    const subscriptions = [];
-    const subscription = (0, import_echo.createSubscription)(({ added, updated }) => {
-      import_log3.log.info("updated", {
-        added: added.length,
-        updated: updated.length
-      }, {
-        F: __dxlog_file3,
-        L: 321,
+        functions: newTriggers.map((t) => t.function)
+      }), {
+        F: __dxlog_file9,
+        L: 159,
         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 } = {} } = trigger;
-    const update = ({ objects }) => {
-      subscription.update(objects);
-      if (deep) {
-        import_log3.log.info("update", {
-          objects: objects.length
-        }, {
-          F: __dxlog_file3,
-          L: 342,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        for (const object of objects) {
-          const content = object.content;
-          if (content instanceof import_types.TextV0Type) {
-            subscriptions.push((0, import_echo.getAutomergeObjectCore)(content).updates.on((0, import_async2.debounce)(() => subscription.update([
-              object
-            ]), 1e3)));
-          }
-        }
+      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);
       }
-    };
-    const query = space.db.query(import_echo.Filter.or(filter.map(({ type, props }) => import_echo.Filter.typename(type, props))));
-    subscriptions.push(query.subscribe(delay ? (0, import_async2.debounce)(update, delay) : update));
-    ctx.onDispose(() => {
-      subscriptions.forEach((unsubscribe) => unsubscribe());
-    });
+    }
+    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);
   }
 };
-var TimerTriggerSchema = S.struct({
-  cron: S.string
-});
-var WebhookTriggerSchema = S.mutable(S.struct({
-  method: S.string,
-  // Assigned port.
-  port: S.optional(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.")),
-  // Context passed to function.
-  context: S.optional(S.record(S.string, S.any)),
-  // Triggers.
-  timer: S.optional(TimerTriggerSchema),
-  webhook: S.optional(WebhookTriggerSchema),
-  websocket: S.optional(WebsocketTriggerSchema),
-  subscription: S.optional(SubscriptionTriggerSchema)
-});
-var FunctionDefSchema = S.struct({
-  id: S.string,
-  // name: S.string,
-  description: S.optional(S.string),
-  path: S.string,
-  // TODO(burdon): NPM/GitHub/Docker/CF URL?
-  handler: S.string
-});
-var FunctionManifestSchema = S.struct({
-  functions: S.mutable(S.array(FunctionDefSchema)),
-  triggers: S.optional(S.mutable(S.array(FunctionTriggerSchema)))
-});
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DevServer,
+  FunctionDef,
   FunctionManifestSchema,
+  FunctionRegistry,
+  FunctionTrigger,
   Scheduler,
+  TriggerRegistry,
   subscriptionHandler
 });
 //# sourceMappingURL=index.cjs.map