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

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

@@ -9,12 +9,16 @@ import {
   DatabaseService,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
+  FunctionError,
+  FunctionNotFoundError,
   MESSAGE_PROPERTY_TOOL_CALL_ID,
   QueueService,
   RemoteFunctionExecutionService,
   SERVICE_TAGS,
   ServiceContainer,
+  ServiceNotAvailableError,
   TracingService,
+  TriggerStateNotFoundError,
   createDefectLogger,
   createEventLogger,
   getInvocationUrl,
@@ -22,47 +26,21 @@ import {
   logCustomEvent,
   setUserFunctionIdInMetadata,
   withAuthorization
-} from "./chunk-Z4CJ62WS.mjs";
+} from "./chunk-NAQIKLZB.mjs";
 import {
   __export
 } from "./chunk-HSLMI22Q.mjs";
 
-// src/errors.ts
-import { BaseError } from "@dxos/errors";
-var ServiceNotAvailableError = class extends BaseError.extend("SERVICE_NOT_AVAILABLE", "Service not available") {
-  constructor(service, options) {
-    super({
-      context: {
-        service
-      },
-      ...options
-    });
-  }
-};
-var FunctionNotFoundError = class extends BaseError.extend("FUNCTION_NOT_FOUND", "Function not found") {
-  constructor(functionKey, options) {
-    super({
-      context: {
-        function: functionKey
-      },
-      ...options
-    });
-  }
-};
-var FunctionError = class extends BaseError.extend("FUNCTION_ERROR", "Function invocation error") {
-};
-var TriggerStateNotFoundError = class extends BaseError.extend("TRIGGER_STATE_NOT_FOUND", "Trigger state not found") {
-};
-
 // src/handler.ts
-import { Effect, Schema as Schema2 } from "effect";
+import * as Effect from "effect/Effect";
+import * as Schema2 from "effect/Schema";
 import { Obj, Type as Type2 } from "@dxos/echo";
 import { assertArgument } from "@dxos/invariant";
 
 // src/schema.ts
-import { Schema } from "effect";
+import * as Schema from "effect/Schema";
 import { Type } from "@dxos/echo";
