@dxos/functions 0.6.10 → 0.6.11-staging.30cf5ba

package/dist/lib/browser/chunk-OERXFETS.mjs

@@ -1,1120 +0,0 @@
-import "@dxos/node-std/globals";
-import {
-  FunctionDef,
-  FunctionTrigger,
-  __require
-} from "./chunk-YSDC6YCF.mjs";
-
-// packages/core/functions/src/function/function-registry.ts
-import { Event } from "@dxos/async";
-import { create, Filter } from "@dxos/client/echo";
-import { Resource } from "@dxos/context";
-import { PublicKey } from "@dxos/keys";
-import { log } from "@dxos/log";
-import { ComplexMap, diff } from "@dxos/util";
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/function/function-registry.ts";
-var FunctionRegistry = class extends Resource {
-  constructor(_client) {
-    super();
-    this._client = _client;
-    this._functionBySpaceKey = new ComplexMap(PublicKey.hash);
-    this.registered = new 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) {
-    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.schemaRegistry.hasSchema(FunctionDef)) {
-      space.db.graph.schemaRegistry.addSchema([
-        FunctionDef
-      ]);
-    }
-    const { objects: existing } = await space.db.query(Filter.schema(FunctionDef)).run();
-    const { added } = diff(existing, functions, (a, b) => a.uri === b.uri);
-    added.forEach((def) => space.db.add(create(FunctionDef, def)));
-    if (added.length > 0) {
-      await space.db.flush({
-        indexes: true,
-        updates: true
-      });
-    }
-  }
-  async _open() {
-    log.info("opening...", void 0, {
-      F: __dxlog_file,
-      L: 68,
-      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(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(_) {
-    log.info("closing...", void 0, {
-      F: __dxlog_file,
-      L: 101,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._functionBySpaceKey.clear();
-  }
-};
-
-// 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 { asyncTimeout, Event as Event2, Trigger } from "@dxos/async";
-import { Context } from "@dxos/context";
-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 FN_TIMEOUT = 2e4;
-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 Event2();
-  }
-  get stats() {
-    return {
-      seq: this._seq
-    };
-  }
-  get endpoint() {
-    invariant(this._port, void 0, {
-      F: __dxlog_file2,
-      L: 60,
-      S: this,
-      A: [
-        "this._port",
-        ""
-      ]
-    });
-    return `http://localhost:${this._port}`;
-  }
-  get proxy() {
-    return this._proxy;
-  }
-  get functions() {
-    return Object.values(this._handlers);
-  }
-  async start() {
-    invariant(!this._server, void 0, {
-      F: __dxlog_file2,
-      L: 73,
-      S: this,
-      A: [
-        "!this._server",
-        ""
-      ]
-    });
-    log2.info("starting...", void 0, {
-      F: __dxlog_file2,
-      L: 74,
-      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;
-      try {
-        log2.info("calling", {
-          path: path2
-        }, {
-          F: __dxlog_file2,
-          L: 84,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (this._options.reload) {
-          const { def } = this._handlers["/" + path2];
-          await this._load(def, true);
-        }
-        res.statusCode = await asyncTimeout(this.invoke("/" + path2, req.body), FN_TIMEOUT);
-        res.end();
-      } catch (err) {
-        log2.catch(err, void 0, {
-          F: __dxlog_file2,
-          L: 94,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        res.statusCode = 500;
-        res.end();
-      }
-    });
-    this._port = this._options.port ?? await 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
-      });
-      log2.info("registered", {
-        endpoint
-      }, {
-        F: __dxlog_file2,
-        L: 109,
-        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).");
-    }
-    log2.info("started", {
-      port: this._port
-    }, {
-      F: __dxlog_file2,
-      L: 121,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async stop() {
-    if (!this._server) {
-      return;
-    }
-    log2.info("stopping...", void 0, {
-      F: __dxlog_file2,
-      L: 129,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    await this._ctx.dispose();
-    const trigger = new Trigger();
-    this._server.close(async () => {
-      log2.info("server stopped", void 0, {
-        F: __dxlog_file2,
-        L: 134,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      try {
-        if (this._functionServiceRegistration) {
-          invariant(this._client.services.services.FunctionRegistryService, void 0, {
-            F: __dxlog_file2,
-            L: 137,
-            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: 142,
-            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;
-    log2.info("stopped", void 0, {
-      F: __dxlog_file2,
-      L: 156,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async _handleNewFunctions(newFunctions) {
-    newFunctions.forEach((def) => this._load(def));
-    await this._safeUpdateRegistration();
-    log2("new functions loaded", {
-      newFunctions
-    }, {
-      F: __dxlog_file2,
-      L: 162,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  /**
-  * Load function.
-  */
-  async _load(def, force) {
-    const { uri, route, handler } = def;
-    const filePath = join(this._options.baseDir, handler);
-    log2.info("loading", {
-      uri,
-      force
-    }, {
-      F: __dxlog_file2,
-      L: 171,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    if (force) {
-      Object.keys(__require.cache).filter((key) => key.startsWith(filePath)).forEach((key) => {
-        delete __require.cache[key];
-      });
-    }
-    const module = __require(filePath);
-    if (typeof module.default !== "function") {
-      throw new Error(`Handler must export default function: ${uri}`);
-    }
-    this._handlers[route] = {
-      def,
-      handler: module.default
-    };
-  }
-  async _safeUpdateRegistration() {
-    invariant(this._functionServiceRegistration, void 0, {
-      F: __dxlog_file2,
-      L: 193,
-      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) {
-      log2.catch(err, void 0, {
-        F: __dxlog_file2,
-        L: 200,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
-  /**
-  * Invoke function.
-  */
-  async invoke(path2, data) {
-    const seq = ++this._seq;
-    const now = Date.now();
-    log2.info("req", {
-      seq,
-      path: path2
-    }, {
-      F: __dxlog_file2,
-      L: 211,
-      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: 214,
-      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: 221,
-      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 Context({
-  name: "DevServer"
-}, {
-  F: __dxlog_file2,
-  L: 240
-});
-
-// packages/core/functions/src/runtime/scheduler.ts
-import path from "@dxos/node-std/path";
-import { Mutex } from "@dxos/async";
-import { loadObjectReferences } from "@dxos/client/echo";
-import { Context as Context2 } from "@dxos/context";
-import { Reference } from "@dxos/echo-protocol";
-import { log as log3 } from "@dxos/log";
-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(log3.catch);
-  }
-  /**
-  * Activate trigger.
-  */
-  async activate(space, functions, trigger) {
-    const definition = functions.find((def) => def.uri === trigger.function);
-    if (!definition) {
-      log3.info("function is not found for trigger", {
-        trigger
-      }, {
-        F: __dxlog_file3,
-        L: 83,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return;
-    }
-    await this.triggers.activate(space, trigger, async (args) => {
-      const mutex = this._functionUriToCallMutex.get(definition.uri) ?? new Mutex();
-      this._functionUriToCallMutex.set(definition.uri, mutex);
-      log3.info("function triggered, waiting for mutex", {
-        uri: definition.uri
-      }, {
-        F: __dxlog_file3,
-        L: 91,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      return mutex.executeSynchronized(async () => {
-        log3.info("mutex acquired", {
-          uri: definition.uri
-        }, {
-          F: __dxlog_file3,
-          L: 93,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        await loadObjectReferences(trigger, (t) => Object.values(t.meta ?? {}));
-        const meta = {};
-        for (const [key, value] of Object.entries(trigger.meta ?? {})) {
-          if (value instanceof Reference) {
-            const object = await space.db.loadObjectById(value.objectId);
-            if (object) {
-              meta[key] = object;
-            }
-          } else {
-            meta[key] = value;
-          }
-        }
-        return this._execFunction(definition, trigger, {
-          meta,
-          data: {
-            ...args,
-            spaceKey: space.key
-          }
-        });
-      });
-    });
-    log3("activated trigger", {
-      space: space.key,
-      trigger
-    }, {
-      F: __dxlog_file3,
-      L: 116,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  /**
-  * Invoke function RPC.
-  */
-  async _execFunction(def, trigger, { meta, data }) {
-    let status = 0;
-    try {
-      const payload = Object.assign({}, meta && {
-        meta
-      }, data);
-      const { endpoint, callback } = this._options;
-      if (endpoint) {
-        const url = path.join(endpoint, def.route);
-        log3.info("exec", {
-          function: def.uri,
-          url,
-          triggerType: trigger.spec.type
-        }, {
-          F: __dxlog_file3,
-          L: 136,
-          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) {
-        log3.info("exec", {
-          function: def.uri
-        }, {
-          F: __dxlog_file3,
-          L: 147,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        status = await callback(payload) ?? 200;
-      }
-      if (status && status >= 400) {
-        throw new Error(`Response: ${status}`);
-      }
-      log3.info("done", {
-        function: def.uri,
-        status
-      }, {
-        F: __dxlog_file3,
-        L: 157,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    } catch (err) {
-      log3.error("error", {
-        function: def.uri,
-        error: err.message
-      }, {
-        F: __dxlog_file3,
-        L: 159,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      status = 500;
-    }
-    return status;
-  }
-};
-var createContext2 = () => new Context2({
-  name: "FunctionScheduler"
-}, {
-  F: __dxlog_file3,
-  L: 167
-});
-
-// packages/core/functions/src/trigger/trigger-registry.ts
-import { Event as Event3 } from "@dxos/async";
-import { create as create2, Filter as Filter3, getMeta } from "@dxos/client/echo";
-import { Context as Context3, Resource as Resource2 } from "@dxos/context";
-import { compareForeignKeys, ECHO_ATTR_META, foreignKey } from "@dxos/echo-schema";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
-import { log as log8 } from "@dxos/log";
-import { ComplexMap as ComplexMap2, diff as diff2 } from "@dxos/util";
-
-// packages/core/functions/src/trigger/type/subscription-trigger.ts
-import { debounce, UpdateScheduler } from "@dxos/async";
-import { Filter as Filter2 } from "@dxos/client/echo";
-import { createSubscription } 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, space, spec, callback) => {
-  const objectIds = /* @__PURE__ */ new Set();
-  const task = new UpdateScheduler(ctx, async () => {
-    if (objectIds.size > 0) {
-      const objects = Array.from(objectIds);
-      objectIds.clear();
-      await callback({
-        objects
-      });
-    }
-  }, {
-    maxFrequency: 4
-  });
-  const subscriptions = [];
-  const subscription = 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) {
-      log4.info("updated", {
-        added: added.length,
-        updated: updated.length
-      }, {
-        F: __dxlog_file4,
-        L: 46,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      task.trigger();
-    }
-  });
-  subscriptions.push(() => subscription.unsubscribe());
-  const { filter, options: { deep, delay } = {} } = spec;
-  const update = ({ objects }) => {
-    log4.info("update", {
-      objects: objects.length
-    }, {
-      F: __dxlog_file4,
-      L: 56,
-      S: void 0,
-      C: (f, a) => f(...a)
-    });
-    subscription.update(objects);
-    if (deep) {
-    }
-  };
-  log4.info("subscription", {
-    filter
-  }, {
-    F: __dxlog_file4,
-    L: 74,
-    S: void 0,
-    C: (f, a) => f(...a)
-  });
-  if (filter) {
-    const query = space.db.query(Filter2.typename(filter[0].type, filter[0].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 } 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, space, spec, callback) => {
-  const task = new DeferredTask(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: 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());
-};
-
-// 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, space, 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: 41,
-      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, space, spec, callback, options = {
-  retryDelay: 2,
-  maxAttempts: 5
-}) => {
-  const { url, init } = spec;
-  let wasOpen = false;
-  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
-        }, {
-          F: __dxlog_file7,
-          L: 41,
-          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: 50,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        if (event.code === 1006 && wasOpen && !ctx.disposed) {
-          setTimeout(async () => {
-            log7.info(`reconnecting in ${options.retryDelay}s...`, {
-              url
-            }, {
-              F: __dxlog_file7,
-              L: 55,
-              S: void 0,
-              C: (f, a) => f(...a)
-            });
-            await createWebsocketTrigger(ctx, space, spec, callback, options);
-          }, options.retryDelay * 1e3);
-        }
-        open.wake(false);
-      },
-      onerror: (event) => {
-        log7.catch(event.error, {
-          url
-        }, {
-          F: __dxlog_file7,
-          L: 63,
-          S: void 0,
-          C: (f, a) => f(...a)
-        });
-        open.wake(false);
-      },
-      onmessage: async (event) => {
-        try {
-          log7.info("message", void 0, {
-            F: __dxlog_file7,
-            L: 69,
-            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: 73,
-            S: void 0,
-            C: (f, a) => f(...a)
-          });
-        }
-      }
-    });
-    const isOpen = await open.wait();
-    if (ctx.disposed) {
-      break;
-    }
-    if (isOpen) {
-      wasOpen = true;
-      break;
-    }
-    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: 88,
-        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(PublicKey2.hash);
-    this.registered = new Event3();
-    this.removed = new Event3();
-  }
-  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) {
-    log8("activate", {
-      space: space.key,
-      trigger
-    }, {
-      F: __dxlog_file8,
-      L: 72,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    const activationCtx = new Context3({
-      name: `FunctionTrigger-${trigger.function}`
-    }, {
-      F: __dxlog_file8,
-      L: 74
-    });
-    this._ctx.onDispose(() => activationCtx.dispose());
-    const registeredTrigger = this._triggersBySpaceKey.get(space.key)?.find((reg) => reg.trigger.id === trigger.id);
-    invariant2(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) {
-    log8("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.schemaRegistry.hasSchema(FunctionTrigger)) {
-      space.db.graph.schemaRegistry.addSchema([
-        FunctionTrigger
-      ]);
-    }
-    const manifestTriggers = manifest.triggers.map((trigger) => {
-      let keys = trigger[ECHO_ATTR_META]?.keys;
-      delete trigger[ECHO_ATTR_META];
-      if (!keys?.length) {
-        keys = [
-          foreignKey("manifest", [
-            trigger.function,
-            trigger.spec.type
-          ].join(":"))
-        ];
-      }
-      return create2(FunctionTrigger, trigger, {
-        keys
-      });
-    });
-    const { objects: existing } = await space.db.query(Filter3.schema(FunctionTrigger)).run();
-    const { added } = diff2(existing, manifestTriggers, compareForeignKeys);
-    added.forEach((trigger) => {
-      space.db.add(trigger);
-      log8.info("added", {
-        meta: getMeta(trigger)
-      }, {
-        F: __dxlog_file8,
-        L: 120,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    });
-    if (added.length > 0) {
-      await space.db.flush();
-    }
-  }
-  async _open() {
-    log8.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(Filter3.schema(FunctionTrigger)).subscribe(async ({ objects: current }) => {
-          log8.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());
-    log8.info("opened", void 0, {
-      F: __dxlog_file8,
-      L: 155,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-  }
-  async _close(_) {
-    log8.info("close...", void 0, {
-      F: __dxlog_file8,
-      L: 159,
-      S: this,
-      C: (f, a) => f(...a)
-    });
-    this._triggersBySpaceKey.clear();
-    log8.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);
-      log8.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) {
-      log8.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);
-  }
-};
-
-export {
-  FunctionRegistry,
-  DevServer,
-  Scheduler,
-  TriggerRegistry
-};
-//# sourceMappingURL=chunk-OERXFETS.mjs.map