@dxos/functions 0.5.4 → 0.5.5-main.288794c

package/dist/lib/node/chunk-INM6XAL7.cjs

@@ -0,0 +1,1097 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var chunk_INM6XAL7_exports = {};
+__export(chunk_INM6XAL7_exports, {
+  DevServer: () => DevServer,
+  FunctionRegistry: () => FunctionRegistry,
+  Scheduler: () => Scheduler,
+  TriggerRegistry: () => TriggerRegistry
+});
+module.exports = __toCommonJS(chunk_INM6XAL7_exports);
+var import_chunk_3UYUR5N5 = require("./chunk-3UYUR5N5.cjs");
+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_express = __toESM(require("express"));
+var import_get_port_please = require("get-port-please");
+var import_node_path = require("node:path");
+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_node_path2 = __toESM(require("node:path"));
+var import_async3 = require("@dxos/async");
+var import_context3 = require("@dxos/context");
+var import_log3 = 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_schema = require("@dxos/echo-schema");
+var import_invariant2 = require("@dxos/invariant");
+var import_keys2 = require("@dxos/keys");
+var import_log4 = require("@dxos/log");
+var import_util2 = require("@dxos/util");
+var import_types = require("@braneframe/types");
+var import_async5 = require("@dxos/async");
+var import_echo3 = require("@dxos/client/echo");
+var import_echo_db = require("@dxos/echo-db");
+var import_log5 = require("@dxos/log");
+var import_cron = require("cron");
+var import_async6 = require("@dxos/async");
+var import_log6 = require("@dxos/log");
+var import_get_port_please2 = require("get-port-please");
+var import_node_http = __toESM(require("node:http"));
+var import_log7 = require("@dxos/log");
+var import_ws = __toESM(require("ws"));
+var import_async7 = require("@dxos/async");
+var import_log8 = require("@dxos/log");
+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) ?? [];
+  }
+  getUniqueByUri() {
+    const uniqueByUri = [
+      ...this._functionBySpaceKey.values()
+    ].flatMap((defs) => defs).reduce((acc, v) => {
+      acc.set(v.uri, v);
+      return acc;
+    }, /* @__PURE__ */ new Map());
+    return [
+      ...uniqueByUri.values()
+    ];
+  }
+  /**
+  * 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: 48,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (!functions?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(import_chunk_3UYUR5N5.FunctionDef)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(import_chunk_3UYUR5N5.FunctionDef);
+    }
+    const { objects: existing } = await space.db.query(import_echo.Filter.schema(import_chunk_3UYUR5N5.FunctionDef)).run();
+    const { added } = (0, import_util.diff)(existing, functions, (a, b) => a.uri === b.uri);
+    added.forEach((def) => space.db.add((0, import_echo.create)(import_chunk_3UYUR5N5.FunctionDef, def)));
+  }
+  async _open() {
+    import_log.log.info("opening...", void 0, {
+      F: __dxlog_file,
+      L: 64,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    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(import_chunk_3UYUR5N5.FunctionDef)).subscribe(({ objects }) => {
+          const { added } = (0, import_util.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(_) {
+    import_log.log.info("closing...", void 0, {
+      F: __dxlog_file,
+      L: 97,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._functionBySpaceKey.clear();
+  }
+};
+var __dxlog_file2 = "/home/runner/work/dxos/dxos/packages/core/functions/src/runtime/dev-server.ts";
+var DevServer = class {
+  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_async2.Event();
+  }
+  get stats() {
+    return {
+      seq: this._seq
+    };
+  }
+  get endpoint() {
+    (0, import_invariant.invariant)(this._port, void 0, {
+      F: __dxlog_file2,
+      L: 57,
+      S: this,
+      A: [
+        "this._port",
+        ""
+      ]
+    });
+    return `http://localhost:${this._port}`;
+  }
+  get proxy() {
+    return this._proxy;
+  }
+  get functions() {
+    return Object.values(this._handlers);
+  }
+  async start() {
+    (0, import_invariant.invariant)(!this._server, void 0, {
+      F: __dxlog_file2,
+      L: 70,
+      S: this,
+      A: [
+        "!this._server",
+        ""
+      ]
+    });
+    import_log2.log.info("starting...", void 0, {
+      F: __dxlog_file2,
+      L: 71,
+      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", {
+          path: path2
+        }, {
+          F: __dxlog_file2,
+          L: 81,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        if (this._options.reload) {
+          const { def } = this._handlers["/" + path2];
+          await this._load(def, true);
+        }
+        res.statusCode = await (0, import_async2.asyncTimeout)(this.invoke("/" + path2, req.body), 2e4);
+        res.end();
+      } catch (err) {
+        import_log2.log.catch(err, void 0, {
+          F: __dxlog_file2,
+          L: 91,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        res.statusCode = 500;
+        res.end();
+      }
+    });
+    this._port = this._options.port ?? await (0, import_get_port_please.getPort)({
+      host: "localhost",
+      port: 7200,
+      portRange: [
+        7200,
+        7299
+      ]
+    });
+    this._server = app.listen(this._port);
+    try {
+      const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService.register({
+        endpoint: this.endpoint
+      });
+      import_log2.log.info("registered", {
+        endpoint
+      }, {
+        F: __dxlog_file2,
+        L: 106,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this._proxy = endpoint;
+      this._functionServiceRegistration = registrationId;
+      await this._handleNewFunctions(this._functionsRegistry.getUniqueByUri());
+      this._ctx.onDispose(this._functionsRegistry.registered.on(({ added }) => this._handleNewFunctions(added)));
+    } catch (err) {
+      await this.stop();
+      throw new Error("FunctionRegistryService not available (check plugin is configured).");
+    }
+    import_log2.log.info("started", {
+      port: this._port
+    }, {
+      F: __dxlog_file2,
+      L: 118,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async stop() {
+    if (!this._server) {
+      return;
+    }
+    import_log2.log.info("stopping...", void 0, {
+      F: __dxlog_file2,
+      L: 126,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    await this._ctx.dispose();
+    const trigger = new import_async2.Trigger();
+    this._server.close(async () => {
+      import_log2.log.info("server stopped", void 0, {
+        F: __dxlog_file2,
+        L: 131,
+        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: 134,
+            S: this,
+            A: [
+              "this._client.services.services.FunctionRegistryService",
+              ""
+            ]
+          });
+          await this._client.services.services.FunctionRegistryService.unregister({
+            registrationId: this._functionServiceRegistration
+          });
+          import_log2.log.info("unregistered", {
+            registrationId: this._functionServiceRegistration
+          }, {
+            F: __dxlog_file2,
+            L: 139,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._functionServiceRegistration = void 0;
+          this._proxy = void 0;
+        }
+        trigger.wake();
+      } catch (err) {
+        trigger.throw(err);
+      }
+    });
+    await trigger.wait();
+    this._port = void 0;
+    this._server = void 0;
+    import_log2.log.info("stopped", void 0, {
+      F: __dxlog_file2,
+      L: 153,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _handleNewFunctions(newFunctions) {
+    newFunctions.forEach((def) => this._load(def));
+    await this._safeUpdateRegistration();
+    (0, import_log2.log)("new functions loaded", {
+      newFunctions
+    }, {
+      F: __dxlog_file2,
+      L: 159,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  /**
+  * Load function.
+  */
+  async _load(def, force) {
+    const { uri, route, handler } = def;
+    const filePath = (0, import_node_path.join)(this._options.baseDir, handler);
+    import_log2.log.info("loading", {
+      uri,
+      force
+    }, {
+      F: __dxlog_file2,
+      L: 168,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (force) {
+      Object.keys(import_chunk_3UYUR5N5.__require.cache).filter((key) => key.startsWith(filePath)).forEach((key) => {
+        delete import_chunk_3UYUR5N5.__require.cache[key];
+      });
+    }
+    const module2 = (0, import_chunk_3UYUR5N5.__require)(filePath);
+    if (typeof module2.default !== "function") {
+      throw new Error(`Handler must export default function: ${uri}`);
+    }
+    this._handlers[route] = {
+      def,
+      handler: module2.default
+    };
+  }
+  async _safeUpdateRegistration() {
+    (0, import_invariant.invariant)(this._functionServiceRegistration, void 0, {
+      F: __dxlog_file2,
+      L: 190,
+      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 (err) {
+      import_log2.log.catch(err, void 0, {
+        F: __dxlog_file2,
+        L: 197,
+        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", {
+      seq,
+      path: path2
+    }, {
+      F: __dxlog_file2,
+      L: 208,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const statusCode = await this._invoke(path2, {
+      data
+    });
+    import_log2.log.info("res", {
+      seq,
+      path: path2,
+      statusCode,
+      duration: Date.now() - now
+    }, {
+      F: __dxlog_file2,
+      L: 211,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this.update.emit(statusCode);
+    return statusCode;
+  }
+  async _invoke(path2, event) {
+    const { handler } = this._handlers[path2] ?? {};
+    (0, import_invariant.invariant)(handler, `invalid path: ${path2}`, {
+      F: __dxlog_file2,
+      L: 218,
+      S: this,
+      A: [
+        "handler",
+        "`invalid path: ${path}`"
+      ]
+    });
+    const context = {
+      client: this._client,
+      dataDir: this._options.dataDir
+    };
+    let statusCode = 200;
+    const response = {
+      status: (code) => {
+        statusCode = code;
+        return response;
+      }
+    };
+    await handler({
+      context,
+      event,
+      response
+    });
+    return statusCode;
+  }
+};
+var createContext = () => new import_context2.Context({
+  name: "DevServer"
+});
+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;
+    this._options = _options;
+    this._ctx = createContext2();
+    this._functionUriToCallMutex = /* @__PURE__ */ new Map();
+    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() {
+    await this._ctx.dispose();
+    this._ctx = createContext2();
+    await this.functions.open(this._ctx);
+    await this.triggers.open(this._ctx);
+  }
+  async stop() {
+    await this._ctx.dispose();
+    await this.functions.close();
+    await this.triggers.close();
+  }
+  // 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);
+    });
+    await Promise.all(mountTasks).catch(import_log3.log.catch);
+  }
+  async activate(space, functions, trigger) {
+    const definition = functions.find((def) => def.uri === trigger.function);
+    if (!definition) {
+      import_log3.log.info("function is not found for trigger", {
+        trigger
+      }, {
+        F: __dxlog_file3,
+        L: 78,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return;
+    }
+    await this.triggers.activate(space, trigger, async (args) => {
+      const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new import_async3.Mutex();
+      this._functionUriToCallMutex.set(definition.uri, mutex);
+      import_log3.log.info("function triggered, waiting for mutex", {
+        uri: definition.uri
+      }, {
+        F: __dxlog_file3,
+        L: 86,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      return mutex.executeSynchronized(() => {
+        import_log3.log.info("mutex acquired", {
+          uri: definition.uri
+        }, {
+          F: __dxlog_file3,
+          L: 88,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        return this._execFunction(definition, trigger, {
+          meta: trigger.meta ?? {},
+          data: {
+            ...args,
+            spaceKey: space.key
+          }
+        });
+      });
+    });
+    (0, import_log3.log)("activated trigger", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file3,
+      L: 96,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _execFunction(def, trigger, { data, meta }) {
+    let status = 0;
+    try {
+      const payload = Object.assign({}, meta && {
+        meta
+      }, data);
+      const { endpoint, callback } = this._options;
+      if (endpoint) {
+        const url = import_node_path2.default.join(endpoint, def.route);
+        import_log3.log.info("exec", {
+          function: def.uri,
+          url,
+          triggerType: trigger.spec.type
+        }, {
+          F: __dxlog_file3,
+          L: 113,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(payload)
+        });
+        status = response.status;
+      } else if (callback) {
+        import_log3.log.info("exec", {
+          function: def.uri
+        }, {
+          F: __dxlog_file3,
+          L: 124,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        status = await callback(payload) ?? 200;
+      }
+      if (status && status >= 400) {
+        throw new Error(`Response: ${status}`);
+      }
+      import_log3.log.info("done", {
+        function: def.uri,
+        status
+      }, {
+        F: __dxlog_file3,
+        L: 134,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } catch (err) {
+      import_log3.log.error("error", {
+        function: def.uri,
+        error: err.message
+      }, {
+        F: __dxlog_file3,
+        L: 136,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      status = 500;
+    }
+    return status;
+  }
+};
+var createContext2 = () => new import_context3.Context({
+  name: "FunctionScheduler"
+});
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/subscription-trigger.ts";
+var createSubscriptionTrigger = async (ctx, space, 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_log5.log.info("updated", {
+        added: added.length,
+        updated: updated.length
+      }, {
+        F: __dxlog_file4,
+        L: 47,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      task.trigger();
+    }
+  });
+  subscriptions.push(() => subscription.unsubscribe());
+  const { filter, options: { deep, delay } = {} } = spec;
+  const update = ({ objects }) => {
+    import_log5.log.info("update", {
+      objects: objects.length
+    }, {
+      F: __dxlog_file4,
+      L: 57,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    subscription.update(objects);
+    if (deep) {
+      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)));
+        }
+      }
+    }
+  };
+  import_log5.log.info("subscription", {
+    filter
+  }, {
+    F: __dxlog_file4,
+    L: 76,
+    S: void 0,
+    C: (f, a) => f(...a)
+  });
+  if (filter) {
+    const query = space.db.query(import_echo3.Filter.typename(filter[0].type, filter[0].props));
+    subscriptions.push(query.subscribe(delay ? (0, import_async5.debounce)(update, delay) : update));
+  }
+  ctx.onDispose(() => {
+    subscriptions.forEach((unsubscribe) => unsubscribe());
+  });
+};
+var __dxlog_file5 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/timer-trigger.ts";
+var createTimerTrigger = async (ctx, space, 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_log6.log.info("tick", {
+        space: space.key.truncate(),
+        count: run,
+        delta
+      }, {
+        F: __dxlog_file5,
+        L: 38,
+        S: void 0,
+        C: (f, a) => f(...a)
+      });
+      task.schedule();
+    }
+  });
+  job.start();
+  ctx.onDispose(() => job.stop());
+};
+var __dxlog_file6 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/webhook-trigger.ts";
+var createWebhookTrigger = async (ctx, space, 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_log7.log.info("started webhook", {
+      port
+    }, {
+      F: __dxlog_file6,
+      L: 41,
+      S: void 0,
+      C: (f, a) => f(...a)
+    });
+    spec.port = port;
+  });
+  ctx.onDispose(() => {
+    server.close();
+  });
+};
+var __dxlog_file7 = "/home/runner/work/dxos/dxos/packages/core/functions/src/trigger/type/websocket-trigger.ts";
+var createWebsocketTrigger = async (ctx, space, 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_log8.log.info("opened", {
+          url
+        }, {
+          F: __dxlog_file7,
+          L: 40,
+          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_log8.log.info("closed", {
+          url,
+          code: event.code
+        }, {
+          F: __dxlog_file7,
+          L: 49,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        if (event.code === 1006) {
+          setTimeout(async () => {
+            import_log8.log.info(`reconnecting in ${options.retryDelay}s...`, {
+              url
+            }, {
+              F: __dxlog_file7,
+              L: 54,
+              S: void 0,
+              C: (f, a) => f(...a)
+            });
+            await createWebsocketTrigger(ctx, space, spec, callback, options);
+          }, options.retryDelay * 1e3);
+        }
+        open.wake(false);
+      },
+      onerror: (event) => {
+        import_log8.log.catch(event.error, {
+          url
+        }, {
+          F: __dxlog_file7,
+          L: 63,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+      },
+      onmessage: async (event) => {
+        try {
+          import_log8.log.info("message", void 0, {
+            F: __dxlog_file7,
+            L: 68,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+          const data = JSON.parse(new TextDecoder().decode(event.data));
+          await callback({
+            data
+          });
+        } catch (err) {
+          import_log8.log.catch(err, {
+            url
+          }, {
+            F: __dxlog_file7,
+            L: 72,
+            S: void 0,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    });
+    const isOpen = await open.wait();
+    if (isOpen) {
+      break;
+    } else {
+      const wait = Math.pow(attempt, 2) * options.retryDelay;
+      if (attempt < options.maxAttempts) {
+        import_log8.log.warn(`failed to connect; trying again in ${wait}s`, {
+          attempt
+        }, {
+          F: __dxlog_file7,
+          L: 83,
+          S: void 0,
+          C: (f, a) => f(...a)
+        });
+        await (0, import_async7.sleep)(wait * 1e3);
+      }
+    }
+  }
+  ctx.onDispose(() => {
+    ws?.close();
+  });
+};
+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 import_context4.Resource {
+  constructor(_client, _options) {
+    super();
+    this._client = _client;
+    this._options = _options;
+    this._triggersBySpaceKey = new import_util2.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(space, trigger, callback) {
+    (0, import_log4.log)("activate", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file8,
+      L: 72,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const activationCtx = new import_context4.Context({
+      name: `FunctionTrigger-${trigger.function}`
+    });
+    this._ctx.onDispose(() => activationCtx.dispose());
+    const registeredTrigger = this._triggersBySpaceKey.get(space.key)?.find((reg) => reg.trigger.id === trigger.id);
+    (0, import_invariant2.invariant)(registeredTrigger, `Trigger is not registered: ${trigger.function}`, {
+      F: __dxlog_file8,
+      L: 77,
+      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, space, trigger.spec, callback, options);
+    } catch (err) {
+      delete registeredTrigger.activationCtx;
+      throw err;
+    }
+  }
+  /**
+  * Loads triggers from the manifest into the space.
+  */
+  async register(space, manifest) {
+    (0, import_log4.log)("register", {
+      space: space.key
+    }, {
+      F: __dxlog_file8,
+      L: 93,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    if (!manifest.triggers?.length) {
+      return;
+    }
+    if (!space.db.graph.runtimeSchemaRegistry.hasSchema(import_chunk_3UYUR5N5.FunctionTrigger)) {
+      space.db.graph.runtimeSchemaRegistry.registerSchema(import_chunk_3UYUR5N5.FunctionTrigger);
+    }
+    const manifestTriggers = manifest.triggers.map((trigger) => {
+      let keys = trigger[import_echo_schema.ECHO_ATTR_META]?.keys;
+      delete trigger[import_echo_schema.ECHO_ATTR_META];
+      if (!keys?.length) {
+        keys = [
+          (0, import_echo_schema.foreignKey)("manifest", [
+            trigger.function,
+            trigger.spec.type
+          ].join(":"))
+        ];
+      }
+      return (0, import_echo2.create)(import_chunk_3UYUR5N5.FunctionTrigger, trigger, {
+        keys
+      });
+    });
+    const { objects: existing } = await space.db.query(import_echo2.Filter.schema(import_chunk_3UYUR5N5.FunctionTrigger)).run();
+    const { added } = (0, import_util2.diff)(existing, manifestTriggers, import_echo_schema.compareForeignKeys);
+    added.forEach((trigger) => {
+      space.db.add(trigger);
+      import_log4.log.info("added", {
+        meta: (0, import_echo2.getMeta)(trigger)
+      }, {
+        F: __dxlog_file8,
+        L: 120,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    });
+    if (added.length > 0) {
+      await space.db.flush();
+    }
+  }
+  async _open() {
+    import_log4.log.info("open...", void 0, {
+      F: __dxlog_file8,
+      L: 129,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const spaceListSubscription = this._client.spaces.subscribe(async (spaces) => {
+      for (const space of spaces) {
+        if (this._triggersBySpaceKey.has(space.key)) {
+          continue;
+        }
+        const registered = [];
+        this._triggersBySpaceKey.set(space.key, registered);
+        await space.waitUntilReady();
+        if (this._ctx.disposed) {
+          break;
+        }
+        this._ctx.onDispose(space.db.query(import_echo2.Filter.schema(import_chunk_3UYUR5N5.FunctionTrigger)).subscribe(async ({ objects: current }) => {
+          import_log4.log.info("update", {
+            space: space.key,
+            registered: registered.length,
+            current: current.length
+          }, {
+            F: __dxlog_file8,
+            L: 146,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          await this._handleRemovedTriggers(space, current, registered);
+          this._handleNewTriggers(space, current, registered);
+        }));
+      }
+    });
+    this._ctx.onDispose(() => spaceListSubscription.unsubscribe());
+    import_log4.log.info("opened", void 0, {
+      F: __dxlog_file8,
+      L: 155,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  async _close(_) {
+    import_log4.log.info("close...", void 0, {
+      F: __dxlog_file8,
+      L: 159,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    this._triggersBySpaceKey.clear();
+    import_log4.log.info("closed", void 0, {
+      F: __dxlog_file8,
+      L: 161,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }
+  _handleNewTriggers(space, current, registered) {
+    const added = current.filter((candidate) => {
+      return candidate.enabled && registered.find((reg) => reg.trigger.id === candidate.id) == null;
+    });
+    if (added.length > 0) {
+      const newRegisteredTriggers = added.map((trigger) => ({
+        trigger
+      }));
+      registered.push(...newRegisteredTriggers);
+      import_log4.log.info("added", () => ({
+        spaceKey: space.key,
+        triggers: added.map((trigger) => trigger.function)
+      }), {
+        F: __dxlog_file8,
+        L: 172,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.registered.emit({
+        space,
+        triggers: added
+      });
+    }
+  }
+  async _handleRemovedTriggers(space, current, registered) {
+    const removed = [];
+    for (let i = registered.length - 1; i >= 0; i--) {
+      const wasRemoved = current.filter((trigger) => trigger.enabled).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);
+      }
+    }
+    if (removed.length > 0) {
+      import_log4.log.info("removed", () => ({
+        spaceKey: space.key,
+        triggers: removed.map((trigger) => trigger.function)
+      }), {
+        F: __dxlog_file8,
+        L: 198,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      this.removed.emit({
+        space,
+        triggers: removed
+      });
+    }
+  }
+  _getTriggers(space, predicate) {
+    const allSpaceTriggers = this._triggersBySpaceKey.get(space.key) ?? [];
+    return allSpaceTriggers.filter(predicate).map((trigger) => trigger.trigger);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DevServer,
+  FunctionRegistry,
+  Scheduler,
+  TriggerRegistry
+});
+//# sourceMappingURL=chunk-INM6XAL7.cjs.map