@dxos/functions 0.8.4-main.bc674ce → 0.8.4-main.bcb3aa67d6

package/dist/lib/{browser → neutral}/index.mjs

@@ -1,8 +1,16 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import {
+  EventType,
+  Trace_exports,
+  writerLayerNoop
+} from "./chunk-BHLSCAA2.mjs";
+import {
+  Fibonacci,
+  Reply,
+  Sleep
+} from "./chunk-Z2XDJJVH.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
 
 // src/errors.ts
 import { BaseError } from "@dxos/errors";
@@ -12,7 +20,8 @@ var ServiceNotAvailableError = class extends BaseError.extend("ServiceNotAvailab
       context: {
         service
       },
-      ...options
+      ...options,
+      message: `Service not available: ${service}`
     });
   }
 };
@@ -31,539 +40,277 @@ var FunctionError = class extends BaseError.extend("FunctionError", "Function in
 var TriggerStateNotFoundError = class extends BaseError.extend("TriggerStateNotFound", "Trigger state not found") {
 };
 
-// src/example/fib.ts
-import * as Effect2 from "effect/Effect";
-import * as Schema6 from "effect/Schema";
-
-// src/sdk.ts
-import * as Effect from "effect/Effect";
-import * as Schema5 from "effect/Schema";
-import { Obj as Obj4, Type as Type5 } from "@dxos/echo";
-import { assertArgument, failedInvariant } from "@dxos/invariant";
-import { Operation } from "@dxos/operation";
+// src/example/index.ts
+import { OperationHandlerSet } from "@dxos/operation";
+var ExampleHandlers = OperationHandlerSet.lazy(() => import("./fib-S6PPI4UW.mjs"), () => import("./reply-TOHXEG7V.mjs"), () => import("./sleep-QPSZDPEH.mjs"));
 
-// src/types/Function.ts
-var Function_exports = {};
-__export(Function_exports, {
-  Function: () => Function,
-  make: () => make2,
-  setFrom: () => setFrom
-});
-import * as Schema2 from "effect/Schema";
-import { Annotation as Annotation2, JsonSchema, Obj as Obj2, Type as Type2 } from "@dxos/echo";
-import { SystemTypeAnnotation } from "@dxos/echo/internal";
-
-// src/types/Script.ts
-var Script_exports = {};
-__export(Script_exports, {
-  Script: () => Script,
-  make: () => make
+// src/process/Process.ts
+var Process_exports = {};
+__export(Process_exports, {
+  ExitedEvent: () => ExitedEvent,
+  ID: () => ID,
+  ProcessMonitorService: () => ProcessMonitorService,
+  ProcessTypeId: () => ProcessTypeId,
+  SpawnedEvent: () => SpawnedEvent,
+  State: () => State,
+  fromOperation: () => fromOperation,
+  isProcess: () => isProcess,
+  make: () => make,
+  prettyProcessTree: () => prettyProcessTree
 });
+import * as Effect from "effect/Effect";
 import * as Schema from "effect/Schema";
-import { Annotation, Obj, Ref, Type } from "@dxos/echo";
-import { FormInputAnnotation } from "@dxos/echo/internal";
-import { Text } from "@dxos/schema";
-var Script = Schema.Struct({
-  name: Schema.String.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema.Boolean.pipe(FormInputAnnotation.set(false), Schema.optional),
-  source: Type.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
-}).pipe(Type.object({
-  typename: "dxos.org/type/Script",
-  version: "0.1.0"
-}), Annotation.LabelAnnotation.set([
-  "name"
-]));
-var make = ({ source = "", ...props } = {}) => Obj.make(Script, {
-  ...props,
-  source: Ref.make(Text.make(source))
-});
-
-// src/types/Function.ts
-var Function = Schema2.Struct({
-  /**
-  * Global registry ID.
-  * NOTE: The `key` property refers to the original registry entry.
-  */
-  // 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"
-  }),
-  name: Schema2.NonEmptyString,
-  version: Schema2.String,
-  description: Schema2.optional(Schema2.String),
-  /**
-  * ISO date string of the last deployment.
-  */
-  updated: Schema2.optional(Schema2.String),
-  // Reference to a source script if it exists within ECHO.
-  // TODO(burdon): Don't ref ScriptType directly (core).
-  source: Schema2.optional(Type2.Ref(Script)),
-  inputSchema: Schema2.optional(JsonSchema.JsonSchema),
-  outputSchema: Schema2.optional(JsonSchema.JsonSchema),
-  /**
-  * List of required services.
-  * Match the Context.Tag keys of the FunctionServices variants.
-  */
-  services: Schema2.optional(Schema2.Array(Schema2.String)),
-  // Local binding to a function name.
-  binding: Schema2.optional(Schema2.String)
-}).pipe(Type2.object({
-  typename: "dxos.org/type/Function",
-  version: "0.1.0"
-}), Annotation2.LabelAnnotation.set([
-  "name"
-]), SystemTypeAnnotation.set(true));
-var make2 = (props) => Obj2.make(Function, props);
-var setFrom = (target, source) => {
-  Obj2.change(target, (t) => {
-    t.key = source.key ?? target.key;
-    t.name = source.name ?? target.name;
-    t.version = source.version;
-    t.description = source.description;
-    t.updated = source.updated;
-    t.inputSchema = source.inputSchema ? JSON.parse(JSON.stringify(source.inputSchema)) : void 0;
-    t.outputSchema = source.outputSchema ? JSON.parse(JSON.stringify(source.outputSchema)) : void 0;
-    Obj2.getMeta(t).keys = JSON.parse(JSON.stringify(Obj2.getMeta(source).keys));
-  });
+import * as Context from "effect/Context";
+import { OperationHandlerSet as OperationHandlerSet2 } from "@dxos/operation";
+import { assertArgument } from "@dxos/invariant";
+var ID = Schema.String.pipe(Schema.brand("ProcessId"));
+var ProcessTypeId = "~@dxos/functions/Process";
+var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
+var make = (opts, create) => {
+  assertArgument(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), "key", "Invalid key");
+  return {
+    [ProcessTypeId]: {},
+    ...opts,
+    create: (ctx) => create(ctx).pipe(Effect.map((partial) => ({
+      onSpawn: () => Effect.void,
+      onInput: () => Effect.void,
+      onAlarm: () => Effect.void,
+      onChildEvent: () => Effect.void,
+      ...partial
+    })))
+  };
 };
-
-// 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 { OptionsAnnotationId, SystemTypeAnnotation as SystemTypeAnnotation2 } from "@dxos/echo/internal";
-import { DXN } from "@dxos/keys";
-import { Expando } from "@dxos/schema";
-var Kinds = [
-  "email",
-  "queue",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
+var fromOperation = (op, handler) => make({
+  key: op.meta.key,
+  input: op.input,
+  output: op.output,
+  services: op.services
+}, (ctx) => Effect.gen(function* () {
+  const semaphore = yield* Effect.makeSemaphore(1);
+  return {
+    onInput: (input) => Effect.gen(function* () {
+      const opHandler = yield* OperationHandlerSet2.getHandler(handler, op).pipe(Effect.orDie);
+      const output = yield* opHandler.handler(input).pipe(Effect.orDie);
+      ctx.submitOutput(output);
+      ctx.succeed();
+    }).pipe(semaphore.withPermits(1))
+  };
+}));
+var State = /* @__PURE__ */ (function(State2) {
+  State2["RUNNING"] = "RUNNING";
+  State2["HYBERNATING"] = "HYBERNATING";
+  State2["IDLE"] = "IDLE";
+  State2["TERMINATING"] = "TERMINATING";
+  State2["TERMINATED"] = "TERMINATED";
+  State2["SUCCEEDED"] = "SUCCEEDED";
+  State2["FAILED"] = "FAILED";
+  return State2;
+})({});
+var ProcessMonitorService = class extends Context.Tag("@dxos/functions/ProcessMonitorService")() {
 };
-var EmailSpec = Schema3.Struct({
-  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
-});
-var QueueSpec = Schema3.Struct({
-  kind: Schema3.Literal("queue").annotations(kindLiteralAnnotations),
-  // TODO(dmaretskyi): Change to a reference.
-  queue: DXN.Schema
-});
-var SubscriptionSpec = Schema3.Struct({
-  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  query: Schema3.Struct({
-    raw: Schema3.optional(Schema3.String.annotations({
-      title: "Query"
-    })),
-    ast: QueryAST.Query
-  }),
-  options: Schema3.optional(Schema3.Struct({
-    // Watch changes to object (not just creation).
-    deep: Schema3.optional(Schema3.Boolean.annotations({
-      title: "Nested"
-    })),
-    // Debounce changes (delay in ms).
-    delay: Schema3.optional(Schema3.Number.annotations({
-      title: "Delay"
-    }))
-  }).annotations({
-    title: "Options"
-  }))
-});
-var TimerSpec = Schema3.Struct({
-  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema3.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-});
-var WebhookSpec = Schema3.Struct({
-  kind: Schema3.Literal("webhook").annotations(kindLiteralAnnotations),
-  method: Schema3.optional(Schema3.String.annotations({
-    title: "Method",
-    [OptionsAnnotationId]: [
-      "GET",
-      "POST"
-    ]
-  })),
-  port: Schema3.optional(Schema3.Number.annotations({
-    title: "Port"
-  }))
-});
-var Spec = Schema3.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var TriggerSchema = Schema3.Struct({
-  /**
-  * Function or workflow to invoke.
-  */
-  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
-  function: Schema3.optional(Type3.Ref(Expando.Expando).annotations({
-    title: "Function"
-  })),
-  /**
-  * Only used for workflowSchema.
-  * Specifies the input node in the circuit.
-  * @deprecated Remove and enforce a single input node in all compute graphSchema.
-  */
-  inputNodeId: Schema3.optional(Schema3.String.annotations({
-    title: "Input Node ID"
-  })),
-  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
-  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
-  enabled: Schema3.optional(Schema3.Boolean.annotations({
-    title: "Enabled"
-  })),
-  spec: Schema3.optional(Spec),
-  /**
-  * Passed as the input data to the function.
-  * Must match the function's input schema.
-  *
-  * @example
-  * {
-  *   item: '{{$.trigger.event}}',
-  *   instructions: 'Summarize and perform entity-extraction'
-  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
-  * }
-  */
-  input: Schema3.optional(Schema3.Record({
-    key: Schema3.String,
-    value: Schema3.Any
-  }))
-}).pipe(Type3.object({
-  typename: "dxos.org/type/Trigger",
-  version: "0.1.0"
-}), SystemTypeAnnotation2.set(true));
-var Trigger = TriggerSchema;
-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,
-  TriggerEvent: () => TriggerEvent,
-  WebhookEvent: () => WebhookEvent
-});
-import * as Schema4 from "effect/Schema";
-import { DXN as DXN2, Type as Type4 } from "@dxos/echo";
-var EmailEvent = Schema4.Struct({
-  from: Schema4.String,
-  to: Schema4.String,
-  subject: Schema4.String,
-  created: Schema4.String,
-  body: Schema4.String
-});
-var QueueEvent = Schema4.Struct({
-  queue: DXN2.Schema,
-  item: Schema4.Any,
-  cursor: Schema4.String
+var SpawnedEvent = EventType("process.spawned", {
+  schema: Schema.Void,
+  isEphemeral: false
 });
-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(Type4.Obj),
-  /**
-  * @deprecated
-  */
-  changedObjectId: Schema4.optional(Schema4.String)
-});
-var TimerEvent = Schema4.Struct({
-  tick: Schema4.Number
-});
-var WebhookEvent = Schema4.Struct({
-  url: Schema4.String,
-  method: Schema4.Literal("GET", "POST"),
-  headers: Schema4.Record({
-    key: Schema4.String,
-    value: Schema4.String
+var ExitedEvent = EventType("process.exited", {
+  schema: Schema.Struct({
+    outcome: Schema.Literal("succeeded", "failed", "terminated")
   }),
-  bodyText: Schema4.String
+  isEphemeral: false
 });
-var TriggerEvent = Schema4.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
-
-// src/types/url.ts
-var FUNCTIONS_META_KEY = "dxos.org/service/function";
-var FUNCTIONS_PRESET_META_KEY = "dxos.org/service/function-preset";
-var getUserFunctionIdInMetadata = (meta) => {
-  return meta.keys.find((key) => key.source === FUNCTIONS_META_KEY)?.id;
-};
-var setUserFunctionIdInMetadata = (meta, functionId) => {
-  const key = meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY);
-  if (key) {
-    if (key.id !== functionId) {
-      throw new Error("Metadata mismatch");
-    }
-  } else {
-    meta.keys.push({
-      source: FUNCTIONS_META_KEY,
-      id: functionId
-    });
+var prettyProcessTree = (tree) => {
+  if (tree.length === 0) {
+    return "";
   }
-};
-
-// src/sdk.ts
-var typeId = Symbol.for("@dxos/functions/FunctionDefinition");
-var defineFunction = ({ key, name, description, inputSchema, outputSchema = Schema5.Any, handler, types, services }) => {
-  if (!Schema5.isSchema(inputSchema)) {
-    throw new Error("Input schema must be a valid schema");
+  const pidSet = new Set(tree.map((node) => node.pid));
+  const childrenByParent = /* @__PURE__ */ new Map();
+  const roots = [];
+  for (const node of tree) {
+    const parent = node.parentPid;
+    if (parent === null || !pidSet.has(parent)) {
+      roots.push(node);
+      continue;
+    }
+    const key2 = String(parent);
+    const siblings = childrenByParent.get(key2) ?? [];
+    siblings.push(node);
+    childrenByParent.set(key2, siblings);
   }
-  if (typeof handler !== "function") {
-    throw new Error("Handler must be a function");
+  const byPid = (a, b) => String(a.pid).localeCompare(String(b.pid));
+  roots.sort(byPid);
+  for (const siblings of childrenByParent.values()) {
+    siblings.sort(byPid);
   }
-  const limit = Error.stackTraceLimit;
-  Error.stackTraceLimit = 2;
-  const traceError = new Error();
-  Error.stackTraceLimit = limit;
-  let cache = false;
-  const captureStackTrace = () => {
-    if (cache !== false) {
-      return cache;
+  const formatLabel = (node) => {
+    const idShort = String(node.pid).slice(0, 6);
+    const parts = [
+      idShort,
+      node.state
+    ];
+    if (node.params.name != null && node.params.name !== "") {
+      parts.push(node.params.name);
     }
-    if (traceError.stack !== void 0) {
-      const stack = traceError.stack.split("\n");
-      if (stack[2] !== void 0) {
-        cache = stack[2].trim();
-        return cache;
-      }
+    if (node.error != null) {
+      parts.push(`(${node.error})`);
     }
+    const { inputCount, outputCount, wallTime } = node.metrics;
+    parts.push(`[in:${inputCount} out:${outputCount} wall:${Math.round(wallTime)}ms]`);
+    return parts.join(" ");
   };
-  const handlerWithSpan = (...args) => {
-    const result = handler(...args);
-    if (Effect.isEffect(result)) {
-      return Effect.withSpan(result, `${key ?? name}`, {
-        captureStackTrace
-      });
+  const lines = [];
+  const walk = (node, prefix, isLast, isRoot) => {
+    if (isRoot) {
+      lines.push(`- ${formatLabel(node)}`);
+    } else {
+      const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      lines.push(`${prefix}${branch}${formatLabel(node)}`);
     }
-    return result;
-  };
-  return {
-    [typeId]: true,
-    key,
-    name,
-    description,
-    inputSchema,
-    outputSchema,
-    handler: handlerWithSpan,
-    types: types ?? [],
-    services: !services ? [] : getServiceKeys(services)
+    const children = childrenByParent.get(String(node.pid)) ?? [];
+    const nextPrefix = isRoot ? "  " : `${prefix}${isLast ? "    " : "\u2502   "}`;
+    children.forEach((child, index) => {
+      walk(child, nextPrefix, index === children.length - 1, false);
+    });
   };
+  for (const root of roots) {
+    walk(root, "", true, true);
+  }
+  return lines.join("\n");
 };
-var getServiceKeys = (services) => {
-  return services.map((tag) => {
-    if (typeof tag.key === "string") {
-      return tag.key;
+
+// src/process/ServiceResolver.ts
+var ServiceResolver_exports = {};
+__export(ServiceResolver_exports, {
+  ServiceResolver: () => ServiceResolver,
+  compose: () => compose,
+  empty: () => empty2,
+  fromContext: () => fromContext,
+  fromRequirements: () => fromRequirements,
+  layerRequirements: () => layerRequirements,
+  make: () => make3,
+  resolve: () => resolve,
+  resolveAll: () => resolveAll,
+  succeed: () => succeed
+});
+import * as Context2 from "effect/Context";
+import * as Effect2 from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Either from "effect/Either";
+var ServiceResolverTypeId = "~@dxos/functions/ServiceResolver";
+var ServiceResolver = Context2.GenericTag("@dxos/functions/ServiceResolver");
+var resolve = Effect2.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
+var resolveAll = (tags, context) => Effect2.gen(function* () {
+  const services = yield* Effect2.forEach(tags, (tag) => resolve(tag, context).pipe(Effect2.map((service) => Context2.make(tag, service))));
+  return Context2.mergeAll(...services);
+});
+var succeed = (tag, getService) => {
+  return make3((tag1, context) => {
+    if (tag1.key !== tag.key) {
+      return Effect2.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
     }
-    failedInvariant();
+    const service = getService(context);
+    return service;
   });
 };
-var toOperation = (functionDef) => {
-  const op = Operation.make({
-    schema: {
-      input: functionDef.inputSchema,
-      output: functionDef.outputSchema ?? Schema5.Any
-    },
-    meta: {
-      key: functionDef.key,
-      name: functionDef.name,
-      description: functionDef.description
+var make3 = (resolveFn) => ({
+  [ServiceResolverTypeId]: ServiceResolverTypeId,
+  resolve: resolveFn
+});
+var fromContext = (ctx) => make3((tag, context) => Effect2.gen(function* () {
+  const service = Context2.getOption(ctx, tag);
+  if (Option.isNone(service)) {
+    return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+  }
+  return service.value;
+}));
+var fromRequirements = (...tags) => Effect2.contextWith((parentCtx) => {
+  const available = new Set(tags.map((tag) => tag.key));
+  return make3((tag, context) => Effect2.gen(function* () {
+    let result = Context2.empty();
+    if (!available.has(tag.key)) {
+      return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
     }
-  });
-  const operationHandler = (input) => {
-    const result = functionDef.handler({
-      context: {},
-      data: input
-    });
-    if (Effect.isEffect(result)) {
-      return result;
+    const service = Context2.getOption(parentCtx, tag);
+    if (Option.isNone(service)) {
+      return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
     }
-    if (result instanceof Promise) {
-      return Effect.tryPromise(() => result);
+    return service.value;
+  }));
+});
+var layerRequirements = (...tags) => Layer.effect(ServiceResolver, fromRequirements(...tags));
+var compose = (...resolvers) => make3((tag, context) => Effect2.gen(function* () {
+  for (const resolver of resolvers) {
+    const single = yield* resolver.resolve(tag, context).pipe(Effect2.either);
+    if (Either.isRight(single)) {
+      return single.right;
     }
-    return Effect.succeed(result);
-  };
-  return {
-    ...op,
-    handler: operationHandler
-  };
-};
-var FunctionDefinition = {
-  make: defineFunction,
-  isFunction: (value2) => {
-    return typeof value2 === "object" && value2 !== null && Symbol.for("@dxos/functions/FunctionDefinition") in value2;
-  },
-  serialize: (functionDef) => {
-    assertArgument(FunctionDefinition.isFunction(functionDef), "functionDef");
-    return serializeFunction(functionDef);
-  },
-  deserialize: (functionObj) => {
-    assertArgument(Obj4.instanceOf(Function_exports.Function, functionObj), "functionObj");
-    return deserializeFunction(functionObj);
-  },
-  toOperation
-};
-var serializeFunction = (functionDef) => {
-  const fn4 = Function_exports.make({
-    key: functionDef.key,
-    name: functionDef.name,
-    version: "0.1.0",
-    description: functionDef.description,
-    inputSchema: Type5.toJsonSchema(functionDef.inputSchema),
-    outputSchema: !functionDef.outputSchema ? void 0 : Type5.toJsonSchema(functionDef.outputSchema),
-    services: functionDef.services
-  });
-  if (functionDef.meta?.deployedFunctionId) {
-    Obj4.change(fn4, (fn5) => setUserFunctionIdInMetadata(Obj4.getMeta(fn5), functionDef.meta.deployedFunctionId));
   }
-  return fn4;
+  return yield* Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+}));
+var empty2 = make3((tag, context) => {
+  return Effect2.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+});
+
+// src/process/StorageService.ts
+import * as Pipeable from "effect/Pipeable";
+import * as Context3 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import * as Option2 from "effect/Option";
+var StorageService = class extends Context3.Tag("@dxos/functions/StorageService")() {
 };
-var deserializeFunction = (functionObj) => {
+var get = Effect3.serviceFunctionEffect(StorageService, (_) => _.get);
+var set = Effect3.serviceFunctionEffect(StorageService, (_) => _.set);
+var deleteKey = Effect3.serviceFunctionEffect(StorageService, (_) => _.delete);
+var list = Effect3.serviceFunctionEffect(StorageService, (_) => _.list);
+var clear = Effect3.serviceFunctionEffect(StorageService, (_) => _.clear);
+var key = (schema, key2) => {
   return {
-    [typeId]: true,
-    // TODO(dmaretskyi): Fix key.
-    key: functionObj.key ?? functionObj.name,
-    name: functionObj.name,
-    description: functionObj.description,
-    inputSchema: !functionObj.inputSchema ? Schema5.Unknown : Type5.toEffectSchema(functionObj.inputSchema),
-    outputSchema: !functionObj.outputSchema ? void 0 : Type5.toEffectSchema(functionObj.outputSchema),
-    // TODO(dmaretskyi): This should throw error.
-    handler: () => {
-    },
-    services: functionObj.services ?? [],
-    types: [],
-    meta: {
-      deployedFunctionId: getUserFunctionIdInMetadata(Obj4.getMeta(functionObj))
+    key: key2,
+    get: get(schema, key2),
+    set: (value2) => set(schema, key2, value2),
+    delete: () => deleteKey(key2),
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, arguments);
     }
   };
 };
-
-// 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;
+var withDefault = (getDefault) => (key2) => {
+  return {
+    key: key2.key,
+    get: key2.get.pipe(Effect3.map(Option2.getOrElse(() => getDefault()))),
+    set: (value2) => key2.set(value2),
+    delete: () => key2.delete(),
+    pipe(...args) {
+      return Pipeable.pipeArguments(this, arguments);
     }
-    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);
-  })
-});
-
-// src/example/index.ts
-(function(Example2) {
-  Example2.fib = fib_default;
-  Example2.reply = reply_default;
-  Example2.sleep = sleep_default;
-})(Example || (Example = {}));
-var Example;
+  };
+};
 
 // src/services/credentials.ts
 import * as HttpClient from "@effect/platform/HttpClient";
 import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as Context from "effect/Context";
-import * as Effect5 from "effect/Effect";
-import * as Layer from "effect/Layer";
+import * as Context4 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
 import * as Redacted from "effect/Redacted";
 import { Query } from "@dxos/echo";
 import { Database } from "@dxos/echo";
 import { AccessToken } from "@dxos/types";
-var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
-  static getCredential = (query) => Effect5.gen(function* () {
+var CredentialsService = class _CredentialsService extends Context4.Tag("@dxos/functions/CredentialsService")() {
+  static getCredential = (query) => Effect4.gen(function* () {
     const credentials = yield* _CredentialsService;
-    return yield* Effect5.promise(() => credentials.getCredential(query));
+    return yield* Effect4.promise(() => credentials.getCredential(query));
   });
-  static getApiKey = (query) => Effect5.gen(function* () {
+  static getApiKey = (query) => Effect4.gen(function* () {
     const credential = yield* _CredentialsService.getCredential(query);
     if (!credential.apiKey) {
       throw new Error(`API key not found for service: ${query.service}`);
     }
     return Redacted.make(credential.apiKey);
   });
-  static configuredLayer = (credentials) => Layer.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
-  static layerConfig = (credentials) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
-    const serviceCredentials = yield* Effect5.forEach(credentials, ({ service, apiKey }) => Effect5.gen(function* () {
+  static configuredLayer = (credentials) => Layer2.succeed(_CredentialsService, new ConfiguredCredentialsService(credentials));
+  static layerConfig = (credentials) => Layer2.effect(_CredentialsService, Effect4.gen(function* () {
+    const serviceCredentials = yield* Effect4.forEach(credentials, ({ service, apiKey }) => Effect4.gen(function* () {
       return {
         service,
         apiKey: Redacted.value(yield* apiKey)
@@ -571,7 +318,7 @@ var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/fu
     }));
     return new ConfiguredCredentialsService(serviceCredentials);
   }));
-  static layerFromDatabase = ({ caching = false } = {}) => Layer.effect(_CredentialsService, Effect5.gen(function* () {
+  static layerFromDatabase = ({ caching = false } = {}) => Layer2.effect(_CredentialsService, Effect4.gen(function* () {
     const dbService = yield* Database.Service;
     const cache = /* @__PURE__ */ new Map();
     const queryCredentials = async (query) => {
@@ -629,46 +376,49 @@ var withAuthorization = (token, kind) => HttpClient.mapRequest((request) => {
 });
 
 // src/services/event-logger.ts
-import * as Context3 from "effect/Context";
-import * as Effect7 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import * as Schema9 from "effect/Schema";
-import { Obj as Obj6, Type as Type6 } from "@dxos/echo";
+import * as Context6 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Layer4 from "effect/Layer";
+import * as Schema2 from "effect/Schema";
+import { Obj as Obj2, Type } from "@dxos/echo";
 import { invariant } from "@dxos/invariant";
-import { LogLevel, log as log2 } from "@dxos/log";
+import { LogLevel, log } from "@dxos/log";
 
 // src/services/tracing.ts
-import * as Context2 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
+import * as Context5 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
 import { AgentStatus } from "@dxos/ai";
-import { Obj as Obj5 } from "@dxos/echo";
+import { Obj } from "@dxos/echo";
 import { ObjectId } from "@dxos/keys";
 import { Message } from "@dxos/types";
-var TracingService = class _TracingService extends Context2.Tag("@dxos/functions/TracingService")() {
+var TracingService = class _TracingService extends Context5.Tag("@dxos/functions/TracingService")() {
   static noop = {
     getTraceContext: () => ({}),
     write: () => {
     },
-    traceInvocationStart: () => Effect6.sync(() => ({
+    ephemeral: () => {
+    },
+    traceInvocationStart: () => Effect5.sync(() => ({
       invocationId: ObjectId.random(),
       invocationTraceQueue: void 0
     })),
-    traceInvocationEnd: () => Effect6.sync(() => {
+    traceInvocationEnd: () => Effect5.sync(() => {
     })
   };
-  static layerNoop = Layer2.succeed(_TracingService, _TracingService.noop);
+  static layerNoop = Layer3.succeed(_TracingService, _TracingService.noop);
   /**
   * Creates a TracingService layer that emits events to the parent tracing service.
   */
-  static layerSubframe = (mapContext) => Layer2.effect(_TracingService, Effect6.gen(function* () {
+  static layerSubframe = (mapContext) => Layer3.effect(_TracingService, Effect5.gen(function* () {
     const tracing = yield* _TracingService;
     const context = mapContext(tracing.getTraceContext());
     return {
       write: (event, context2) => tracing.write(event, context2),
+      ephemeral: (event, context2) => tracing.ephemeral(event, context2),
       getTraceContext: () => context,
-      traceInvocationStart: () => Effect6.die("Tracing invocation inside another invocation is not supported."),
-      traceInvocationEnd: () => Effect6.die("Tracing invocation inside another invocation is not supported.")
+      traceInvocationStart: () => Effect5.die("Tracing invocation inside another invocation is not supported."),
+      traceInvocationEnd: () => Effect5.die("Tracing invocation inside another invocation is not supported.")
     };
   }));
   /**
@@ -683,18 +433,18 @@ var TracingService = class _TracingService extends Context2.Tag("@dxos/functions
   /**
   * Emit the current human-readable execution status.
   */
-  static emitStatus = Effect6.fnUntraced(function* (data) {
+  static emitStatus = Effect5.fnUntraced(function* (data) {
     const tracing = yield* _TracingService;
-    tracing.write(Obj5.make(AgentStatus, {
+    tracing.write(Obj.make(AgentStatus, {
       parentMessage: tracing.getTraceContext().parentMessage,
       toolCallId: tracing.getTraceContext().toolCallId,
       created: (/* @__PURE__ */ new Date()).toISOString(),
       ...data
     }), tracing.getTraceContext());
   });
-  static emitConverationMessage = Effect6.fnUntraced(function* (data) {
+  static emitConverationMessage = Effect5.fnUntraced(function* (data) {
     const tracing = yield* _TracingService;
-    tracing.write(Obj5.make(Message.Message, {
+    tracing.write(Obj.make(Message.Message, {
       parentMessage: tracing.getTraceContext().parentMessage,
       ...data,
       properties: {
@@ -703,47 +453,51 @@ var TracingService = class _TracingService extends Context2.Tag("@dxos/functions
       }
     }), tracing.getTraceContext());
   });
+  static emitEphemeralMessage = Effect5.fnUntraced(function* (data) {
+    const tracing = yield* _TracingService;
+    tracing.ephemeral(data, tracing.getTraceContext());
+  });
 };
 var MESSAGE_PROPERTY_TOOL_CALL_ID = "toolCallId";
 
 // src/services/event-logger.ts
 var __dxlog_file = "/__w/dxos/dxos/packages/core/functions/src/services/event-logger.ts";
-var ComputeEventPayload = Schema9.Union(Schema9.Struct({
-  type: Schema9.Literal("begin-compute"),
-  nodeId: Schema9.String,
+var ComputeEventPayload = Schema2.Union(Schema2.Struct({
+  type: Schema2.Literal("begin-compute"),
+  nodeId: Schema2.String,
   /**
    * Names of the inputs begin computed.
    */
-  inputs: Schema9.Array(Schema9.String)
-}), Schema9.Struct({
-  type: Schema9.Literal("end-compute"),
-  nodeId: Schema9.String,
+  inputs: Schema2.Array(Schema2.String)
+}), Schema2.Struct({
+  type: Schema2.Literal("end-compute"),
+  nodeId: Schema2.String,
   /**
    * Names of the outputs computed.
    */
-  outputs: Schema9.Array(Schema9.String)
-}), Schema9.Struct({
-  type: Schema9.Literal("compute-input"),
-  nodeId: Schema9.String,
-  property: Schema9.String,
-  value: Schema9.Any
-}), Schema9.Struct({
-  type: Schema9.Literal("compute-output"),
-  nodeId: Schema9.String,
-  property: Schema9.String,
-  value: Schema9.Any
-}), Schema9.Struct({
-  type: Schema9.Literal("custom"),
-  nodeId: Schema9.String,
-  event: Schema9.Any
+  outputs: Schema2.Array(Schema2.String)
+}), Schema2.Struct({
+  type: Schema2.Literal("compute-input"),
+  nodeId: Schema2.String,
+  property: Schema2.String,
+  value: Schema2.Any
+}), Schema2.Struct({
+  type: Schema2.Literal("compute-output"),
+  nodeId: Schema2.String,
+  property: Schema2.String,
+  value: Schema2.Any
+}), Schema2.Struct({
+  type: Schema2.Literal("custom"),
+  nodeId: Schema2.String,
+  event: Schema2.Any
 }));
-var ComputeEvent = Schema9.Struct({
+var ComputeEvent = Schema2.Struct({
   payload: ComputeEventPayload
-}).pipe(Type6.object({
-  typename: "dxos.org/type/ComputeEvent",
+}).pipe(Type.object({
+  typename: "org.dxos.type.computeEvent",
   version: "0.1.0"
 }));
-var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/functions/ComputeEventLogger")() {
+var ComputeEventLogger = class _ComputeEventLogger extends Context6.Tag("@dxos/functions/ComputeEventLogger")() {
   static noop = {
     log: () => {
     },
@@ -752,11 +506,11 @@ var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/f
   /**
   * Implements ComputeEventLogger using TracingService.
   */
-  static layerFromTracing = Layer3.effect(_ComputeEventLogger, Effect7.gen(function* () {
+  static layerFromTracing = Layer4.effect(_ComputeEventLogger, Effect6.gen(function* () {
     const tracing = yield* TracingService;
     return {
       log: (event) => {
-        tracing.write(Obj6.make(ComputeEvent, {
+        tracing.write(Obj2.make(ComputeEvent, {
           payload: event
         }), tracing.getTraceContext());
       },
@@ -764,7 +518,7 @@ var ComputeEventLogger = class _ComputeEventLogger extends Context3.Tag("@dxos/f
     };
   }));
 };
-var logCustomEvent = (data) => Effect7.gen(function* () {
+var logCustomEvent = (data) => Effect6.gen(function* () {
   const logger = yield* ComputeEventLogger;
   if (!logger.nodeId) {
     throw new Error("logCustomEvent must be called within a node compute function");
@@ -775,8 +529,8 @@ var logCustomEvent = (data) => Effect7.gen(function* () {
     event: data
   });
 });
-var createDefectLogger = () => Effect7.catchAll((error) => Effect7.gen(function* () {
-  log2.error("unhandled effect error", {
+var createDefectLogger = () => Effect6.catchAll((error) => Effect6.gen(function* () {
+  log.error("unhandled effect error", {
     error
   }, {
     F: __dxlog_file,
@@ -788,11 +542,11 @@ var createDefectLogger = () => Effect7.catchAll((error) => Effect7.gen(function*
 }));
 var createEventLogger = (level, message = "event") => {
   const logFunction = {
-    [LogLevel.WARN]: log2.warn,
-    [LogLevel.VERBOSE]: log2.verbose,
-    [LogLevel.DEBUG]: log2.debug,
-    [LogLevel.INFO]: log2.info,
-    [LogLevel.ERROR]: log2.error
+    [LogLevel.WARN]: log.warn,
+    [LogLevel.VERBOSE]: log.verbose,
+    [LogLevel.DEBUG]: log.debug,
+    [LogLevel.INFO]: log.info,
+    [LogLevel.ERROR]: log.error
   }[level];
   invariant(logFunction, void 0, {
     F: __dxlog_file,
@@ -812,24 +566,25 @@ var createEventLogger = (level, message = "event") => {
 };
 
 // src/services/function-invocation-service.ts
-import * as Context4 from "effect/Context";
-import * as Effect8 from "effect/Effect";
-import * as Layer4 from "effect/Layer";
-var FunctionInvocationService = class _FunctionInvocationService extends Context4.Tag("@dxos/functions/FunctionInvocationService")() {
-  static layerNotAvailable = Layer4.succeed(_FunctionInvocationService, {
-    invokeFunction: () => Effect8.die("FunctionInvocationService is not avaialble."),
-    resolveFunction: () => Effect8.die("FunctionInvocationService is not available.")
+import * as Context7 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Layer5 from "effect/Layer";
+var FunctionInvocationService = class _FunctionInvocationService extends Context7.Tag("@dxos/functions/FunctionInvocationService")() {
+  static layerNotAvailable = Layer5.succeed(_FunctionInvocationService, {
+    invokeFunction: () => Effect7.die("FunctionInvocationService is not avaialble."),
+    resolveFunction: () => Effect7.die("FunctionInvocationService is not available.")
   });
-  static invokeFunction = (functionDef, input) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
-  static resolveFunction = (key) => Effect8.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key);
+  static invokeFunction = (functionDef, input) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.invokeFunction)(functionDef, input);
+  static resolveFunction = (key2) => Effect7.serviceFunctionEffect(_FunctionInvocationService, (service) => service.resolveFunction)(key2);
 };
 
 // src/services/queues.ts
-import * as Context5 from "effect/Context";
-import * as Effect9 from "effect/Effect";
-import * as Layer5 from "effect/Layer";
-var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/QueueService")() {
-  static notAvailable = Layer5.succeed(_QueueService, {
+import * as Context8 from "effect/Context";
+import * as Effect8 from "effect/Effect";
+import * as Layer6 from "effect/Layer";
+import { createFeedServiceLayer } from "@dxos/echo-db";
+var QueueService = class _QueueService extends Context8.Tag("@dxos/functions/QueueService")() {
+  static notAvailable = Layer6.succeed(_QueueService, {
     queues: {
       get(_dxn) {
         throw new Error("Queues not available");
@@ -846,49 +601,294 @@ var QueueService = class _QueueService extends Context5.Tag("@dxos/functions/Que
       queue
     };
   };
-  static layer = (queues, queue) => Layer5.succeed(_QueueService, _QueueService.make(queues, queue));
+  static layer = (queues, queue) => Layer6.succeed(_QueueService, _QueueService.make(queues, queue));
   /**
   * Gets a queue by its DXN.
   */
-  static getQueue = (dxn) => _QueueService.pipe(Effect9.map(({ queues }) => queues.get(dxn)));
+  static getQueue = (dxn) => _QueueService.pipe(Effect8.map(({ queues }) => queues.get(dxn)));
   /**
   * Creates a new queue.
   */
-  static createQueue = (options) => _QueueService.pipe(Effect9.map(({ queues }) => queues.create(options)));
-  static append = (queue, objects) => Effect9.promise(() => queue.append(objects));
+  static createQueue = (options) => _QueueService.pipe(Effect8.map(({ queues }) => queues.create(options)));
+  static append = (queue, objects) => Effect8.promise(() => queue.append(objects));
 };
-var ContextQueueService = class _ContextQueueService extends Context5.Tag("@dxos/functions/ContextQueueService")() {
-  static layer = (queue) => Layer5.succeed(_ContextQueueService, {
+var ContextQueueService = class _ContextQueueService extends Context8.Tag("@dxos/functions/ContextQueueService")() {
+  static layer = (queue) => Layer6.succeed(_ContextQueueService, {
     queue
   });
 };
+var feedServiceFromQueueServiceLayer = Layer6.unwrapEffect(Effect8.gen(function* () {
+  const { queues } = yield* QueueService;
+  return createFeedServiceLayer(queues);
+}));
+
+// src/types/Script.ts
+var Script_exports = {};
+__export(Script_exports, {
+  Script: () => Script,
+  make: () => make5
+});
+import * as Schema3 from "effect/Schema";
+import { Annotation, Obj as Obj3, Ref, Type as Type2 } from "@dxos/echo";
+import { FormInputAnnotation } from "@dxos/echo/internal";
+import { Text } from "@dxos/schema";
+var Script = Schema3.Struct({
+  name: Schema3.String.pipe(Schema3.optional),
+  description: Schema3.String.pipe(Schema3.optional),
+  // TODO(burdon): Change to hash of deployed content.
+  // Whether source has changed since last deploy.
+  changed: Schema3.Boolean.pipe(FormInputAnnotation.set(false), Schema3.optional),
+  source: Ref.Ref(Text.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Type2.object({
+  typename: "org.dxos.type.script",
+  version: "0.1.0"
+}), Annotation.LabelAnnotation.set([
+  "name"
+]), Annotation.IconAnnotation.set({
+  icon: "ph--code--regular",
+  hue: "sky"
+}));
+var make5 = ({ source = "", ...props } = {}) => Obj3.make(Script, {
+  ...props,
+  source: Ref.make(Text.make({
+    content: source
+  }))
+});
+
+// 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: () => make6
+});
+import * as Schema4 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Annotation as Annotation2, Obj as Obj4, QueryAST, Ref as Ref2, Type as Type3 } from "@dxos/echo";
+import { OptionsAnnotationId, SystemTypeAnnotation } from "@dxos/echo/internal";
+import { DXN } from "@dxos/keys";
+var Kinds = [
+  "email",
+  "queue",
+  "subscription",
+  "timer",
+  "webhook"
+];
+var kindLiteralAnnotations = {
+  title: "Kind"
+};
+var EmailSpec = Schema4.Struct({
+  kind: Schema4.Literal("email").annotations(kindLiteralAnnotations)
+});
+var QueueSpec = Schema4.Struct({
+  kind: Schema4.Literal("queue").annotations(kindLiteralAnnotations),
+  // TODO(dmaretskyi): Rename to `feed` and change to a reference.
+  queue: DXN.Schema
+});
+var SubscriptionSpec = Schema4.Struct({
+  kind: Schema4.Literal("subscription").annotations(kindLiteralAnnotations),
+  query: Schema4.Struct({
+    raw: Schema4.optional(Schema4.String.annotations({
+      title: "Query"
+    })),
+    ast: QueryAST.Query
+  }),
+  options: Schema4.optional(Schema4.Struct({
+    // Watch changes to object (not just creation).
+    deep: Schema4.optional(Schema4.Boolean.annotations({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: Schema4.optional(Schema4.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+});
+var TimerSpec = Schema4.Struct({
+  kind: Schema4.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema4.String.annotations({
+    title: "Cron",
+    [SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+});
+var WebhookSpec = Schema4.Struct({
+  kind: Schema4.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: Schema4.optional(Schema4.String.annotations({
+    title: "Method",
+    [OptionsAnnotationId]: [
+      "GET",
+      "POST"
+    ]
+  })),
+  port: Schema4.optional(Schema4.Number.annotations({
+    title: "Port"
+  }))
+});
+var Spec = Schema4.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+  title: "Trigger"
+});
+var TriggerSchema = Schema4.Struct({
+  /**
+  * Function or workflow to invoke.
+  */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: Schema4.optional(Ref2.Ref(Obj4.Unknown).annotations({
+    title: "Function"
+  })),
+  /**
+  * Only used for workflowSchema.
+  * Specifies the input node in the circuit.
+  * @deprecated Remove and enforce a single input node in all compute graphSchema.
+  */
+  inputNodeId: Schema4.optional(Schema4.String.annotations({
+    title: "Input Node ID"
+  })),
+  // TODO(burdon): NO BOOLEAN PROPERTIES (enabld/disabled/paused, etc.)
+  //  Need lint rule; or agent rule to require PR review for "boolean" key word.
+  enabled: Schema4.optional(Schema4.Boolean.annotations({
+    title: "Enabled"
+  })),
+  spec: Schema4.optional(Spec),
+  concurrency: Schema4.optional(Schema4.Number.annotations({
+    title: "Concurrency",
+    default: 1,
+    description: "Maximum number of concurrent invocations of the trigger. For Feed triggers, this will process Feed items in parallel."
+  })),
+  /**
+  * Passed as the input data to the function.
+  * Must match the function's input schema.
+  *
+  * @example
+  * {
+  *   item: '{{event.item}}',
+  *   instructions: 'Summarize and perform entity-extraction'
+  *   mailbox: { '/': 'dxn:echo:AAA:ZZZ' }
+  * }
+  */
+  input: Schema4.optional(Schema4.Record({
+    key: Schema4.String,
+    value: Schema4.Any
+  }))
+}).pipe(Type3.object({
+  typename: "org.dxos.type.trigger",
+  version: "0.1.0"
+}), Annotation2.IconAnnotation.set({
+  icon: "ph--lightning--regular",
+  hue: "yellow"
+}), SystemTypeAnnotation.set(true));
+var Trigger = TriggerSchema;
+var make6 = (props) => Obj4.make(Trigger, props);
+
+// src/types/TriggerEvent.ts
+var TriggerEvent_exports = {};
+__export(TriggerEvent_exports, {
+  EmailEvent: () => EmailEvent,
+  QueueEvent: () => QueueEvent,
+  SubscriptionEvent: () => SubscriptionEvent,
+  TimerEvent: () => TimerEvent,
+  TriggerEvent: () => TriggerEvent,
+  WebhookEvent: () => WebhookEvent
+});
+import * as Schema5 from "effect/Schema";
+import { DXN as DXN2, Obj as Obj5, Ref as Ref3 } from "@dxos/echo";
+var EmailEvent = Schema5.Struct({
+  from: Schema5.String,
+  to: Schema5.String,
+  subject: Schema5.String,
+  created: Schema5.String,
+  body: Schema5.String
+});
+var QueueEvent = Schema5.Struct({
+  queue: DXN2.Schema,
+  item: Schema5.Any,
+  cursor: Schema5.String
+});
+var SubscriptionEvent = Schema5.Struct({
+  /**
+  * Type of the mutation.
+  */
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema5.String,
+  /**
+  * Reference to the object that was changed or created.
+  */
+  subject: Ref3.Ref(Obj5.Unknown),
+  /**
+  * @deprecated
+  */
+  changedObjectId: Schema5.optional(Schema5.String)
+});
+var TimerEvent = Schema5.Struct({
+  tick: Schema5.Number
+});
+var WebhookEvent = Schema5.Struct({
+  url: Schema5.String,
+  method: Schema5.Literal("GET", "POST"),
+  headers: Schema5.Record({
+    key: Schema5.String,
+    value: Schema5.String
+  }),
+  bodyText: Schema5.String
+});
+var TriggerEvent = Schema5.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+
+// src/types/url.ts
+var FUNCTIONS_META_KEY = "org.dxos.service.function";
+var FUNCTIONS_PRESET_META_KEY = "org.dxos.service.function-preset";
+var getUserFunctionIdInMetadata = (meta) => {
+  return meta.keys.find((key2) => key2.source === FUNCTIONS_META_KEY)?.id;
+};
+var setUserFunctionIdInMetadata = (meta, functionId) => {
+  const key2 = meta.keys.find((key3) => key3.source === FUNCTIONS_META_KEY);
+  if (key2) {
+    if (key2.id !== functionId) {
+      throw new Error("Metadata mismatch");
+    }
+  } else {
+    meta.keys.push({
+      source: FUNCTIONS_META_KEY,
+      id: functionId
+    });
+  }
+};
 
 // src/protocol/protocol.ts
 import * as AnthropicClient from "@effect/ai-anthropic/AnthropicClient";
-import * as Effect11 from "effect/Effect";
-import * as Layer7 from "effect/Layer";
-import * as Schema10 from "effect/Schema";
+import * as Effect10 from "effect/Effect";
+import * as Layer8 from "effect/Layer";
+import * as Schema6 from "effect/Schema";
 import * as SchemaAST2 from "effect/SchemaAST";
 import { AiModelResolver, AiService } from "@dxos/ai";
 import { AnthropicResolver } from "@dxos/ai/resolvers";
 import { LifecycleState, Resource } from "@dxos/context";
-import { Database as Database2, Ref as Ref2, Type as Type7 } from "@dxos/echo";
+import { Database as Database2, Feed, JsonSchema, Ref as Ref4 } from "@dxos/echo";
 import { refFromEncodedReference } from "@dxos/echo/internal";
-import { EchoClient } from "@dxos/echo-db";
+import { EchoClient, createFeedServiceLayer as createFeedServiceLayer2 } from "@dxos/echo-db";
 import { runAndForwardErrors } from "@dxos/effect";
-import { assertState, failedInvariant as failedInvariant2, invariant as invariant2 } from "@dxos/invariant";
+import { assertState, failedInvariant, invariant as invariant2 } from "@dxos/invariant";
 import { PublicKey } from "@dxos/keys";
+import { Operation } from "@dxos/operation";
 
 // src/protocol/functions-ai-http-client.ts
 import * as Headers from "@effect/platform/Headers";
 import * as HttpClient2 from "@effect/platform/HttpClient";
 import * as HttpClientError from "@effect/platform/HttpClientError";
 import * as HttpClientResponse from "@effect/platform/HttpClientResponse";
-import * as Effect10 from "effect/Effect";
+import * as Effect9 from "effect/Effect";
 import * as FiberRef from "effect/FiberRef";
-import * as Layer6 from "effect/Layer";
+import * as Layer7 from "effect/Layer";
 import * as Stream from "effect/Stream";
-import { log as log3 } from "@dxos/log";
+import { log as log2 } from "@dxos/log";
 import { ErrorCodec } from "@dxos/protocols";
 var __dxlog_file2 = "/__w/dxos/dxos/packages/core/functions/src/protocol/functions-ai-http-client.ts";
 var requestInitTagKey = "@effect/platform/FetchHttpClient/FetchOptions";
@@ -897,7 +897,7 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
     const context = fiber.getFiberRef(FiberRef.currentContext);
     const options = context.unsafeMap.get(requestInitTagKey) ?? {};
     const headers = options.headers ? Headers.merge(Headers.fromInput(options.headers), request.headers) : request.headers;
-    const send = (body) => Effect10.tryPromise({
+    const send = (body) => Effect9.tryPromise({
       try: () => service.fetch(new Request(url, {
         ...options,
         method: request.method,
@@ -905,7 +905,7 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
         body
       })),
       catch: (cause) => {
-        log3.error("Failed to fetch", {
+        log2.error("Failed to fetch", {
           errorSerialized: ErrorCodec.encode(cause)
         }, {
           F: __dxlog_file2,
@@ -919,7 +919,7 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
           cause
         });
       }
-    }).pipe(Effect10.map((response) => HttpClientResponse.fromWeb(request, response)));
+    }).pipe(Effect9.map((response) => HttpClientResponse.fromWeb(request, response)));
     switch (request.body._tag) {
       case "Raw":
       case "Uint8Array":
@@ -927,11 +927,11 @@ var FunctionsAiHttpClient = class _FunctionsAiHttpClient {
       case "FormData":
         return send(request.body.formData);
       case "Stream":
-        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect10.flatMap(send));
+        return Stream.toReadableStreamEffect(request.body.stream).pipe(Effect9.flatMap(send));
     }
     return send(void 0);
   });
-  static layer = (service) => Layer6.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
+  static layer = (service) => Layer7.succeed(HttpClient2.HttpClient, _FunctionsAiHttpClient.make(service));
 };
 
 // src/protocol/protocol.ts
@@ -974,7 +974,7 @@ function _ts_dispose_resources(env) {
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
   };
   return (_ts_dispose_resources = function _ts_dispose_resources2(env2) {
-    function fail(e) {
+    function fail2(e) {
       env2.error = env2.hasError ? new _SuppressedError(e, env2.error, "An error was suppressed during disposal.") : e;
       env2.hasError = true;
     }
@@ -986,12 +986,12 @@ function _ts_dispose_resources(env) {
           if (r.dispose) {
             var result = r.dispose.call(r.value);
             if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) {
-              fail(e);
+              fail2(e);
               return next();
             });
           } else s |= 1;
         } catch (e) {
-          fail(e);
+          fail2(e);
         }
       }
       if (s === 1) return env2.hasError ? Promise.reject(env2.error) : Promise.resolve();
@@ -1002,20 +1002,21 @@ function _ts_dispose_resources(env) {
 }
 var __dxlog_file3 = "/__w/dxos/dxos/packages/core/functions/src/protocol/protocol.ts";
 var wrapFunctionHandler = (func) => {
-  if (!FunctionDefinition.isFunction(func)) {
-    throw new TypeError("Invalid function definition");
+  if (!Operation.isOperationWithHandler(func)) {
+    throw new TypeError("Expected operation with handler");
   }
+  const serviceTags = func.services.map((service) => service.key);
   return {
     meta: {
-      key: func.key,
-      name: func.name,
-      description: func.description,
-      inputSchema: Type7.toJsonSchema(func.inputSchema),
-      outputSchema: func.outputSchema === void 0 ? void 0 : Type7.toJsonSchema(func.outputSchema),
-      services: func.services
+      key: func.meta.key,
+      name: func.meta.name,
+      description: func.meta.description,
+      inputSchema: JsonSchema.toJsonSchema(func.input),
+      outputSchema: func.output === void 0 ? void 0 : JsonSchema.toJsonSchema(func.output),
+      services: func.services.map((service) => service.key)
     },
     handler: async ({ data, context }) => {
-      if ((func.services.includes(Database2.Service.key) || func.services.includes(QueueService.key)) && (!context.services.dataService || !context.services.queryService)) {
+      if ((serviceTags.includes(Database2.Service.key) || serviceTags.includes(QueueService.key) || serviceTags.includes(Feed.Service.key)) && (!context.services.dataService || !context.services.queryService)) {
         throw new FunctionError({
           message: "Services not provided: dataService, queryService"
         });
@@ -1027,9 +1028,9 @@ var wrapFunctionHandler = (func) => {
           hasError: false
         };
         try {
-          if (!SchemaAST2.isAnyKeyword(func.inputSchema.ast)) {
+          if (!SchemaAST2.isAnyKeyword(func.input.ast)) {
             try {
-              Schema10.validateSync(func.inputSchema)(data);
+              Schema6.validateSync(func.input)(data);
             } catch (error) {
               throw new FunctionError({
                 message: "Invalid input schema",
@@ -1041,7 +1042,7 @@ var wrapFunctionHandler = (func) => {
           if (func.types.length > 0) {
             invariant2(funcContext.db, "Database is required for functions with types", {
               F: __dxlog_file3,
-              L: 68,
+              L: 74,
               S: void 0,
               A: [
                 "funcContext.db",
@@ -1050,17 +1051,13 @@ var wrapFunctionHandler = (func) => {
             });
             await funcContext.db.graph.schemaRegistry.register(func.types);
           }
-          const dataWithDecodedRefs = funcContext.db && !SchemaAST2.isAnyKeyword(func.inputSchema.ast) ? decodeRefsFromSchema(func.inputSchema.ast, data, funcContext.db) : data;
-          let result = await func.handler({
-            // TODO(dmaretskyi): Fix the types.
-            context,
-            data: dataWithDecodedRefs
-          });
-          if (Effect11.isEffect(result)) {
-            result = await runAndForwardErrors(result.pipe(Effect11.orDie, Effect11.provide(funcContext.createLayer())));
+          const dataWithDecodedRefs = funcContext.db && !SchemaAST2.isAnyKeyword(func.input.ast) ? decodeRefsFromSchema(func.input.ast, data, funcContext.db) : data;
+          let result = await func.handler(dataWithDecodedRefs);
+          if (Effect10.isEffect(result)) {
+            result = await runAndForwardErrors(result.pipe(Effect10.orDie, Effect10.provide(funcContext.createLayer())));
           }
-          if (func.outputSchema && !SchemaAST2.isAnyKeyword(func.outputSchema.ast)) {
-            Schema10.validateSync(func.outputSchema)(result);
+          if (func.output && !SchemaAST2.isAnyKeyword(func.output.ast)) {
+            Schema6.validateSync(func.output)(result);
           }
           return result;
         } catch (e) {
@@ -1095,12 +1092,12 @@ var FunctionContext = class extends Resource {
   async _open() {
     await this.client?.open();
     this.db = this.client && this.context.spaceId ? this.client.constructDatabase({
-      spaceId: this.context.spaceId ?? failedInvariant2(),
-      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant2("spaceKey missing in context")),
+      spaceId: this.context.spaceId ?? failedInvariant(),
+      spaceKey: PublicKey.fromHex(this.context.spaceKey ?? failedInvariant("spaceKey missing in context")),
       reactiveSchemaQuery: false,
       preloadSchemaOnOpen: false
     }) : void 0;
-    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant2("spaceRootUrl missing in context"));
+    await this.db?.setSpaceRoot(this.context.spaceRootUrl ?? failedInvariant("spaceRootUrl missing in context"));
     await this.db?.open();
     this.queues = this.client && this.context.spaceId ? this.client.constructQueueFactory(this.context.spaceId) : void 0;
   }
@@ -1110,31 +1107,41 @@ var FunctionContext = class extends Resource {
   }
   createLayer() {
     assertState(this._lifecycleState === LifecycleState.OPEN, "FunctionContext is not open");
-    const dbLayer = this.db ? Database2.Service.layer(this.db) : Database2.Service.notAvailable;
+    const dbLayer = this.db ? Database2.layer(this.db) : Database2.notAvailable;
     const queuesLayer = this.queues ? QueueService.layer(this.queues) : QueueService.notAvailable;
+    const feedLayer = this.queues ? createFeedServiceLayer2(this.queues) : Feed.notAvailable;
     const credentials = dbLayer ? CredentialsService.layerFromDatabase({
       caching: true
-    }).pipe(Layer7.provide(dbLayer)) : CredentialsService.configuredLayer([]);
+    }).pipe(Layer8.provide(dbLayer)) : CredentialsService.configuredLayer([]);
     const functionInvocationService = MockedFunctionInvocationService;
     const tracing = TracingService.layerNoop;
-    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer7.provide(AnthropicResolver.make().pipe(Layer7.provide(AnthropicClient.layer({
+    const aiLayer = this.context.services.functionsAiService ? AiModelResolver.AiModelResolver.buildAiService.pipe(Layer8.provide(AnthropicResolver.make().pipe(Layer8.provide(AnthropicClient.layer({
       // Note: It doesn't matter what is base url here, it will be proxied to ai gateway in edge.
       apiUrl: "http://internal/provider/anthropic"
-    }).pipe(Layer7.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
-    return Layer7.mergeAll(dbLayer, queuesLayer, credentials, functionInvocationService, aiLayer, tracing);
+    }).pipe(Layer8.provide(FunctionsAiHttpClient.layer(this.context.services.functionsAiService))))))) : AiService.notAvailable;
+    return Layer8.mergeAll(
+      dbLayer,
+      queuesLayer,
+      feedLayer,
+      credentials,
+      functionInvocationService,
+      aiLayer,
+      tracing,
+      writerLayerNoop
+    );
   }
 };
-var MockedFunctionInvocationService = Layer7.succeed(FunctionInvocationService, {
-  invokeFunction: () => Effect11.die("Calling functions from functions is not implemented yet."),
-  resolveFunction: () => Effect11.die("Not implemented.")
+var MockedFunctionInvocationService = Layer8.succeed(FunctionInvocationService, {
+  invokeFunction: () => Effect10.die("Calling functions from functions is not implemented yet."),
+  resolveFunction: () => Effect10.die("Not implemented.")
 });
 var decodeRefsFromSchema = (ast, value2, db) => {
   if (value2 == null) {
     return value2;
   }
   const encoded = SchemaAST2.encodedBoundAST(ast);
-  if (Ref2.isRefType(encoded)) {
-    if (Ref2.isRef(value2)) {
+  if (Ref4.isRefType(encoded)) {
+    if (Ref4.isRef(value2)) {
       return value2;
     }
     if (typeof value2 === "object" && value2 !== null && typeof value2["/"] === "string") {
@@ -1156,9 +1163,9 @@ var decodeRefsFromSchema = (ast, value2, db) => {
         ...value2
       };
       for (const prop of SchemaAST2.getPropertySignatures(encoded)) {
-        const key = prop.name.toString();
-        if (key in result) {
-          result[key] = decodeRefsFromSchema(prop.type, result[key], db);
+        const key2 = prop.name.toString();
+        if (key2 in result) {
+          result[key2] = decodeRefsFromSchema(prop.type, result[key2], db);
         }
       }
       return result;
@@ -1198,32 +1205,41 @@ export {
   ConfiguredCredentialsService,
   ContextQueueService,
   CredentialsService,
-  Example,
+  ExampleHandlers,
   FUNCTIONS_META_KEY,
   FUNCTIONS_PRESET_META_KEY,
-  Function_exports as Function,
-  FunctionDefinition,
+  Fibonacci,
   FunctionError,
   FunctionInvocationService,
   FunctionNotFoundError,
   MESSAGE_PROPERTY_TOOL_CALL_ID,
+  Process_exports as Process,
   QueueService,
+  Reply,
   Script_exports as Script,
   ServiceNotAvailableError,
+  ServiceResolver_exports as ServiceResolver,
+  Sleep,
+  StorageService,
+  Trace_exports as Trace,
   TracingService,
   Trigger_exports as Trigger,
   TriggerEvent_exports as TriggerEvent,
   TriggerStateNotFoundError,
+  clear,
   createDefectLogger,
   createEventLogger,
-  defineFunction,
-  deserializeFunction,
+  deleteKey,
+  feedServiceFromQueueServiceLayer,
+  get,
   getUserFunctionIdInMetadata,
+  key,
+  list,
   logCustomEvent,
-  serializeFunction,
+  set,
   setUserFunctionIdInMetadata,
-  toOperation,
   withAuthorization,
+  withDefault,
   wrapFunctionHandler
 };
 //# sourceMappingURL=index.mjs.map