@dxos/functions 0.8.4-main.84f28bd → 0.8.4-main.ae835ea

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

@@ -1,98 +1,173 @@
 import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
 import {
-  AiService,
+  ComputeEvent,
+  ComputeEventLogger,
+  ComputeEventPayload,
   ConfiguredCredentialsService,
+  ContextQueueService,
   CredentialsService,
   DatabaseService,
-  EventLogger,
-  FunctionCallService,
+  FUNCTIONS_META_KEY,
+  FUNCTIONS_PRESET_META_KEY,
+  FunctionError,
+  FunctionNotFoundError,
+  MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
+  RemoteFunctionExecutionService,
   SERVICE_TAGS,
   ServiceContainer,
-  ToolResolverService,
+  ServiceNotAvailableError,
   TracingService,
+  TriggerStateNotFoundError,
   createDefectLogger,
   createEventLogger,
-  logCustomEvent
-} from "./chunk-XDSX35BS.mjs";
+  getInvocationUrl,
+  getUserFunctionIdInMetadata,
+  logCustomEvent,
+  setUserFunctionIdInMetadata,
+  withAuthorization
+} from "./chunk-P3IATZMZ.mjs";
+import {
+  __export
+} from "./chunk-HSLMI22Q.mjs";
+
+// src/example/fib.ts
+import * as Effect2 from "effect/Effect";
+import * as Schema6 from "effect/Schema";
 
 // src/handler.ts
-import { Schema } from "effect";
-var defineFunction = (params) => {
-  if (!Schema.isSchema(params.inputSchema)) {
-    throw new Error("Input schema must be a valid schema");
-  }
-  if (typeof params.handler !== "function") {
-    throw new Error("Handler must be a function");
-  }
-  return {
-    description: params.description,
-    inputSchema: params.inputSchema,
-    outputSchema: params.outputSchema ?? Schema.Any,
-    handler: params.handler
-  };
-};
+import * as Effect from "effect/Effect";
+import * as Schema5 from "effect/Schema";
+import { Obj as Obj5, Type as Type5 } from "@dxos/echo";
+import { assertArgument } 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/schema.ts
-import { Schema as Schema2 } from "effect";
-import { Type } from "@dxos/echo";
-import { JsonSchemaType, LabelAnnotation, Ref } from "@dxos/echo-schema";
+// 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 { DataType } from "@dxos/schema";
-var ScriptType = Schema2.Struct({
-  name: Schema2.optional(Schema2.String),
-  description: Schema2.optional(Schema2.String),
+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: Schema2.optional(Schema2.Boolean),
-  source: Ref(DataType.Text)
+  changed: Schema.Boolean.pipe(FormAnnotation.set(false), Schema.optional),
+  source: Type.Ref(DataType.Text).pipe(FormAnnotation.set(false))
 }).pipe(Type.Obj({
   typename: "dxos.org/type/Script",
   version: "0.1.0"
 }), LabelAnnotation.set([
   "name"
 ]));
-var FunctionType = Schema2.Struct({
+var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
+  ...props,
+  source: Ref.make(DataType.makeText(source))
+});
+
+// src/types/Function.ts
+var Function = Schema2.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: Schema2.optional(Schema2.String).annotations({
+    description: "Unique registration key for the blueprint"
+  }),
   // TODO(burdon): Rename to id/uri?
   name: Schema2.NonEmptyString,
   version: Schema2.String,
   description: Schema2.optional(Schema2.String),
   // Reference to a source script if it exists within ECHO.
   // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema2.optional(Ref(ScriptType)),
+  source: Schema2.optional(Ref2(Script)),
   inputSchema: Schema2.optional(JsonSchemaType),
   outputSchema: Schema2.optional(JsonSchemaType),
   // Local binding to a function name.
   binding: Schema2.optional(Schema2.String)
-}).pipe(Type.Obj({
+}).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/trace.ts
-import { Schema as Schema4 } from "effect";
-import { Type as Type2 } 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 { Expando, OptionsAnnotationId, TypedObject, Ref as Ref2, RawObject } from "@dxos/echo-schema";
+// 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
+});
+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 TriggerKind = /* @__PURE__ */ function(TriggerKind2) {
-  TriggerKind2["Timer"] = "timer";
-  TriggerKind2["Webhook"] = "webhook";
-  TriggerKind2["Subscription"] = "subscription";
-  TriggerKind2["Email"] = "email";
-  TriggerKind2["Queue"] = "queue";
-  return TriggerKind2;
-}({});
+var Kinds = [
+  "email",
+  "queue",
+  "subscription",
+  "timer",
+  "webhook"
+];
 var kindLiteralAnnotations = {
   title: "Kind"
 };
