@dxos/functions-runtime-cloudflare 0.8.4-main.7ace549 → 0.8.4-main.8360d9e660

package/dist/lib/browser/index.mjs

@@ -1,14 +1,85 @@
 // src/functions-client.ts
 import { Resource as Resource2 } from "@dxos/context";
 import { EchoClient } from "@dxos/echo-db";
-import { invariant as invariant5 } from "@dxos/invariant";
+import { invariant as invariant3 } from "@dxos/invariant";
 
 // src/internal/data-service-impl.ts
 import { Stream } from "@dxos/codec-protobuf/stream";
 import { raise } from "@dxos/debug";
+import { NotImplementedError, RuntimeServiceError } from "@dxos/errors";
 import { invariant } from "@dxos/invariant";
 import { SpaceId } from "@dxos/keys";
 import { log } from "@dxos/log";
+
+// src/internal/utils.ts
+var copyUint8Array = (value) => new Uint8Array(value);
+
+// src/internal/data-service-impl.ts
+function _ts_add_disposable_resource(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+function _ts_dispose_resources(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources = function _ts_dispose_resources5(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
 var __dxlog_file = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/data-service-impl.ts";
 var DataServiceImpl = class {
   _executionContext;
@@ -22,7 +93,7 @@ var DataServiceImpl = class {
     return new Stream(({ next }) => {
       invariant(SpaceId.isValid(spaceId), void 0, {
         F: __dxlog_file,
-        L: 34,
+        L: 39,
         S: this,
         A: [
           "SpaceId.isValid(spaceId)",
@@ -38,158 +109,218 @@ var DataServiceImpl = class {
       };
     });
   }
-  async updateSubscription({ subscriptionId, addIds, removeIds }) {
-    const sub = this.dataSubscriptions.get(subscriptionId) ?? raise(new Error("Subscription not found"));
+  async updateSubscription({ subscriptionId, addIds }) {
+    const sub = this.dataSubscriptions.get(subscriptionId) ?? raise(new RuntimeServiceError({
+      message: "Subscription not found.",
+      context: {
+        subscriptionId
+      }
+    }));
     if (addIds) {
       log.info("request documents", {
         count: addIds.length
       }, {
         F: __dxlog_file,
-        L: 47,
+        L: 59,
         S: this,
         C: (f, a) => f(...a)
       });
       for (const documentId of addIds) {
-        const document = await this._dataService.getDocument(this._executionContext, sub.spaceId, documentId);
-        log.info("document loaded", {
-          documentId,
-          spaceId: sub.spaceId,
-          found: !!document
-        }, {
-          F: __dxlog_file,
-          L: 51,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        if (!document) {
-          log.warn("not found", {
-            documentId
+        const env = {
+          stack: [],
+          error: void 0,
+          hasError: false
+        };
+        try {
+          const document = _ts_add_disposable_resource(env, await this._dataService.getDocument(this._executionContext, sub.spaceId, documentId), false);
+          log.info("document loaded", {
+            documentId,
+            spaceId: sub.spaceId,
+            found: !!document
           }, {
             F: __dxlog_file,
-            L: 53,
+            L: 63,
             S: this,
             C: (f, a) => f(...a)
           });
-          continue;
+          if (!document) {
+            log.warn("not found", {
+              documentId
+            }, {
+              F: __dxlog_file,
+              L: 65,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            continue;
+          }
+          sub.next({
+            updates: [
+              {
+                documentId,
+                // Copy returned object to avoid hanging RPC stub
+                // See https://developers.cloudflare.com/workers/runtime-apis/rpc/lifecycle/
+                mutation: copyUint8Array(document.data)
+              }
+            ]
+          });
+        } catch (e) {
+          env.error = e;
+          env.hasError = true;
+        } finally {
+          _ts_dispose_resources(env);
         }
-        sub.next({
-          updates: [
-            {
-              documentId,
-              mutation: document.data
-            }
-          ]
-        });
       }
     }
   }
+  async createDocument({ spaceId, initialValue }) {
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const response = _ts_add_disposable_resource(env, await this._dataService.createDocument(this._executionContext, {
+        spaceId,
+        initialValue
+      }), false);
+      return {
+        documentId: response.documentId
+      };
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
+    } finally {
+      _ts_dispose_resources(env);
+    }
+  }
   async update({ updates, subscriptionId }) {
-    const sub = this.dataSubscriptions.get(subscriptionId) ?? raise(new Error("Subscription not found"));
-    for (const update of updates ?? []) {
-      await this._dataService.changeDocument(this._executionContext, sub.spaceId, update.documentId, update.mutation);
+    const sub = this.dataSubscriptions.get(subscriptionId) ?? raise(new RuntimeServiceError({
+      message: "Subscription not found.",
+      context: {
+        subscriptionId
+      }
+    }));
+    try {
+      for (const update of updates ?? []) {
+        await this._dataService.changeDocument(this._executionContext, sub.spaceId, update.documentId, update.mutation);
+      }
+    } catch (error) {
+      throw RuntimeServiceError.wrap({
+        message: "Failed to apply document updates.",
+        context: {
+          subscriptionId
+        },
+        ifTypeDiffers: true
+      })(error);
     }
-    throw new Error("Method not implemented.");
   }
   async flush() {
   }
-  subscribeSpaceSyncState(request, options) {
-    throw new Error("Method not implemented.");
+  subscribeSpaceSyncState(_request, _options) {
+    throw new NotImplementedError({
+      message: "subscribeSpaceSyncState is not implemented."
+    });
   }
-  async getDocumentHeads({ documentIds }) {
-    throw new Error("Method not implemented.");
+  async getDocumentHeads({ documentIds: _documentIds }) {
+    throw new NotImplementedError({
+      message: "getDocumentHeads is not implemented."
+    });
   }
-  async reIndexHeads({ documentIds }) {
-    throw new Error("Method not implemented.");
+  async reIndexHeads({ documentIds: _documentIds }) {
+    throw new NotImplementedError({
+      message: "reIndexHeads is not implemented."
+    });
   }
   async updateIndexes() {
-    throw new Error("Method not implemented.");
+    log.error("updateIndexes is not available in EDGE env.", void 0, {
+      F: __dxlog_file,
+      L: 133,
+      S: this,
+      C: (f, a) => f(...a)
+    });
   }
-  async waitUntilHeadsReplicated({ heads }) {
-    throw new Error("Method not implemented.");
+  async waitUntilHeadsReplicated({ heads: _heads }) {
+    throw new NotImplementedError({
+      message: "waitUntilHeadsReplicated is not implemented."
+    });
   }
 };
 
 // src/internal/query-service-impl.ts
-import * as Schema from "effect/Schema";
 import { Stream as Stream2 } from "@dxos/codec-protobuf/stream";
-import { QueryAST } from "@dxos/echo-protocol";
-import { invariant as invariant3 } from "@dxos/invariant";
-import { PublicKey } from "@dxos/keys";
-import { SpaceId as SpaceId3 } from "@dxos/keys";
+import { NotImplementedError as NotImplementedError2, RuntimeServiceError as RuntimeServiceError2 } from "@dxos/errors";
 import { log as log2 } from "@dxos/log";
-
-// src/internal/adapter.ts
-import { failUndefined } from "@dxos/debug";
-import { invariant as invariant2 } from "@dxos/invariant";
-import { SpaceId as SpaceId2 } from "@dxos/keys";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/adapter.ts";
-var queryToDataServiceRequest = (query) => {
-  const { filter, options } = isSimpleSelectionQuery(query) ?? failUndefined();
-  invariant2(options?.spaceIds?.length === 1, "Only one space is supported", {
-    F: __dxlog_file2,
-    L: 13,
-    S: void 0,
-    A: [
-      "options?.spaceIds?.length === 1",
-      "'Only one space is supported'"
-    ]
-  });
-  invariant2(filter.type === "object", "Only object filters are supported", {
-    F: __dxlog_file2,
-    L: 14,
-    S: void 0,
-    A: [
-      "filter.type === 'object'",
-      "'Only object filters are supported'"
-    ]
-  });
-  const spaceId = options.spaceIds[0];
-  invariant2(SpaceId2.isValid(spaceId), void 0, {
-    F: __dxlog_file2,
-    L: 17,
-    S: void 0,
-    A: [
-      "SpaceId.isValid(spaceId)",
-      ""
-    ]
-  });
-  return {
-    spaceId,
-    type: filter.typename ?? void 0,
-    objectIds: [
-      ...filter.id ?? []
-    ]
-  };
-};
-var isSimpleSelectionQuery = (query) => {
-  switch (query.type) {
-    case "options": {
-      const maybeFilter = isSimpleSelectionQuery(query.query);
-      if (!maybeFilter) {
-        return null;
-      }
-      return {
-        filter: maybeFilter.filter,
-        options: query.options
-      };
-    }
-    case "select": {
-      return {
-        filter: query.filter,
-        options: void 0
-      };
+function _ts_add_disposable_resource2(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
     }
-    default: {
-      return null;
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
     }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
   }
-};
-
-// src/internal/query-service-impl.ts
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/query-service-impl.ts";
+  return value;
+}
+function _ts_dispose_resources2(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources2 = function _ts_dispose_resources5(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/internal/query-service-impl.ts";
 var QueryServiceImpl = class {
   _executionContext;
   _dataService;
+  _queryCount = 0;
   constructor(_executionContext, _dataService) {
     this._executionContext = _executionContext;
     this._dataService = _dataService;
@@ -198,92 +329,142 @@ var QueryServiceImpl = class {
     log2.info("execQuery", {
       request
     }, {
-      F: __dxlog_file3,
-      L: 30,
+      F: __dxlog_file2,
+      L: 20,
       S: this,
       C: (f, a) => f(...a)
     });
-    const query = QueryAST.Query.pipe(Schema.decodeUnknownSync)(JSON.parse(request.query));
-    const requestedSpaceIds = getTargetSpacesForQuery(query);
-    invariant3(requestedSpaceIds.length === 1, "Only one space is supported", {
-      F: __dxlog_file3,
-      L: 33,
-      S: this,
-      A: [
-        "requestedSpaceIds.length === 1",
-        "'Only one space is supported'"
-      ]
-    });
-    const spaceId = requestedSpaceIds[0];
     return Stream2.fromPromise((async () => {
       try {
-        log2.info("begin query", {
-          spaceId
-        }, {
-          F: __dxlog_file3,
-          L: 39,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        const queryResponse = await this._dataService.queryDocuments(this._executionContext, queryToDataServiceRequest(query));
-        log2.info("query response", {
-          spaceId,
-          filter: request.filter,
-          resultCount: queryResponse.results.length
-        }, {
-          F: __dxlog_file3,
-          L: 44,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-        return {
-          results: queryResponse.results.map((object) => ({
-            id: object.objectId,
-            spaceId,
-            spaceKey: PublicKey.ZERO,
-            documentId: object.document.documentId,
-            rank: 0,
-            documentAutomerge: object.document.data
-          }))
+        const env = {
+          stack: [],
+          error: void 0,
+          hasError: false
         };
-      } catch (err) {
+        try {
+          this._queryCount++;
+          log2.info("begin query", {
+            request
+          }, {
+            F: __dxlog_file2,
+            L: 26,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          const queryResponse = _ts_add_disposable_resource2(env, await this._dataService.execQuery(this._executionContext, request), false);
+          log2.info("query response", {
+            resultCount: queryResponse.results?.length
+          }, {
+            F: __dxlog_file2,
+            L: 28,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          return structuredClone(queryResponse);
+        } catch (e) {
+          env.error = e;
+          env.hasError = true;
+        } finally {
+          _ts_dispose_resources2(env);
+        }
+      } catch (error) {
         log2.error("query failed", {
-          err
+          err: error
         }, {
-          F: __dxlog_file3,
-          L: 58,
+          F: __dxlog_file2,
+          L: 31,
           S: this,
           C: (f, a) => f(...a)
         });
-        throw err;
+        throw new RuntimeServiceError2({
+          message: `Query execution failed (queryCount=${this._queryCount})`,
+          context: {
+            queryCount: this._queryCount
+          },
+          cause: error
+        });
       }
     })());
   }
   async reindex() {
-    throw new Error("Method not implemented.");
+    throw new NotImplementedError2({
+      message: "Reindex is not implemented."
+    });
   }
   async setConfig() {
-    throw new Error("Method not implemented.");
+    throw new NotImplementedError2({
+      message: "SetConfig is not implemented."
+    });
   }
 };
-var getTargetSpacesForQuery = (query) => {
-  const spaces = /* @__PURE__ */ new Set();
-  const visitor = (node) => {
-    if (node.type === "options") {
-      if (node.options.spaceIds) {
-        for (const spaceId of node.options.spaceIds) {
-          spaces.add(SpaceId3.make(spaceId));
+
+// src/internal/queue-service-impl.ts
+import { RuntimeServiceError as RuntimeServiceError3 } from "@dxos/errors";
+function _ts_add_disposable_resource3(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+function _ts_dispose_resources3(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources3 = function _ts_dispose_resources5(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
         }
       }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
     }
-  };
-  QueryAST.visit(query, visitor);
-  return [
-    ...spaces
-  ];
-};
-
-// src/internal/queue-service-impl.ts
+    return next();
+  })(env);
+}
 var QueueServiceImpl = class {
   _ctx;
   _queueService;
@@ -291,29 +472,194 @@ var QueueServiceImpl = class {
     this._ctx = _ctx;
     this._queueService = _queueService;
   }
-  queryQueue(subspaceTag, spaceId, { queueId, ...query }) {
-    return this._queueService.query(this._ctx, `dxn:queue:${subspaceTag}:${spaceId}:${queueId}`, query);
+  async queryQueue(request) {
+    try {
+      const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+      };
+      try {
+        const result = _ts_add_disposable_resource3(env, await this._queueService.queryQueue(this._ctx, request), false);
+        return {
+          objects: structuredClone(result.objects),
+          nextCursor: result.nextCursor,
+          prevCursor: result.prevCursor
+        };
+      } catch (e) {
+        env.error = e;
+        env.hasError = true;
+      } finally {
+        _ts_dispose_resources3(env);
+      }
+    } catch (error) {
+      const { query } = request;
+      throw RuntimeServiceError3.wrap({
+        message: "Queue query failed.",
+        context: {
+          subspaceTag: query?.queuesNamespace,
+          spaceId: query?.spaceId,
+          queueId: query?.queueIds?.[0]
+        },
+        ifTypeDiffers: true
+      })(error);
+    }
+  }
+  async insertIntoQueue(request) {
+    try {
+      const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+      };
+      try {
+        const _ = _ts_add_disposable_resource3(env, await this._queueService.insertIntoQueue(this._ctx, request), false);
+      } catch (e) {
+        env.error = e;
+        env.hasError = true;
+      } finally {
+        _ts_dispose_resources3(env);
+      }
+    } catch (error) {
+      const { subspaceTag, spaceId, queueId } = request;
+      throw RuntimeServiceError3.wrap({
+        message: "Queue append failed.",
+        context: {
+          subspaceTag,
+          spaceId,
+          queueId
+        },
+        ifTypeDiffers: true
+      })(error);
+    }
   }
-  insertIntoQueue(subspaceTag, spaceId, queueId, objects) {
-    return this._queueService.append(this._ctx, `dxn:queue:${subspaceTag}:${spaceId}:${queueId}`, objects);
+  async deleteFromQueue(request) {
+    try {
+      const env = {
+        stack: [],
+        error: void 0,
+        hasError: false
+      };
+      try {
+        const _ = _ts_add_disposable_resource3(env, await this._queueService.deleteFromQueue(this._ctx, request), false);
+      } catch (e) {
+        env.error = e;
+        env.hasError = true;
+      } finally {
+        _ts_dispose_resources3(env);
+      }
+    } catch (error) {
+      const { subspaceTag, spaceId, queueId } = request;
+      throw RuntimeServiceError3.wrap({
+        message: "Queue delete failed.",
+        context: {
+          subspaceTag,
+          spaceId,
+          queueId
+        },
+        ifTypeDiffers: true
+      })(error);
+    }
   }
-  deleteFromQueue(subspaceTag, spaceId, queueId, objectIds) {
-    throw new Error("Deleting from queue is not supported.");
+  async syncQueue(_) {
   }
 };
 
 // src/internal/service-container.ts
+function _ts_add_disposable_resource4(env, value, async) {
+  if (value !== null && value !== void 0) {
+    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+    var dispose, inner;
+    if (async) {
+      if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+      dispose = value[Symbol.asyncDispose];
+    }
+    if (dispose === void 0) {
+      if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+      dispose = value[Symbol.dispose];
+      if (async) inner = dispose;
+    }
+    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    env.stack.push({
+      value,
+      dispose,
+      async
+    });
+  } else if (async) {
+    env.stack.push({
+      async: true
+    });
+  }
+  return value;
+}
+function _ts_dispose_resources4(env) {
+  var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+  };
+  return (_ts_dispose_resources4 = function _ts_dispose_resources5(env2) {
+    function fail(e) {
+      env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
+      env2.hasError = true;
+    }
+    var r, s = 0;
+    function next() {
+      while (r = env2.stack.pop()) {
+        try {
+          if (!r.async && s === 1) return s = 0, env2.stack.push(r), Promise.resolve().then(next);
+          if (r.dispose) {
+            var result = r.dispose.call(r.value);
+            if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
+              fail(e);
+              return next();
+            });
+          } else s |= 1;
+        } catch (e) {
+          fail(e);
+        }
+      }
+      if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
+      if (env2.hasError) throw env2.error;
+    }
+    return next();
+  })(env);
+}
 var ServiceContainer = class {
   _executionContext;
   _dataService;
   _queueService;
-  constructor(_executionContext, _dataService, _queueService) {
+  _functionsService;
+  constructor(_executionContext, _dataService, _queueService, _functionsService) {
     this._executionContext = _executionContext;
     this._dataService = _dataService;
     this._queueService = _queueService;
+    this._functionsService = _functionsService;
   }
   async getSpaceMeta(spaceId) {
-    return this._dataService.getSpaceMeta(this._executionContext, spaceId);
+    const env = {
+      stack: [],
+      error: void 0,
+      hasError: false
+    };
+    try {
+      const result = _ts_add_disposable_resource4(env, await this._dataService.getSpaceMeta(this._executionContext, spaceId), false);
+      return result ? {
+        spaceKey: result.spaceKey,
+        rootDocumentId: result.rootDocumentId
+      } : void 0;
+    } catch (e) {
+      env.error = e;
+      env.hasError = true;
+    } finally {
+      _ts_dispose_resources4(env);
+    }
   }
   async createServices() {
     const dataService = new DataServiceImpl(this._executionContext, this._dataService);
@@ -322,21 +668,50 @@ var ServiceContainer = class {
     return {
       dataService,
       queryService,
-      queueService
+      queueService,
+      functionsAiService: this._functionsService
     };
   }
-  queryQueue(queue) {
-    return this._queueService.query({}, queue.toString(), {});
+  async queryQueue(queue) {
+    const parts = queue.asQueueDXN();
+    if (!parts) {
+      throw new Error("Invalid queue DXN");
+    }
+    const { subspaceTag, spaceId, queueId } = parts;
+    const result = await this._queueService.queryQueue(this._executionContext, {
+      query: {
+        spaceId,
+        queuesNamespace: subspaceTag,
+        queueIds: [
+          queueId
+        ]
+      }
+    });
+    return {
+      objects: structuredClone(result.objects),
+      nextCursor: result.nextCursor ?? null,
+      prevCursor: result.prevCursor ?? null
+    };
   }
-  insertIntoQueue(queue, objects) {
-    return this._queueService.append({}, queue.toString(), objects);
+  async insertIntoQueue(queue, objects) {
+    const parts = queue.asQueueDXN();
+    if (!parts) {
+      throw new Error("Invalid queue DXN");
+    }
+    const { subspaceTag, spaceId, queueId } = parts;
+    await this._queueService.insertIntoQueue(this._executionContext, {
+      subspaceTag,
+      spaceId,
+      queueId,
+      objects
+    });
   }
 };
 
 // src/space-proxy.ts
 import { Resource } from "@dxos/context";
-import { invariant as invariant4 } from "@dxos/invariant";
-import { PublicKey as PublicKey2 } from "@dxos/keys";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
 
 // src/queues-api.ts
 var QueuesAPIImpl = class {
@@ -355,7 +730,7 @@ var QueuesAPIImpl = class {
 };
 
 // src/space-proxy.ts
-var __dxlog_file4 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/space-proxy.ts";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/space-proxy.ts";
 var SpaceProxy = class extends Resource {
   _serviceContainer;
   _echoClient;
@@ -370,9 +745,9 @@ var SpaceProxy = class extends Resource {
     return this._id;
   }
   get db() {
-    invariant4(this._db, void 0, {
-      F: __dxlog_file4,
-      L: 34,
+    invariant2(this._db, void 0, {
+      F: __dxlog_file3,
+      L: 35,
       S: this,
       A: [
         "this._db",
@@ -385,9 +760,9 @@ var SpaceProxy = class extends Resource {
   * @deprecated Use db API.
   */
   get crud() {
-    invariant4(this._db, void 0, {
-      F: __dxlog_file4,
-      L: 42,
+    invariant2(this._db, void 0, {
+      F: __dxlog_file3,
+      L: 43,
       S: this,
       A: [
         "this._db",
@@ -406,7 +781,7 @@ var SpaceProxy = class extends Resource {
     }
     this._db = this._echoClient.constructDatabase({
       spaceId: this._id,
-      spaceKey: PublicKey2.from(meta.spaceKey),
+      spaceKey: PublicKey.from(meta.spaceKey),
       reactiveSchemaQuery: false,
       owningObject: this
     });
@@ -417,7 +792,7 @@ var SpaceProxy = class extends Resource {
 };
 
 // src/functions-client.ts
-var __dxlog_file5 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/functions-client.ts";
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/functions-client.ts";
 var FunctionsClient = class extends Resource2 {
   _serviceContainer;
   _echoClient;
@@ -425,25 +800,25 @@ var FunctionsClient = class extends Resource2 {
   _spaces = /* @__PURE__ */ new Map();
   constructor(services) {
     super();
-    invariant5(typeof services.dataService !== "undefined", "DataService is required", {
-      F: __dxlog_file5,
-      L: 32,
+    invariant3(typeof services.dataService !== "undefined", "DataService is required", {
+      F: __dxlog_file4,
+      L: 33,
       S: this,
       A: [
         "typeof services.dataService !== 'undefined'",
         "'DataService is required'"
       ]
     });
-    invariant5(typeof services.queueService !== "undefined", "QueueService is required", {
-      F: __dxlog_file5,
-      L: 33,
+    invariant3(typeof services.queueService !== "undefined", "QueueService is required", {
+      F: __dxlog_file4,
+      L: 34,
       S: this,
       A: [
         "typeof services.queueService !== 'undefined'",
         "'QueueService is required'"
       ]
     });
-    this._serviceContainer = new ServiceContainer(this._executionContext, services.dataService, services.queueService);
+    this._serviceContainer = new ServiceContainer(this._executionContext, services.dataService, services.queueService, services.functionsAiService);
     this._echoClient = new EchoClient({});
   }
   get echo() {
@@ -477,7 +852,8 @@ var FunctionsClient = class extends Resource2 {
 var createClientFromEnv = async (env) => {
   const client = new FunctionsClient({
     dataService: env.DATA_SERVICE,
-    queueService: env.QUEUE_SERVICE
+    queueService: env.QUEUE_SERVICE,
+    functionsAiService: env.FUNCTIONS_AI_SERVICE
   });
   await client.open();
   return client;
@@ -491,34 +867,26 @@ var FunctionRouteValue = /* @__PURE__ */ (function(FunctionRouteValue2) {
 })({});
 
 // src/wrap-handler-for-cloudflare.ts
-import { invariant as invariant6 } from "@dxos/invariant";
-import { SpaceId as SpaceId4 } from "@dxos/keys";
+import { invariant as invariant4 } from "@dxos/invariant";
+import { SpaceId as SpaceId2 } from "@dxos/keys";
 import { log as log3 } from "@dxos/log";
 import { EdgeResponse } from "@dxos/protocols";
-var __dxlog_file6 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/wrap-handler-for-cloudflare.ts";
+var __dxlog_file5 = "/__w/dxos/dxos/packages/core/functions-runtime-cloudflare/src/wrap-handler-for-cloudflare.ts";
 var wrapHandlerForCloudflare = (func) => {
   return async (request, env) => {
     if (request.headers.get(FUNCTION_ROUTE_HEADER) === FunctionRouteValue.Meta) {
-      log3.info(">>> meta", {
-        func
-      }, {
-        F: __dxlog_file6,
-        L: 25,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
       return handleFunctionMetaCall(func, request);
     }
     try {
       const spaceId = new URL(request.url).searchParams.get("spaceId");
       if (spaceId) {
-        if (!SpaceId4.isValid(spaceId)) {
+        if (!SpaceId2.isValid(spaceId)) {
           return new Response("Invalid spaceId", {
             status: 400
           });
         }
       }
-      const serviceContainer = new ServiceContainer({}, env.DATA_SERVICE, env.QUEUE_SERVICE);
+      const serviceContainer = new ServiceContainer({}, env.DATA_SERVICE, env.QUEUE_SERVICE, env.FUNCTIONS_AI_SERVICE);
       const context = await createFunctionContext({
         serviceContainer,
         contextSpaceId: spaceId
@@ -529,8 +897,8 @@ var wrapHandlerForCloudflare = (func) => {
         error,
         stack: error.stack
       }, {
-        F: __dxlog_file6,
-        L: 45,
+        F: __dxlog_file5,
+        L: 44,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -567,8 +935,8 @@ var decodeRequest = async (request) => {
     };
   } catch (err) {
     log3.catch(err, void 0, {
-      F: __dxlog_file6,
-      L: 80,
+      F: __dxlog_file5,
+      L: 79,
       S: void 0,
       C: (f, a) => f(...a)
     });
@@ -595,7 +963,7 @@ var handleFunctionMetaCall = (functionDefinition, request) => {
   });
 };
 var createFunctionContext = async ({ serviceContainer, contextSpaceId }) => {
-  const { dataService, queryService, queueService } = await serviceContainer.createServices();
+  const { dataService, queryService, queueService, functionsAiService } = await serviceContainer.createServices();
   let spaceKey;
   let rootUrl;
   if (contextSpaceId) {
@@ -604,9 +972,9 @@ var createFunctionContext = async ({ serviceContainer, contextSpaceId }) => {
       throw new Error(`Space not found: ${contextSpaceId}`);
     }
     spaceKey = meta.spaceKey;
-    invariant6(!meta.rootDocumentId.startsWith("automerge:"), void 0, {
-      F: __dxlog_file6,
-      L: 118,
+    invariant4(!meta.rootDocumentId.startsWith("automerge:"), void 0, {
+      F: __dxlog_file5,
+      L: 117,
       S: void 0,
       A: [
         "!meta.rootDocumentId.startsWith('automerge:')",
@@ -619,19 +987,56 @@ var createFunctionContext = async ({ serviceContainer, contextSpaceId }) => {
     services: {
       dataService,
       queryService,
-      queueService
+      queueService,
+      functionsAiService
     },
     spaceId: contextSpaceId,
     spaceKey,
     spaceRootUrl: rootUrl
   };
 };
+
+// src/logger.ts
+import { LogLevel, log as log4, shouldLog } from "@dxos/log";
+var setupFunctionsLogger = () => {
+  log4.runtimeConfig.processors.length = 0;
+  log4.runtimeConfig.processors.push(functionLogProcessor);
+};
+var functionLogProcessor = (config, entry) => {
+  if (!shouldLog(entry, config.filters)) {
+    return;
+  }
+  switch (entry.level) {
+    case LogLevel.DEBUG:
+      console.debug(entry.message, entry.context);
+      break;
+    case LogLevel.TRACE:
+      console.debug(entry.message, entry.context);
+      break;
+    case LogLevel.VERBOSE:
+      console.log(entry.message, entry.context);
+      break;
+    case LogLevel.INFO:
+      console.info(entry.message, entry.context);
+      break;
+    case LogLevel.WARN:
+      console.warn(entry.message, entry.context);
+      break;
+    case LogLevel.ERROR:
+      console.error(entry.message, entry.context);
+      break;
+    default:
+      console.log(entry.message, entry.context);
+      break;
+  }
+};
 export {
   FUNCTION_ROUTE_HEADER,
   FunctionRouteValue,
   FunctionsClient,
   ServiceContainer,
   createClientFromEnv,
+  setupFunctionsLogger,
   wrapHandlerForCloudflare
 };
 //# sourceMappingURL=index.mjs.map