@dxos/functions 0.8.4-main.a4bbb77 → 0.8.4-main.abd8ff62ef

package/dist/lib/browser/index.mjs

@@ -1,1366 +0,0 @@
-import {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
-  ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  DatabaseService,
-  FUNCTIONS_META_KEY,
-  FUNCTIONS_PRESET_META_KEY,
-  FunctionError,
-  FunctionNotFoundError,
-  MESSAGE_PROPERTY_TOOL_CALL_ID,
-  QueueService,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
-  ServiceContainer,
-  ServiceNotAvailableError,
-  TracingService,
-  TriggerStateNotFoundError,
-  createDefectLogger,
-  createEventLogger,
-  getInvocationUrl,
-  getUserFunctionIdInMetadata,
-  logCustomEvent,
-  setUserFunctionIdInMetadata,
-  withAuthorization
-} from "./chunk-C2Z7LCJ2.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/handler.ts
-import { Effect, Schema as Schema2 } from "effect";
-import { Obj, Type as Type2 } from "@dxos/echo";
-import { assertArgument } from "@dxos/invariant";
-
-// 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 = 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: Schema.optional(Schema.Boolean),
-  source: Ref(DataType.Text)
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Script",
-  version: "0.1.0"
-}), LabelAnnotation.set([
-  "name"
-]));
-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: 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: Schema.optional(Ref(ScriptType)),
-  inputSchema: Schema.optional(JsonSchemaType),
-  outputSchema: Schema.optional(JsonSchemaType),
-  // Local binding to a function name.
-  binding: Schema.optional(Schema.String)
-}).pipe(Type.Obj({
-  typename: "dxos.org/type/Function",
-  version: "0.1.0"
-}), LabelAnnotation.set([
-  "name"
-]));
-
-// 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,
-    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) => {
-  const fn = Obj.make(FunctionType, {
-    key: functionDef.key,
-    name: functionDef.name,
-    version: "0.1.0",
-    description: functionDef.description,
-    inputSchema: Type2.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? void 0 : Type2.toJsonSchema(functionDef.outputSchema)
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    setUserFunctionIdInMetadata(Obj.getMeta(fn), functionDef.meta.deployedFunctionId);
-  }
-  return fn;
-};
-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: () => {
-    },
-    meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj))
-    }
-  };
-};
-
-// src/trace.ts
-import { Schema as Schema4 } from "effect";
-import { Type as Type4 } from "@dxos/echo";
-import { Queue } from "@dxos/echo-db";
-import { ObjectId } from "@dxos/echo-schema";
-import { log } from "@dxos/log";
-
-// src/types.ts
-import { Schema as Schema3, SchemaAST } from "effect";
-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 TriggerKinds = [
-  "timer",
-  "webhook",
-  "subscription",
-  "email",
-  "queue"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var TimerTriggerSchema = Schema3.Struct({
-  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema3.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-}).pipe(Schema3.mutable);
-var EmailTriggerSchema = Schema3.Struct({
-  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
-}).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({
-  kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema3.optional(Schema3.String.annotations({
-    title: "Method",
-    [OptionsAnnotationId]: [
-      "GET",
-      "POST"
-    ]
-  })),
-  port: Schema3.optional(Schema3.Number.annotations({
-    title: "Port"
-  }))
-}).pipe(Schema3.mutable);
-var SubscriptionTriggerSchema = Schema3.Struct({
-  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: QueryAST.Query.annotations({
-    title: "Query"
-  }),
-  options: Schema3.optional(Schema3.Struct({
-    // Watch changes to object (not just creation).
-    deep: Schema3.optional(Schema3.Boolean.annotations({
-      title: "Nested"
-    })),
-    // Debounce changes (delay in ms).
-    delay: Schema3.optional(Schema3.Number.annotations({
-      title: "Delay"
-    }))
-  }).annotations({
-    title: "Options"
-  }))
-}).pipe(Schema3.mutable);
-var TriggerSchema = Schema3.Union(TimerTriggerSchema, WebhookTriggerSchema, SubscriptionTriggerSchema, EmailTriggerSchema, QueueTriggerSchema).annotations({
-  title: "Trigger"
-});
-var EmailTriggerOutput = Schema3.mutable(Schema3.Struct({
-  from: Schema3.String,
-  to: Schema3.String,
-  subject: Schema3.String,
-  created: Schema3.String,
-  body: Schema3.String
-}));
-var WebhookTriggerOutput = Schema3.mutable(Schema3.Struct({
-  url: Schema3.String,
-  method: Schema3.Literal("GET", "POST"),
-  headers: Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.String
-  }),
-  bodyText: Schema3.String
-}));
-var QueueTriggerOutput = Schema3.mutable(Schema3.Struct({
-  queue: DXN.Schema,
-  item: Schema3.Any,
-  cursor: Schema3.String
-}));
-var SubscriptionTriggerOutput = Schema3.Struct({
-  /**
-  * Type of the mutation.
-  */
-  // TODO(dmaretskyi): Specify enum.
-  type: 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 FunctionTrigger_ = Schema3.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Ref2(Expando).annotations({
-    title: "Function"
-  })),
-  /**
-  * Only used for workflowSchema.
-  * Specifies the input node in the circuit.
-  * @deprecated Remove and enforce a single input node in all compute graphSchema.
-  */
-  inputNodeId: Schema3.optional(Schema3.String.annotations({
-    title: "Input Node ID"
-  })),
-  enabled: Schema3.optional(Schema3.Boolean.annotations({
-    title: "Enabled"
-  })),
-  spec: Schema3.optional(TriggerSchema),
-  /**
-  * Passed as the input data to the function.
-  * Must match the function's input schema.
-  *
-  * @example
-  * {
-  *   item: '{{$.trigger.event}}',
-  *   instructions: 'Summarize and perform entity-extraction'
-  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-  * }
-  */
-  input: Schema3.optional(Schema3.mutable(Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.Any
-  })))
-}).pipe(Type3.Obj({
-  typename: "dxos.org/type/FunctionTrigger",
-  version: "0.2.0"
-}));
-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))))
-});
-var FUNCTION_TYPES = [
-  FunctionType,
-  FunctionTrigger
-];
-
-// 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) {
-  InvocationTraceEventType2["START"] = "start";
-  InvocationTraceEventType2["END"] = "end";
-  return InvocationTraceEventType2;
-})({});
-var TraceEventException = Schema4.Struct({
-  timestamp: Schema4.Number,
-  message: Schema4.String,
-  name: Schema4.String,
-  stack: Schema4.optional(Schema4.String)
-});
-var InvocationTraceStartEvent = Schema4.Struct({
-  /**
-  * Queue message id.
-  */
-  id: ObjectId,
-  type: Schema4.Literal("start"),
-  /**
-  * Invocation id, the same for invocation start and end events.
-  */
-  invocationId: ObjectId,
-  /**
-  * Event generation time.
-  */
-  timestamp: Schema4.Number,
-  /**
-  * Data passed to function / workflow as an argument.
-  */
-  // TODO(burdon): Input schema?
-  input: Schema4.Object,
-  /**
-  * Queue  for function/workflow invocation events.
-  */
-  invocationTraceQueue: Schema4.optional(Type4.Ref(Queue)),
-  /**
-  * DXN of the invoked function/workflow.
-  */
-  invocationTarget: Schema4.optional(Type4.Ref(Type4.Expando)),
-  /**
-  * Present for automatic invocations.
-  */
-  trigger: Schema4.optional(Type4.Ref(FunctionTrigger))
-}).pipe(Type4.Obj({
-  typename: "dxos.org/type/InvocationTraceStart",
-  version: "0.1.0"
-}));
-var InvocationTraceEndEvent = Schema4.Struct({
-  /**
-  * Trace event id.
-  */
-  id: ObjectId,
-  type: Schema4.Literal("end"),
-  /**
-  * Invocation id, will be the same for invocation start and end.
-  */
-  invocationId: ObjectId,
-  /**
-  * Event generation time.
-  */
-  // TODO(burdon): Remove ms suffix.
-  timestamp: Schema4.Number,
-  outcome: Schema4.Enums(InvocationOutcome),
-  exception: Schema4.optional(TraceEventException)
-}).pipe(Type4.Obj({
-  typename: "dxos.org/type/InvocationTraceEnd",
-  version: "0.1.0"
-}));
-var TraceEventLog = Schema4.Struct({
-  timestamp: Schema4.Number,
-  level: Schema4.String,
-  message: Schema4.String,
-  context: Schema4.optional(Schema4.Object)
-});
-var TraceEvent = Schema4.Struct({
-  id: ObjectId,
-  // TODO(burdon): Need enum/numeric result (not string).
-  outcome: Schema4.String,
-  truncated: Schema4.Boolean,
-  /** Time when the event was persisted. */
-  ingestionTimestamp: Schema4.Number,
-  logs: Schema4.Array(TraceEventLog),
-  exceptions: Schema4.Array(TraceEventException)
-}).pipe(Type4.Obj({
-  typename: "dxos.org/type/TraceEvent",
-  version: "0.1.0"
-}));
-var createInvocationSpans = (items) => {
-  if (!items) {
-    return [];
-  }
-  const eventsByInvocationId = /* @__PURE__ */ new Map();
-  for (const event of items) {
-    if (!("invocationId" in event)) {
-      continue;
-    }
-    const invocationId = event.invocationId;
-    const entry = eventsByInvocationId.get(invocationId) || {
-      start: void 0,
-      end: void 0
-    };
-    if (event.type === "start") {
-      entry.start = event;
-    } else if (event.type === "end") {
-      entry.end = event;
-    }
-    eventsByInvocationId.set(invocationId, entry);
-  }
-  const now = Date.now();
-  const result = [];
-  for (const [invocationId, { start, end }] of eventsByInvocationId.entries()) {
-    if (!start) {
-      log.warn("found end event without matching start", {
-        invocationId
-      }, {
-        F: __dxlog_file,
-        L: 158,
-        S: void 0,
-        C: (f, a) => f(...a)
-      });
-      continue;
-    }
-    const isInProgress = end === void 0;
-    result.push({
-      id: invocationId,
-      timestamp: start.timestamp,
-      duration: isInProgress ? now - start.timestamp : end.timestamp - start.timestamp,
-      outcome: end?.outcome ?? "pending",
-      exception: end?.exception,
-      input: start.input,
-      invocationTraceQueue: start.invocationTraceQueue,
-      invocationTarget: start.invocationTarget,
-      trigger: start.trigger
-    });
-  }
-  return result;
-};
-
-// src/triggers/invocation-tracer.ts
-import { Context as Context3, Effect as Effect4, Layer as Layer3 } from "effect";
-import { Obj as Obj3, Ref as Ref3 } from "@dxos/echo";
-import { DXN as DXN2, ObjectId as ObjectId2 } from "@dxos/keys";
-
-// src/services/function-invocation-service.ts
-import { Context as Context2, Effect as Effect3, Layer as Layer2 } from "effect";
-import { AiService as AiService2 } from "@dxos/ai";
-
-// src/services/local-function-execution.ts
-import { Context, Effect as Effect2, Layer, Schema as Schema5 } from "effect";
-import { AiService } from "@dxos/ai";
-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")()) {
-};
-_define_property(LocalFunctionExecutionService, "layerLive", Layer.effect(LocalFunctionExecutionService, Effect2.gen(function* () {
-  const resolver = yield* FunctionImplementationResolver;
-  const ai = yield* AiService.AiService;
-  const credentials = yield* CredentialsService;
-  const database = yield* DatabaseService;
-  const queues = yield* QueueService;
-  const functionCallService = yield* RemoteFunctionExecutionService;
-  return {
-    // TODO(dmaretskyi): Better error types.
-    invokeFunction: (functionDef, input) => Effect2.gen(function* () {
-      const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect2.orDie);
-      const output = yield* invokeFunction(resolved, input);
-      return output;
-    }).pipe(Effect2.provideService(AiService.AiService, ai), Effect2.provideService(CredentialsService, credentials), Effect2.provideService(DatabaseService, database), Effect2.provideService(QueueService, queues), Effect2.provideService(RemoteFunctionExecutionService, functionCallService))
-  };
-})));
-_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: 95,
-    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: 119,
-    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")()) {
-};
-_define_property(FunctionImplementationResolver, "layerTest", ({ functions }) => Layer.succeed(FunctionImplementationResolver, {
-  resolveFunctionImplementation: (functionDef) => {
-    const resolved = functions.find((f) => f.key === functionDef.key);
-    if (!resolved) {
-      return Effect2.fail(new FunctionNotFoundError(functionDef.name));
-    }
-    return Effect2.succeed(resolved);
-  }
-}));
-
-// src/services/function-invocation-service.ts
-function _define_property2(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 _Context_Tag2;
-var FunctionInvocationService = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/FunctionInvocationService")()) {
-};
-_define_property2(FunctionInvocationService, "invokeFunction", Effect3.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction));
-_define_property2(FunctionInvocationService, "layer", Layer2.effect(FunctionInvocationService, Effect3.gen(function* () {
-  const localExecutioner = yield* LocalFunctionExecutionService;
-  const remoteExecutioner = yield* RemoteFunctionExecutionService;
-  return {
-    invokeFunction: (functionDef, input) => Effect3.gen(function* () {
-      if (functionDef.meta?.deployedFunctionId) {
-        return yield* remoteExecutioner.callFunction(functionDef.meta.deployedFunctionId, input);
-      }
-      return yield* localExecutioner.invokeFunction(functionDef, input);
-    })
-  };
-})));
-_define_property2(FunctionInvocationService, "layerTest", ({ functions = [] } = {}) => FunctionInvocationService.layer.pipe(Layer2.provide(LocalFunctionExecutionService.layerLive), Layer2.provide(FunctionImplementationResolver.layerTest({
-  functions
-})), Layer2.provide(RemoteFunctionExecutionService.layerMock)));
-_define_property2(FunctionInvocationService, "layerTestMocked", ({ functions }) => FunctionInvocationService.layerTest({
-  functions
-}).pipe(Layer2.provide(AiService2.notAvailable), Layer2.provide(CredentialsService.configuredLayer([])), Layer2.provide(DatabaseService.notAvailable), Layer2.provide(QueueService.notAvailable)));
-
-// src/triggers/invocation-tracer.ts
-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 _Context_Tag3;
-var InvocationTracer = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/InvocationTracer")()) {
-};
-_define_property3(InvocationTracer, "layerLive", (opts) => Layer3.effect(InvocationTracer, Effect4.gen(function* () {
-  return {
-    traceInvocationStart: Effect4.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: Effect4.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_property3(InvocationTracer, "layerTest", Layer3.unwrapEffect(Effect4.gen(function* () {
-  const queue = yield* QueueService.createQueue({
-    subspaceTag: "trace"
-  });
-  return InvocationTracer.layerLive({
-    invocationTraceQueue: queue
-  });
-})));
-
-// src/triggers/trigger-dispatcher.ts
-import { Cause, Context as Context5, Cron, Duration, Effect as Effect6, Either, Exit, Fiber, Layer as Layer5, 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 Context4 } from "effect";
-import { Schema as Schema6 } from "effect";
-import { Effect as Effect5, Layer as Layer4 } from "effect";
-import { Option } from "effect";
-import { ObjectId as ObjectId3 } from "@dxos/keys";
-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 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_Tag4;
-var TriggerStateStore = class extends (_Context_Tag4 = Context4.Tag("@dxos/functions/TriggerStateStore")()) {
-};
-_define_property4(TriggerStateStore, "getState", Effect5.serviceFunctionEffect(TriggerStateStore, (_) => _.getState));
-_define_property4(TriggerStateStore, "saveState", Effect5.serviceFunctionEffect(TriggerStateStore, (_) => _.saveState));
-_define_property4(TriggerStateStore, "layerKv", Layer4.effect(TriggerStateStore, Effect5.gen(function* () {
-  const kv = yield* KeyValueStore.KeyValueStore;
-  const schemaStore = kv.forSchema(Schema6.parseJson(TriggerState));
-  const store = {
-    getState: Effect5.fn("TriggerStateStore.getState")(function* (triggerId) {
-      const valueOption = yield* schemaStore.get(triggerId).pipe(Effect5.orDie);
-      if (Option.isNone(valueOption)) {
-        return yield* Effect5.fail(new TriggerStateNotFoundError());
-      }
-      return valueOption.value;
-    }),
-    saveState: Effect5.fn("TriggerStateStore.saveState")(function* (state) {
-      yield* schemaStore.set(state.triggerId, state).pipe(Effect5.orDie);
-    })
-  };
-  return store;
-})));
-_define_property4(TriggerStateStore, "layerMemory", TriggerStateStore.layerKv.pipe(Layer4.provide(KeyValueStore.layerMemory)));
-
-// src/triggers/trigger-dispatcher.ts
-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 __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/triggers/trigger-dispatcher.ts";
-var _Context_Tag5;
-var TriggerDispatcher = class extends (_Context_Tag5 = Context5.Tag("@dxos/functions/TriggerDispatcher")()) {
-};
-_define_property5(TriggerDispatcher, "layer", (options) => Layer5.effect(TriggerDispatcher, Effect6.gen(function* () {
-  return new TriggerDispatcherImpl(options);
-})));
-var TriggerDispatcherImpl = class {
-  get running() {
-    return this._running;
-  }
-  constructor(options) {
-    _define_property5(this, "livePollInterval", void 0);
-    _define_property5(this, "timeControl", void 0);
-    _define_property5(this, "_running", false);
-    _define_property5(this, "_internalTime", void 0);
-    _define_property5(this, "_timerFiber", void 0);
-    _define_property5(this, "_scheduledTriggers", /* @__PURE__ */ new Map());
-    _define_property5(this, "start", () => Effect6.gen(this, function* () {
-      if (this._running) {
-        return;
-      }
-      this._running = true;
-      if (this.timeControl === "natural") {
-        this._timerFiber = yield* this._startNaturalTimeProcessing().pipe(Effect6.tapErrorCause((cause) => {
-          const error = causeToError(cause);
-          log3.error("trigger dispatcher error", {
-            error
-          }, {
-            F: __dxlog_file3,
-            L: 176,
-            S: this,
-            C: (f, a) => f(...a)
-          });
-          this._running = false;
-          return Effect6.void;
-        }), Effect6.forkDaemon);
-      } else {
-        return yield* Effect6.dieMessage("TriggerDispatcher started in manual time control mode");
-      }
-      log3.info("TriggerDispatcher started", {
-        timeControl: this.timeControl
-      }, {
-        F: __dxlog_file3,
-        L: 186,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }));
-    _define_property5(this, "stop", () => Effect6.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: 206,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }));
-    _define_property5(this, "invokeTrigger", (options2) => Effect6.gen(this, function* () {
-      const { trigger, event } = options2;
-      log3.info("running trigger", {
-        triggerId: trigger.id,
-        spec: trigger.spec,
-        event
-      }, {
-        F: __dxlog_file3,
-        L: 214,
-        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* Effect6.gen(this, function* () {
-        if (!trigger.enabled) {
-          return yield* Effect6.dieMessage("Attempting to invoke disabled trigger");
-        }
-        if (!trigger.function) {
-          return yield* Effect6.dieMessage("Trigger has no function reference");
-        }
-        const serialiedFunction = yield* DatabaseService.load(trigger.function).pipe(Effect6.orDie);
-        invariant(Obj4.instanceOf(FunctionType, serialiedFunction), void 0, {
-          F: __dxlog_file3,
-          L: 241,
-          S: this,
-          A: [
-            "Obj.instanceOf(FunctionType, serialiedFunction)",
-            ""
-          ]
-        });
-        const functionDef = deserializeFunction(serialiedFunction);
-        const inputData = this._prepareInputData(trigger, event);
-        return yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(Effect6.provide(ComputeEventLogger.layerFromTracing.pipe(Layer5.provideMerge(TracingService.layerQueue(trace.invocationTraceQueue)))));
-      }).pipe(Effect6.exit);
-      const triggerExecutionResult = {
-        triggerId: trigger.id,
-        result
-      };
-      if (Exit.isSuccess(result)) {
-        log3.info("trigger execution success", {
-          triggerId: trigger.id
-        }, {
-          F: __dxlog_file3,
-          L: 262,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      } else {
-        log3.error("trigger execution failure", {
-          error: causeToError(result.cause)
-        }, {
-          F: __dxlog_file3,
-          L: 266,
-          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_property5(this, "invokeScheduledTriggers", ({ kinds = [
-      "timer",
-      "queue",
-      "subscription"
-    ] } = {}) => Effect6.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* Effect6.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* Effect6.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(Effect6.catchTag("TRIGGER_STATE_NOT_FOUND", () => Effect6.succeed({
-                version: "1",
-                triggerId: trigger.id,
-                state: {
-                  _tag: "subscription",
-                  processedVersions: {}
-                }
-              })));
-              invariant(state.state?._tag === "subscription", void 0, {
-                F: __dxlog_file3,
-                L: 379,
-                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* Effect6.dieMessage(`Unknown trigger kind: ${kind}`);
-          }
-        }
-      }
-      return invocations;
-    }));
-    _define_property5(this, "advanceTime", (duration) => Effect6.gen(this, function* () {
-      if (this.timeControl !== "manual") {
-        return yield* Effect6.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: 436,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }).pipe(Effect6.orDie));
-    _define_property5(this, "getCurrentTime", () => {
-      if (this.timeControl === "natural") {
-        return /* @__PURE__ */ new Date();
-      } else {
-        return new Date(this._internalTime);
-      }
-    });
-    _define_property5(this, "refreshTriggers", () => Effect6.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: 476,
-              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: 488,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-        }
-      }
-      log3("Updated scheduled triggers", {
-        count: this._scheduledTriggers.size
-      }, {
-        F: __dxlog_file3,
-        L: 497,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }).pipe(Effect6.withSpan("TriggerDispatcher.refreshTriggers")));
-    _define_property5(this, "_fetchTriggers", () => Effect6.gen(this, function* () {
-      const { objects } = yield* DatabaseService.runQuery(Filter.type(FunctionTrigger));
-      return objects;
-    }).pipe(Effect6.withSpan("TriggerDispatcher.fetchTriggers")));
-    _define_property5(this, "_startNaturalTimeProcessing", () => Effect6.gen(this, function* () {
-      yield* this.invokeScheduledTriggers();
-    }).pipe(Effect6.repeat(Schedule.fixed(this.livePollInterval)), Effect6.asVoid));
-    _define_property5(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";
-
-// src/executor/executor.ts
-import { Effect as Effect7, Schema as Schema7 } from "effect";
-import { runAndForwardErrors } from "@dxos/effect";
-function _define_property6(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(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.");
-      }
-    };
-    const result = functionDef.handler({
-      context,
-      data: input
-    });
-    let data;
-    if (Effect7.isEffect(result)) {
-      data = await result.pipe(Effect7.provide(this._services.createLayer()), runAndForwardErrors);
-    } else {
-      data = await result;
-    }
-    const assertOutput = functionDef.outputSchema?.pipe(Schema7.asserts);
-    assertOutput(data);
-    return data;
-  }
-  constructor(_services) {
-    _define_property6(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 Effect8, Schema as Schema8 } from "effect";
-var fib_default = defineFunction({
-  key: "example.org/function/fib",
-  name: "Fibonacci",
-  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: Effect8.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 Effect9, Schema as Schema9 } from "effect";
-var reply_default = defineFunction({
-  key: "example.org/function/reply",
-  name: "Reply",
-  description: "Function that echoes the input",
-  inputSchema: Schema9.Any,
-  outputSchema: Schema9.Any,
-  handler: Effect9.fn(function* ({ data }) {
-    yield* Console.log("reply", {
-      data
-    });
-    return data;
-  })
-});
-
-// src/examples/sleep.ts
-import { Effect as Effect10, Schema as Schema10 } from "effect";
-var sleep_default = defineFunction({
-  key: "example.org/function/sleep",
-  name: "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: Effect10.fn(function* ({ data: { duration = 1e5 } }) {
-    yield* Effect10.sleep(duration);
-  })
-});
-export {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
-  ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  DatabaseService,
-  EmailTriggerOutput,
-  FUNCTIONS_META_KEY,
-  FUNCTIONS_PRESET_META_KEY,
-  FUNCTION_TYPES,
-  FunctionDefinition,
-  FunctionError,
-  FunctionExecutor,
-  FunctionImplementationResolver,
-  FunctionInvocationService,
-  FunctionManifestSchema,
-  FunctionNotFoundError,
-  FunctionTrigger,
-  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,
-  TriggerDispatcher,
-  TriggerKinds,
-  TriggerSchema,
-  TriggerState,
-  TriggerStateNotFoundError,
-  TriggerStateStore,
-  WebhookTriggerOutput,
-  createDefectLogger,
-  createEventLogger,
-  createInvocationSpans,
-  defineFunction,
-  deserializeFunction,
-  examples_exports as exampleFunctions,
-  getInvocationUrl,
-  getUserFunctionIdInMetadata,
-  logCustomEvent,
-  serializeFunction,
-  setUserFunctionIdInMetadata,
-  withAuthorization
-};
-//# sourceMappingURL=index.mjs.map