-var TimerTriggerSchema = Schema3.Struct({
+var EmailSpec = Schema3.Struct({
+  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
+}).pipe(Schema3.mutable);
+var QueueSpec = Schema3.Struct({
+  kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
+  // TODO(dmaretskyi): Change to a reference.
+  queue: DXN.Schema
+}).pipe(Schema3.mutable);
+var SubscriptionSpec = Schema3.Struct({
+  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
+  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({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: Schema3.optional(Schema3.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+}).pipe(Schema3.mutable);
+var TimerSpec = Schema3.Struct({
   kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
   cron: Schema3.String.annotations({
     title: "Cron",
@@ -101,14 +176,7 @@ var TimerTriggerSchema = Schema3.Struct({
     ]
   })
 }).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),
-  queue: DXN.Schema
-}).pipe(Schema3.mutable);
-var WebhookTriggerSchema = Schema3.Struct({
+var WebhookSpec = Schema3.Struct({
   kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
   method: Schema3.optional(Schema3.String.annotations({
     title: "Method",
@@ -121,71 +189,15 @@ var WebhookTriggerSchema = Schema3.Struct({
     title: "Port"
   }))
 }).pipe(Schema3.mutable);
-var QuerySchema = Schema3.Struct({
-  type: Schema3.optional(Schema3.String.annotations({
-    title: "Type"
-  })),
-  props: Schema3.optional(Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.Any
-  }))
-}).annotations({
-  title: "Query"
-});
-var SubscriptionTriggerSchema = Schema3.Struct({
-  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  // TODO(burdon): Define query DSL (from ECHO). Reconcile with Table.Query.
-  filter: QuerySchema,
-  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({
+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 FunctionTriggerSchema = 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"
   })),
   /**
@@ -199,7 +211,7 @@ var FunctionTriggerSchema = 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.
@@ -215,46 +227,446 @@ var FunctionTriggerSchema = Schema3.Struct({
     key: Schema3.String,
     value: Schema3.Any
   })))
+}).pipe(Type3.Obj({
+  typename: "dxos.org/type/Trigger",
+  version: "0.1.0"
+}));
+var Trigger = Trigger_;
+var make3 = (props) => Obj3.make(Trigger, props);
+
+// src/types/TriggerEvent.ts
+var TriggerEvent_exports = {};
+__export(TriggerEvent_exports, {
+  EmailEvent: () => EmailEvent,
+  QueueEvent: () => QueueEvent,
+  SubscriptionEvent: () => SubscriptionEvent,
+  TimerEvent: () => TimerEvent,
+  WebhookEvent: () => WebhookEvent
 });
-var FunctionTrigger = class extends TypedObject({
-  typename: "dxos.org/type/FunctionTrigger",
-  version: "0.2.0"
-})(FunctionTriggerSchema.fields) {
+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 QueueEvent = Schema4.mutable(Schema4.Struct({
+  queue: DXN2.Schema,
+  item: Schema4.Any,
+  cursor: Schema4.String
+}));
+var SubscriptionEvent = Schema4.Struct({
+  /**
+  * Type of the mutation.
+  */
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema4.String,
+  /**
+  * Reference to the object that was changed or created.
+  */
+  subject: Type4.Ref(Obj4.Any),
+  /**
+  * @deprecated
+  */
+  changedObjectId: Schema4.optional(Schema4.String)
+}).pipe(Schema4.mutable);
+var TimerEvent = Schema4.mutable(Schema4.Struct({
+  tick: Schema4.Number
+}));
+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
+}));
+
+// src/handler.ts
+var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
+var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler }) => {
+  if (!Schema5.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(Obj5.instanceOf(Function_exports.Function, functionObj), "functionObj");
+    return deserializeFunction(functionObj);
+  }
+};
+var serializeFunction = (functionDef) => {
+  const fn6 = 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)
+  });
+  if (functionDef.meta?.deployedFunctionId) {
+    setUserFunctionIdInMetadata(Obj5.getMeta(fn6), functionDef.meta.deployedFunctionId);
+  }
+  return fn6;
+};
+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: () => {
+    },
+    meta: {
+      deployedFunctionId: getUserFunctionIdInMetadata(Obj5.getMeta(functionObj))
+    }
+  };
 };
