@dxos/functions 0.8.3 → 0.8.4-main.1da679c

package/dist/lib/node-esm/index.mjs

@@ -1,48 +1,75 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  AiService,
+  ComputeEvent,
+  ComputeEventLogger,
+  ComputeEventPayload,
   ConfiguredCredentialsService,
+  ContextQueueService,
   CredentialsService,
   DatabaseService,
-  EventLogger,
-  FunctionCallService,
+  FUNCTIONS_META_KEY,
+  FUNCTIONS_PRESET_META_KEY,
+  MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
+  RemoteFunctionExecutionService,
   SERVICE_TAGS,
   ServiceContainer,
   TracingService,
   createDefectLogger,
   createEventLogger,
-  logCustomEvent
-} from "./chunk-LIYPMWNQ.mjs";
+  getInvocationUrl,
+  getUserFunctionIdInMetadata,
+  logCustomEvent,
+  setUserFunctionIdInMetadata,
+  withAuthorization
+} from "./chunk-Z4CJ62WS.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
 
-// packages/core/functions/src/handler.ts
-import { Schema } from "effect";
-var defineFunction = (params) => {
-  if (!Schema.isSchema(params.inputSchema)) {
-    throw new Error("Input schema must be a valid schema");
+// src/errors.ts
+import { BaseError } from "@dxos/errors";
+var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAILABLE", "Service not available") {
+  constructor(service, options) {
+    super({
+      context: {
+        service
+      },
+      ...options
+    });
   }
-  if (typeof params.handler !== "function") {
-    throw new Error("Handler must be a function");
+};
+var FunctionNotFoundError = class extends BaseError.extend("FUNCTION_NOT_FOUND", "Function not found") {
+  constructor(functionKey, options) {
+    super({
+      context: {
+        function: functionKey
+      },
+      ...options
+    });
   }
-  return {
-    description: params.description,
-    inputSchema: params.inputSchema,
-    outputSchema: params.outputSchema ?? Schema.Any,
-    handler: params.handler
-  };
 };
+var FunctionError = class extends BaseError.extend("FUNCTION_ERROR", "Function invocation error") {
+};
+var TriggerStateNotFoundError = class extends BaseError.extend("TRIGGER_STATE_NOT_FOUND", "Trigger state not found") {
+};
+
+// src/handler.ts
+import { Effect, Schema as Schema2 } from "effect";
+import { Obj, Type as Type2 } from "@dxos/echo";
+import { assertArgument } from "@dxos/invariant";
 
-// packages/core/functions/src/schema.ts
-import { Schema as Schema2 } from "effect";
+// src/schema.ts
+import { Schema } from "effect";
 import { Type } from "@dxos/echo";
 import { JsonSchemaType, LabelAnnotation, Ref } from "@dxos/echo-schema";
 import { DataType } from "@dxos/schema";
-var ScriptType = Schema2.Struct({
-  name: Schema2.optional(Schema2.String),
-  description: Schema2.optional(Schema2.String),
+var ScriptType = Schema.Struct({
+  name: Schema.optional(Schema.String),
+  description: Schema.optional(Schema.String),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema2.optional(Schema2.Boolean),
+  changed: Schema.optional(Schema.Boolean),
   source: Ref(DataType.Text)
 }).pipe(Type.Obj({
   typename: "dxos.org/type/Script",
@@ -50,18 +77,28 @@ var ScriptType = Schema2.Struct({
 }), LabelAnnotation.set([
   "name"
 ]));
-var FunctionType = Schema2.Struct({
+var FunctionType = Schema.Struct({
+  /**
+  * Global registry ID.
+  * NOTE: The `key` property refers to the original registry entry.
+  */
+  // TODO(burdon): Create Format type for DXN-like ids, such as this and schema type.
+  // TODO(dmaretskyi): Consider making it part of ECHO meta.
+  // TODO(dmaretskyi): Make required.
+  key: Schema.optional(Schema.String).annotations({
+    description: "Unique registration key for the blueprint"
+  }),
   // TODO(burdon): Rename to id/uri?
-  name: Schema2.NonEmptyString,
-  version: Schema2.String,
-  description: Schema2.optional(Schema2.String),
+  name: Schema.NonEmptyString,
+  version: Schema.String,
+  description: Schema.optional(Schema.String),
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema2.optional(Ref(ScriptType)),
-  inputSchema: Schema2.optional(JsonSchemaType),
-  outputSchema: Schema2.optional(JsonSchemaType),
+  source: Schema.optional(Ref(ScriptType)),
+  inputSchema: Schema.optional(JsonSchemaType),
+  outputSchema: Schema.optional(JsonSchemaType),
   // Local binding to a function name.
-  binding: Schema2.optional(Schema2.String)
+  binding: Schema.optional(Schema.String)
 }).pipe(Type.Obj({
   typename: "dxos.org/type/Function",
   version: "0.1.0"
@@ -69,25 +106,107 @@ var FunctionType = Schema2.Struct({
   "name"
 ]));
 
-// packages/core/functions/src/trace.ts
+// src/handler.ts
+var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
+var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema2.Any, handler }) => {
+  if (!Schema2.isSchema(inputSchema)) {
+    throw new Error("Input schema must be a valid schema");
+  }
+  if (typeof handler !== "function") {
+    throw new Error("Handler must be a function");
+  }
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 2;
+  const traceError = new Error();
+  Error.stackTraceLimit = limit;
+  let cache = false;
+  const captureStackTrace = () => {
+    if (cache !== false) {
+      return cache;
+    }
+    if (traceError.stack !== void 0) {
+      const stack = traceError.stack.split("\n");
+      if (stack[2] !== void 0) {
+        cache = stack[2].trim();
+        return cache;
+      }
+    }
+  };
+  const handlerWithSpan = (...args) => {
+    const result = handler(...args);
+    if (Effect.isEffect(result)) {
+      return Effect.withSpan(result, `${key ?? name}`, {
+        captureStackTrace
+      });
+    }
+    return result;
+  };
+  return {
+    [typeId]: true,
+    key: key ?? name,
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    handler: handlerWithSpan
+  };
+};
+var FunctionDefinition = {
+  make: defineFunction,
+  isFunction: (value) => {
+    return typeof value === "object" && value !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value;
+  },
+  serialize: (functionDef) => {
+    assertArgument(FunctionDefinition.isFunction(functionDef), "functionDef");
+    return serializeFunction(functionDef);
+  },
+  deserialize: (functionObj) => {
+    assertArgument(Obj.instanceOf(FunctionType, functionObj), "functionObj");
+    return deserializeFunction(functionObj);
+  }
+};
+var serializeFunction = (functionDef) => Obj.make(FunctionType, {
+  key: functionDef.name,
+  name: functionDef.name,
+  version: "0.1.0",
+  description: functionDef.description,
+  inputSchema: Type2.toJsonSchema(functionDef.inputSchema),
+  outputSchema: !functionDef.outputSchema ? void 0 : Type2.toJsonSchema(functionDef.outputSchema)
+});
+var deserializeFunction = (functionObj) => {
+  return {
+    [typeId]: true,
+    // TODO(dmaretskyi): Fix key.
+    key: functionObj.key ?? functionObj.name,
+    name: functionObj.name,
+    description: functionObj.description,
+    inputSchema: !functionObj.inputSchema ? Schema2.Unknown : Type2.toEffectSchema(functionObj.inputSchema),
+    outputSchema: !functionObj.outputSchema ? void 0 : Type2.toEffectSchema(functionObj.outputSchema),
+    // TODO(dmaretskyi): This should throw error.
+    handler: () => {
+    }
+  };
+};
+
+// src/trace.ts
 import { Schema as Schema4 } from "effect";
-import { Type as Type2 } from "@dxos/echo";
+import { Type as Type4 } from "@dxos/echo";
 import { Queue } from "@dxos/echo-db";
 import { ObjectId } from "@dxos/echo-schema";
 import { log } from "@dxos/log";
 
-// packages/core/functions/src/types.ts
+// src/types.ts
 import { Schema as Schema3, SchemaAST } from "effect";
-import { Expando, OptionsAnnotationId, TypedObject, Ref as Ref2, RawObject } from "@dxos/echo-schema";
+import { Obj as Obj2, QueryAST, Type as Type3 } from "@dxos/echo";
+import { Expando, OptionsAnnotationId, RawObject, Ref as Ref2 } from "@dxos/echo-schema";
 import { DXN } from "@dxos/keys";
-var TriggerKind = /* @__PURE__ */ function(TriggerKind2) {
-  TriggerKind2["Timer"] = "timer";
-  TriggerKind2["Webhook"] = "webhook";
-  TriggerKind2["Subscription"] = "subscription";
-  TriggerKind2["Email"] = "email";
-  TriggerKind2["Queue"] = "queue";
-  return TriggerKind2;
-}({});
+var TriggerKinds = [
+  "timer",
+  "webhook",
+  "subscription",
+  "email",
+  "queue"
+];
 var kindLiteralAnnotations = {
   title: "Kind"
 };
@@ -105,6 +224,7 @@ var EmailTriggerSchema = Schema3.Struct({
 }).pipe(Schema3.mutable);
 var QueueTriggerSchema = Schema3.Struct({
   kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
+  // TODO(dmaretskyi): Change to a reference.
   queue: DXN.Schema
 }).pipe(Schema3.mutable);
 var WebhookTriggerSchema = Schema3.Struct({
@@ -120,21 +240,11 @@ var WebhookTriggerSchema = Schema3.Struct({
     title: "Port"
   }))
 }).pipe(Schema3.mutable);
-var QuerySchema = Schema3.Struct({
-  type: Schema3.optional(Schema3.String.annotations({
-    title: "Type"
-  })),
-  props: Schema3.optional(Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.Any
-  }))
-}).annotations({
-  title: "Query"
-});
 var SubscriptionTriggerSchema = Schema3.Struct({
   kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
-  filter: QuerySchema,
+  query: QueryAST.Query.annotations({
+    title: "Query"
+  }),
   options: Schema3.optional(Schema3.Struct({
     // Watch changes to object (not just creation).
     deep: Schema3.optional(Schema3.Boolean.annotations({
@@ -172,14 +282,25 @@ var QueueTriggerOutput = Schema3.mutable(Schema3.Struct({
   item: Schema3.Any,
   cursor: Schema3.String
 }));
-var SubscriptionTriggerOutput = Schema3.mutable(Schema3.Struct({
+var SubscriptionTriggerOutput = Schema3.Struct({
+  /**
+  * Type of the mutation.
+  */
+  // TODO(dmaretskyi): Specify enum.
   type: Schema3.String,
-  changedObjectId: Schema3.String
-}));
+  /**
+  * Reference to the object that was changed or created.
+  */
+  subject: Type3.Ref(Obj2.Any),
+  /**
+  * @deprecated
+  */
+  changedObjectId: Schema3.optional(Schema3.String)
+}).pipe(Schema3.mutable);
 var TimerTriggerOutput = Schema3.mutable(Schema3.Struct({
   tick: Schema3.Number
 }));
-var FunctionTriggerSchema = Schema3.Struct({
+var FunctionTrigger_ = Schema3.Struct({
   /**
   * Function or workflow to invoke.
   */
@@ -214,12 +335,11 @@ var FunctionTriggerSchema = Schema3.Struct({
     key: Schema3.String,
     value: Schema3.Any
   })))
-});
-var FunctionTrigger = class extends TypedObject({
+}).pipe(Type3.Obj({
   typename: "dxos.org/type/FunctionTrigger",
   version: "0.2.0"
-})(FunctionTriggerSchema.fields) {
-};
+}));
+var FunctionTrigger = FunctionTrigger_;
 var FunctionManifestSchema = Schema3.Struct({
   functions: Schema3.optional(Schema3.mutable(Schema3.Array(RawObject(FunctionType)))),
   triggers: Schema3.optional(Schema3.mutable(Schema3.Array(RawObject(FunctionTrigger))))
@@ -229,21 +349,21 @@ var FUNCTION_TYPES = [
   FunctionTrigger
 ];
 
-// packages/core/functions/src/trace.ts
-var __dxlog_file = "/home/runner/work/dxos/dxos/packages/core/functions/src/trace.ts";
-var InvocationOutcome = /* @__PURE__ */ function(InvocationOutcome2) {
+// src/trace.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/trace.ts";
+var InvocationOutcome = /* @__PURE__ */ (function(InvocationOutcome2) {
   InvocationOutcome2["SUCCESS"] = "success";
   InvocationOutcome2["FAILURE"] = "failure";
   InvocationOutcome2["PENDING"] = "pending";
   return InvocationOutcome2;
-}({});
-var InvocationTraceEventType = /* @__PURE__ */ function(InvocationTraceEventType2) {
+})({});
+var InvocationTraceEventType = /* @__PURE__ */ (function(InvocationTraceEventType2) {
   InvocationTraceEventType2["START"] = "start";
   InvocationTraceEventType2["END"] = "end";
   return InvocationTraceEventType2;
-}({});
+})({});
 var TraceEventException = Schema4.Struct({
-  timestampMs: Schema4.Number,
+  timestamp: Schema4.Number,
   message: Schema4.String,
   name: Schema4.String,
   stack: Schema4.optional(Schema4.String)
@@ -261,7 +381,7 @@ var InvocationTraceStartEvent = Schema4.Struct({
   /**
   * Event generation time.
   */
-  timestampMs: Schema4.Number,
+  timestamp: Schema4.Number,
   /**
   * Data passed to function / workflow as an argument.
   */
@@ -270,16 +390,16 @@ var InvocationTraceStartEvent = Schema4.Struct({
   /**
   * Queue  for function/workflow invocation events.
   */
-  invocationTraceQueue: Type2.Ref(Queue),
+  invocationTraceQueue: Schema4.optional(Type4.Ref(Queue)),
   /**
   * DXN of the invoked function/workflow.
   */
-  invocationTarget: Type2.Ref(Type2.Expando),
+  invocationTarget: Schema4.optional(Type4.Ref(Type4.Expando)),
   /**
   * Present for automatic invocations.
   */
-  trigger: Schema4.optional(Type2.Ref(FunctionTrigger))
-}).pipe(Type2.Obj({
+  trigger: Schema4.optional(Type4.Ref(FunctionTrigger))
+}).pipe(Type4.Obj({
   typename: "dxos.org/type/InvocationTraceStart",
   version: "0.1.0"
 }));
@@ -297,15 +417,15 @@ var InvocationTraceEndEvent = Schema4.Struct({
   * Event generation time.
   */
   // TODO(burdon): Remove ms suffix.
-  timestampMs: Schema4.Number,
+  timestamp: Schema4.Number,
   outcome: Schema4.Enums(InvocationOutcome),
   exception: Schema4.optional(TraceEventException)
-}).pipe(Type2.Obj({
+}).pipe(Type4.Obj({
   typename: "dxos.org/type/InvocationTraceEnd",
   version: "0.1.0"
 }));
 var TraceEventLog = Schema4.Struct({
-  timestampMs: Schema4.Number,
+  timestamp: Schema4.Number,
   level: Schema4.String,
   message: Schema4.String,
   context: Schema4.optional(Schema4.Object)
@@ -315,13 +435,11 @@ var TraceEvent = Schema4.Struct({
   // TODO(burdon): Need enum/numeric result (not string).
   outcome: Schema4.String,
   truncated: Schema4.Boolean,
-  /**
-  * Time when the event was persisted.
-  */
-  ingestionTimestampMs: Schema4.Number,
+  /** Time when the event was persisted. */
+  ingestionTimestamp: Schema4.Number,
   logs: Schema4.Array(TraceEventLog),
   exceptions: Schema4.Array(TraceEventException)
-}).pipe(Type2.Obj({
+}).pipe(Type4.Obj({
   typename: "dxos.org/type/TraceEvent",
   version: "0.1.0"
 }));
@@ -354,7 +472,7 @@ var createInvocationSpans = (items) => {
         invocationId
       }, {
         F: __dxlog_file,
-        L: 160,
+        L: 158,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -363,8 +481,8 @@ var createInvocationSpans = (items) => {
     const isInProgress = end === void 0;
     result.push({
       id: invocationId,
-      timestampMs: start.timestampMs,
-      durationMs: isInProgress ? now - start.timestampMs : end.timestampMs - start.timestampMs,
+      timestamp: start.timestamp,
+      duration: isInProgress ? now - start.timestamp : end.timestamp - start.timestamp,
       outcome: end?.outcome ?? "pending",
       exception: end?.exception,
       input: start.input,
@@ -376,112 +494,838 @@ var createInvocationSpans = (items) => {
   return result;
 };
 
-// packages/core/functions/src/url.ts
-var FUNCTIONS_META_KEY = "dxos.org/service/function";
-var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
-var isSecure = (protocol) => {
-  return protocol === "https:" || protocol === "wss:";
+// src/triggers/invocation-tracer.ts
+import { Context as Context2, Effect as Effect3, Layer as Layer2 } from "effect";
+import { Obj as Obj3, Ref as Ref3 } from "@dxos/echo";
+import { DXN as DXN2, ObjectId as ObjectId2 } from "@dxos/keys";
+
+// src/services/local-function-execution.ts
+import { Context, Effect as Effect2, Layer, Schema as Schema5 } from "effect";
+import { todo } from "@dxos/debug";
+import { log as log2 } from "@dxos/log";
+function _define_property(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/services/local-function-execution.ts";
+var _Context_Tag;
+var LocalFunctionExecutionService = class extends (_Context_Tag = Context.Tag("@dxos/functions/LocalFunctionExecutionService")()) {
 };
-var getUserFunctionUrlInMetadata = (meta) => {
-  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+_define_property(LocalFunctionExecutionService, "layer", Layer.succeed(LocalFunctionExecutionService, {
+  invokeFunction: (functionDef, input) => invokeFunction(functionDef, input)
+}));
+_define_property(LocalFunctionExecutionService, "layerLive", Layer.effect(LocalFunctionExecutionService, Effect2.gen(function* () {
+  const resolver = yield* FunctionImplementationResolver;
+  return {
+    invokeFunction: Effect2.fn("invokeFunction")(function* (functionDef, input) {
+      const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect2.orDie);
+      return yield* invokeFunction(resolved, input);
+    })
+  };
+})));
+_define_property(LocalFunctionExecutionService, "invokeFunction", Effect2.serviceFunctionEffect(LocalFunctionExecutionService, (_) => _.invokeFunction));
+var invokeFunction = (functionDef, input) => Effect2.gen(function* () {
+  try {
+    const assertInput = functionDef.inputSchema.pipe(Schema5.asserts);
+    assertInput(input);
+  } catch (e) {
+    throw new FunctionError({
+      message: "Invalid function input",
+      context: {
+        name: functionDef.name
+      },
+      cause: e
+    });
+  }
+  const context = {
+    space: void 0,
+    getService: () => todo(),
+    getSpace: async (_spaceId) => {
+      throw new Error("Not available. Use the database service instead.");
+    }
+  };
+  log2.info("Invoking function", {
+    name: functionDef.name,
+    input
+  }, {
+    F: __dxlog_file2,
+    L: 72,
+    S: this,
+    C: (f, a) => f(...a)
+  });
+  const data = yield* Effect2.gen(function* () {
+    const result = functionDef.handler({
+      context,
+      data: input
+    });
+    if (Effect2.isEffect(result)) {
+      return yield* result.pipe(Effect2.orDie);
+    } else if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") {
+      return yield* Effect2.promise(() => result);
+    } else {
+      return result;
+    }
+  }).pipe(Effect2.orDie, Effect2.catchAllDefect((defect) => Effect2.die(new FunctionError({
+    context: {
+      name: functionDef.name
+    },
+    cause: defect
+  }))));
+  log2.info("Function completed", {
+    name: functionDef.name,
+    input,
+    data
+  }, {
+    F: __dxlog_file2,
+    L: 96,
+    S: this,
+    C: (f, a) => f(...a)
+  });
+  try {
+    const assertOutput = functionDef.outputSchema?.pipe(Schema5.asserts);
+    assertOutput(data);
+  } catch (e) {
+    throw new FunctionError({
+      message: "Invalid function output",
+      context: {
+        name: functionDef.name
+      },
+      cause: e
+    });
+  }
+  return data;
+}).pipe(Effect2.withSpan("invokeFunction", {
+  attributes: {
+    name: functionDef.name
+  }
+}));
+var _Context_Tag1;
+var FunctionImplementationResolver = class extends (_Context_Tag1 = Context.Tag("@dxos/functions/FunctionImplementationResolver")()) {
 };
-var setUserFunctionUrlInMetadata = (meta, functionUrl) => {
-  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
-  if (key) {
-    if (key.id !== functionUrl) {
-      throw new Error("Metadata mismatch");
+_define_property(FunctionImplementationResolver, "layerTest", ({ functions }) => Layer.succeed(FunctionImplementationResolver, {
+  resolveFunctionImplementation: (functionDef) => {
+    const resolved = functions.find((f) => f.name === functionDef.name);
+    if (!resolved) {
+      return Effect2.fail(new FunctionNotFoundError(functionDef.name));
     }
+    return Effect2.succeed(resolved);
+  }
+}));
+
+// src/triggers/invocation-tracer.ts
+function _define_property2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
   } else {
-    meta.keys.push({
-      source: FUNCTIONS_META_KEY,
-      id: functionUrl
+    obj[key] = value;
+  }
+  return obj;
+}
+var _Context_Tag2;
+var InvocationTracer = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/InvocationTracer")()) {
+};
+_define_property2(InvocationTracer, "layerLive", (opts) => Layer2.effect(InvocationTracer, Effect3.gen(function* () {
+  return {
+    traceInvocationStart: Effect3.fn("traceInvocationStart")(function* ({ payload, target }) {
+      const invocationId = ObjectId2.random();
+      const invocationTraceQueue = yield* QueueService.createQueue({
+        subspaceTag: "trace"
+      });
+      const now = Date.now();
+      const traceEvent = Obj3.make(InvocationTraceStartEvent, {
+        type: InvocationTraceEventType.START,
+        invocationId,
+        timestamp: now,
+        // TODO(dmaretskyi): Not json-stringifying this makes ECHO fail when one ECHO object becomes embedded in another ECHO object.
+        input: JSON.parse(JSON.stringify(payload.data ?? {})),
+        invocationTraceQueue: Ref3.fromDXN(invocationTraceQueue.dxn),
+        invocationTarget: target ? Ref3.fromDXN(target) : void 0,
+        trigger: payload.trigger ? Ref3.fromDXN(DXN2.fromLocalObjectId(payload.trigger.id)) : void 0
+      });
+      yield* QueueService.append(opts.invocationTraceQueue, [
+        traceEvent
+      ]);
+      return {
+        invocationId,
+        invocationTraceQueue
+      };
+    }),
+    traceInvocationEnd: Effect3.fn("traceInvocationEnd")(function* ({ trace, exception }) {
+      const now = Date.now();
+      const traceEvent = Obj3.make(InvocationTraceEndEvent, {
+        type: InvocationTraceEventType.END,
+        invocationId: trace.invocationId,
+        timestamp: now,
+        outcome: exception ? InvocationOutcome.FAILURE : InvocationOutcome.SUCCESS,
+        exception: exception ? {
+          name: exception.constructor.name,
+          timestamp: now,
+          message: exception?.message ?? "Unknown error",
+          stack: exception?.stack
+        } : void 0
+      });
+      yield* QueueService.append(opts.invocationTraceQueue, [
+        traceEvent
+      ]);
+    })
+  };
+})));
+_define_property2(InvocationTracer, "layerTest", Layer2.unwrapEffect(Effect3.gen(function* () {
+  const queue = yield* QueueService.createQueue({
+    subspaceTag: "trace"
+  });
+  return InvocationTracer.layerLive({
+    invocationTraceQueue: queue
+  });
+})));
+
+// src/triggers/trigger-dispatcher.ts
+import { Cause, Context as Context4, Cron, Duration, Effect as Effect5, Either, Exit, Fiber, Layer as Layer4, Option as Option2, Record, Schedule } from "effect";
+import { DXN as DXN3, Filter, Obj as Obj4, Query } from "@dxos/echo";
+import { causeToError } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { log as log3 } from "@dxos/log";
+import { KEY_QUEUE_POSITION } from "@dxos/protocols";
+
+// src/triggers/input-builder.ts
+var createInvocationPayload = (trigger, event) => {
+  if (!trigger.input) {
+    return event;
+  }
+  const payload = {};
+  for (const [key, value] of Object.entries(trigger.input)) {
+    if (typeof value !== "string" || !(value.startsWith("{{") && value.endsWith("}}"))) {
+      payload[key] = value;
+      continue;
+    }
+    const propertyPath = value.slice(2, -2);
+    let valueSubstitution = propertyPath.startsWith("trigger.") ? trigger : propertyPath.startsWith("event.") ? event : void 0;
+    for (const pathSegment of propertyPath.split(".").slice(1)) {
+      if (valueSubstitution && typeof valueSubstitution === "object") {
+        valueSubstitution = valueSubstitution[pathSegment];
+      }
+    }
+    payload[key] = valueSubstitution;
+  }
+  return payload;
+};
+
+// src/triggers/trigger-state-store.ts
+import { KeyValueStore } from "@effect/platform";
+import { Context as Context3 } from "effect";
+import { Schema as Schema6 } from "effect";
+import { Effect as Effect4, Layer as Layer3 } from "effect";
+import { Option } from "effect";
+import { ObjectId as ObjectId3 } from "@dxos/keys";
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
     });
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+var TriggerState = Schema6.Struct({
+  version: Schema6.Literal("1"),
+  triggerId: Schema6.String,
+  state: Schema6.optional(Schema6.Union(Schema6.TaggedStruct("subscription", {
+    processedVersions: Schema6.Record({
+      key: ObjectId3,
+      value: Schema6.String
+    })
+  })))
+});
+var _Context_Tag3;
+var TriggerStateStore = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/TriggerStateStore")()) {
 };
-var makeFunctionUrl = (fn) => `/${fn.functionId}`;
-var getInvocationUrl = (functionUrl, edgeUrl, options = {}) => {
-  const baseUrl = new URL("functions/", edgeUrl);
-  const relativeUrl = functionUrl.replace(/^\//, "");
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
-  options.spaceId && url.searchParams.set("spaceId", options.spaceId);
-  options.subjectId && url.searchParams.set("subjectId", options.subjectId);
-  url.protocol = isSecure(url.protocol) ? "https" : "http";
-  return url.toString();
+_define_property3(TriggerStateStore, "getState", Effect4.serviceFunctionEffect(TriggerStateStore, (_) => _.getState));
+_define_property3(TriggerStateStore, "saveState", Effect4.serviceFunctionEffect(TriggerStateStore, (_) => _.saveState));
+_define_property3(TriggerStateStore, "layerKv", Layer3.effect(TriggerStateStore, Effect4.gen(function* () {
+  const kv = yield* KeyValueStore.KeyValueStore;
+  const schemaStore = kv.forSchema(Schema6.parseJson(TriggerState));
+  const store = {
+    getState: Effect4.fn("TriggerStateStore.getState")(function* (triggerId) {
+      const valueOption = yield* schemaStore.get(triggerId).pipe(Effect4.orDie);
+      if (Option.isNone(valueOption)) {
+        return yield* Effect4.fail(new TriggerStateNotFoundError());
+      }
+      return valueOption.value;
+    }),
+    saveState: Effect4.fn("TriggerStateStore.saveState")(function* (state) {
+      yield* schemaStore.set(state.triggerId, state).pipe(Effect4.orDie);
+    })
+  };
+  return store;
+})));
+_define_property3(TriggerStateStore, "layerMemory", TriggerStateStore.layerKv.pipe(Layer3.provide(KeyValueStore.layerMemory)));
+
+// src/triggers/trigger-dispatcher.ts
+function _define_property4(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/triggers/trigger-dispatcher.ts";
+var _Context_Tag4;
+var TriggerDispatcher = class extends (_Context_Tag4 = Context4.Tag("@dxos/functions/TriggerDispatcher")()) {
+};
+_define_property4(TriggerDispatcher, "layer", (options) => Layer4.effect(TriggerDispatcher, Effect5.gen(function* () {
+  return new TriggerDispatcherImpl(options);
+})));
+var TriggerDispatcherImpl = class {
+  get running() {
+    return this._running;
+  }
+  constructor(options) {
+    _define_property4(this, "livePollInterval", void 0);
+    _define_property4(this, "timeControl", void 0);
+    _define_property4(this, "_running", false);
+    _define_property4(this, "_internalTime", void 0);
+    _define_property4(this, "_timerFiber", void 0);
+    _define_property4(this, "_scheduledTriggers", /* @__PURE__ */ new Map());
+    _define_property4(this, "start", () => Effect5.gen(this, function* () {
+      if (this._running) {
+        return;
+      }
+      this._running = true;
+      if (this.timeControl === "natural") {
+        this._timerFiber = yield* this._startNaturalTimeProcessing().pipe(Effect5.tapErrorCause((cause) => {
+          const error = causeToError(cause);
+          log3.error("trigger dispatcher error", {
+            error
+          }, {
+            F: __dxlog_file3,
+            L: 170,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._running = false;
+          return Effect5.void;
+        }), Effect5.forkDaemon);
+      } else {
+        return yield* Effect5.dieMessage("TriggerDispatcher started in manual time control mode");
+      }
+      log3.info("TriggerDispatcher started", {
+        timeControl: this.timeControl
+      }, {
+        F: __dxlog_file3,
+        L: 180,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }));
+    _define_property4(this, "stop", () => Effect5.gen(this, function* () {
+      if (!this._running) {
+        return;
+      }
+      this._running = false;
+      if (this._timerFiber) {
+        yield* Fiber.interrupt(this._timerFiber);
+        this._timerFiber = void 0;
+      }
+      this._scheduledTriggers.clear();
+      log3.info("TriggerDispatcher stopped", void 0, {
+        F: __dxlog_file3,
+        L: 200,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }));
+    _define_property4(this, "invokeTrigger", (options2) => Effect5.gen(this, function* () {
+      const { trigger, event } = options2;
+      log3.info("running trigger", {
+        triggerId: trigger.id,
+        spec: trigger.spec,
+        event
+      }, {
+        F: __dxlog_file3,
+        L: 208,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+      const tracer = yield* InvocationTracer;
+      const trace = yield* tracer.traceInvocationStart({
+        target: trigger.function?.dxn,
+        payload: {
+          trigger: {
+            id: trigger.id,
+            // TODO(dmaretskyi): Is `spec` always there>
+            kind: trigger.spec.kind
+          },
+          data: event
+        }
+      });
+      const result = yield* Effect5.gen(this, function* () {
+        if (!trigger.enabled) {
+          return yield* Effect5.dieMessage("Attempting to invoke disabled trigger");
+        }
+        if (!trigger.function) {
+          return yield* Effect5.dieMessage("Trigger has no function reference");
+        }
+        const serialiedFunction = yield* DatabaseService.load(trigger.function).pipe(Effect5.orDie);
+        invariant(Obj4.instanceOf(FunctionType, serialiedFunction), void 0, {
+          F: __dxlog_file3,
+          L: 235,
+          S: this,
+          A: [
+            "Obj.instanceOf(FunctionType, serialiedFunction)",
+            ""
+          ]
+        });
+        const functionDef = deserializeFunction(serialiedFunction);
+        const inputData = this._prepareInputData(trigger, event);
+        return yield* LocalFunctionExecutionService.invokeFunction(functionDef, inputData).pipe(Effect5.provide(ComputeEventLogger.layerFromTracing.pipe(Layer4.provideMerge(TracingService.layerQueue(trace.invocationTraceQueue)))));
+      }).pipe(Effect5.exit);
+      const triggerExecutionResult = {
+        triggerId: trigger.id,
+        result
+      };
+      if (Exit.isSuccess(result)) {
+        log3.info("trigger execution success", {
+          triggerId: trigger.id
+        }, {
+          F: __dxlog_file3,
+          L: 256,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      } else {
+        log3.error("trigger execution failure", {
+          error: causeToError(result.cause)
+        }, {
+          F: __dxlog_file3,
+          L: 260,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+      }
+      yield* tracer.traceInvocationEnd({
+        trace,
+        // TODO(dmaretskyi): Might miss errors.
+        exception: Exit.isFailure(result) ? Cause.prettyErrors(result.cause)[0] : void 0
+      });
+      return triggerExecutionResult;
+    }));
+    _define_property4(this, "invokeScheduledTriggers", ({ kinds = [
+      "timer",
+      "queue",
+      "subscription"
+    ] } = {}) => Effect5.gen(this, function* () {
+      const invocations = [];
+      for (const kind of kinds) {
+        switch (kind) {
+          case "timer":
+            {
+              yield* this.refreshTriggers();
+              const now = this.getCurrentTime();
+              const triggersToInvoke = [];
+              for (const [triggerId, scheduledTrigger] of this._scheduledTriggers.entries()) {
+                if (scheduledTrigger.nextExecution <= now) {
+                  triggersToInvoke.push(scheduledTrigger.trigger);
+                  scheduledTrigger.nextExecution = Cron.next(scheduledTrigger.cron, now);
+                }
+              }
+              invocations.push(...yield* Effect5.forEach(triggersToInvoke, (trigger) => this.invokeTrigger({
+                trigger,
+                event: {
+                  tick: now.getTime()
+                }
+              }), {
+                concurrency: 1
+              }));
+            }
+            break;
+          case "queue": {
+            const triggers = yield* this._fetchTriggers();
+            for (const trigger of triggers) {
+              const spec = trigger.spec;
+              if (spec?.kind !== "queue") {
+                continue;
+              }
+              const cursor = Obj4.getKeys(trigger, KEY_QUEUE_CURSOR).at(0)?.id;
+              const queue = yield* QueueService.getQueue(DXN3.parse(spec.queue));
+              const objects = yield* Effect5.promise(() => queue.queryObjects());
+              for (const object of objects) {
+                const objectPos = Obj4.getKeys(object, KEY_QUEUE_POSITION).at(0)?.id;
+                if (!objectPos || cursor && parseInt(cursor) >= parseInt(objectPos)) {
+                  continue;
+                }
+                invocations.push(yield* this.invokeTrigger({
+                  trigger,
+                  event: {
+                    queue: spec.queue,
+                    item: object,
+                    cursor: objectPos
+                  }
+                }));
+                Obj4.deleteKeys(trigger, KEY_QUEUE_CURSOR);
+                Obj4.getMeta(trigger).keys.push({
+                  source: KEY_QUEUE_CURSOR,
+                  id: objectPos
+                });
+                yield* DatabaseService.flush();
+                break;
+              }
+            }
+            break;
+          }
+          case "subscription": {
+            const triggers = yield* this._fetchTriggers();
+            for (const trigger of triggers) {
+              const spec = Obj4.getSnapshot(trigger).spec;
+              if (spec?.kind !== "subscription") {
+                continue;
+              }
+              const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query));
+              const state = yield* TriggerStateStore.getState(trigger.id).pipe(Effect5.catchTag("TRIGGER_STATE_NOT_FOUND", () => Effect5.succeed({
+                version: "1",
+                triggerId: trigger.id,
+                state: {
+                  _tag: "subscription",
+                  processedVersions: {}
+                }
+              })));
+              invariant(state.state?._tag === "subscription", void 0, {
+                F: __dxlog_file3,
+                L: 373,
+                S: this,
+                A: [
+                  "state.state?._tag === 'subscription'",
+                  ""
+                ]
+              });
+              let updated = false;
+              for (const object of objects) {
+                const existingVersion = Record.get(state.state.processedVersions, object.id).pipe(Option2.map(Obj4.decodeVersion));
+                const currentVersion = Obj4.version(object);
+                const run = Option2.isNone(existingVersion) || Obj4.compareVersions(currentVersion, existingVersion.value) === "different";
+                if (!run) {
+                  continue;
+                }
+                const { db } = yield* DatabaseService;
+                invocations.push(yield* this.invokeTrigger({
+                  trigger,
+                  event: {
+                    // TODO(dmaretskyi): Change type not supported.
+                    type: "unknown",
+                    subject: db.ref(Obj4.getDXN(object)),
+                    changedObjectId: object.id
+                  }
+                }));
+                state.state.processedVersions[object.id] = Obj4.encodeVersion(currentVersion);
+                updated = true;
+              }
+              if (updated) {
+                yield* TriggerStateStore.saveState(state);
+              }
+            }
+            break;
+          }
+          default: {
+            return yield* Effect5.dieMessage(`Unknown trigger kind: ${kind}`);
+          }
+        }
+      }
+      return invocations;
+    }));
+    _define_property4(this, "advanceTime", (duration) => Effect5.gen(this, function* () {
+      if (this.timeControl !== "manual") {
+        return yield* Effect5.dieMessage("advanceTime can only be used in manual time control mode");
+      }
+      const millis = Duration.toMillis(duration);
+      this._internalTime = new Date(this._internalTime.getTime() + millis);
+      log3("Advanced internal time", {
+        newTime: this._internalTime,
+        advancedBy: Duration.format(duration)
+      }, {
+        F: __dxlog_file3,
+        L: 430,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }).pipe(Effect5.orDie));
+    _define_property4(this, "getCurrentTime", () => {
+      if (this.timeControl === "natural") {
+        return /* @__PURE__ */ new Date();
+      } else {
+        return new Date(this._internalTime);
+      }
+    });
+    _define_property4(this, "refreshTriggers", () => Effect5.gen(this, function* () {
+      const triggers = yield* this._fetchTriggers();
+      const currentTriggerIds = new Set(triggers.map((t) => t.id));
+      for (const triggerId of this._scheduledTriggers.keys()) {
+        if (!currentTriggerIds.has(triggerId)) {
+          this._scheduledTriggers.delete(triggerId);
+        }
+      }
+      for (const trigger of triggers) {
+        if (trigger.spec?.kind === "timer" && trigger.enabled) {
+          const timerSpec = trigger.spec;
+          const cronEither = Cron.parse(timerSpec.cron);
+          if (Either.isRight(cronEither)) {
+            const cron = cronEither.right;
+            const existing = this._scheduledTriggers.get(trigger.id);
+            const now = this.getCurrentTime();
+            const nextExecution = existing?.nextExecution ?? Cron.next(cron, now);
+            log3("Updated scheduled trigger", {
+              triggerId: trigger.id,
+              cron: timerSpec.cron,
+              nextExecution,
+              now
+            }, {
+              F: __dxlog_file3,
+              L: 470,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+            this._scheduledTriggers.set(trigger.id, {
+              trigger,
+              cron,
+              nextExecution
+            });
+          } else {
+            log3.error("Invalid cron expression", {
+              triggerId: trigger.id,
+              cron: timerSpec.cron,
+              error: cronEither.left.message
+            }, {
+              F: __dxlog_file3,
+              L: 482,
+              S: this,
+              C: (f, a) => f(...a)
+            });
+          }
+        }
+      }
+      log3("Updated scheduled triggers", {
+        count: this._scheduledTriggers.size
+      }, {
+        F: __dxlog_file3,
+        L: 491,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    }).pipe(Effect5.withSpan("TriggerDispatcher.refreshTriggers")));
+    _define_property4(this, "_fetchTriggers", () => Effect5.gen(this, function* () {
+      const { objects } = yield* DatabaseService.runQuery(Filter.type(FunctionTrigger));
+      return objects;
+    }).pipe(Effect5.withSpan("TriggerDispatcher.fetchTriggers")));
+    _define_property4(this, "_startNaturalTimeProcessing", () => Effect5.gen(this, function* () {
+      yield* this.invokeScheduledTriggers();
+    }).pipe(Effect5.repeat(Schedule.fixed(this.livePollInterval)), Effect5.asVoid));
+    _define_property4(this, "_prepareInputData", (trigger, event) => {
+      return createInvocationPayload(trigger, event);
+    });
+    this.timeControl = options.timeControl;
+    this.livePollInterval = options.livePollInterval ?? Duration.seconds(1);
+    this._internalTime = options.startingTime ?? /* @__PURE__ */ new Date();
+  }
 };
+var KEY_QUEUE_CURSOR = "dxos.org/key/local-trigger-dispatcher/queue-cursor";
 
-// packages/core/functions/src/executor/executor.ts
-import { Effect, Schema as Schema5 } from "effect";
-var FunctionExecutor = class {
-  constructor(_services) {
-    this._services = _services;
+// src/executor/executor.ts
+import { Effect as Effect6, Schema as Schema7 } from "effect";
+import { runAndForwardErrors } from "@dxos/effect";
+function _define_property5(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
   }
+  return obj;
+}
+var FunctionExecutor = class {
+  /**
+  * Invoke function.
+  */
   // TODO(dmaretskyi): Invocation context: queue, space, etc...
-  async invoke(fnDef, input) {
-    const assertInput = fnDef.inputSchema.pipe(Schema5.asserts);
+  async invoke(functionDef, input) {
+    const assertInput = functionDef.inputSchema.pipe(Schema7.asserts);
     assertInput(input);
     const context = {
+      space: void 0,
       getService: this._services.getService.bind(this._services),
       getSpace: async (_spaceId) => {
         throw new Error("Not available. Use the database service instead.");
-      },
-      space: void 0,
-      get ai() {
-        throw new Error("Not available. Use the ai service instead.");
       }
     };
-    const result = await fnDef.handler({
+    const result = functionDef.handler({
       context,
       data: input
     });
-    const assertOutput = fnDef.outputSchema?.pipe(Schema5.asserts);
-    assertOutput(result);
-    if (Effect.isEffect(result)) {
-      return Effect.runPromise(result);
+    let data;
+    if (Effect6.isEffect(result)) {
+      data = await result.pipe(Effect6.provide(this._services.createLayer()), runAndForwardErrors);
+    } else {
+      data = await result;
     }
-    return result;
+    const assertOutput = functionDef.outputSchema?.pipe(Schema7.asserts);
+    assertOutput(data);
+    return data;
+  }
+  constructor(_services) {
+    _define_property5(this, "_services", void 0);
+    this._services = _services;
   }
 };
+
+// src/examples/index.ts
+var examples_exports = {};
+__export(examples_exports, {
+  fib: () => fib_default,
+  reply: () => reply_default,
+  sleep: () => sleep_default
+});
+
+// src/examples/fib.ts
+import { Effect as Effect7, Schema as Schema8 } from "effect";
+var fib_default = defineFunction({
+  name: "example.org/function/fib",
+  description: "Function that calculates a Fibonacci number",
+  inputSchema: Schema8.Struct({
+    iterations: Schema8.optional(Schema8.Number).annotations({
+      description: "Number of iterations",
+      default: 1e5
+    })
+  }),
+  outputSchema: Schema8.Struct({
+    result: Schema8.String
+  }),
+  handler: Effect7.fn(function* ({ data: { iterations = 1e5 } }) {
+    let a = 0n;
+    let b = 1n;
+    for (let i = 0; i < iterations; i++) {
+      a += b;
+      b = a - b;
+    }
+    return {
+      result: a.toString()
+    };
+  })
+});
+
+// src/examples/reply.ts
+import { Console, Effect as Effect8, Schema as Schema9 } from "effect";
+var reply_default = defineFunction({
+  name: "example.org/function/reply",
+  description: "Function that echoes the input",
+  inputSchema: Schema9.Any,
+  outputSchema: Schema9.Any,
+  handler: Effect8.fn(function* ({ data }) {
+    yield* Console.log("reply", {
+      data
+    });
+    return data;
+  })
+});
+
+// src/examples/sleep.ts
+import { Effect as Effect9, Schema as Schema10 } from "effect";
+var sleep_default = defineFunction({
+  name: "example.org/function/sleep",
+  description: "Function that sleeps for a given amount of time",
+  inputSchema: Schema10.Struct({
+    duration: Schema10.optional(Schema10.Number).annotations({
+      description: "Milliseconds to sleep",
+      default: 1e5
+    })
+  }),
+  outputSchema: Schema10.Void,
+  handler: Effect9.fn(function* ({ data: { duration = 1e5 } }) {
+    yield* Effect9.sleep(duration);
+  })
+});
 export {
-  AiService,
+  ComputeEvent,
+  ComputeEventLogger,
+  ComputeEventPayload,
   ConfiguredCredentialsService,
+  ContextQueueService,
   CredentialsService,
   DatabaseService,
   EmailTriggerOutput,
-  EventLogger,
+  FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
   FUNCTION_TYPES,
-  FunctionCallService,
+  FunctionDefinition,
+  FunctionError,
   FunctionExecutor,
+  FunctionImplementationResolver,
   FunctionManifestSchema,
+  FunctionNotFoundError,
   FunctionTrigger,
-  FunctionTriggerSchema,
   FunctionType,
   InvocationOutcome,
   InvocationTraceEndEvent,
   InvocationTraceEventType,
   InvocationTraceStartEvent,
+  InvocationTracer,
+  LocalFunctionExecutionService,
+  MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
   QueueTriggerOutput,
+  RemoteFunctionExecutionService,
   SERVICE_TAGS,
   ScriptType,
   ServiceContainer,
+  ServiceNotAvailableError,
   SubscriptionTriggerOutput,
   TimerTriggerOutput,
   TraceEvent,
   TraceEventException,
   TraceEventLog,
   TracingService,
-  TriggerKind,
+  TriggerDispatcher,
+  TriggerKinds,
   TriggerSchema,
+  TriggerState,
+  TriggerStateNotFoundError,
+  TriggerStateStore,
   WebhookTriggerOutput,
   createDefectLogger,
   createEventLogger,
   createInvocationSpans,
   defineFunction,
+  deserializeFunction,
+  examples_exports as exampleFunctions,
   getInvocationUrl,
-  getUserFunctionUrlInMetadata,
+  getUserFunctionIdInMetadata,
   logCustomEvent,
-  makeFunctionUrl,
-  setUserFunctionUrlInMetadata
+  serializeFunction,
+  setUserFunctionIdInMetadata,
+  withAuthorization
 };
 //# sourceMappingURL=index.mjs.map