@dxos/functions 0.8.4-main.e098934 → 0.8.4-main.e8ec1fe

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

@@ -1,31 +1,9 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
-import {
-  ComputeEvent,
-  ComputeEventLogger,
-  ComputeEventPayload,
-  ConfiguredCredentialsService,
-  ContextQueueService,
-  CredentialsService,
-  DatabaseService,
-  FUNCTIONS_META_KEY,
-  FUNCTIONS_PRESET_META_KEY,
-  MESSAGE_PROPERTY_TOOL_CALL_ID,
-  QueueService,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
-  ServiceContainer,
-  TracingService,
-  createDefectLogger,
-  createEventLogger,
-  getInvocationUrl,
-  getUserFunctionIdInMetadata,
-  logCustomEvent,
-  setUserFunctionIdInMetadata,
-  withAuthorization
-} from "./chunk-Z4CJ62WS.mjs";
-import {
-  __export
-} from "./chunk-HSLMI22Q.mjs";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 
 // src/errors.ts
 import { BaseError } from "@dxos/errors";
@@ -54,30 +32,56 @@ var FunctionError = class extends BaseError.extend("FUNCTION_ERROR", "Function i
 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";
+// src/example/fib.ts
+import * as Effect2 from "effect/Effect";
+import * as Schema6 from "effect/Schema";
 
-// 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),
+// src/sdk.ts
+import * as Effect from "effect/Effect";
+import * as Schema5 from "effect/Schema";
+import { Obj as Obj5, Type as Type5 } from "@dxos/echo";
+import { assertArgument, failedInvariant } from "@dxos/invariant";
+
+// src/types/Function.ts
+var Function_exports = {};
+__export(Function_exports, {
+  Function: () => Function,
+  make: () => make2
+});
+import * as Schema2 from "effect/Schema";
+import { Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import { JsonSchemaType, LabelAnnotation as LabelAnnotation2, Ref as Ref2 } from "@dxos/echo/internal";
+
+// src/types/Script.ts
+var Script_exports = {};
+__export(Script_exports, {
+  Script: () => Script,
+  make: () => make
+});
+import * as Schema from "effect/Schema";
+import { Obj, Ref, Type } from "@dxos/echo";
+import { FormAnnotation, LabelAnnotation } from "@dxos/echo/internal";
+import { Text } from "@dxos/schema";
+var Script = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional),
+  description: Schema.String.pipe(Schema.optional),
   // TODO(burdon): Change to hash of deployed content.
   // Whether source has changed since last deploy.
-  changed: Schema.optional(Schema.Boolean),
-  source: Ref(DataType.Text)
+  changed: Schema.Boolean.pipe(FormAnnotation.set(false), Schema.optional),
+  source: Type.Ref(Text.Text).pipe(FormAnnotation.set(false))
 }).pipe(Type.Obj({
   typename: "dxos.org/type/Script",
   version: "0.1.0"
 }), LabelAnnotation.set([
   "name"
 ]));
-var FunctionType = Schema.Struct({
+var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
+  ...props,
+  source: Ref.make(Text.make(source))
+});
+
+// src/types/Function.ts
+var Function = Schema2.Struct({
   /**
   * Global registry ID.
   * NOTE: The `key` property refers to the original registry entry.
@@ -85,165 +89,81 @@ var FunctionType = Schema.Struct({
   // 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({
+  key: Schema2.optional(Schema2.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),
+  name: Schema2.NonEmptyString,
+  version: Schema2.String,
+  description: Schema2.optional(Schema2.String),
+  /**
+  * ISO date string of the last deployment.
+  */
+  updated: Schema2.optional(Schema2.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),
+  source: Schema2.optional(Ref2(Script)),
+  inputSchema: Schema2.optional(JsonSchemaType),
+  outputSchema: Schema2.optional(JsonSchemaType),
+  /**
+  * List of required services.
+  * Match the Context.Tag keys of the FunctionServices variants.
+  */
+  services: Schema2.optional(Schema2.Array(Schema2.String)),
   // Local binding to a function name.
-  binding: Schema.optional(Schema.String)
-}).pipe(Type.Obj({
+  binding: Schema2.optional(Schema2.String)
+}).pipe(Type2.Obj({
   typename: "dxos.org/type/Function",
   version: "0.1.0"
-}), LabelAnnotation.set([
+}), LabelAnnotation2.set([
   "name"
 ]));
+var make2 = (props) => Obj2.make(Function, props);
 
-// 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)
+// src/types/Trigger.ts
+var Trigger_exports = {};
+__export(Trigger_exports, {
+  EmailSpec: () => EmailSpec,
+  Kinds: () => Kinds,
+  QueueSpec: () => QueueSpec,
+  Spec: () => Spec,
+  SubscriptionSpec: () => SubscriptionSpec,
+  TimerSpec: () => TimerSpec,
+  Trigger: () => Trigger,
+  WebhookSpec: () => WebhookSpec,
+  make: () => make3
 });
-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),
-    handler: () => {
-    }
-  };
-};
-
-// 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 { QueryAST, Type as Type3 } from "@dxos/echo";
-import { Expando, OptionsAnnotationId, RawObject, Ref as Ref2 } from "@dxos/echo-schema";
+import * as Schema3 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Obj as Obj3, QueryAST, Type as Type3 } from "@dxos/echo";
+import { Expando, OptionsAnnotationId, Ref as Ref3 } from "@dxos/echo/internal";
 import { DXN } from "@dxos/keys";