-var FunctionManifestSchema = Schema3.Struct({
-  functions: Schema3.optional(Schema3.mutable(Schema3.Array(RawObject(FunctionType)))),
-  triggers: Schema3.optional(Schema3.mutable(Schema3.Array(RawObject(FunctionTrigger))))
+
+// src/example/fib.ts
+var fib_default = defineFunction({
+  key: "example.org/function/fib",
+  name: "Fibonacci",
+  description: "Function that calculates a Fibonacci number",
+  inputSchema: Schema6.Struct({
+    iterations: Schema6.optional(Schema6.Number).annotations({
+      description: "Number of iterations",
+      default: 1e5
+    })
+  }),
+  outputSchema: Schema6.Struct({
+    result: Schema6.String
+  }),
+  handler: Effect2.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/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({
+  key: "example.org/function/reply",
+  name: "Reply",
+  description: "Function that echoes the input",
+  inputSchema: Schema7.Any,
+  outputSchema: Schema7.Any,
+  handler: Effect3.fn(function* ({ data }) {
+    yield* Console.log("reply", {
+      data
+    });
+    return data;
+  })
+});
+
+// src/example/sleep.ts
+import * as Effect4 from "effect/Effect";
+import * as Schema8 from "effect/Schema";
+var sleep_default = defineFunction({
+  key: "example.org/function/sleep",
+  name: "Sleep",
+  description: "Function that sleeps for a given amount of time",
+  inputSchema: Schema8.Struct({
+    duration: Schema8.optional(Schema8.Number).annotations({
+      description: "Milliseconds to sleep",
+      default: 1e5
+    })
+  }),
+  outputSchema: Schema8.Void,
+  handler: Effect4.fn(function* ({ data: { duration = 1e5 } }) {
+    yield* Effect4.sleep(duration);
+  })
 });
-var FUNCTION_TYPES = [
-  FunctionType,
-  FunctionTrigger
-];
+
+// src/example/index.ts
+(function(Example2) {
+  Example2.fib = fib_default;
+  Example2.reply = reply_default;
+  Example2.sleep = sleep_default;
+})(Example || (Example = {}));
+var Example;
+
+// src/executor/executor.ts
+import * as Effect5 from "effect/Effect";
+import * as Schema9 from "effect/Schema";
+import { runAndForwardErrors } from "@dxos/effect";
+var FunctionExecutor = class {
+  _services;
+  constructor(_services) {
+    this._services = _services;
+  }
+  /**
+  * Invoke function.
+  */
+  // TODO(dmaretskyi): Invocation context: queue, space, etc...
+  async invoke(functionDef, input) {
+    const assertInput = functionDef.inputSchema.pipe(Schema9.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 (Effect5.isEffect(result)) {
+      data = await result.pipe(Effect5.provide(this._services.createLayer()), runAndForwardErrors);
+    } else {
+      data = await result;
+    }
+    const assertOutput = functionDef.outputSchema?.pipe(Schema9.asserts);
+    assertOutput(data);
+    return data;
+  }
+};
+
+// src/services/function-invocation-service.ts
+import * as Context2 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { AiService as AiService2 } from "@dxos/ai";
+
+// src/services/local-function-execution.ts
+import * as Context from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema10 from "effect/Schema";
+import { AiService } from "@dxos/ai";
+import { todo } from "@dxos/debug";
+import { log as log2 } from "@dxos/log";
+var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/local-function-execution.ts";
+var LocalFunctionExecutionService = class _LocalFunctionExecutionService extends Context.Tag("@dxos/functions/LocalFunctionExecutionService")() {
+  static layerLive = Layer.effect(_LocalFunctionExecutionService, Effect6.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) => Effect6.gen(function* () {
+        const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect6.orDie);
+        const output = yield* invokeFunction(resolved, input);
+        return output;
+      }).pipe(Effect6.provideService(AiService.AiService, ai), Effect6.provideService(CredentialsService, credentials), Effect6.provideService(DatabaseService, database), Effect6.provideService(QueueService, queues), Effect6.provideService(RemoteFunctionExecutionService, functionCallService))
+    };
+  }));
+  static invokeFunction = Effect6.serviceFunctionEffect(_LocalFunctionExecutionService, (_) => _.invokeFunction);
+};
+var invokeFunction = (functionDef, input) => Effect6.gen(function* () {
+  try {
+    const assertInput = functionDef.inputSchema.pipe(Schema10.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_file,
+    L: 98,
+    S: this,
+    C: (f, a) => f(...a)
+  });
+  const data = yield* Effect6.gen(function* () {
+    const result = functionDef.handler({
+      context,
+      data: input
+    });
+    if (Effect6.isEffect(result)) {
+      return yield* result.pipe(Effect6.orDie);
+    } else if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") {
+      return yield* Effect6.promise(() => result);
+    } else {
+      return result;
+    }
+  }).pipe(Effect6.orDie, Effect6.catchAllDefect((defect) => Effect6.die(new FunctionError({
+    context: {
+      name: functionDef.name
+    },
+    cause: defect
+  }))));
+  log2.info("completed", {
+    function: functionDef.name,
+    input,
+    data
+  }, {
+    F: __dxlog_file,
+    L: 122,
+    S: this,
+    C: (f, a) => f(...a)
+  });
+  try {
+    const assertOutput = functionDef.outputSchema?.pipe(Schema10.asserts);
+    assertOutput(data);
+  } catch (e) {
+    throw new FunctionError({
+      message: "Invalid function output",
+      context: {
+        name: functionDef.name
+      },
+      cause: e
+    });
+  }
+  return data;
+}).pipe(Effect6.withSpan("invokeFunction", {
+  attributes: {
+    name: functionDef.name
+  }
+}));
+var FunctionImplementationResolver = class _FunctionImplementationResolver extends Context.Tag("@dxos/functions/FunctionImplementationResolver")() {
+  static layerTest = ({ functions }) => Layer.succeed(_FunctionImplementationResolver, {
+    resolveFunctionImplementation: (functionDef) => {
+      const resolved = functions.find((f) => f.key === functionDef.key);
+      if (!resolved) {
+        return Effect6.fail(new FunctionNotFoundError(functionDef.name));
+      }
+      return Effect6.succeed(resolved);
+    }
+  });
+};
+
+// src/services/function-invocation-service.ts
+var FunctionInvocationService = class _FunctionInvocationService extends Context2.Tag("@dxos/functions/FunctionInvocationService")() {
+  static invokeFunction = Effect7.serviceFunctionEffect(_FunctionInvocationService, (_) => _.invokeFunction);
+  static layer = Layer2.effect(_FunctionInvocationService, Effect7.gen(function* () {
+    const localExecutioner = yield* LocalFunctionExecutionService;
+    const remoteExecutioner = yield* RemoteFunctionExecutionService;
+    return {
+      invokeFunction: (functionDef, input) => Effect7.gen(function* () {
+        if (functionDef.meta?.deployedFunctionId) {
+          return yield* remoteExecutioner.callFunction(functionDef.meta.deployedFunctionId, input);
+        }
+        return yield* localExecutioner.invokeFunction(functionDef, input);
+      })
+    };
+  }));
+  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
+  static layerTest = ({ functions = [] } = {}) => _FunctionInvocationService.layer.pipe(Layer2.provide(LocalFunctionExecutionService.layerLive), Layer2.provide(FunctionImplementationResolver.layerTest({
+    functions
+  })), Layer2.provide(RemoteFunctionExecutionService.layerMock));
+  // TODO(dmaretskyi): This shouldn't default to all services being not available.
+  // TODO(dmaretskyi): Don't provide `FunctionImplementationResolver`.
+  /**
+  * @deprecated Use {@link layerTest} instead.
+  */
+  static layerTestMocked = ({ functions }) => _FunctionInvocationService.layerTest({
+    functions
+  }).pipe(Layer2.provide(AiService2.notAvailable), Layer2.provide(CredentialsService.configuredLayer([])), Layer2.provide(DatabaseService.notAvailable), Layer2.provide(QueueService.notAvailable));
+};
 
 // src/trace.ts