-import { JsonSchemaType, LabelAnnotation, Ref } from "@dxos/echo-schema";
+import { JsonSchemaType, LabelAnnotation, Ref } from "@dxos/echo/internal";
 import { DataType } from "@dxos/schema";
 var ScriptType = Schema.Struct({
   name: Schema.optional(Schema.String),
@@ -143,7 +121,7 @@ var defineFunction = ({ key, name, description, inputSchema, outputSchema = Sche
   };
   return {
     [typeId]: true,
-    key: key ?? name,
+    key,
     name,
     description,
     inputSchema,
@@ -165,14 +143,20 @@ var FunctionDefinition = {
     return deserializeFunction(functionObj);
   }
 };
-var serializeFunction = (functionDef) => Obj.make(FunctionType, {
-  key: functionDef.name,
-  name: functionDef.name,
-  version: "0.1.0",
-  description: functionDef.description,
-  inputSchema: Type2.toJsonSchema(functionDef.inputSchema),
-  outputSchema: !functionDef.outputSchema ? void 0 : Type2.toJsonSchema(functionDef.outputSchema)
-});
+var serializeFunction = (functionDef) => {
+  const fn6 = Obj.make(FunctionType, {
+    key: functionDef.key,
+    name: functionDef.name,
+    version: "0.1.0",
+    description: functionDef.description,
+    inputSchema: Type2.toJsonSchema(functionDef.inputSchema),
+    outputSchema: !functionDef.outputSchema ? void 0 : Type2.toJsonSchema(functionDef.outputSchema)
+  });
+  if (functionDef.meta?.deployedFunctionId) {
+    setUserFunctionIdInMetadata(Obj.getMeta(fn6), functionDef.meta.deployedFunctionId);
+  }
+  return fn6;
+};
 var deserializeFunction = (functionObj) => {
   return {
     [typeId]: true,
@@ -182,22 +166,27 @@ var deserializeFunction = (functionObj) => {
     description: functionObj.description,
     inputSchema: !functionObj.inputSchema ? Schema2.Unknown : Type2.toEffectSchema(functionObj.inputSchema),
     outputSchema: !functionObj.outputSchema ? void 0 : Type2.toEffectSchema(functionObj.outputSchema),
+    // TODO(dmaretskyi): This should throw error.
     handler: () => {
+    },
+    meta: {
+      deployedFunctionId: getUserFunctionIdInMetadata(Obj.getMeta(functionObj))
     }
   };
 };
 
 // src/trace.ts
-import { Schema as Schema4 } from "effect";
+import * as Schema4 from "effect/Schema";
 import { Type as Type4 } from "@dxos/echo";
+import { ObjectId } from "@dxos/echo/internal";
 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 Obj2, QueryAST, Type as Type3 } from "@dxos/echo";
+import { Expando, OptionsAnnotationId, RawObject, Ref as Ref2 } from "@dxos/echo/internal";
 import { DXN } from "@dxos/keys";
 var TriggerKinds = [
   "timer",
@@ -241,9 +230,12 @@ var WebhookTriggerSchema = Schema3.Struct({
 }).pipe(Schema3.mutable);
 var SubscriptionTriggerSchema = 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,7 +249,7 @@ var SubscriptionTriggerSchema = Schema3.Struct({
     title: "Options"
   }))
 }).pipe(Schema3.mutable);
-var TriggerSchema = Schema3.Union(TimerTriggerSchema, WebhookTriggerSchema, SubscriptionTriggerSchema, EmailTriggerSchema, QueueTriggerSchema).annotations({
+var TriggerSchema = Schema3.Union(EmailTriggerSchema, QueueTriggerSchema, SubscriptionTriggerSchema, TimerTriggerSchema, WebhookTriggerSchema).annotations({
   title: "Trigger"
 });
 var EmailTriggerOutput = Schema3.mutable(Schema3.Struct({
@@ -281,10 +273,21 @@ var QueueTriggerOutput = Schema3.mutable(Schema3.Struct({
   item: Schema3.Any,
   cursor: Schema3.String
 }));
-var SubscriptionTriggerOutput = Schema3.mutable(Schema3.Struct({
+var SubscriptionTriggerOutput = Schema3.Struct({
+  /**
+  * Type of the mutation.
+  */
+  // TODO(dmaretskyi): Specify enum.
   type: Schema3.String,
-  changedObjectId: Schema3.String
-}));
+  /**
+  * Reference to the object that was changed or created.
+  */
+  subject: Type3.Ref(Obj2.Any),
+  /**
+  * @deprecated
+  */
+  changedObjectId: Schema3.optional(Schema3.String)
+}).pipe(Schema3.mutable);
 var TimerTriggerOutput = Schema3.mutable(Schema3.Struct({
   tick: Schema3.Number
 }));
@@ -339,17 +342,17 @@ var FUNCTION_TYPES = [
 
 // src/trace.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/trace.ts";
-var InvocationOutcome = /* @__PURE__ */ function(InvocationOutcome2) {
+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({
   timestamp: Schema4.Number,
   message: Schema4.String,
@@ -483,13 +486,26 @@ var createInvocationSpans = (items) => {
 };
 
 // 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 * as Context3 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import { Obj as Obj3, Ref as Ref3 } from "@dxos/echo";
 import { DXN as DXN2, ObjectId as ObjectId2 } from "@dxos/keys";
 
+// src/services/function-invocation-service.ts
+import * as Context2 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import { AiService as AiService2 } from "@dxos/ai";
+
 // src/services/local-function-execution.ts
-import { Context, Effect as Effect2, Layer, Schema as Schema5 } from "effect";
+import * as Context from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema5 from "effect/Schema";
+import { AiService } from "@dxos/ai";
 import { todo } from "@dxos/debug";
+import { log as log2 } from "@dxos/log";
 function _define_property(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -503,25 +519,40 @@ function _define_property(obj, key, value) {
   }
   return obj;
 }
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/services/local-function-execution.ts";
 var _Context_Tag;
 var LocalFunctionExecutionService = class extends (_Context_Tag = Context.Tag("@dxos/functions/LocalFunctionExecutionService")()) {
 };
-_define_property(LocalFunctionExecutionService, "layer", Layer.succeed(LocalFunctionExecutionService, {
-  invokeFunction: (functionDef, input) => invokeFunction(functionDef, input)
-}));
 _define_property(LocalFunctionExecutionService, "layerLive", Layer.effect(LocalFunctionExecutionService, Effect2.gen(function* () {
   const resolver = yield* FunctionImplementationResolver;
+  const ai = yield* AiService.AiService;
+  const credentials = yield* CredentialsService;
+  const database = yield* DatabaseService;
+  const queues = yield* QueueService;
+  const functionCallService = yield* RemoteFunctionExecutionService;
   return {
-    invokeFunction: Effect2.fn("invokeFunction")(function* (functionDef, input) {
+    // TODO(dmaretskyi): Better error types.
+    invokeFunction: (functionDef, input) => Effect2.gen(function* () {
       const resolved = yield* resolver.resolveFunctionImplementation(functionDef).pipe(Effect2.orDie);
-      return yield* invokeFunction(resolved, input);
-    })
+      const output = yield* invokeFunction(resolved, input);
+      return output;
+    }).pipe(Effect2.provideService(AiService.AiService, ai), Effect2.provideService(CredentialsService, credentials), Effect2.provideService(DatabaseService, database), Effect2.provideService(QueueService, queues), Effect2.provideService(RemoteFunctionExecutionService, functionCallService))
   };
 })));
 _define_property(LocalFunctionExecutionService, "invokeFunction", Effect2.serviceFunctionEffect(LocalFunctionExecutionService, (_) => _.invokeFunction));
 var invokeFunction = (functionDef, input) => Effect2.gen(function* () {
-  const assertInput = functionDef.inputSchema.pipe(Schema5.asserts);
-  assertInput(input);
+  try {
+    const assertInput = functionDef.inputSchema.pipe(Schema5.asserts);
+    assertInput(input);
+  } catch (e) {
+    throw new FunctionError({
+      message: "Invalid function input",
+      context: {
+        name: functionDef.name
+      },
+      cause: e
+    });
+  }
   const context = {
     space: void 0,
     getService: () => todo(),
@@ -529,6 +560,15 @@ var invokeFunction = (functionDef, input) => Effect2.gen(function* () {
       throw new Error("Not available. Use the database service instead.");
     }
   };
+  log2.info("invoking function", {
+    name: functionDef.name,
+    input
+  }, {
+    F: __dxlog_file2,
+    L: 98,
+    S: this,
+    C: (f, a) => f(...a)
+  });
   const data = yield* Effect2.gen(function* () {
     const result = functionDef.handler({
       context,
@@ -547,8 +587,28 @@ var invokeFunction = (functionDef, input) => Effect2.gen(function* () {
     },
     cause: defect
   }))));
-  const assertOutput = functionDef.outputSchema?.pipe(Schema5.asserts);
-  assertOutput(data);
+  log2.info("completed", {
+    function: functionDef.name,
+    input,
+    data
+  }, {
+    F: __dxlog_file2,
+    L: 122,
+    S: this,
+    C: (f, a) => f(...a)
+  });
+  try {
+    const assertOutput = functionDef.outputSchema?.pipe(Schema5.asserts);
+    assertOutput(data);
+  } catch (e) {
+    throw new FunctionError({
+      message: "Invalid function output",
+      context: {
+        name: functionDef.name
+      },
+      cause: e
+    });
+  }
   return data;
 }).pipe(Effect2.withSpan("invokeFunction", {
   attributes: {
@@ -560,7 +620,7 @@ var FunctionImplementationResolver = class extends (_Context_Tag1 = Context.Tag(
 };
 _define_property(FunctionImplementationResolver, "layerTest", ({ functions }) => Layer.succeed(FunctionImplementationResolver, {
   resolveFunctionImplementation: (functionDef) => {
-    const resolved = functions.find((f) => f.name === functionDef.name);
+    const resolved = functions.find((f) => f.key === functionDef.key);
     if (!resolved) {
       return Effect2.fail(new FunctionNotFoundError(functionDef.name));
     }
@@ -568,7 +628,7 @@ _define_property(FunctionImplementationResolver, "layerTest", ({ functions }) =>
   }
 }));
 
-// src/triggers/invocation-tracer.ts
+// src/services/function-invocation-service.ts
 function _define_property2(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -583,17 +643,54 @@ function _define_property2(obj, key, value) {
   return obj;
 }
 var _Context_Tag2;
-var InvocationTracer = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/InvocationTracer")()) {
+var FunctionInvocationService = class extends (_Context_Tag2 = Context2.Tag("@dxos/functions/FunctionInvocationService")()) {
+};
+_define_property2(FunctionInvocationService, "invokeFunction", Effect3.serviceFunctionEffect(FunctionInvocationService, (_) => _.invokeFunction));
+_define_property2(FunctionInvocationService, "layer", Layer2.effect(FunctionInvocationService, Effect3.gen(function* () {
+  const localExecutioner = yield* LocalFunctionExecutionService;
+  const remoteExecutioner = yield* RemoteFunctionExecutionService;
+  return {
+    invokeFunction: (functionDef, input) => Effect3.gen(function* () {
+      if (functionDef.meta?.deployedFunctionId) {
+        return yield* remoteExecutioner.callFunction(functionDef.meta.deployedFunctionId, input);
+      }
+      return yield* localExecutioner.invokeFunction(functionDef, input);
+    })
+  };
+})));
+_define_property2(FunctionInvocationService, "layerTest", ({ functions = [] } = {}) => FunctionInvocationService.layer.pipe(Layer2.provide(LocalFunctionExecutionService.layerLive), Layer2.provide(FunctionImplementationResolver.layerTest({
+  functions
+})), Layer2.provide(RemoteFunctionExecutionService.layerMock)));
+_define_property2(FunctionInvocationService, "layerTestMocked", ({ functions }) => FunctionInvocationService.layerTest({
+  functions
+}).pipe(Layer2.provide(AiService2.notAvailable), Layer2.provide(CredentialsService.configuredLayer([])), Layer2.provide(DatabaseService.notAvailable), Layer2.provide(QueueService.notAvailable)));
+
+// src/triggers/invocation-tracer.ts
+function _define_property3(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+var _Context_Tag3;
+var InvocationTracer = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/InvocationTracer")()) {
 };
-_define_property2(InvocationTracer, "layerLive", (opts) => Layer2.effect(InvocationTracer, Effect3.gen(function* () {
+_define_property3(InvocationTracer, "layerLive", (opts) => Layer3.effect(InvocationTracer, Effect4.gen(function* () {
   return {
-    traceInvocationStart: Effect3.fn("traceInvocationStart")(function* ({ payload, target }) {
+    traceInvocationStart: Effect4.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, {
+      const traceEvent = Obj3.make(InvocationTraceStartEvent, {
         type: InvocationTraceEventType.START,
         invocationId,
         timestamp: now,
@@ -611,9 +708,9 @@ _define_property2(InvocationTracer, "layerLive", (opts) => Layer2.effect(Invocat
         invocationTraceQueue
       };
     }),
-    traceInvocationEnd: Effect3.fn("traceInvocationEnd")(function* ({ trace, exception }) {
+    traceInvocationEnd: Effect4.fn("traceInvocationEnd")(function* ({ trace, exception }) {
       const now = Date.now();
-      const traceEvent = Obj2.make(InvocationTraceEndEvent, {
+      const traceEvent = Obj3.make(InvocationTraceEndEvent, {
         type: InvocationTraceEventType.END,
         invocationId: trace.invocationId,
         timestamp: now,
@@ -631,7 +728,7 @@ _define_property2(InvocationTracer, "layerLive", (opts) => Layer2.effect(Invocat
     })
   };
 })));
-_define_property2(InvocationTracer, "layerTest", Layer2.unwrapEffect(Effect3.gen(function* () {
+_define_property3(InvocationTracer, "layerTest", Layer3.unwrapEffect(Effect4.gen(function* () {
   const queue = yield* QueueService.createQueue({
     subspaceTag: "trace"
   });
@@ -641,11 +738,22 @@ _define_property2(InvocationTracer, "layerTest", Layer2.unwrapEffect(Effect3.gen
 })));
 
 // 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 * 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 Effect6 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 Record3 from "effect/Record";
+import * as Schedule from "effect/Schedule";
+import { DXN as DXN3, Filter, Obj as Obj4, Query } from "@dxos/echo";
 import { causeToError } from "@dxos/effect";
 import { invariant } from "@dxos/invariant";
-import { log as log2 } from "@dxos/log";
+import { log as log3 } from "@dxos/log";
 import { KEY_QUEUE_POSITION } from "@dxos/protocols";
 
 // src/triggers/input-builder.ts
@@ -672,13 +780,14 @@ var createInvocationPayload = (trigger, event) => {
 };
 
 // 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 * as KeyValueStore from "@effect/platform/KeyValueStore";
+import * as Context4 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Schema6 from "effect/Schema";
 import { ObjectId as ObjectId3 } from "@dxos/keys";
-function _define_property3(obj, key, value) {
+function _define_property4(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value,
@@ -701,32 +810,32 @@ var TriggerState = Schema6.Struct({
     })
   })))
 });
-var _Context_Tag3;
-var TriggerStateStore = class extends (_Context_Tag3 = Context3.Tag("@dxos/functions/TriggerStateStore")()) {
+var _Context_Tag4;
+var TriggerStateStore = class extends (_Context_Tag4 = Context4.Tag("@dxos/functions/TriggerStateStore")()) {
 };
-_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* () {
+_define_property4(TriggerStateStore, "getState", Effect5.serviceFunctionEffect(TriggerStateStore, (_) => _.getState));
+_define_property4(TriggerStateStore, "saveState", Effect5.serviceFunctionEffect(TriggerStateStore, (_) => _.saveState));
+_define_property4(TriggerStateStore, "layerKv", Layer4.effect(TriggerStateStore, Effect5.gen(function* () {
   const kv = yield* KeyValueStore.KeyValueStore;
   const schemaStore = kv.forSchema(Schema6.parseJson(TriggerState));
   const store = {
-    getState: Effect4.fn("TriggerStateStore.getState")(function* (triggerId) {
-      const valueOption = yield* schemaStore.get(triggerId).pipe(Effect4.orDie);
+    getState: Effect5.fn("TriggerStateStore.getState")(function* (triggerId) {
+      const valueOption = yield* schemaStore.get(triggerId).pipe(Effect5.orDie);
       if (Option.isNone(valueOption)) {
-        return yield* Effect4.fail(new TriggerStateNotFoundError());
+        return yield* Effect5.fail(new TriggerStateNotFoundError());
       }
       return valueOption.value;
     }),
-    saveState: Effect4.fn("TriggerStateStore.saveState")(function* (state) {
-      yield* schemaStore.set(state.triggerId, state).pipe(Effect4.orDie);
+    saveState: Effect5.fn("TriggerStateStore.saveState")(function* (state) {
+      yield* schemaStore.set(state.triggerId, state).pipe(Effect5.orDie);
     })
   };
   return store;
 })));
-_define_property3(TriggerStateStore, "layerMemory", TriggerStateStore.layerKv.pipe(Layer3.provide(KeyValueStore.layerMemory)));
+_define_property4(TriggerStateStore, "layerMemory", TriggerStateStore.layerKv.pipe(Layer4.provide(KeyValueStore.layerMemory)));
 
 // src/triggers/trigger-dispatcher.ts
-function _define_property4(obj, key, value) {
+function _define_property5(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value,
@@ -739,11 +848,11 @@ function _define_property4(obj, key, value) {
   }
   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")()) {
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/triggers/trigger-dispatcher.ts";
+var _Context_Tag5;
+var TriggerDispatcher = class extends (_Context_Tag5 = Context5.Tag("@dxos/functions/TriggerDispatcher")()) {
 };
-_define_property4(TriggerDispatcher, "layer", (options) => Layer4.effect(TriggerDispatcher, Effect5.gen(function* () {
+_define_property5(TriggerDispatcher, "layer", (options) => Layer5.effect(TriggerDispatcher, Effect6.gen(function* () {
   return new TriggerDispatcherImpl(options);
 })));
 var TriggerDispatcherImpl = class {
@@ -751,44 +860,44 @@ var TriggerDispatcherImpl = class {
     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* () {
+    _define_property5(this, "livePollInterval", void 0);
+    _define_property5(this, "timeControl", void 0);
+    _define_property5(this, "_running", false);
+    _define_property5(this, "_internalTime", void 0);
+    _define_property5(this, "_timerFiber", void 0);
+    _define_property5(this, "_scheduledTriggers", /* @__PURE__ */ new Map());
+    _define_property5(this, "start", () => Effect6.gen(this, function* () {
       if (this._running) {
         return;
       }
       this._running = true;
       if (this.timeControl === "natural") {
-        this._timerFiber = yield* this._startNaturalTimeProcessing().pipe(Effect5.tapErrorCause((cause) => {
+        this._timerFiber = yield* this._startNaturalTimeProcessing().pipe(Effect6.tapErrorCause((cause) => {
           const error = causeToError(cause);
-          log2.error("trigger dispatcher error", {
+          log3.error("trigger dispatcher error", {
             error
           }, {
-            F: __dxlog_file2,
-            L: 170,
+            F: __dxlog_file3,
+            L: 187,
             S: this,
             C: (f, a) => f(...a)
           });
           this._running = false;
-          return Effect5.void;
-        }), Effect5.forkDaemon);
+          return Effect6.void;
+        }), Effect6.forkDaemon);
       } else {
-        return yield* Effect5.dieMessage("TriggerDispatcher started in manual time control mode");
+        return yield* Effect6.dieMessage("TriggerDispatcher started in manual time control mode");
       }
-      log2.info("TriggerDispatcher started", {
+      log3.info("TriggerDispatcher started", {
         timeControl: this.timeControl
       }, {
-        F: __dxlog_file2,
-        L: 180,
+        F: __dxlog_file3,
+        L: 197,
         S: this,
         C: (f, a) => f(...a)
       });
     }));
-    _define_property4(this, "stop", () => Effect5.gen(this, function* () {
+    _define_property5(this, "stop", () => Effect6.gen(this, function* () {
       if (!this._running) {
         return;
       }
@@ -798,22 +907,22 @@ var TriggerDispatcherImpl = class {
         this._timerFiber = void 0;
       }
       this._scheduledTriggers.clear();
-      log2.info("TriggerDispatcher stopped", void 0, {
-        F: __dxlog_file2,
-        L: 200,
+      log3.info("TriggerDispatcher stopped", void 0, {
+        F: __dxlog_file3,
+        L: 217,
         S: this,
         C: (f, a) => f(...a)
       });
     }));
-    _define_property4(this, "invokeTrigger", (options2) => Effect5.gen(this, function* () {
+    _define_property5(this, "invokeTrigger", (options2) => Effect6.gen(this, function* () {
       const { trigger, event } = options2;
-      log2.info("running trigger", {
+      log3.info("running trigger", {
         triggerId: trigger.id,
         spec: trigger.spec,
         event
       }, {
-        F: __dxlog_file2,
-        L: 208,
+        F: __dxlog_file3,
+        L: 225,
         S: this,
         C: (f, a) => f(...a)
       });
@@ -829,17 +938,17 @@ var TriggerDispatcherImpl = class {
           data: event
         }
       });
-      const result = yield* Effect5.gen(this, function* () {
+      const result = yield* Effect6.gen(this, function* () {
         if (!trigger.enabled) {
-          return yield* Effect5.dieMessage("Attempting to invoke disabled trigger");
+          return yield* Effect6.dieMessage("Attempting to invoke disabled trigger");
         }
         if (!trigger.function) {
-          return yield* Effect5.dieMessage("Trigger has no function reference");
+          return yield* Effect6.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,
+        const serialiedFunction = yield* DatabaseService.load(trigger.function).pipe(Effect6.orDie);
+        invariant(Obj4.instanceOf(FunctionType, serialiedFunction), void 0, {
+          F: __dxlog_file3,
+          L: 252,
           S: this,
           A: [
             "Obj.instanceOf(FunctionType, serialiedFunction)",
@@ -848,27 +957,27 @@ var TriggerDispatcherImpl = class {
         });
         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);
+        return yield* FunctionInvocationService.invokeFunction(functionDef, inputData).pipe(Effect6.provide(ComputeEventLogger.layerFromTracing.pipe(Layer5.provideMerge(TracingService.layerQueue(trace.invocationTraceQueue)))));
+      }).pipe(Effect6.exit);
       const triggerExecutionResult = {
         triggerId: trigger.id,
         result
       };
       if (Exit.isSuccess(result)) {
-        log2.info("trigger execution success", {
+        log3.info("trigger execution success", {
           triggerId: trigger.id
         }, {
-          F: __dxlog_file2,
-          L: 256,
+          F: __dxlog_file3,
+          L: 273,
           S: this,
           C: (f, a) => f(...a)
         });
       } else {
-        log2.error("trigger execution failure", {
+        log3.error("trigger execution failure", {
           error: causeToError(result.cause)
         }, {
-          F: __dxlog_file2,
-          L: 260,
+          F: __dxlog_file3,
+          L: 277,
           S: this,
           C: (f, a) => f(...a)
         });
@@ -880,11 +989,11 @@ var TriggerDispatcherImpl = class {
       });
       return triggerExecutionResult;
     }));
-    _define_property4(this, "invokeScheduledTriggers", ({ kinds = [
+    _define_property5(this, "invokeScheduledTriggers", ({ kinds = [
       "timer",
       "queue",
       "subscription"
-    ] } = {}) => Effect5.gen(this, function* () {
+    ] } = {}) => Effect6.gen(this, function* () {
       const invocations = [];
       for (const kind of kinds) {
         switch (kind) {
@@ -899,7 +1008,7 @@ var TriggerDispatcherImpl = class {
                   scheduledTrigger.nextExecution = Cron.next(scheduledTrigger.cron, now);
                 }
               }
-              invocations.push(...yield* Effect5.forEach(triggersToInvoke, (trigger) => this.invokeTrigger({
+              invocations.push(...yield* Effect6.forEach(triggersToInvoke, (trigger) => this.invokeTrigger({
                 trigger,
                 event: {
                   tick: now.getTime()
@@ -916,11 +1025,11 @@ var TriggerDispatcherImpl = class {
               if (spec?.kind !== "queue") {
                 continue;
               }
-              const cursor = Obj3.getKeys(trigger, KEY_QUEUE_CURSOR).at(0)?.id;
+              const cursor = Obj4.getKeys(trigger, KEY_QUEUE_CURSOR).at(0)?.id;
               const queue = yield* QueueService.getQueue(DXN3.parse(spec.queue));
-              const objects = yield* Effect5.promise(() => queue.queryObjects());
+              const objects = yield* Effect6.promise(() => queue.queryObjects());
               for (const object of objects) {
-                const objectPos = Obj3.getKeys(object, KEY_QUEUE_POSITION).at(0)?.id;
+                const objectPos = Obj4.getKeys(object, KEY_QUEUE_POSITION).at(0)?.id;
                 if (!objectPos || cursor && parseInt(cursor) >= parseInt(objectPos)) {
                   continue;
                 }
@@ -932,8 +1041,8 @@ var TriggerDispatcherImpl = class {
                     cursor: objectPos
                   }
                 }));
-                Obj3.deleteKeys(trigger, KEY_QUEUE_CURSOR);
-                Obj3.getMeta(trigger).keys.push({
+                Obj4.deleteKeys(trigger, KEY_QUEUE_CURSOR);
+                Obj4.getMeta(trigger).keys.push({
                   source: KEY_QUEUE_CURSOR,
                   id: objectPos
                 });
@@ -946,12 +1055,12 @@ var TriggerDispatcherImpl = class {
           case "subscription": {
             const triggers = yield* this._fetchTriggers();
             for (const trigger of triggers) {
-              const spec = Obj3.getSnapshot(trigger).spec;
+              const spec = Obj4.getSnapshot(trigger).spec;
               if (spec?.kind !== "subscription") {
                 continue;
               }
-              const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query));
-              const state = yield* TriggerStateStore.getState(trigger.id).pipe(Effect5.catchTag("TRIGGER_STATE_NOT_FOUND", () => Effect5.succeed({
+              const { objects } = yield* DatabaseService.runQuery(Query.fromAst(spec.query.ast));
+              const state = yield* TriggerStateStore.getState(trigger.id).pipe(Effect6.catchTag("TRIGGER_STATE_NOT_FOUND", () => Effect6.succeed({
                 version: "1",
                 triggerId: trigger.id,
                 state: {
@@ -960,8 +1069,8 @@ var TriggerDispatcherImpl = class {
                 }
               })));
               invariant(state.state?._tag === "subscription", void 0, {
-                F: __dxlog_file2,
-                L: 373,
+                F: __dxlog_file3,
+                L: 390,
                 S: this,
                 A: [
                   "state.state?._tag === 'subscription'",
@@ -970,21 +1079,23 @@ var TriggerDispatcherImpl = class {
               });
               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";
+                const existingVersion = Record3.get(state.state.processedVersions, object.id).pipe(Option2.map(Obj4.decodeVersion));
+                const currentVersion = Obj4.version(object);
+                const run = Option2.isNone(existingVersion) || Obj4.compareVersions(currentVersion, existingVersion.value) === "different";
                 if (!run) {
                   continue;
                 }
+                const { db } = yield* DatabaseService;
                 invocations.push(yield* this.invokeTrigger({
                   trigger,
                   event: {
                     // TODO(dmaretskyi): Change type not supported.
                     type: "unknown",
+                    subject: db.ref(Obj4.getDXN(object)),
                     changedObjectId: object.id
                   }
                 }));
-                state.state.processedVersions[object.id] = Obj3.encodeVersion(currentVersion);
+                state.state.processedVersions[object.id] = Obj4.encodeVersion(currentVersion);
                 updated = true;
               }
               if (updated) {
@@ -994,36 +1105,36 @@ var TriggerDispatcherImpl = class {
             break;
           }
           default: {
-            return yield* Effect5.dieMessage(`Unknown trigger kind: ${kind}`);
+            return yield* Effect6.dieMessage(`Unknown trigger kind: ${kind}`);
           }
         }
       }
       return invocations;
     }));
-    _define_property4(this, "advanceTime", (duration) => Effect5.gen(this, function* () {
+    _define_property5(this, "advanceTime", (duration) => Effect6.gen(this, function* () {
       if (this.timeControl !== "manual") {
-        return yield* Effect5.dieMessage("advanceTime can only be used in manual time control mode");
+        return yield* Effect6.dieMessage("advanceTime can only be used in manual time control mode");
       }
       const millis = Duration.toMillis(duration);
       this._internalTime = new Date(this._internalTime.getTime() + millis);
-      log2("Advanced internal time", {
+      log3("Advanced internal time", {
         newTime: this._internalTime,
         advancedBy: Duration.format(duration)
       }, {
-        F: __dxlog_file2,
-        L: 426,
+        F: __dxlog_file3,
+        L: 447,
         S: this,
         C: (f, a) => f(...a)
       });
-    }).pipe(Effect5.orDie));
-    _define_property4(this, "getCurrentTime", () => {
+    }).pipe(Effect6.orDie));
+    _define_property5(this, "getCurrentTime", () => {
       if (this.timeControl === "natural") {
         return /* @__PURE__ */ new Date();
       } else {
         return new Date(this._internalTime);
       }
     });
-    _define_property4(this, "refreshTriggers", () => Effect5.gen(this, function* () {
+    _define_property5(this, "refreshTriggers", () => Effect6.gen(this, function* () {
       const triggers = yield* this._fetchTriggers();
       const currentTriggerIds = new Set(triggers.map((t) => t.id));
       for (const triggerId of this._scheduledTriggers.keys()) {
@@ -1040,14 +1151,14 @@ var TriggerDispatcherImpl = class {
             const existing = this._scheduledTriggers.get(trigger.id);
             const now = this.getCurrentTime();
             const nextExecution = existing?.nextExecution ?? Cron.next(cron, now);
-            log2("Updated scheduled trigger", {
+            log3("Updated scheduled trigger", {
               triggerId: trigger.id,
               cron: timerSpec.cron,
               nextExecution,
               now
             }, {
-              F: __dxlog_file2,
-              L: 466,
+              F: __dxlog_file3,
+              L: 487,
               S: this,
               C: (f, a) => f(...a)
             });
@@ -1057,36 +1168,36 @@ var TriggerDispatcherImpl = class {
               nextExecution
             });
           } else {
-            log2.error("Invalid cron expression", {
+            log3.error("Invalid cron expression", {
               triggerId: trigger.id,
               cron: timerSpec.cron,
               error: cronEither.left.message
             }, {
-              F: __dxlog_file2,
-              L: 478,
+              F: __dxlog_file3,
+              L: 499,
               S: this,
               C: (f, a) => f(...a)
             });
           }
         }
       }
-      log2("Updated scheduled triggers", {
+      log3("Updated scheduled triggers", {
         count: this._scheduledTriggers.size
       }, {
-        F: __dxlog_file2,
-        L: 487,
+        F: __dxlog_file3,
+        L: 508,
         S: this,
         C: (f, a) => f(...a)
       });
-    }).pipe(Effect5.withSpan("TriggerDispatcher.refreshTriggers")));
-    _define_property4(this, "_fetchTriggers", () => Effect5.gen(this, function* () {
+    }).pipe(Effect6.withSpan("TriggerDispatcher.refreshTriggers")));
+    _define_property5(this, "_fetchTriggers", () => Effect6.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* () {
+    }).pipe(Effect6.withSpan("TriggerDispatcher.fetchTriggers")));
+    _define_property5(this, "_startNaturalTimeProcessing", () => Effect6.gen(this, function* () {
       yield* this.invokeScheduledTriggers();
-    }).pipe(Effect5.repeat(Schedule.fixed(this.livePollInterval)), Effect5.asVoid));
-    _define_property4(this, "_prepareInputData", (trigger, event) => {
+    }).pipe(Effect6.repeat(Schedule.fixed(this.livePollInterval)), Effect6.asVoid));
+    _define_property5(this, "_prepareInputData", (trigger, event) => {
       return createInvocationPayload(trigger, event);
     });
     this.timeControl = options.timeControl;
@@ -1097,9 +1208,10 @@ var TriggerDispatcherImpl = class {
 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 * as Effect7 from "effect/Effect";
+import * as Schema7 from "effect/Schema";
 import { runAndForwardErrors } from "@dxos/effect";
-function _define_property5(obj, key, value) {
+function _define_property6(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
       value,
@@ -1132,8 +1244,8 @@ var FunctionExecutor = class {
       data: input
     });
     let data;
-    if (Effect6.isEffect(result)) {
-      data = await result.pipe(Effect6.provide(this._services.createLayer()), runAndForwardErrors);
+    if (Effect7.isEffect(result)) {
+      data = await result.pipe(Effect7.provide(this._services.createLayer()), runAndForwardErrors);
     } else {
       data = await result;
     }
@@ -1142,7 +1254,7 @@ var FunctionExecutor = class {
     return data;
   }
   constructor(_services) {
-    _define_property5(this, "_services", void 0);
+    _define_property6(this, "_services", void 0);
     this._services = _services;
   }
 };
@@ -1156,9 +1268,11 @@ __export(examples_exports, {
 });
 
 // src/examples/fib.ts
-import { Effect as Effect7, Schema as Schema8 } from "effect";
+import * as Effect8 from "effect/Effect";
+import * as Schema8 from "effect/Schema";
 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({
@@ -1169,7 +1283,7 @@ var fib_default = defineFunction({
   outputSchema: Schema8.Struct({
     result: Schema8.String
   }),
-  handler: Effect7.fn(function* ({ data: { iterations = 1e5 } }) {
+  handler: Effect8.fn(function* ({ data: { iterations = 1e5 } }) {
     let a = 0n;
     let b = 1n;
     for (let i = 0; i < iterations; i++) {
@@ -1183,13 +1297,16 @@ var fib_default = defineFunction({
 });
 
 // src/examples/reply.ts
-import { Console, Effect as Effect8, Schema as Schema9 } from "effect";
+import * as Console from "effect/Console";
+import * as Effect9 from "effect/Effect";
+import * as Schema9 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 }) {
+  handler: Effect9.fn(function* ({ data }) {
     yield* Console.log("reply", {
       data
     });
@@ -1198,9 +1315,11 @@ var reply_default = defineFunction({
 });
 
 // src/examples/sleep.ts
-import { Effect as Effect9, Schema as Schema10 } from "effect";
+import * as Effect10 from "effect/Effect";
+import * as Schema10 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({
@@ -1209,8 +1328,8 @@ var sleep_default = defineFunction({
     })
   }),
   outputSchema: Schema10.Void,
-  handler: Effect9.fn(function* ({ data: { duration = 1e5 } }) {
-    yield* Effect9.sleep(duration);
+  handler: Effect10.fn(function* ({ data: { duration = 1e5 } }) {
+    yield* Effect10.sleep(duration);
   })
 });
 export {
@@ -1229,6 +1348,7 @@ export {
   FunctionError,
   FunctionExecutor,
   FunctionImplementationResolver,
+  FunctionInvocationService,
   FunctionManifestSchema,
   FunctionNotFoundError,
   FunctionTrigger,