-var TriggerKinds = [
-  "timer",
-  "webhook",
-  "subscription",
+var Kinds = [
   "email",
-  "queue"
+  "queue",
+  "subscription",
+  "timer",
+  "webhook"
 ];
 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({
+var EmailSpec = Schema3.Struct({
   kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
 }).pipe(Schema3.mutable);
-var QueueTriggerSchema = Schema3.Struct({
+var QueueSpec = 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({
+var SubscriptionSpec = Schema3.Struct({
   kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: QueryAST.Query.annotations({
-    title: "Query"
-  }),
+  query: Schema3.Struct({
+    raw: Schema3.optional(Schema3.String.annotations({
+      title: "Query"
+    })),
+    ast: QueryAST.Query
+  }).pipe(Schema3.mutable),
   options: Schema3.optional(Schema3.Struct({
     // Watch changes to object (not just creation).
     deep: Schema3.optional(Schema3.Boolean.annotations({
@@ -257,43 +177,37 @@ var SubscriptionTriggerSchema = Schema3.Struct({
     title: "Options"
   }))
 }).pipe(Schema3.mutable);
-var TriggerSchema = Schema3.Union(TimerTriggerSchema, WebhookTriggerSchema, SubscriptionTriggerSchema, EmailTriggerSchema, QueueTriggerSchema).annotations({
+var TimerSpec = Schema3.Struct({
+  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema3.String.annotations({
+    title: "Cron",
+    [SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+}).pipe(Schema3.mutable);
+var WebhookSpec = 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 Spec = Schema3.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).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.mutable(Schema3.Struct({
-  type: Schema3.String,
-  changedObjectId: Schema3.String
-}));
-var TimerTriggerOutput = Schema3.mutable(Schema3.Struct({
-  tick: Schema3.Number
-}));
-var FunctionTrigger_ = Schema3.Struct({
+var Trigger_ = Schema3.Struct({
   /**
   * Function or workflow to invoke.
   */
   // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Ref2(Expando).annotations({
+  function: Schema3.optional(Ref3(Expando).annotations({
     title: "Function"
   })),
   /**
@@ -307,7 +221,7 @@ var FunctionTrigger_ = Schema3.Struct({
   enabled: Schema3.optional(Schema3.Boolean.annotations({
     title: "Enabled"
   })),
-  spec: Schema3.optional(TriggerSchema),
+  spec: Schema3.optional(Spec),
   /**
   * Passed as the input data to the function.
   * Must match the function's input schema.
@@ -324,852 +238,201 @@ var FunctionTrigger_ = Schema3.Struct({
     value: Schema3.Any
   })))
 }).pipe(Type3.Obj({
-  typename: "dxos.org/type/FunctionTrigger",
-  version: "0.2.0"
+  typename: "dxos.org/type/Trigger",
+  version: "0.1.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
-];
+var Trigger = Trigger_;
+var make3 = (props) => Obj3.make(Trigger, props);
 
-// 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)
+// src/types/TriggerEvent.ts
+var TriggerEvent_exports = {};
+__export(TriggerEvent_exports, {
+  EmailEvent: () => EmailEvent,
+  QueueEvent: () => QueueEvent,
+  SubscriptionEvent: () => SubscriptionEvent,
+  TimerEvent: () => TimerEvent,
+  WebhookEvent: () => WebhookEvent
 });
-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"
+import * as Schema4 from "effect/Schema";
+import { DXN as DXN2, Obj as Obj4, Type as Type4 } from "@dxos/echo";
+var EmailEvent = Schema4.mutable(Schema4.Struct({
+  from: Schema4.String,
+  to: Schema4.String,
+  subject: Schema4.String,
+  created: Schema4.String,
+  body: Schema4.String
 }));
-var InvocationTraceEndEvent = Schema4.Struct({
+var QueueEvent = Schema4.mutable(Schema4.Struct({
+  queue: DXN2.Schema,
+  item: Schema4.Any,
+  cursor: Schema4.String
+}));
+var SubscriptionEvent = Schema4.Struct({
   /**
-  * Trace event id.
+  * Type of the mutation.
   */
-  id: ObjectId,
-  type: Schema4.Literal("end"),
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema4.String,
   /**
-  * Invocation id, will be the same for invocation start and end.
+  * Reference to the object that was changed or created.
   */
-  invocationId: ObjectId,
+  subject: Type4.Ref(Obj4.Any),
   /**
-  * Event generation time.
+  * @deprecated
   */
-  // 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"
+  changedObjectId: Schema4.optional(Schema4.String)
+}).pipe(Schema4.mutable);
+var TimerEvent = Schema4.mutable(Schema4.Struct({
+  tick: Schema4.Number
 }));
-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 WebhookEvent = Schema4.mutable(Schema4.Struct({
+  url: Schema4.String,
+  method: Schema4.Literal("GET", "POST"),
+  headers: Schema4.Record({
+    key: Schema4.String,
+    value: Schema4.String
+  }),
+  bodyText: Schema4.String
 }));
-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 Context2, Effect as Effect3, Layer as Layer2 } from "effect";
-import { Obj as Obj2, 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";
-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 _Context_Tag;
-var LocalFunctionExecutionService = class extends (_Context_Tag = Context.Tag("@dxos/functions/LocalFunctionExecutionService")()) {
+// src/types/url.ts
+var FUNCTIONS_META_KEY = "dxos.org/service/function";
+var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
+var getUserFunctionIdInMetadata = (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* () {
-  const assertInput = functionDef.inputSchema.pipe(Schema5.asserts);
-  assertInput(input);
-  const context = {
-    space: void 0,
-    getService: () => todo(),
-    getSpace: async (_spaceId) => {
-      throw new Error("Not available. Use the database service instead.");
+var setUserFunctionIdInMetadata = (meta, functionId) => {
+  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
+  if (key) {
+    if (key.id !== functionId) {
+      throw new Error("Metadata mismatch");
     }
-  };
-  const data = yield* Effect2.gen(function* () {
-    const result = functionDef.handler({
-      context,
-      data: input
+  } else {
+    meta.keys.push({
+      source: FUNCTIONS_META_KEY,
+      id: functionId
     });
-    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
-  }))));
-  const assertOutput = functionDef.outputSchema?.pipe(Schema5.asserts);
-  assertOutput(data);
-  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.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 {
-    obj[key] = value;
+// src/sdk.ts
+var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
+var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, services }) => {
+  if (!Schema5.isSchema(inputSchema)) {
+    throw new Error("Input schema must be a valid schema");
   }
-  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 = Obj2.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 = Obj2.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 Obj3, Query } from "@dxos/echo";
-import { causeToError } from "@dxos/effect";
-import { invariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
-import { KEY_QUEUE_POSITION } from "@dxos/protocols";
-
-// src/triggers/input-builder.ts
-var createInvocationPayload = (trigger, event) => {
-  if (!trigger.input) {
-    return event;
+  if (typeof handler !== "function") {
+    throw new Error("Handler must be a function");
   }
-  const payload = {};
-  for (const [key, value] of Object.entries(trigger.input)) {
-    if (typeof value !== "string" || !(value.startsWith("{{") && value.endsWith("}}"))) {
-      payload[key] = value;
-      continue;
+  const limit = Error.stackTraceLimit;
+  Error.stackTraceLimit = 2;
+  const traceError = new Error();
+  Error.stackTraceLimit = limit;
+  let cache = false;
+  const captureStackTrace = () => {
+    if (cache !== false) {
+      return cache;
     }
-    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];
+    if (traceError.stack !== void 0) {
+      const stack = traceError.stack.split("\n");
+      if (stack[2] !== void 0) {
+        cache = stack[2].trim();
+        return cache;
       }
     }
-    payload[key] = valueSubstitution;
-  }
-  return payload;
+  };
+  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,
+    services: !services ? [] : getServiceKeys(services)
+  };
 };
-
-// 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 getServiceKeys = (services) => {
+  return services.map((tag) => {
+    if (typeof tag.key === "string") {
+      return tag.key;
+    }
+    console.log(tag);
+    failedInvariant();
+  });
 };
-_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;
+var FunctionDefinition = {
+  make: defineFunction,
+  isFunction: (value2) => {
+    return typeof value2 === "object" && value2 !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value2;
+  },
+  serialize: (functionDef) => {
+    assertArgument(FunctionDefinition.isFunction(functionDef), "functionDef");
+    return serializeFunction(functionDef);
+  },
+  deserialize: (functionObj) => {
+    assertArgument(Obj5.instanceOf(Function_exports.Function, functionObj), "functionObj");
+    return deserializeFunction(functionObj);
   }
-  return obj;
-}
-var __dxlog_file2 = "/__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);
-          log2.error("trigger dispatcher error", {
-            error
-          }, {
-            F: __dxlog_file2,
-            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");
-      }
-      log2.info("TriggerDispatcher started", {
-        timeControl: this.timeControl
-      }, {
-        F: __dxlog_file2,
-        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();
-      log2.info("TriggerDispatcher stopped", void 0, {
-        F: __dxlog_file2,
-        L: 200,
-        S: this,
-        C: (f, a) => f(...a)
-      });
-    }));
-    _define_property4(this, "invokeTrigger", (options2) => Effect5.gen(this, function* () {
-      const { trigger, event } = options2;
-      log2.info("running trigger", {
-        triggerId: trigger.id,
-        spec: trigger.spec,
-        event
-      }, {
-        F: __dxlog_file2,
-        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(Obj3.instanceOf(FunctionType, serialiedFunction), void 0, {
-          F: __dxlog_file2,
-          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)) {
-        log2.info("trigger execution success", {
-          triggerId: trigger.id
-        }, {
-          F: __dxlog_file2,
-          L: 256,
-          S: this,
-          C: (f, a) => f(...a)
-        });
-      } else {
-        log2.error("trigger execution failure", {
-          error: causeToError(result.cause)
-        }, {
-          F: __dxlog_file2,
-          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 = Obj3.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 = Obj3.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
-                  }
-                }));
-                Obj3.deleteKeys(trigger, KEY_QUEUE_CURSOR);
-                Obj3.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 = Obj3.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_file2,
-                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(Obj3.decodeVersion));
-                const currentVersion = Obj3.version(object);
-                const run = Option2.isNone(existingVersion) || Obj3.compareVersions(currentVersion, existingVersion.value) === "different";
-                if (!run) {
-                  continue;
-                }
-                invocations.push(yield* this.invokeTrigger({
-                  trigger,
-                  event: {
-                    // TODO(dmaretskyi): Change type not supported.
-                    type: "unknown",
-                    changedObjectId: object.id
-                  }
-                }));
-                state.state.processedVersions[object.id] = Obj3.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);
-      log2("Advanced internal time", {
-        newTime: this._internalTime,
-        advancedBy: Duration.format(duration)
-      }, {
-        F: __dxlog_file2,
-        L: 426,
-        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);
-            log2("Updated scheduled trigger", {
-              triggerId: trigger.id,
-              cron: timerSpec.cron,
-              nextExecution,
-              now
-            }, {
-              F: __dxlog_file2,
-              L: 466,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-            this._scheduledTriggers.set(trigger.id, {
-              trigger,
-              cron,
-              nextExecution
-            });
-          } else {
-            log2.error("Invalid cron expression", {
-              triggerId: trigger.id,
-              cron: timerSpec.cron,
-              error: cronEither.left.message
-            }, {
-              F: __dxlog_file2,
-              L: 478,
-              S: this,
-              C: (f, a) => f(...a)
-            });
-          }
-        }
-      }
-      log2("Updated scheduled triggers", {
-        count: this._scheduledTriggers.size
-      }, {
-        F: __dxlog_file2,
-        L: 487,
-        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 serializeFunction = (functionDef) => {
+  const fn4 = Function_exports.make({
+    key: functionDef.key,
+    name: functionDef.name,
+    version: "0.1.0",
+    description: functionDef.description,
+    inputSchema: Type5.toJsonSchema(functionDef.inputSchema),
+    outputSchema: !functionDef.outputSchema ? void 0 : Type5.toJsonSchema(functionDef.outputSchema),
+    services: functionDef.services
+  });
+  if (functionDef.meta?.deployedFunctionId) {
+    setUserFunctionIdInMetadata(Obj5.getMeta(fn4), functionDef.meta.deployedFunctionId);
   }
+  return fn4;
 };
-var KEY_QUEUE_CURSOR = "dxos.org/key/local-trigger-dispatcher/queue-cursor";
-
-// 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(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 (Effect6.isEffect(result)) {
-      data = await result.pipe(Effect6.provide(this._services.createLayer()), runAndForwardErrors);
-    } else {
-      data = await result;
+var deserializeFunction = (functionObj) => {
+  return {
+    [typeId]: true,
+    // TODO(dmaretskyi): Fix key.
+    key: functionObj.key ?? functionObj.name,
+    name: functionObj.name,
+    description: functionObj.description,
+    inputSchema: !functionObj.inputSchema ? Schema5.Unknown : Type5.toEffectSchema(functionObj.inputSchema),
+    outputSchema: !functionObj.outputSchema ? void 0 : Type5.toEffectSchema(functionObj.outputSchema),
+    // TODO(dmaretskyi): This should throw error.
+    handler: () => {
+    },
+    services: functionObj.services ?? [],
+    meta: {
+      deployedFunctionId: getUserFunctionIdInMetadata(Obj5.getMeta(functionObj))
     }
-    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";
+// src/example/fib.ts
 var fib_default = defineFunction({
-  name: "example.org/function/fib",
+  key: "example.org/function/fib",
+  name: "Fibonacci",
   description: "Function that calculates a Fibonacci number",
-  inputSchema: Schema8.Struct({
-    iterations: Schema8.optional(Schema8.Number).annotations({
+  inputSchema: Schema6.Struct({
+    iterations: Schema6.optional(Schema6.Number).annotations({
       description: "Number of iterations",
       default: 1e5
     })
   }),
-  outputSchema: Schema8.Struct({
-    result: Schema8.String
+  outputSchema: Schema6.Struct({
+    result: Schema6.String
   }),
-  handler: Effect7.fn(function* ({ data: { iterations = 1e5 } }) {
+  handler: Effect2.fn(function* ({ data: { iterations = 1e5 } }) {
     let a = 0n;
     let b = 1n;
     for (let i = 0; i < iterations; i++) {
@@ -1182,14 +445,17 @@ var fib_default = defineFunction({
   })
 });
 
-// src/examples/reply.ts
-import { Console, Effect as Effect8, Schema as Schema9 } from "effect";
+// src/example/reply.ts
+import * as Console from "effect/Console";
+import * as Effect3 from "effect/Effect";
+import * as Schema7 from "effect/Schema";
 var reply_default = defineFunction({
-  name: "example.org/function/reply",
+  key: "example.org/function/reply",
+  name: "Reply",
   description: "Function that echoes the input",
-  inputSchema: Schema9.Any,
-  outputSchema: Schema9.Any,
-  handler: Effect8.fn(function* ({ data }) {
+  inputSchema: Schema7.Any,
+  outputSchema: Schema7.Any,
+  handler: Effect3.fn(function* ({ data }) {
     yield* Console.log("reply", {
       data
     });
@@ -1197,22 +463,433 @@ var reply_default = defineFunction({
   })
 });
 
-// src/examples/sleep.ts
-import { Effect as Effect9, Schema as Schema10 } from "effect";
+// src/example/sleep.ts
+import * as Effect4 from "effect/Effect";
+import * as Schema8 from "effect/Schema";
 var sleep_default = defineFunction({
-  name: "example.org/function/sleep",
+  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({
+  inputSchema: Schema8.Struct({
+    duration: Schema8.optional(Schema8.Number).annotations({
       description: "Milliseconds to sleep",
       default: 1e5
     })
   }),
-  outputSchema: Schema10.Void,
-  handler: Effect9.fn(function* ({ data: { duration = 1e5 } }) {
-    yield* Effect9.sleep(duration);
+  outputSchema: Schema8.Void,
+  handler: Effect4.fn(function* ({ data: { duration = 1e5 } }) {
+    yield* Effect4.sleep(duration);
   })
 });
+
+// src/example/index.ts
+(function(Example2) {
+  Example2.fib = fib_default;
+  Example2.reply = reply_default;
+  Example2.sleep = sleep_default;
+})(Example || (Example = {}));
+var Example;
+
+// src/services/index.ts
+import { DatabaseService as DatabaseService2 } from "@dxos/echo-db";
+
+// src/services/credentials.ts
+import * as HttpClient from "@effect/platform/HttpClient";
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
+import * as Context from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { Query } from "@dxos/echo";
+import { DatabaseService } from "@dxos/echo-db";
+import { AccessToken } from "@dxos/types";
+var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
+  static getCredential = (query) => Effect5.gen(function* () {
+    const credentials = yield* _CredentialsService;
+    return yield* Effect5.promise(() => credentials.getCredential(query));
+  });
+  static getApiKey = (query) => Effect5.gen(function* () {
+    const credential = yield* _CredentialsService.getCredential(query);
+    if (!credential.apiKey) {
+      throw new Error(`API key not found for service: ${query.service}`);
+    }
+    return Redacted.make(credential.apiKey);
+  });
+  static configuredLayer = (credentials) => Layer.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
+  static layerConfig = (credentials) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
+    const serviceCredentials = yield* Effect5.forEach(credentials, ({ service, apiKey }) => Effect5.gen(function* () {
+      return {
+        service,
+        apiKey: Redacted.value(yield* apiKey)
+      };
+    }));
+    return new ConfiguredCredentialsService(serviceCredentials);
+  }));
+  static layerFromDatabase = () => Layer.effect(_CredentialsService, Effect5.gen(function* () {
+    const dbService = yield* DatabaseService;
+    const queryCredentials = async (query) => {
+      const { objects: accessTokens } = await dbService.db.query(Query.type(AccessToken.AccessToken)).run();
+      return accessTokens.filter((accessToken) => accessToken.source === query.service).map((accessToken) => ({
+        service: accessToken.source,
+        apiKey: accessToken.token
+      }));
+    };
+    return {
+      getCredential: async (query) => {
+        const credentials = await queryCredentials(query);
+        if (credentials.length === 0) {
+          throw new Error(`Credential not found for service: ${query.service}`);
+        }
+        return credentials[0];
+      },
+      queryCredentials: async (query) => {
+        return queryCredentials(query);
+      }
+    };
+  }));
+};
+var ConfiguredCredentialsService = class {
+  credentials;
+  constructor(credentials = []) {
+    this.credentials = credentials;
+  }
+  addCredentials(credentials) {
+    this.credentials.push(...credentials);
+    return this;
+  }
+  async queryCredentials(query) {
+    return this.credentials.filter((credential) => credential.service === query.service);
+  }
+  async getCredential(query) {
+    const credential = this.credentials.find((credential2) => credential2.service === query.service);
+    if (!credential) {
+      throw new Error(`Credential not found for service: ${query.service}`);
+    }
+    return credential;
+  }
+};
+var withAuthorization = (query, kind) => HttpClient.mapRequestEffect(Effect5.fnUntraced(function* (request) {
+  const key = yield* CredentialsService.getApiKey(query).pipe(Effect5.map(Redacted.value));
+  const authorization = kind ? `${kind} ${key}` : key;
+  return HttpClientRequest.setHeader(request, "Authorization", authorization);
+}));
+
+// src/services/event-logger.ts
+import * as Context3 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import * as Schema9 from "effect/Schema";
+import { Obj as Obj7, Type as Type6 } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { LogLevel, log as log2 } from "@dxos/log";
+
+// src/services/tracing.ts
+import * as Context2 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { AgentStatus } from "@dxos/ai";
+import { Obj as Obj6 } from "@dxos/echo";
+import { Message } from "@dxos/types";
+var TracingService = class _TracingService extends Context2.Tag("@dxos/functions/TracingService")() {
+  static noop = {
+    getTraceContext: () => ({}),
+    write: () => {
+    }
+  };
+  static layerNoop = Layer2.succeed(_TracingService, _TracingService.noop);
+  /**
+  * Creates a TracingService layer that emits events to the parent tracing service.
+  */
+  static layerSubframe = (mapContext) => Layer2.effect(_TracingService, Effect6.gen(function* () {
+    const tracing = yield* _TracingService;
+    const context = mapContext(tracing.getTraceContext());
+    return {
+      write: (event) => tracing.write(event),
+      getTraceContext: () => context
+    };
+  }));
+  /**
+  * Emit the current human-readable execution status.
+  */
+  static emitStatus = Effect6.fnUntraced(function* (data) {
+    const tracing = yield* _TracingService;
+    tracing.write(Obj6.make(AgentStatus, {
+      parentMessage: tracing.getTraceContext().parentMessage,
+      toolCallId: tracing.getTraceContext().toolCallId,
+      created: (/* @__PURE__ */ new Date()).toISOString(),
+      ...data
+    }));
+  });
+  static emitConverationMessage = Effect6.fnUntraced(function* (data) {
+    const tracing = yield* _TracingService;
+    tracing.write(Obj6.make(Message.Message, {
+      parentMessage: tracing.getTraceContext().parentMessage,
+      ...data,
+      properties: {
+        [MESSAGE_PROPERTY_TOOL_CALL_ID]: tracing.getTraceContext().toolCallId,
+        ...data.properties
+      }
+    }));
+  });
+};
+var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
+
+// src/services/event-logger.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
+var ComputeEventPayload = Schema9.Union(Schema9.Struct({
+  type: Schema9.Literal("begin-compute"),
+  nodeId: Schema9.String,
+  /**
+   * Names of the inputs begin computed.
+   */
+  inputs: Schema9.Array(Schema9.String)
+}), Schema9.Struct({
+  type: Schema9.Literal("end-compute"),
+  nodeId: Schema9.String,
+  /**
+   * Names of the outputs computed.
+   */
+  outputs: Schema9.Array(Schema9.String)
+}), Schema9.Struct({
+  type: Schema9.Literal("compute-input"),
+  nodeId: Schema9.String,
+  property: Schema9.String,
+  value: Schema9.Any
+}), Schema9.Struct({
+  type: Schema9.Literal("compute-output"),
+  nodeId: Schema9.String,
+  property: Schema9.String,
+  value: Schema9.Any
+}), Schema9.Struct({
+  type: Schema9.Literal("custom"),
+  nodeId: Schema9.String,
+  event: Schema9.Any
+}));
+var ComputeEvent = Schema9.Struct({
+  payload: ComputeEventPayload
+}).pipe(Type6.Obj({
+  typename: "dxos.org/type/ComputeEvent",
+  version: "0.1.0"
+}));
+var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/functions/ComputeEventLogger")() {
+  static noop = {
+    log: () => {
+    },
+    nodeId: void 0
+  };
+  /**
+  * Implements ComputeEventLogger using TracingService.
+  */
+  static layerFromTracing = Layer3.effect(_ComputeEventLogger, Effect7.gen(function* () {
+    const tracing = yield* TracingService;
+    return {
+      log: (event) => {
+        tracing.write(Obj7.make(ComputeEvent, {
+          payload: event
+        }));
+      },
+      nodeId: void 0
+    };
+  }));
+};
+var logCustomEvent = (data) => Effect7.gen(function* () {
+  const logger = yield* ComputeEventLogger;
+  if (!logger.nodeId) {
+    throw new Error("logCustomEvent must be called within a node compute function");
+  }
+  logger.log({
+    type: "custom",
+    nodeId: logger.nodeId,
+    event: data
+  });
+});
+var createDefectLogger = () => Effect7.catchAll((error) => Effect7.gen(function* () {
+  log2.error("unhandled effect error", {
+    error
+  }, {
+    F: __dxlog_file,
+    L: 102,
+    S: this,
+    C: (f, a) => f(...a)
+  });
+  throw error;
+}));
+var createEventLogger = (level, message = "event") => {
+  const logFunction = {
+    [LogLevel.WARN]: log2.warn,
+    [LogLevel.VERBOSE]: log2.verbose,
+    [LogLevel.DEBUG]: log2.debug,
+    [LogLevel.INFO]: log2.info,
+    [LogLevel.ERROR]: log2.error
+  }[level];
+  invariant(logFunction, void 0, {
+    F: __dxlog_file,
+    L: 120,
+    S: void 0,
+    A: [
+      "logFunction",
+      ""
+    ]
+  });
+  return {
+    log: (event) => {
+      logFunction(message, event);
+    },
+    nodeId: void 0
+  };
+};
+
+// src/services/function-invocation-service.ts
+import * as Context4 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+var FunctionInvocationService = class _FunctionInvocationService extends Context4.Tag("@dxos/functions/FunctionInvocationService")() {
+  static invokeFunction = (functionDef, input) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+};
+
+// src/services/queues.ts
+import * as Context5 from "effect/Context";
+import * as Effect9 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/QueueService")() {
+  static notAvailable = Layer4.succeed(_QueueService, {
+    queues: {
+      get(_dxn) {
+        throw new Error("Queues not available");
+      },
+      create() {
+        throw new Error("Queues not available");
+      }
+    },
+    queue: void 0
+  });
+  static make = (queues, queue) => {
+    return {
+      queues,
+      queue
+    };
+  };
+  static layer = (queues, queue) => Layer4.succeed(_QueueService, _QueueService.make(queues, queue));
+  /**
+  * Gets a queue by its DXN.
+  */
+  static getQueue = (dxn) => _QueueService.pipe(Effect9.map(({ queues }) => queues.get(dxn)));
+  /**
+  * Creates a new queue.
+  */
+  static createQueue = (options) => _QueueService.pipe(Effect9.map(({ queues }) => queues.create(options)));
+  static append = (queue, objects) => Effect9.promise(() => queue.append(objects));
+};
+var ContextQueueService = class _ContextQueueService extends Context5.Tag("@dxos/functions/ContextQueueService")() {
+  static layer = (queue) => Layer4.succeed(_ContextQueueService, {
+    queue
+  });
+};
+
+// src/protocol/protocol.ts
+import * as Effect10 from "effect/Effect";
+import * as Layer5 from "effect/Layer";
+import * as Schema10 from "effect/Schema";
+import * as SchemaAST2 from "effect/SchemaAST";
+import { AiService } from "@dxos/ai";
+import { Type as Type7 } from "@dxos/echo";
+import { EchoClient } from "@dxos/echo-db";
+import { acquireReleaseResource } from "@dxos/effect";
+import { failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
+import { PublicKey } from "@dxos/keys";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
+var wrapFunctionHandler = (func) => {
+  if (!FunctionDefinition.isFunction(func)) {
+    throw new TypeError("Invalid function definition");
+  }
+  return {
+    meta: {
+      key: func.key,
+      name: func.name,
+      description: func.description,
+      inputSchema: Type7.toJsonSchema(func.inputSchema),
+      outputSchema: func.outputSchema === void 0 ? void 0 : Type7.toJsonSchema(func.outputSchema),
+      services: func.services
+    },
+    handler: async ({ data, context }) => {
+      if ((func.services.includes(DatabaseService2.key) || func.services.includes(QueueService.key)) && (!context.services.dataService || !context.services.queryService)) {
+        throw new FunctionError({
+          message: "Services not provided: dataService, queryService"
+        });
+      }
+      try {
+        if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
+          Schema10.validateSync(func.inputSchema)(data);
+        }
+        let result = await func.handler({
+          // TODO(dmaretskyi): Fix the types.
+          context,
+          data
+        });
+        if (Effect10.isEffect(result)) {
+          result = await Effect10.runPromise(result.pipe(Effect10.orDie, Effect10.provide(createServiceLayer(context))));
+        }
+        if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
+          Schema10.validateSync(func.outputSchema)(result);
+        }
+        return result;
+      } catch (error) {
+        if (FunctionError.is(error)) {
+          throw error;
+        } else {
+          throw new FunctionError({
+            cause: error,
+            context: {
+              func: func.key
+            }
+          });
+        }
+      }
+    }
+  };
+};
+var createServiceLayer = (context) => {
+  return Layer5.unwrapScoped(Effect10.gen(function* () {
+    let client;
+    if (context.services.dataService && context.services.queryService) {
+      client = yield* acquireReleaseResource(() => {
+        invariant2(context.services.dataService && context.services.queryService, void 0, {
+          F: __dxlog_file2,
+          L: 99,
+          S: this,
+          A: [
+            "context.services.dataService && context.services.queryService",
+            ""
+          ]
+        });
+        return new EchoClient().connectToService({
+          dataService: context.services.dataService,
+          queryService: context.services.queryService,
+          queueService: context.services.queueService
+        });
+      });
+    }
+    const db = client && context.spaceId ? yield* acquireReleaseResource(() => client.constructDatabase({
+      spaceId: context.spaceId ?? failedInvariant2(),
+      spaceKey: PublicKey.fromHex(context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
+      reactiveSchemaQuery: false
+    })) : void 0;
+    if (db) {
+      console.log("Setting space root", context.spaceRootUrl);
+      yield* Effect10.promise(() => db.setSpaceRoot(context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context")));
+    }
+    const queues = client && context.spaceId ? client.constructQueueFactory(context.spaceId) : void 0;
+    const dbLayer = db ? DatabaseService2.layer(db) : DatabaseService2.notAvailable;
+    const queuesLayer = queues ? QueueService.layer(queues) : QueueService.notAvailable;
+    const credentials = dbLayer ? CredentialsService.layerFromDatabase().pipe(Layer5.provide(dbLayer)) : CredentialsService.configuredLayer([]);
+    const functionInvocationService = MockedFunctionInvocationService;
+    const aiService = AiService.notAvailable;
+    const tracing = TracingService.layerNoop;
+    return Layer5.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiService, tracing);
+  }));
+};
+var MockedFunctionInvocationService = Layer5.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet.")
+});
 export {
   ComputeEvent,
   ComputeEventLogger,
@@ -1220,57 +897,32 @@ export {
   ConfiguredCredentialsService,
   ContextQueueService,
   CredentialsService,
-  DatabaseService,
-  EmailTriggerOutput,
+  DatabaseService2 as DatabaseService,
+  Example,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
-  FUNCTION_TYPES,
+  Function_exports as Function,
   FunctionDefinition,
   FunctionError,
-  FunctionExecutor,
-  FunctionImplementationResolver,
-  FunctionManifestSchema,
+  FunctionInvocationService,
   FunctionNotFoundError,
-  FunctionTrigger,
-  FunctionType,
-  InvocationOutcome,
-  InvocationTraceEndEvent,
-  InvocationTraceEventType,
-  InvocationTraceStartEvent,
-  InvocationTracer,
-  LocalFunctionExecutionService,
   MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
-  QueueTriggerOutput,
-  RemoteFunctionExecutionService,
-  SERVICE_TAGS,
-  ScriptType,
-  ServiceContainer,
+  Script_exports as Script,
   ServiceNotAvailableError,
-  SubscriptionTriggerOutput,
-  TimerTriggerOutput,
-  TraceEvent,
-  TraceEventException,
-  TraceEventLog,
   TracingService,
-  TriggerDispatcher,
-  TriggerKinds,
-  TriggerSchema,
-  TriggerState,
+  Trigger_exports as Trigger,
+  TriggerEvent_exports as TriggerEvent,
   TriggerStateNotFoundError,
-  TriggerStateStore,
-  WebhookTriggerOutput,
   createDefectLogger,
   createEventLogger,
-  createInvocationSpans,
   defineFunction,
   deserializeFunction,
-  examples_exports as exampleFunctions,
-  getInvocationUrl,
   getUserFunctionIdInMetadata,
   logCustomEvent,
   serializeFunction,
   setUserFunctionIdInMetadata,
-  withAuthorization
+  withAuthorization,
+  wrapFunctionHandler
 };
 //# sourceMappingURL=index.mjs.map