-var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/trace.ts";
-var InvocationOutcome = /* @__PURE__ */ function(InvocationOutcome2) {
+import * as Schema11 from "effect/Schema";
+import { Type as Type6 } from "@dxos/echo";
+import { ObjectId } from "@dxos/echo/internal";
+import { Queue } from "@dxos/echo-db";
+import { log as log3 } from "@dxos/log";
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/trace.ts";
+var InvocationOutcome = /* @__PURE__ */ (function(InvocationOutcome2) {
   InvocationOutcome2["SUCCESS"] = "success";
   InvocationOutcome2["FAILURE"] = "failure";
   InvocationOutcome2["PENDING"] = "pending";
   return InvocationOutcome2;
-}({});
-var InvocationTraceEventType = /* @__PURE__ */ function(InvocationTraceEventType2) {
+})({});
+var InvocationTraceEventType = /* @__PURE__ */ (function(InvocationTraceEventType2) {
   InvocationTraceEventType2["START"] = "start";
   InvocationTraceEventType2["END"] = "end";
   return InvocationTraceEventType2;
-}({});
-var TraceEventException = Schema4.Struct({
-  timestampMs: Schema4.Number,
-  message: Schema4.String,
-  name: Schema4.String,
-  stack: Schema4.optional(Schema4.String)
+})({});
+var TraceEventException = Schema11.Struct({
+  timestamp: Schema11.Number,
+  message: Schema11.String,
+  name: Schema11.String,
+  stack: Schema11.optional(Schema11.String)
 });
-var InvocationTraceStartEvent = Schema4.Struct({
+var InvocationTraceStartEvent = Schema11.Struct({
   /**
   * Queue message id.
   */
   id: ObjectId,
-  type: Schema4.Literal("start"),
+  type: Schema11.Literal("start"),
   /**
   * Invocation id, the same for invocation start and end events.
   */
@@ -262,34 +674,34 @@ var InvocationTraceStartEvent = Schema4.Struct({
   /**
   * Event generation time.
   */
-  timestampMs: Schema4.Number,
+  timestamp: Schema11.Number,
   /**
   * Data passed to function / workflow as an argument.
   */
   // TODO(burdon): Input schema?
-  input: Schema4.Object,
+  input: Schema11.Object,
   /**
   * Queue  for function/workflow invocation events.
   */
-  invocationTraceQueue: Type2.Ref(Queue),
+  invocationTraceQueue: Schema11.optional(Type6.Ref(Queue)),
   /**
   * DXN of the invoked function/workflow.
   */
-  invocationTarget: Type2.Ref(Type2.Expando),
+  invocationTarget: Schema11.optional(Type6.Ref(Type6.Expando)),
   /**
   * Present for automatic invocations.
   */
-  trigger: Schema4.optional(Type2.Ref(FunctionTrigger))
-}).pipe(Type2.Obj({
+  trigger: Schema11.optional(Type6.Ref(Trigger_exports.Trigger))
+}).pipe(Type6.Obj({
   typename: "dxos.org/type/InvocationTraceStart",
   version: "0.1.0"
 }));
-var InvocationTraceEndEvent = Schema4.Struct({
+var InvocationTraceEndEvent = Schema11.Struct({
   /**
   * Trace event id.
   */
   id: ObjectId,
-  type: Schema4.Literal("end"),
+  type: Schema11.Literal("end"),
   /**
   * Invocation id, will be the same for invocation start and end.
   */
@@ -298,31 +710,29 @@ var InvocationTraceEndEvent = Schema4.Struct({
   * Event generation time.
   */
   // TODO(burdon): Remove ms suffix.
-  timestampMs: Schema4.Number,
-  outcome: Schema4.Enums(InvocationOutcome),
-  exception: Schema4.optional(TraceEventException)
-}).pipe(Type2.Obj({
+  timestamp: Schema11.Number,
+  outcome: Schema11.Enums(InvocationOutcome),
+  exception: Schema11.optional(TraceEventException)
+}).pipe(Type6.Obj({
   typename: "dxos.org/type/InvocationTraceEnd",
   version: "0.1.0"
 }));
-var TraceEventLog = Schema4.Struct({
-  timestampMs: Schema4.Number,
-  level: Schema4.String,
-  message: Schema4.String,
-  context: Schema4.optional(Schema4.Object)
+var TraceEventLog = Schema11.Struct({
+  timestamp: Schema11.Number,
+  level: Schema11.String,
+  message: Schema11.String,
+  context: Schema11.optional(Schema11.Object)
 });
-var TraceEvent = Schema4.Struct({
+var TraceEvent = Schema11.Struct({
   id: ObjectId,
   // TODO(burdon): Need enum/numeric result (not string).
-  outcome: Schema4.String,
-  truncated: Schema4.Boolean,
-  /**
-  * Time when the event was persisted.
-  */
-  ingestionTimestampMs: Schema4.Number,
-  logs: Schema4.Array(TraceEventLog),
-  exceptions: Schema4.Array(TraceEventException)
-}).pipe(Type2.Obj({
+  outcome: Schema11.String,
+  truncated: Schema11.Boolean,
+  /** Time when the event was persisted. */
+  ingestionTimestamp: Schema11.Number,
+  logs: Schema11.Array(TraceEventLog),
+  exceptions: Schema11.Array(TraceEventException)
+}).pipe(Type6.Obj({
   typename: "dxos.org/type/TraceEvent",
   version: "0.1.0"
 }));
@@ -351,11 +761,11 @@ var createInvocationSpans = (items) => {
   const result = [];
   for (const [invocationId, { start, end }] of eventsByInvocationId.entries()) {
     if (!start) {
-      log.warn("found end event without matching start", {
+      log3.warn("found end event without matching start", {
         invocationId
       }, {
-        F: __dxlog_file,
-        L: 160,
+        F: __dxlog_file2,
+        L: 158,
         S: void 0,
         C: (f, a) => f(...a)
       });
@@ -364,8 +774,8 @@ var createInvocationSpans = (items) => {
     const isInProgress = end === void 0;
     result.push({
       id: invocationId,
-      timestampMs: start.timestampMs,
-      durationMs: isInProgress ? now - start.timestampMs : end.timestampMs - start.timestampMs,
+      timestamp: start.timestamp,
+      duration: isInProgress ? now - start.timestamp : end.timestamp - start.timestamp,
       outcome: end?.outcome ?? "pending",
       exception: end?.exception,
       input: start.input,
@@ -377,117 +787,561 @@ var createInvocationSpans = (items) => {
   return result;
 };
 
-// src/url.ts
-var FUNCTIONS_META_KEY = "dxos.org/service/function";
-var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
-var isSecure = (protocol) => {
-  return protocol === "https:" || protocol === "wss:";
-};
-var getUserFunctionUrlInMetadata = (meta) => {
-  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
+// src/triggers/invocation-tracer.ts
+import * as Context3 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import { Obj as Obj6, Ref as Ref4 } from "@dxos/echo";
+import { DXN as DXN3, ObjectId as ObjectId2 } from "@dxos/keys";
+var InvocationTracer = class _InvocationTracer extends Context3.Tag("@dxos/functions/InvocationTracer")() {
+  static layerLive = (opts) => Layer3.effect(_InvocationTracer, Effect8.gen(function* () {
+    return {
+      traceInvocationStart: Effect8.fn("traceInvocationStart")(function* ({ payload, target }) {
+        const invocationId = ObjectId2.random();
+        const invocationTraceQueue = yield* QueueService.createQueue({
+          subspaceTag: "trace"
+        });
+        const now = Date.now();
+        const traceEvent = Obj6.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: Ref4.fromDXN(invocationTraceQueue.dxn),
+          invocationTarget: target ? Ref4.fromDXN(target) : void 0,
+          trigger: payload.trigger ? Ref4.fromDXN(DXN3.fromLocalObjectId(payload.trigger.id)) : void 0
+        });
+        yield* QueueService.append(opts.invocationTraceQueue, [
+          traceEvent
+        ]);
+        return {
+          invocationId,
+          invocationTraceQueue
+        };
+      }),
+      traceInvocationEnd: Effect8.fn("traceInvocationEnd")(function* ({ trace, exception }) {
+        const now = Date.now();
+        const traceEvent = Obj6.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
+        ]);
+      })
+    };
+  }));
+  static layerTest = Layer3.unwrapEffect(Effect8.gen(function* () {
+    const queue = yield* QueueService.createQueue({
+      subspaceTag: "trace"
+    });
+    return _InvocationTracer.layerLive({
+      invocationTraceQueue: queue
+    });
+  }));
 };
-var setUserFunctionUrlInMetadata = (meta, functionUrl) => {
-  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
-  if (key) {
-    if (key.id !== functionUrl) {
-      throw new Error("Metadata mismatch");
+
+// src/triggers/trigger-dispatcher.ts
+import * as Cause from "effect/Cause";
+import * as Context5 from "effect/Context";
+import * as Cron from "effect/Cron";
+import * as Duration from "effect/Duration";
+import * as Effect10 from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Layer5 from "effect/Layer";
+import * as Option2 from "effect/Option";
+import * as Record4 from "effect/Record";
+import * as Schedule from "effect/Schedule";
+import { DXN as DXN4, Filter, Obj as Obj7, Query } from "@dxos/echo";
+import { causeToError } from "@dxos/effect";
+import { invariant } from "@dxos/invariant";
+import { log as log4 } 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;
     }
-  } else {
-    meta.keys.push({
-      source: FUNCTIONS_META_KEY,
-      id: functionUrl
-    });
+    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;
 };
-var makeFunctionUrl = (fn) => `/${fn.functionId}`;
-var getInvocationUrl = (functionUrl, edgeUrl, options = {}) => {
-  const baseUrl = new URL("functions/", edgeUrl);
-  const relativeUrl = functionUrl.replace(/^\//, "");
-  const url = new URL(`./${relativeUrl}`, baseUrl.toString());
-  options.spaceId && url.searchParams.set("spaceId", options.spaceId);
-  options.subjectId && url.searchParams.set("subjectId", options.subjectId);
-  url.protocol = isSecure(url.protocol) ? "https" : "http";
-  return url.toString();
+
+// src/triggers/trigger-state-store.ts
+import * as KeyValueStore from "@effect/platform/KeyValueStore";
+import * as Context4 from "effect/Context";
+import * as Effect9 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema12 from "effect/Schema";
+import { ObjectId as ObjectId3 } from "@dxos/keys";
+var TriggerState = Schema12.Struct({
+  version: Schema12.Literal("1"),
+  triggerId: Schema12.String,
+  state: Schema12.optional(Schema12.Union(Schema12.TaggedStruct("subscription", {
+    processedVersions: Schema12.Record({
+      key: ObjectId3,
+      value: Schema12.String
+    })
+  })))
+});
+var TriggerStateStore = class _TriggerStateStore extends Context4.Tag("@dxos/functions/TriggerStateStore")() {
+  static getState = Effect9.serviceFunctionEffect(_TriggerStateStore, (_) => _.getState);
+  static saveState = Effect9.serviceFunctionEffect(_TriggerStateStore, (_) => _.saveState);
+  static layerKv = Layer4.effect(_TriggerStateStore, Effect9.gen(function* () {
+    const kv = yield* KeyValueStore.KeyValueStore;
+    const schemaStore = kv.forSchema(Schema12.parseJson(TriggerState));
+    const store = {
+      getState: Effect9.fn("TriggerStateStore.getState")(function* (triggerId) {
+        const valueOption = yield* schemaStore.get(triggerId).pipe(Effect9.orDie);
+        if (Option.isNone(valueOption)) {
+          return yield* Effect9.fail(new TriggerStateNotFoundError());
+        }
+        return valueOption.value;
+      }),
+      saveState: Effect9.fn("TriggerStateStore.saveState")(function* (state) {
+        yield* schemaStore.set(state.triggerId, state).pipe(Effect9.orDie);
+      })
+    };
+    return store;
+  }));
+  static layerMemory = _TriggerStateStore.layerKv.pipe(Layer4.provide(KeyValueStore.layerMemory));
 };
 
-// src/executor/executor.ts
-import { Effect, Schema as Schema5 } from "effect";
-import { runAndForwardErrors } from "@dxos/effect";
-var FunctionExecutor = class {
-  constructor(_services) {
-    this._services = _services;
+// src/triggers/trigger-dispatcher.ts
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/triggers/trigger-dispatcher.ts";
+var TriggerDispatcher = class _TriggerDispatcher extends Context5.Tag("@dxos/functions/TriggerDispatcher")() {
+  static layer = (options) => Layer5.effect(_TriggerDispatcher, Effect10.gen(function* () {
+    return new TriggerDispatcherImpl(options);
+  }));
+};
+var TriggerDispatcherImpl = class {
+  livePollInterval;
+  timeControl;
+  _running = false;
+  _internalTime;
+  _timerFiber;
+  _scheduledTriggers = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.timeControl = options.timeControl;
+    this.livePollInterval = options.livePollInterval ?? Duration.seconds(1);
+    this._internalTime = options.startingTime ?? /* @__PURE__ */ new Date();
   }
-  // TODO(dmaretskyi): Invocation context: queue, space, etc...
-  async invoke(fnDef, input) {
-    const assertInput = fnDef.inputSchema.pipe(Schema5.asserts);
-    assertInput(input);
-    const context = {
-      getService: this._services.getService.bind(this._services),
-      getSpace: async (_spaceId) => {
-        throw new Error("Not available. Use the database service instead.");
-      },
-      space: void 0,
-      get ai() {
-        throw new Error("Not available. Use the ai service instead.");
+  get running() {
+    return this._running;
+  }
+  start = () => Effect10.gen(this, function* () {
+    if (this._running) {
+      return;
+    }
+    this._running = true;
+    if (this.timeControl === "natural") {
+      this._timerFiber = yield* this._startNaturalTimeProcessing().pipe(Effect10.tapErrorCause((cause) => {
+        const error = causeToError(cause);
+        log4.error("trigger dispatcher error", {
+          error
+        }, {
+          F: __dxlog_file3,
+          L: 178,
+          S: this,
+          C: (f, a) => f(...a)
+        });
+        this._running = false;
+        return Effect10.void;
+      }), Effect10.forkDaemon);
+    } else {
+      return yield* Effect10.dieMessage("TriggerDispatcher started in manual time control mode");
+    }
+    log4.info("TriggerDispatcher started", {
+      timeControl: this.timeControl
+    }, {
+      F: __dxlog_file3,
+      L: 188,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  });
+  stop = () => Effect10.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();
+    log4.info("TriggerDispatcher stopped", void 0, {
+      F: __dxlog_file3,
+      L: 208,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  });
+  invokeTrigger = (options) => Effect10.gen(this, function* () {
+    const { trigger, event } = options;
+    log4.info("running trigger", {
+      triggerId: trigger.id,
+      spec: trigger.spec,
+      event
+    }, {
+      F: __dxlog_file3,
+      L: 216,
+      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* Effect10.gen(this, function* () {
+      if (!trigger.enabled) {
+        return yield* Effect10.dieMessage("Attempting to invoke disabled trigger");
+      }
+      if (!trigger.function) {
+        return yield* Effect10.dieMessage("Trigger has no function reference");
       }
+      const serialiedFunction = yield* DatabaseService.load(trigger.function).pipe(Effect10.orDie);
+      invariant(Obj7.instanceOf(Function_exports.Function, serialiedFunction), void 0, {
+        F: __dxlog_file3,
+        L: 243,
+        S: this,
+        A: [
+          "Obj.instanceOf(Function.Function, serialiedFunction)",
+          ""
+        ]
+      });
+      const functionDef = deserializeFunction(serialiedFunction);
+      const inputData = this._prepareInputData(trigger, event);
+      return yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(Effect10.provide(ComputeEventLogger.layerFromTracing.pipe(Layer5.provideMerge(TracingService.layerQueue(trace.invocationTraceQueue)))));
+    }).pipe(Effect10.exit);
+    const triggerExecutionResult = {
+      triggerId: trigger.id,
+      result
     };
-    const result = fnDef.handler({
-      context,
-      data: input
+    if (Exit.isSuccess(result)) {
+      log4.info("trigger execution success", {
+        triggerId: trigger.id
+      }, {
+        F: __dxlog_file3,
+        L: 264,
+        S: this,
+        C: (f, a) => f(...a)
+      });
+    } else {
+      log4.error("trigger execution failure", {
+        error: causeToError(result.cause)
+      }, {
+        F: __dxlog_file3,
+        L: 268,
+        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
     });
-    let data;
-    if (Effect.isEffect(result)) {
-      data = await result.pipe(Effect.provide(this._services.createLayer()), runAndForwardErrors);
+    return triggerExecutionResult;
+  });
+  invokeScheduledTriggers = ({ kinds = [
+    "timer",
+    "queue",
+    "subscription"
+  ] } = {}) => Effect10.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* Effect10.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 = Obj7.getKeys(trigger, KEY_QUEUE_CURSOR).at(0)?.id;
+            const queue = yield* QueueService.getQueue(DXN4.parse(spec.queue));
+            const objects = yield* Effect10.promise(() => queue.queryObjects());
+            for (const object of objects) {
+              const objectPos = Obj7.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
+                }
+              }));
+              Obj7.deleteKeys(trigger, KEY_QUEUE_CURSOR);
+              Obj7.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 = Obj7.getSnapshot(trigger).spec;
+            if (spec?.kind !== "subscription") {
+              continue;
+            }
+            const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query.ast));
+            const state = yield* TriggerStateStore.getState(trigger.id).pipe(Effect10.catchTag("TRIGGER_STATE_NOT_FOUND", () => Effect10.succeed({
+              version: "1",
+              triggerId: trigger.id,
+              state: {
+                _tag: "subscription",
+                processedVersions: {}
+              }
+            })));
+            invariant(state.state?._tag === "subscription", void 0, {
+              F: __dxlog_file3,
+              L: 381,
+              S: this,
+              A: [
+                "state.state?._tag === 'subscription'",
+                ""
+              ]
+            });
+            let updated = false;
+            for (const object of objects) {
+              const existingVersion = Record4.get(state.state.processedVersions, object.id).pipe(Option2.map(Obj7.decodeVersion));
+              const currentVersion = Obj7.version(object);
+              const run = Option2.isNone(existingVersion) || Obj7.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(Obj7.getDXN(object)),
+                  changedObjectId: object.id
+                }
+              }));
+              state.state.processedVersions[object.id] = Obj7.encodeVersion(currentVersion);
+              updated = true;
+            }
+            if (updated) {
+              yield* TriggerStateStore.saveState(state);
+            }
+          }
+          break;
+        }
+        default: {
+          return yield* Effect10.dieMessage(`Unknown trigger kind: ${kind}`);
+        }
+      }
+    }
+    return invocations;
+  });
+  advanceTime = (duration) => Effect10.gen(this, function* () {
+    if (this.timeControl !== "manual") {
+      return yield* Effect10.dieMessage("advanceTime can only be used in manual time control mode");
+    }
+    const millis = Duration.toMillis(duration);
+    this._internalTime = new Date(this._internalTime.getTime() + millis);
+    log4("Advanced internal time", {
+      newTime: this._internalTime,
+      advancedBy: Duration.format(duration)
+    }, {
+      F: __dxlog_file3,
+      L: 438,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }).pipe(Effect10.orDie);
+  getCurrentTime = () => {
+    if (this.timeControl === "natural") {
+      return /* @__PURE__ */ new Date();
     } else {
-      data = await result;
+      return new Date(this._internalTime);
     }
-    const assertOutput = fnDef.outputSchema?.pipe(Schema5.asserts);
-    assertOutput(data);
-    return data;
-  }
+  };
+  refreshTriggers = () => Effect10.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);
+          log4("Updated scheduled trigger", {
+            triggerId: trigger.id,
+            cron: timerSpec.cron,
+            nextExecution,
+            now
+          }, {
+            F: __dxlog_file3,
+            L: 478,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+          this._scheduledTriggers.set(trigger.id, {
+            trigger,
+            cron,
+            nextExecution
+          });
+        } else {
+          log4.error("Invalid cron expression", {
+            triggerId: trigger.id,
+            cron: timerSpec.cron,
+            error: cronEither.left.message
+          }, {
+            F: __dxlog_file3,
+            L: 490,
+            S: this,
+            C: (f, a) => f(...a)
+          });
+        }
+      }
+    }
+    log4("Updated scheduled triggers", {
+      count: this._scheduledTriggers.size
+    }, {
+      F: __dxlog_file3,
+      L: 499,
+      S: this,
+      C: (f, a) => f(...a)
+    });
+  }).pipe(Effect10.withSpan("TriggerDispatcher.refreshTriggers"));
+  _fetchTriggers = () => Effect10.gen(this, function* () {
+    const { objects } = yield* DatabaseService.runQuery(Filter.type(Trigger_exports.Trigger));
+    return objects;
+  }).pipe(Effect10.withSpan("TriggerDispatcher.fetchTriggers"));
+  _startNaturalTimeProcessing = () => Effect10.gen(this, function* () {
+    yield* this.invokeScheduledTriggers();
+  }).pipe(Effect10.repeat(Schedule.fixed(this.livePollInterval)), Effect10.asVoid);
+  _prepareInputData = (trigger, event) => {
+    return createInvocationPayload(trigger, event);
+  };
 };
+var KEY_QUEUE_CURSOR = "dxos.org/key/local-trigger-dispatcher/queue-cursor";
 export {
-  AiService,
+  ComputeEvent,
+  ComputeEventLogger,
+  ComputeEventPayload,
   ConfiguredCredentialsService,
+  ContextQueueService,
   CredentialsService,
   DatabaseService,
-  EmailTriggerOutput,
-  EventLogger,
+  Example,
+  FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
-  FUNCTION_TYPES,
-  FunctionCallService,
+  Function_exports as Function,
+  FunctionDefinition,
+  FunctionError,
   FunctionExecutor,
-  FunctionManifestSchema,
-  FunctionTrigger,
-  FunctionTriggerSchema,
-  FunctionType,
+  FunctionImplementationResolver,
+  FunctionInvocationService,
+  FunctionNotFoundError,
   InvocationOutcome,
   InvocationTraceEndEvent,
   InvocationTraceEventType,
   InvocationTraceStartEvent,
+  InvocationTracer,
+  LocalFunctionExecutionService,
+  MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
-  QueueTriggerOutput,
+  RemoteFunctionExecutionService,
   SERVICE_TAGS,
-  ScriptType,
+  Script_exports as Script,
   ServiceContainer,
-  SubscriptionTriggerOutput,
-  TimerTriggerOutput,
-  ToolResolverService,
+  ServiceNotAvailableError,
   TraceEvent,
   TraceEventException,
   TraceEventLog,
   TracingService,
-  TriggerKind,
-  TriggerSchema,
-  WebhookTriggerOutput,
+  Trigger_exports as Trigger,
+  TriggerDispatcher,
+  TriggerEvent_exports as TriggerEvent,
+  TriggerState,
+  TriggerStateNotFoundError,
+  TriggerStateStore,
   createDefectLogger,
   createEventLogger,
   createInvocationSpans,
   defineFunction,
+  deserializeFunction,
   getInvocationUrl,
-  getUserFunctionUrlInMetadata,
+  getUserFunctionIdInMetadata,
   logCustomEvent,
-  makeFunctionUrl,
-  setUserFunctionUrlInMetadata
+  serializeFunction,
+  setUserFunctionIdInMetadata,
+  withAuthorization
 };
 //# sourceMappingURL=index.mjs.map