@dxos/functions 0.5.2 → 0.5.3-main.088a2c8

package/dist/lib/node/index.cjs

@@ -29,6 +29,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var node_exports = {};
 __export(node_exports, {
   DevServer: () => DevServer,
+  FunctionManifestSchema: () => FunctionManifestSchema,
   Scheduler: () => Scheduler,
   subscriptionHandler: () => subscriptionHandler
 });
@@ -43,6 +44,10 @@ var import_async = require("@dxos/async");
 var import_invariant = require("@dxos/invariant");
 var import_log2 = require("@dxos/log");
 var import_cron = require("cron");
+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_ws = __toESM(require("ws"));
 var import_types = require("@braneframe/types");
 var import_async2 = require("@dxos/async");
 var import_echo = require("@dxos/client/echo");
@@ -50,6 +55,7 @@ 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 __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) {
@@ -59,16 +65,16 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 });
 var __dxlog_file = "/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.space ? client.spaces.get(import_client.PublicKey.from(event.space)) : void 0;
-    const objects = space && event.objects?.map((id) => space.db.getObjectById(id)).filter(import_util.nonNullable);
-    if (!!event.space && !space) {
+    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_util.nonNullable) : [];
+    if (!!data.spaceKey && !space) {
       import_log.log.warn("invalid space", {
-        event
+        data
       }, {
         F: __dxlog_file,
-        L: 61,
+        L: 91,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -78,15 +84,18 @@ var subscriptionHandler = (handler) => {
         objects: objects?.length
       }, {
         F: __dxlog_file,
-        L: 63,
+        L: 93,
         S: void 0,
         C: (f, a) => f(...a)
       });
     }
     return handler({
       event: {
-        space,
-        objects
+        data: {
+          ...data,
+          space,
+          objects
+        }
       },
       context,
       ...rest
@@ -101,11 +110,17 @@ var DevServer = class {
     this._options = _options;
     this._handlers = {};
     this._seq = 0;
+    this.update = new import_async.Event();
+  }
+  get stats() {
+    return {
+      seq: this._seq
+    };
   }
   get endpoint() {
     (0, import_invariant.invariant)(this._port, void 0, {
       F: __dxlog_file2,
-      L: 46,
+      L: 54,
       S: this,
       A: [
         "this._port",
@@ -127,7 +142,7 @@ var DevServer = class {
       } catch (err) {
         import_log2.log.error("parsing function (check manifest)", err, {
           F: __dxlog_file2,
-          L: 63,
+          L: 71,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -135,29 +150,44 @@ var DevServer = class {
     }
   }
   async start() {
+    (0, import_invariant.invariant)(!this._server, void 0, {
+      F: __dxlog_file2,
+      L: 77,
+      S: this,
+      A: [
+        "!this._server",
+        ""
+      ]
+    });
+    import_log2.log.info("starting...", void 0, {
+      F: __dxlog_file2,
+      L: 78,
+      S: this,
+      C: (f, a) => f(...a)
+    });
     const app = (0, import_express.default)();
     app.use(import_express.default.json());
-    app.post("/:name", async (req, res) => {
-      const { name } = req.params;
+    app.post("/:path", async (req, res) => {
+      const { path: path2 } = req.params;
       try {
         import_log2.log.info("calling", {
-          name
+          path: path2
         }, {
           F: __dxlog_file2,
-          L: 75,
+          L: 87,
           S: this,
           C: (f, a) => f(...a)
         });
         if (this._options.reload) {
-          const { def } = this._handlers[name];
+          const { def } = this._handlers["/" + path2];
           await this._load(def, true);
         }
-        res.statusCode = await this._invoke(name, req.body);
+        res.statusCode = await this.invoke("/" + path2, req.body);
         res.end();
       } catch (err) {
         import_log2.log.catch(err, void 0, {
           F: __dxlog_file2,
-          L: 84,
+          L: 97,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -177,92 +207,170 @@ var DevServer = class {
     try {
       const { registrationId, endpoint } = await this._client.services.services.FunctionRegistryService.register({
         endpoint: this.endpoint,
-        functions: this.functions.map(({ def: { name } }) => ({
-          name
+        functions: this.functions.map(({ def: { id, path: path2 } }) => ({
+          id,
+          path: path2
         }))
       });
       import_log2.log.info("registered", {
-        registrationId,
         endpoint
       }, {
         F: __dxlog_file2,
-        L: 100,
+        L: 113,
         S: this,
         C: (f, a) => f(...a)
       });
-      this._registrationId = registrationId;
       this._proxy = endpoint;
+      this._functionServiceRegistration = registrationId;
     } 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: 121,
+      S: this,
+      C: (f, a) => f(...a)
+    });
   }
   async stop() {
+    (0, import_invariant.invariant)(this._server, void 0, {
+      F: __dxlog_file2,
+      L: 125,
+      S: this,
+      A: [
+        "this._server",
+        ""
+      ]
+    });
+    import_log2.log.info("stopping...", void 0, {
+      F: __dxlog_file2,
+      L: 126,
+      S: this,
+      C: (f, a) => f(...a)
+    });
     const trigger = new import_async.Trigger();
-    this._server?.close(async () => {
-      if (this._registrationId) {
-        await this._client.services.services.FunctionRegistryService.unregister({
-          registrationId: this._registrationId
-        });
-        import_log2.log.info("unregistered", {
-          registrationId: this._registrationId
-        }, {
-          F: __dxlog_file2,
-          L: 117,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        this._registrationId = void 0;
-        this._proxy = void 0;
+    this._server.close(async () => {
+      import_log2.log.info("server stopped", void 0, {
+        F: __dxlog_file2,
+        L: 130,
+        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,
+            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: 138,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._functionServiceRegistration = void 0;
+          this._proxy = void 0;
+        }
+        trigger.wake();
+      } catch (err) {
+        trigger.throw(err);
       }
-      trigger.wake();
     });
     await trigger.wait();
     this._port = void 0;
     this._server = void 0;
+    import_log2.log.info("stopped", void 0, {
+      F: __dxlog_file2,
+      L: 152,
+      S: this,
+      C: (f, a) => f(...a)
+    });
   }
   /**
   * Load function.
   */
-  async _load(def, flush = false) {
-    const { id, name, handler } = def;
-    const path = (0, import_node_path.join)(this._options.directory, handler);
+  async _load(def, force = false) {
+    const { id, path: path2, handler } = def;
+    const filePath = (0, import_node_path.join)(this._options.baseDir, handler);
     import_log2.log.info("loading", {
-      id
+      id,
+      force
     }, {
       F: __dxlog_file2,
-      L: 136,
+      L: 161,
       S: this,
       C: (f, a) => f(...a)
     });
-    if (flush) {
-      Object.keys(__require.cache).filter((key) => key.startsWith(path)).forEach((key) => delete __require.cache[key]);
+    if (force) {
+      Object.keys(__require.cache).filter((key) => key.startsWith(filePath)).forEach((key) => {
+        delete __require.cache[key];
+      });
     }
-    const module2 = __require(path);
+    const module2 = __require(filePath);
     if (typeof module2.default !== "function") {
       throw new Error(`Handler must export default function: ${id}`);
     }
-    this._handlers[name] = {
+    this._handlers[path2] = {
       def,
       handler: module2.default
     };
   }
   /**
-  * Invoke function handler.
+  * Invoke function.
   */
-  async _invoke(name, event) {
+  async invoke(path2, data) {
     const seq = ++this._seq;
     const now = Date.now();
     import_log2.log.info("req", {
       seq,
-      name
+      path: path2
     }, {
       F: __dxlog_file2,
-      L: 161,
+      L: 188,
+      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: 191,
       S: this,
       C: (f, a) => f(...a)
     });
-    const { handler } = this._handlers[name];
+    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: 198,
+      S: this,
+      A: [
+        "handler",
+        "`invalid path: ${path}`"
+      ]
+    });
     const context = {
       client: this._client,
       dataDir: this._options.dataDir
@@ -279,17 +387,6 @@ var DevServer = class {
       event,
       response
     });
-    import_log2.log.info("res", {
-      seq,
-      name,
-      statusCode,
-      duration: Date.now() - now
-    }, {
-      F: __dxlog_file2,
-      L: 178,
-      S: this,
-      C: (f, a) => f(...a)
-    });
     return statusCode;
   }
 };
@@ -299,7 +396,13 @@ var Scheduler = class {
     this._client = _client;
     this._manifest = _manifest;
     this._options = _options;
-    this._mounts = new import_util2.ComplexMap(({ id, spaceKey }) => `${spaceKey.toHex()}:${id}`);
+    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;
+    }, []);
   }
   async start() {
     this._client.spaces.subscribe(async (spaces) => {
@@ -316,15 +419,18 @@ var Scheduler = class {
       await this.unmount(id, spaceKey);
     }
   }
+  /**
+  * Mount trigger.
+  */
   async mount(ctx, space, trigger) {
     const key = {
-      id: trigger.function,
-      spaceKey: space.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: 63,
+      L: 76,
       S: this,
       A: [
         "def",
@@ -342,18 +448,24 @@ var Scheduler = class {
         trigger
       }, {
         F: __dxlog_file3,
-        L: 69,
+        L: 82,
         S: this,
         C: (f, a) => f(...a)
       });
       if (ctx.disposed) {
         return;
       }
-      if (trigger.schedule) {
-        this._createTimer(ctx, space, def, trigger);
+      if (trigger.timer) {
+        await this._createTimer(ctx, space, def, trigger);
+      }
+      if (trigger.webhook) {
+        await this._createWebhook(ctx, space, def, trigger);
+      }
+      if (trigger.websocket) {
+        await this._createWebsocket(ctx, space, def, trigger);
       }
-      for (const triggerSubscription of trigger.subscriptions ?? []) {
-        this._createSubscription(ctx, space, def, triggerSubscription);
+      if (trigger.subscription) {
+        await this._createSubscription(ctx, space, def, trigger);
       }
     }
   }
@@ -368,25 +480,95 @@ var Scheduler = class {
       await ctx.dispose();
     }
   }
-  _createTimer(ctx, space, def, trigger) {
-    const task = new import_async2.DeferredTask(ctx, async () => {
-      await this._execFunction(def, {
-        space: space.key
+  async _execFunction(def, trigger, data) {
+    let status = 0;
+    try {
+      const payload = Object.assign({}, {
+        meta: trigger.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
+        }, {
+          F: __dxlog_file3,
+          L: 128,
+          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.id
+        }, {
+          F: __dxlog_file3,
+          L: 139,
+          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.id,
+        status
+      }, {
+        F: __dxlog_file3,
+        L: 149,
+        S: this,
+        C: (f, a) => f(...a)
       });
-    });
-    (0, import_invariant2.invariant)(trigger.schedule, void 0, {
+    } catch (err) {
+      import_log3.log.error("error", {
+        function: def.id,
+        error: err.message
+      }, {
+        F: __dxlog_file3,
+        L: 151,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      status = 500;
+    }
+    return status;
+  }
+  //
+  // Triggers
+  //
+  /**
+  * Cron timer.
+  */
+  async _createTimer(ctx, space, def, trigger) {
+    import_log3.log.info("timer", {
+      space: space.key,
+      trigger
+    }, {
       F: __dxlog_file3,
-      L: 102,
+      L: 166,
       S: this,
-      A: [
-        "trigger.schedule",
-        ""
-      ]
+      C: (f, a) => f(...a)
+    });
+    const spec = trigger.timer;
+    const task = new import_async2.DeferredTask(ctx, async () => {
+      await this._execFunction(def, trigger, {
+        spaceKey: space.key
+      });
     });
     let last = 0;
     let run = 0;
     const job = import_cron.CronJob.from({
-      cronTime: trigger.schedule,
+      cronTime: spec.cron,
       runOnInit: false,
       onTick: () => {
         const now = Date.now();
@@ -399,7 +581,7 @@ var Scheduler = class {
           delta
         }, {
           F: __dxlog_file3,
-          L: 116,
+          L: 186,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -409,20 +591,180 @@ var Scheduler = class {
     job.start();
     ctx.onDispose(() => job.stop());
   }
-  _createSubscription(ctx, space, def, triggerSubscription) {
+  /**
+  * Webhook.
+  */
+  async _createWebhook(ctx, space, def, trigger) {
+    import_log3.log.info("webhook", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file3,
+      L: 199,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const spec = trigger.webhook;
+    const server = import_node_http.default.createServer(async (req, res) => {
+      if (req.method !== spec.method) {
+        res.statusCode = 405;
+        return res.end();
+      }
+      res.statusCode = await this._execFunction(def, trigger, {
+        spaceKey: space.key
+      });
+      res.end();
+    });
+    const port = await (0, import_get_port_please2.getPort)({
+      random: true
+    });
+    server.listen(port, () => {
+      import_log3.log.info("started webhook", {
+        port
+      }, {
+        F: __dxlog_file3,
+        L: 223,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      spec.port = port;
+    });
+    ctx.onDispose(() => {
+      server.close();
+    });
+  }
+  /**
+  * Websocket.
+  * NOTE: The port must be unique, so the same hook cannot be used for multiple spaces.
+  */
+  async _createWebsocket(ctx, space, def, trigger, options = {
+    retryDelay: 2,
+    maxAttempts: 5
+  }) {
+    import_log3.log.info("websocket", {
+      space: space.key,
+      trigger
+    }, {
+      F: __dxlog_file3,
+      L: 249,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+    const spec = trigger.websocket;
+    const { url, init } = spec;
+    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: 260,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          if (spec.init) {
+            ws.send(new TextEncoder().encode(JSON.stringify(init)));
+          }
+          open.wake(true);
+        },
+        onclose: (event) => {
+          import_log3.log.info("closed", {
+            url,
+            code: event.code
+          }, {
+            F: __dxlog_file3,
+            L: 269,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          if (event.code === 1006) {
+            setTimeout(async () => {
+              import_log3.log.info(`reconnecting in ${options.retryDelay}s...`, {
+                url
+              }, {
+                F: __dxlog_file3,
+                L: 274,
+                S: this,
+                C: (f, a) => f(...a)
+              });
+              await this._createWebsocket(ctx, space, def, trigger, options);
+            }, options.retryDelay * 1e3);
+          }
+          open.wake(false);
+        },
+        onerror: (event) => {
+          import_log3.log.catch(event.error, {
+            url
+          }, {
+            F: __dxlog_file3,
+            L: 283,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        },
+        onmessage: async (event) => {
+          try {
+            const data = JSON.parse(new TextDecoder().decode(event.data));
+            await this._execFunction(def, trigger, {
+              spaceKey: space.key,
+              data
+            });
+          } catch (err) {
+            import_log3.log.catch(err, {
+              url
+            }, {
+              F: __dxlog_file3,
+              L: 291,
+              S: this,
+              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_log3.log.warn(`failed to connect; trying again in ${wait}s`, {
+            attempt
+          }, {
+            F: __dxlog_file3,
+            L: 302,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          await (0, import_async2.sleep)(wait * 1e3);
+        }
+      }
+    }
+    ctx.onDispose(() => {
+      ws?.close();
+    });
+  }
+  /**
+  * ECHO subscription.
+  */
+  async _createSubscription(ctx, space, def, trigger) {
     import_log3.log.info("subscription", {
       space: space.key,
-      triggerSubscription
+      trigger
     }, {
       F: __dxlog_file3,
-      L: 126,
+      L: 317,
       S: this,
       C: (f, a) => f(...a)
     });
+    const spec = trigger.subscription;
     const objectIds = /* @__PURE__ */ new Set();
     const task = new import_async2.DeferredTask(ctx, async () => {
-      await this._execFunction(def, {
-        space: space.key,
+      await this._execFunction(def, trigger, {
+        spaceKey: space.key,
         objects: Array.from(objectIds)
       });
     });
@@ -433,7 +775,7 @@ var Scheduler = class {
         updated: updated.length
       }, {
         F: __dxlog_file3,
-        L: 139,
+        L: 329,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -446,17 +788,15 @@ var Scheduler = class {
       task.schedule();
     });
     subscriptions.push(() => subscription.unsubscribe());
-    const { type, props, deep, delay } = triggerSubscription;
+    const { filter, options: { deep, delay } = {} } = spec;
     const update = ({ objects }) => {
       subscription.update(objects);
       if (deep) {
         import_log3.log.info("update", {
-          type,
-          deep,
           objects: objects.length
         }, {
           F: __dxlog_file3,
-          L: 159,
+          L: 349,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -470,61 +810,66 @@ var Scheduler = class {
         }
       }
     };
-    const query = space.db.query(import_echo.Filter.typename(type, props));
-    subscriptions.push(query.subscribe(delay ? (0, import_async2.debounce)(update, delay * 1e3) : update));
+    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());
     });
   }
-  async _execFunction(def, data) {
-    try {
-      (0, import_log3.log)("request", {
-        function: def.id
-      }, {
-        F: __dxlog_file3,
-        L: 183,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-      const { endpoint, callback } = this._options;
-      let status = 0;
-      if (endpoint) {
-        const response = await fetch(`${this._options.endpoint}/${def.name}`, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json"
-          },
-          body: JSON.stringify(data)
-        });
-        status = response.status;
-      } else if (callback) {
-        status = await callback(data);
-      }
-      (0, import_log3.log)("result", {
-        function: def.id,
-        result: status
-      }, {
-        F: __dxlog_file3,
-        L: 202,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    } catch (err) {
-      import_log3.log.error("error", {
-        function: def.id,
-        error: err.message
-      }, {
-        F: __dxlog_file3,
-        L: 204,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }
-  }
 };
+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.
+  meta: 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),
+  // TODO(burdon): Rename route?
+  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,
+  FunctionManifestSchema,
   Scheduler,
   subscriptionHandler
 });