@dxos/compute 0.8.4-main.e8ec1fe → 0.8.4-main.f466a3d56e

package/dist/lib/neutral/index.mjs

@@ -0,0 +1,1225 @@
+import {
+  StorageService_exports
+} from "./chunk-XEVFBI6S.mjs";
+import {
+  FunctionError,
+  FunctionNotFoundError,
+  FunctionsAiMemoizationMissError,
+  FunctionsAiUpstreamError,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  InvokerNotInitializedError,
+  NoHandlerError,
+  OperationHandlerProvider,
+  OperationHandlerSet_exports,
+  ServiceNotAvailableError,
+  TriggerStateNotFoundError,
+  getHandler,
+  getHandlerByKey
+} from "./chunk-LF2ANNYW.mjs";
+import {
+  Operation_exports,
+  PersistentOperation,
+  deserialize,
+  invoke
+} from "./chunk-SEBWOTOU.mjs";
+import {
+  __export
+} from "./chunk-J5LGTIGS.mjs";
+
+// src/Blueprint.ts
+var Blueprint_exports = {};
+__export(Blueprint_exports, {
+  Blueprint: () => Blueprint,
+  Blueprint_v0_1_0: () => Blueprint_v0_1_0,
+  NotFoundError: () => NotFoundError,
+  Registry: () => Registry,
+  RegistryService: () => RegistryService,
+  getKey: () => getKey,
+  getVersion: () => getVersion,
+  make: () => make2,
+  migrations: () => migrations,
+  resolve: () => resolve2,
+  toolDefinitions: () => toolDefinitions,
+  upsert: () => upsert
+});
+import * as Context2 from "effect/Context";
+import * as Effect3 from "effect/Effect";
+import * as Layer2 from "effect/Layer";
+import * as Schema3 from "effect/Schema";
+import { ToolId } from "@dxos/ai";
+import { Annotation, Database as Database3, Filter as Filter2, Migration, Obj, Type } from "@dxos/echo";
+import { BaseError } from "@dxos/errors";
+import { log as log2 } from "@dxos/log";
+
+// src/McpServer.ts
+var McpServer_exports = {};
+__export(McpServer_exports, {
+  McpServer: () => McpServer
+});
+import * as Schema from "effect/Schema";
+var McpServer = Schema.Struct({
+  name: Schema.String.pipe(Schema.optional).annotations({
+    description: "Human-readable name of the MCP server"
+  }),
+  url: Schema.String.annotations({
+    description: "URL of the MCP server"
+  }),
+  /**
+  * Transport protocol. Prefer `'http'` (Streamable HTTP) for new servers; `'sse'` is
+  * kept for compatibility with servers that haven't migrated and is deprecated per
+  * the MCP SDK. Clients support both during the migration period.
+  */
+  protocol: Schema.Union(Schema.Literal("http"), Schema.Literal("sse")).annotations({
+    description: 'Transport protocol of the MCP server (prefer "http"; "sse" deprecated)'
+  }),
+  /**
+  * Optional API key sent with requests.
+  * Persisted in plaintext when stored on a space-replicated ECHO object — see the
+  * `@dxos/assistant-toolkit` `McpServer` type for security implications.
+  */
+  apiKey: Schema.optional(Schema.String).annotations({
+    description: "Optional API key sent with requests"
+  })
+});
+
+// src/Template.ts
+var Template_exports = {};
+__export(Template_exports, {
+  Input: () => Input,
+  InputKind: () => InputKind,
+  Template: () => Template,
+  make: () => make,
+  process: () => process,
+  processTemplate: () => processTemplate
+});
+import * as Effect2 from "effect/Effect";
+import * as Schema2 from "effect/Schema";
+import { Database as Database2, Ref } from "@dxos/echo";
+import { invariant } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { Text } from "@dxos/schema";
+import Handlebars from "@dxos/vendor-kbn-handlebars";
+
+// src/OperationRegistry.ts
+var OperationRegistry_exports = {};
+__export(OperationRegistry_exports, {
+  Service: () => Service,
+  layer: () => layer,
+  resolve: () => resolve
+});
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Database, Filter, Query } from "@dxos/echo";
+var Service = class extends Context.Tag("@dxos/operation/OperationRegistry")() {
+};
+var resolve = Effect.serviceFunctionEffect(Service, (service) => service.resolve);
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const database = yield* Database.Service;
+  const handlerSet = yield* OperationHandlerProvider;
+  return {
+    resolve: (key) => Database.runQueryFirst(Query.select(Filter.and(Filter.type(PersistentOperation), Filter.key(key)))).pipe(Effect.flatten, Effect.map(deserialize), Effect.catchTag("NoSuchElementException", () => getHandlerByKey(handlerSet, key)), Effect.option).pipe(Effect.provideService(Database.Service, database))
+  };
+}));
+
+// src/Template.ts
+var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/compute/src/Template.ts";
+var InputKind = Schema2.Literal("value", "operation");
+var Input = Schema2.Struct({
+  name: Schema2.String,
+  kind: InputKind,
+  default: Schema2.optional(Schema2.Any),
+  /**
+  * Operation key invoked when `kind === 'operation'`. The referenced operation must accept void input —
+  * template inputs have no mechanism for passing arguments.
+  */
+  operation: Schema2.optional(Schema2.String)
+});
+var Template = Schema2.Struct({
+  source: Ref.Ref(Text.Text).annotations({
+    description: "Markdown + Handlebars template."
+  }),
+  /**
+  * NOTE: We use an array rather than map so that updating variable names in the template doesn't disconnect existing inputs.
+  */
+  inputs: Schema2.optional(Schema2.Array(Input))
+});
+var make = ({ id, source, inputs = [] } = {}) => ({
+  source: Ref.make(Text.make({
+    id,
+    content: source
+  })),
+  inputs
+});
+var process = (source, variables = {}) => {
+  invariant(typeof source === "string", void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 50, S: void 0, A: ["typeof source === 'string'", ""] });
+  let section = 0;
+  const handlebars = Handlebars.create();
+  handlebars.registerHelper("section", () => String(++section));
+  const template = handlebars.compileAST(source.trim());
+  const output = template(variables);
+  return output.trim().replace(/(\n\s*){3,}/g, "\n\n");
+};
+var processTemplate = (template) => Effect2.gen(function* () {
+  const entries = yield* Effect2.forEach(template.inputs ?? [], (input) => Effect2.gen(function* () {
+    switch (input.kind) {
+      case "value": {
+        return [
+          input.name,
+          input.default
+        ];
+      }
+      case "operation": {
+        invariant(input.operation, void 0, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 70, S: this, A: ["input.operation", ""] });
+        const fn = yield* resolve(input.operation).pipe(Effect2.flatten, Effect2.catchTag("NoSuchElementException", () => Effect2.fail(new FunctionNotFoundError(input.operation))));
+        const result = yield* invoke(fn, void 0).pipe(Effect2.orDie);
+        return [
+          input.name,
+          result
+        ];
+      }
+      default: {
+        return yield* Effect2.dieMessage(`Unsupported input kind: ${input.kind}`);
+      }
+    }
+  }));
+  const variables = Object.fromEntries(entries);
+  log("processTemplate", {
+    variables
+  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 86, S: this });
+  return process((yield* Database2.load(template.source)).content, variables);
+});
+
+// src/Blueprint.ts
+var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/compute/src/Blueprint.ts";
+var Blueprint = Schema3.Struct({
+  /**
+  * Human-readable name of the blueprint.
+  */
+  name: Schema3.String.annotations({
+    description: "Human-readable name of the blueprint"
+  }),
+  /**
+  * Description of the blueprint's purpose and functionality.
+  */
+  description: Schema3.optional(Schema3.String).annotations({
+    description: "Description of the blueprint's purpose and functionality"
+  }),
+  /**
+  * Instructions that guide the AI assistant's behavior and responses.
+  * These are system prompts or guidelines that the AI should follow.
+  */
+  instructions: Template.annotations({
+    description: "Instructions that guide the AI assistant's behavior and responses"
+  }),
+  /**
+  * Array of tools that the AI assistant can use when this blueprint is active.
+  */
+  tools: Schema3.Array(ToolId).annotations({
+    description: "Array of tools that the AI assistant can use when this blueprint is active"
+  }),
+  /**
+  * Whether an agent is allowed to auto-enable this blueprint in a conversation.
+  */
+  agentCanEnable: Schema3.optional(Schema3.Boolean).annotations({
+    description: "Whether an agent is allowed to auto-enable this blueprint in a conversation."
+  }),
+  /**
+  * Array of MCP servers that the AI assistant can use when this blueprint is active.
+  */
+  mcpServers: Schema3.optional(Schema3.Array(McpServer))
+}).pipe(Type.object({
+  typename: "org.dxos.type.blueprint",
+  version: "0.2.0"
+}), Annotation.LabelAnnotation.set([
+  "name"
+]), Annotation.IconAnnotation.set({
+  icon: "ph--blueprint--regular",
+  hue: "sky"
+}));
+var make2 = ({ key, version, tools = [], instructions = make(), ...props }) => Obj.make(Blueprint, {
+  [Obj.Meta]: {
+    key,
+    version
+  },
+  tools,
+  instructions,
+  ...props
+});
+var getKey = (blueprint) => {
+  const key = Obj.getMeta(blueprint).key;
+  if (key === void 0) {
+    throw new Error("Blueprint is missing the meta key.");
+  }
+  return key;
+};
+var getVersion = (blueprint) => Obj.getMeta(blueprint).version;
+var toolDefinitions = ({ tools = [], operations = [] }) => [
+  ...operations.map((op) => ToolId.make(op.meta.key)),
+  ...tools.map((tool) => ToolId.make(tool))
+];
+var Registry = class {
+  _blueprints = [];
+  constructor(blueprints) {
+    const seen = /* @__PURE__ */ new Set();
+    blueprints.forEach((blueprint) => {
+      const key = getKey(blueprint);
+      if (seen.has(key)) {
+        log2.warn("duplicate blueprint", {
+          key
+        }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 104, S: this });
+      } else {
+        seen.add(key);
+        this._blueprints.push(blueprint);
+      }
+    });
+    this._blueprints.sort(({ name: a }, { name: b }) => a.localeCompare(b));
+  }
+  get blueprints() {
+    return this._blueprints;
+  }
+  getByKey(key) {
+    return this._blueprints.find((blueprint) => Obj.getMeta(blueprint).key === key);
+  }
+  query() {
+    return this._blueprints;
+  }
+  updateBlueprints() {
+    return Effect3.gen(this, function* () {
+      const blueprints = yield* Database3.runQuery(Filter2.type(Blueprint));
+      for (const blueprint of blueprints) {
+        const blueprintKey = Obj.getMeta(blueprint).key;
+        if (!blueprintKey) {
+          continue;
+        }
+        const registryBlueprint = this.getByKey(blueprintKey);
+        if (!registryBlueprint) {
+          continue;
+        }
+        const source = Obj.clone(registryBlueprint, {
+          deep: true
+        });
+        Obj.update(blueprint, (blueprint2) => {
+          void Obj.updateFrom(blueprint2, source);
+        });
+      }
+    }).pipe(Effect3.orDie);
+  }
+};
+var RegistryService = class _RegistryService extends Context2.Tag("@dxos/blueprints/RegistryService")() {
+  static notAvailable = Layer2.succeed(_RegistryService, {
+    get blueprints() {
+      throw new Error("Blueprint registry not available");
+    },
+    getByKey(_key) {
+      throw new Error("Blueprint registry not available");
+    },
+    query() {
+      throw new Error("Blueprint registry not available");
+    },
+    updateBlueprints() {
+      throw new Error("Blueprint registry not available");
+    }
+  });
+};
+var resolve2 = (key) => Effect3.gen(function* () {
+  const registry = yield* RegistryService;
+  const blueprint = registry.getByKey(key);
+  if (!blueprint) {
+    return yield* Effect3.fail(new NotFoundError({
+      context: {
+        key
+      }
+    }));
+  }
+  return blueprint;
+});
+var upsert = (key) => Effect3.gen(function* () {
+  const local = yield* Database3.runQuery(Filter2.and(Filter2.type(Blueprint), Filter2.key(key)));
+  if (local.length > 0) {
+    return local[0];
+  }
+  return yield* Database3.add(Obj.clone(yield* resolve2(key), {
+    deep: true
+  }));
+});
+var NotFoundError = class extends BaseError.extend("BlueprintNotFound", "Blueprint not found") {
+};
+var Blueprint_v0_1_0 = Schema3.Struct({
+  /**
+  * Global registry ID.
+  * NOTE: The `key` property refers to the original registry entry.
+  */
+  key: Schema3.String.annotations({
+    description: "Unique registration key for the blueprint"
+  }),
+  name: Schema3.String.annotations({
+    description: "Human-readable name of the blueprint"
+  }),
+  description: Schema3.optional(Schema3.String),
+  instructions: Template,
+  tools: Schema3.Array(ToolId),
+  agentCanEnable: Schema3.optional(Schema3.Boolean),
+  mcpServers: Schema3.optional(Schema3.Array(McpServer))
+}).pipe(Type.object({
+  typename: "org.dxos.type.blueprint",
+  version: "0.1.0"
+}));
+var _migration = Migration.define({
+  from: Blueprint_v0_1_0,
+  to: Blueprint,
+  transform: async (from) => ({
+    [Obj.Meta]: {
+      key: from.key,
+      version: "0.1.0"
+    },
+    name: from.name,
+    description: from.description,
+    instructions: from.instructions,
+    tools: from.tools,
+    agentCanEnable: from.agentCanEnable,
+    mcpServers: from.mcpServers
+  })
+});
+var migrations = [
+  _migration
+];
+
+// src/Credential.ts
+var Credential_exports = {};
+__export(Credential_exports, {
+  CredentialsService: () => CredentialsService
+});
+import * as Context3 from "effect/Context";
+import * as Effect4 from "effect/Effect";
+import * as Redacted from "effect/Redacted";
+var CredentialsService = class _CredentialsService extends Context3.Tag("@dxos/functions/CredentialsService")() {
+  static getCredential = (query) => Effect4.gen(function* () {
+    const credentials = yield* _CredentialsService;
+    return yield* Effect4.promise(() => credentials.getCredential(query));
+  });
+  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);
+  });
+};
+
+// src/LayerSpec.ts
+var LayerSpec_exports = {};
+__export(LayerSpec_exports, {
+  TypeId: () => TypeId,
+  make: () => make4
+});
+var TypeId = "~@dxos/functions/LayerSpec";
+var make4 = (opts, make11) => {
+  return {
+    [TypeId]: TypeId,
+    affinity: opts.affinity,
+    requires: opts.requires,
+    provides: opts.provides,
+    make: make11
+  };
+};
+
+// src/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: () => make5,
+  prettyProcessTree: () => prettyProcessTree
+});
+import * as Context5 from "effect/Context";
+import * as Effect6 from "effect/Effect";
+import * as Schema5 from "effect/Schema";
+import { assertArgument } from "@dxos/invariant";
+import { log as log4 } from "@dxos/log";
+
+// src/Trace.ts
+var Trace_exports = {};
+__export(Trace_exports, {
+  CommonRuntimeName: () => CommonRuntimeName,
+  Event: () => Event,
+  EventType: () => EventType,
+  Message: () => Message,
+  MessageData: () => MessageData,
+  Meta: () => Meta,
+  OperationEnd: () => OperationEnd,
+  OperationInput: () => OperationInput,
+  OperationOutput: () => OperationOutput,
+  OperationStart: () => OperationStart,
+  RuntimeName: () => RuntimeName,
+  StatusUpdate: () => StatusUpdate,
+  TraceService: () => TraceService,
+  TraceSink: () => TraceSink,
+  emitStatus: () => emitStatus,
+  flatten: () => flatten3,
+  isEdgeRuntime: () => isEdgeRuntime,
+  isOfType: () => isOfType,
+  layerConsole: () => layerConsole,
+  layerNoop: () => layerNoop,
+  mergeSinks: () => mergeSinks,
+  noopSink: () => noopSink,
+  noopWriter: () => noopWriter,
+  testTraceService: () => testTraceService,
+  write: () => write,
+  writerLayerNoop: () => writerLayerNoop
+});
+import * as Context4 from "effect/Context";
+import * as Effect5 from "effect/Effect";
+import * as Layer3 from "effect/Layer";
+import * as Schema4 from "effect/Schema";
+import { Annotation as Annotation2, Obj as Obj2, Type as Type2 } from "@dxos/echo";
+import { log as log3 } from "@dxos/log";
+var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/compute/src/Trace.ts";
+var TraceService = class extends Context4.Tag("@dxos/functions/TraceService")() {
+};
+function write(eventType, payload) {
+  return Effect5.gen(function* () {
+    log3("trace write", {
+      key: eventType.key,
+      isEphemeral: eventType.isEphemeral
+    }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 20, S: this });
+    const writer = yield* TraceService;
+    writer.write(eventType, payload);
+  });
+}
+var EventType = (key, opts) => {
+  return {
+    key,
+    schema: opts.schema,
+    isEphemeral: opts.isEphemeral
+  };
+};
+var Event = Schema4.Struct({
+  timestamp: Schema4.Number,
+  type: Schema4.String,
+  data: Schema4.Unknown
+});
+var isOfType = (eventType, event) => {
+  return event.type === eventType.key;
+};
+var RuntimeName = Schema4.String.pipe(Schema4.brand("@dxos/compute/Trace/RuntimeName"));
+var CommonRuntimeName = {
+  /**
+  * Web app / CLI / Desktop app / Mobile app.
+  */
+  local: RuntimeName.make("local"),
+  edgeIntrinsic: RuntimeName.make("edge-intrinsic"),
+  edgeWorkerLoader: RuntimeName.make("edge-worker-loader"),
+  edgeWorkerForPlatforms: RuntimeName.make("edge-worker-for-platforms")
+};
+var Meta = Schema4.Struct({
+  pid: Schema4.optional(Schema4.String),
+  parentPid: Schema4.optional(Schema4.String),
+  processName: Schema4.optional(Schema4.String),
+  /**
+  * Space the message was produced in.
+  * Stored as a string to avoid circular dependency on `@dxos/keys`.
+  */
+  space: Schema4.optional(Schema4.String),
+  /**
+  * ID of the conversation feed object if present.
+  */
+  conversationId: Schema4.optional(Obj2.ID),
+  /**
+  * ID of the trigger object if invocation resulted from a trigger.
+  */
+  triggerId: Schema4.optional(Obj2.ID),
+  /**
+  * ID of the tool call that created the current process.
+  */
+  toolCallId: Schema4.optional(Schema4.String),
+  /**
+  * Extensible name informing which runtime executed the code that produced the event.
+  */
+  runtimeName: Schema4.optional(RuntimeName)
+});
+var isEdgeRuntime = (name) => name === CommonRuntimeName.edgeIntrinsic || name === CommonRuntimeName.edgeWorkerLoader || name === CommonRuntimeName.edgeWorkerForPlatforms;
+var MessageData = Schema4.Struct({
+  meta: Meta,
+  isEphemeral: Schema4.Boolean,
+  events: Schema4.Array(Event)
+});
+var Message = MessageData.pipe(Type2.object({
+  typename: "org.dxos.type.traceMessage",
+  version: "0.1.0"
+}), Annotation2.IconAnnotation.set({
+  icon: "ph--note--regular",
+  hue: "rose"
+}));
+var flatten3 = (message) => {
+  return message.events.map((event) => ({
+    ...event,
+    meta: message.meta,
+    isEphemeral: message.isEphemeral
+  }));
+};
+var TraceSink = class extends Context4.Tag("@dxos/functions/TraceSink")() {
+};
+var noopWriter = {
+  write: () => {
+  }
+};
+var writerLayerNoop = Layer3.succeed(TraceService, noopWriter);
+var noopSink = {
+  write: () => {
+  }
+};
+var layerNoop = Layer3.succeed(TraceSink, noopSink);
+var layerConsole = Layer3.succeed(TraceSink, {
+  write: (message) => {
+    console.log(message);
+  }
+});
+var mergeSinks = (sinks) => {
+  if (sinks.length === 0) {
+    return noopSink;
+  }
+  return {
+    write: (message) => {
+      for (const sink of sinks) {
+        try {
+          sink.write(message);
+        } catch (err) {
+          console.error("[trace] sink.write threw", err);
+        }
+      }
+    }
+  };
+};
+var testTraceService = (opts = {}) => Layer3.effect(TraceService, Effect5.gen(function* () {
+  const sink = yield* TraceSink;
+  const clock = opts.clock ?? Date.now;
+  return {
+    write: (event, data) => {
+      sink.write(Obj2.make(Message, {
+        meta: opts.meta ?? {},
+        isEphemeral: event.isEphemeral,
+        events: [
+          {
+            type: event.key,
+            timestamp: clock(),
+            data
+          }
+        ]
+      }));
+    }
+  };
+}));
+var OperationStart = EventType("operation.start", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String)
+  }),
+  isEphemeral: false
+});
+var OperationEnd = EventType("operation.end", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Outcome of the operation. */
+    outcome: Schema4.Literal("success", "failure"),
+    /** Error message if the operation failed. */
+    error: Schema4.optional(Schema4.String)
+  }),
+  isEphemeral: false
+});
+var OperationInput = EventType("operation.input", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Raw operation input. Shape determined by the operation definition. */
+    input: Schema4.Unknown
+  }),
+  isEphemeral: true
+});
+var OperationOutput = EventType("operation.output", {
+  schema: Schema4.Struct({
+    /** Operation key. */
+    key: Schema4.String,
+    /** Human-readable operation name. */
+    name: Schema4.optional(Schema4.String),
+    /** Raw operation output. Shape determined by the operation definition. */
+    output: Schema4.Unknown
+  }),
+  isEphemeral: true
+});
+var StatusUpdate = EventType("status.update", {
+  schema: Schema4.Struct({
+    /** Human-readable status message. */
+    message: Schema4.String
+  }),
+  isEphemeral: true
+});
+var emitStatus = (message) => write(StatusUpdate, {
+  message
+});
+
+// src/Process.ts
+var __dxlog_file4 = "/__w/dxos/dxos/packages/core/compute/compute/src/Process.ts";
+var ID = Schema5.String.pipe(Schema5.brand("ProcessId"));
+var ProcessTypeId = "~@dxos/functions/Process";
+var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
+var make5 = (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(Effect6.map((partial) => ({
+      onSpawn: () => Effect6.void,
+      onInput: () => Effect6.void,
+      onAlarm: () => Effect6.void,
+      onChildEvent: () => Effect6.void,
+      ...partial
+    })))
+  };
+};
+var fromOperation = (op, handler) => make5({
+  key: op.meta.key,
+  input: op.input,
+  output: op.output,
+  services: op.services
+}, (ctx) => Effect6.gen(function* () {
+  const semaphore = yield* Effect6.makeSemaphore(1);
+  return {
+    onInput: (input) => Effect6.gen(function* () {
+      log4("operation process invoking", {
+        key: op.meta.key,
+        name: op.meta.name
+      }, { "~LogMeta": "~LogMeta", F: __dxlog_file4, L: 45, S: this });
+      yield* write(OperationStart, {
+        key: op.meta.key,
+        name: op.meta.name
+      });
+      yield* write(OperationInput, {
+        key: op.meta.key,
+        name: op.meta.name,
+        input
+      });
+      const opHandler = yield* getHandler(handler, op).pipe(Effect6.orDie);
+      const output = yield* opHandler.handler(input).pipe(Effect6.orDie, Effect6.withSpan(op.meta.key));
+      ctx.submitOutput(output);
+      ctx.succeed();
+      yield* write(OperationOutput, {
+        key: op.meta.key,
+        name: op.meta.name,
+        output
+      });
+      yield* write(OperationEnd, {
+        key: op.meta.key,
+        name: op.meta.name,
+        outcome: "success"
+      });
+    }).pipe(Effect6.catchAllDefect((defect) => Effect6.gen(function* () {
+      const errorMessage = defect instanceof Error ? defect.message : String(defect);
+      yield* write(OperationEnd, {
+        key: op.meta.key,
+        name: op.meta.name,
+        outcome: "failure",
+        error: errorMessage
+      });
+      return yield* Effect6.die(defect);
+    })), 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 Context5.Tag("@dxos/functions/ProcessMonitorService")() {
+};
+var SpawnedEvent = EventType("process.spawned", {
+  schema: Schema5.Void,
+  isEphemeral: false
+});
+var ExitedEvent = EventType("process.exited", {
+  schema: Schema5.Struct({
+    outcome: Schema5.Literal("succeeded", "failed", "terminated")
+  }),
+  isEphemeral: false
+});
+var prettyProcessTree = (tree) => {
+  if (tree.length === 0) {
+    return "";
+  }
+  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 key = String(parent);
+    const siblings = childrenByParent.get(key) ?? [];
+    siblings.push(node);
+    childrenByParent.set(key, siblings);
+  }
+  const byPid = (a, b) => String(a.pid).localeCompare(String(b.pid));
+  roots.sort(byPid);
+  for (const siblings of childrenByParent.values()) {
+    siblings.sort(byPid);
+  }
+  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 (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 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)}`);
+    }
+    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");
+};
+
+// src/Routine.ts
+var Routine_exports = {};
+__export(Routine_exports, {
+  Routine: () => Routine,
+  make: () => make6
+});
+import * as Schema6 from "effect/Schema";
+import { Annotation as Annotation3, JsonSchema, Obj as Obj3, Ref as Ref2, Type as Type3 } from "@dxos/echo";
+var Routine = Schema6.Struct({
+  name: Schema6.optional(Schema6.String),
+  description: Schema6.optional(Schema6.String),
+  input: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Input schema"
+  }),
+  output: JsonSchema.JsonSchema.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Output schema"
+  }),
+  // TODO(burdon): Form editor.
+  instructions: Template.pipe(Annotation3.FormInputAnnotation.set(false)).annotations({
+    description: "Agent instructions"
+  }),
+  blueprints: Schema6.Array(Ref2.Ref(Blueprint)),
+  // TODO(burdon): Change to map?
+  context: Schema6.Array(Schema6.Any).pipe(Annotation3.FormInputAnnotation.set(false))
+}).pipe(Type3.object({
+  typename: "org.dxos.type.routine",
+  version: "0.1.0"
+}), Annotation3.LabelAnnotation.set([
+  "name"
+]), Annotation3.IconAnnotation.set({
+  icon: "ph--scroll--regular",
+  hue: "sky"
+}));
+var make6 = ({ name, description, input, output, instructions, blueprints = [], context = [] }) => Obj3.make(Routine, {
+  name,
+  description,
+  input: JsonSchema.toJsonSchema(input ?? Schema6.Void),
+  output: JsonSchema.toJsonSchema(output ?? Schema6.Void),
+  instructions: make({
+    source: instructions
+  }),
+  blueprints,
+  context
+});
+
+// src/Script.ts
+var Script_exports = {};
+__export(Script_exports, {
+  Script: () => Script,
+  make: () => make7
+});
+import * as Schema7 from "effect/Schema";
+import { Annotation as Annotation4, Obj as Obj4, Ref as Ref3, Type as Type4 } from "@dxos/echo";
+import { FormInputAnnotation } from "@dxos/echo/internal";
+import { Text as Text2 } from "@dxos/schema";
+var Script = Schema7.Struct({
+  name: Schema7.String.pipe(Schema7.optional),
+  description: Schema7.String.pipe(Schema7.optional),
+  // TODO(burdon): Change to hash of deployed content.
+  // Whether source has changed since last deploy.
+  changed: Schema7.Boolean.pipe(FormInputAnnotation.set(false), Schema7.optional),
+  source: Ref3.Ref(Text2.Text).pipe(FormInputAnnotation.set(false))
+}).pipe(Type4.object({
+  typename: "org.dxos.type.script",
+  version: "0.1.0"
+}), Annotation4.LabelAnnotation.set([
+  "name"
+]), Annotation4.IconAnnotation.set({
+  icon: "ph--code--regular",
+  hue: "sky"
+}));
+var make7 = ({ source = "", ...props } = {}) => Obj4.make(Script, {
+  ...props,
+  source: Ref3.make(Text2.make({
+    content: source
+  }))
+});
+
+// src/ServiceResolver.ts
+var ServiceResolver_exports = {};
+__export(ServiceResolver_exports, {
+  ServiceResolver: () => ServiceResolver,
+  compose: () => compose,
+  empty: () => empty2,
+  fromContext: () => fromContext,
+  fromRequirements: () => fromRequirements,
+  layerRequirements: () => layerRequirements,
+  make: () => make9,
+  provide: () => provide,
+  resolve: () => resolve3,
+  resolveAll: () => resolveAll,
+  succeed: () => succeed3
+});
+import * as Context6 from "effect/Context";
+import * as Effect7 from "effect/Effect";
+import * as Either from "effect/Either";
+import * as Layer4 from "effect/Layer";
+import * as Option from "effect/Option";
+var ServiceResolverTypeId = "~@dxos/functions/ServiceResolver";
+var ServiceResolver = Context6.GenericTag("@dxos/functions/ServiceResolver");
+var resolve3 = Effect7.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
+var resolveAll = (tags, context) => Effect7.gen(function* () {
+  const services = yield* Effect7.forEach(tags, (tag) => resolve3(tag, context).pipe(Effect7.map((service) => Context6.make(tag, service))));
+  return Context6.mergeAll(...services);
+});
+var succeed3 = (tag, getService) => {
+  return make9((tag1, context) => {
+    if (tag1.key !== tag.key) {
+      return Effect7.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
+    }
+    const service = getService(context);
+    return service;
+  });
+};
+var make9 = (resolveFn) => ({
+  [ServiceResolverTypeId]: ServiceResolverTypeId,
+  resolve: resolveFn
+});
+var fromContext = (ctx) => make9((tag, context) => Effect7.gen(function* () {
+  const service = Context6.getOption(ctx, tag);
+  if (Option.isNone(service)) {
+    return yield* Effect7.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+  }
+  return service.value;
+}));
+var fromRequirements = (...tags) => Effect7.contextWith((parentCtx) => {
+  const available = new Set(tags.map((tag) => tag.key));
+  return make9((tag, context) => Effect7.gen(function* () {
+    let result = Context6.empty();
+    if (!available.has(tag.key)) {
+      return yield* Effect7.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+    }
+    const service = Context6.getOption(parentCtx, tag);
+    if (Option.isNone(service)) {
+      return yield* Effect7.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+    }
+    return service.value;
+  }));
+});
+var layerRequirements = (...tags) => Layer4.effect(ServiceResolver, fromRequirements(...tags));
+var provide = (context, ...tags) => Layer4.scopedContext(resolveAll(tags, context));
+var compose = (...resolvers) => make9((tag, context) => Effect7.gen(function* () {
+  for (const resolver of resolvers) {
+    const single = yield* resolver.resolve(tag, context).pipe(Effect7.either);
+    if (Either.isRight(single)) {
+      return single.right;
+    }
+  }
+  return yield* Effect7.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+}));
+var empty2 = make9((tag, context) => {
+  return Effect7.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
+});
+
+// src/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: () => make10,
+  specEmail: () => specEmail,
+  specFeed: () => specFeed,
+  specQueue: () => specQueue,
+  specSubscription: () => specSubscription,
+  specTimer: () => specTimer,
+  specWebhook: () => specWebhook
+});
+import * as Schema8 from "effect/Schema";
+import * as SchemaAST from "effect/SchemaAST";
+import { Annotation as Annotation5, Feed, Obj as Obj5, QueryAST, Ref as Ref4, Type as Type5 } from "@dxos/echo";
+import { OptionsAnnotationId, SystemTypeAnnotation } from "@dxos/echo/internal";
+import { failedInvariant } from "@dxos/invariant";
+import { DXN } from "@dxos/keys";
+var Kinds = [
+  "email",
+  "queue",
+  "subscription",
+  "timer",
+  "webhook"
+];
+var kindLiteralAnnotations = {
+  title: "Kind"
+};
+var EmailSpec = Schema8.Struct({
+  kind: Schema8.Literal("email").annotations(kindLiteralAnnotations)
+});
+var specEmail = () => ({
+  kind: "email"
+});
+var QueueSpec = Schema8.Struct({
+  kind: Schema8.Literal("queue").annotations(kindLiteralAnnotations),
+  // TODO(dmaretskyi): Rename to `feed` and change to a reference.
+  queue: DXN.Schema
+});
+var specQueue = (queueDXN) => ({
+  kind: "queue",
+  queue: queueDXN
+});
+var specFeed = (feed) => specQueue(Feed.getQueueDxn(feed)?.toString() ?? failedInvariant(new Error("Could not extract DXN from feed")));
+var SubscriptionSpec = Schema8.Struct({
+  kind: Schema8.Literal("subscription").annotations(kindLiteralAnnotations),
+  query: Schema8.Struct({
+    raw: Schema8.optional(Schema8.String.annotations({
+      title: "Query"
+    })),
+    ast: QueryAST.Query
+  }),
+  options: Schema8.optional(Schema8.Struct({
+    // Watch changes to object (not just creation).
+    deep: Schema8.optional(Schema8.Boolean.annotations({
+      title: "Nested"
+    })),
+    // Debounce changes (delay in ms).
+    delay: Schema8.optional(Schema8.Number.annotations({
+      title: "Delay"
+    }))
+  }).annotations({
+    title: "Options"
+  }))
+});
+var specSubscription = (query, options) => ({
+  kind: "subscription",
+  query: {
+    ast: query.ast
+  },
+  options: options ? {
+    deep: options.deep,
+    delay: options.delay
+  } : void 0
+});
+var TimerSpec = Schema8.Struct({
+  kind: Schema8.Literal("timer").annotations(kindLiteralAnnotations),
+  cron: Schema8.String.annotations({
+    title: "Cron",
+    [SchemaAST.ExamplesAnnotationId]: [
+      "0 0 * * *"
+    ]
+  })
+});
+var specTimer = (cron) => ({
+  kind: "timer",
+  cron
+});
+var WebhookSpec = Schema8.Struct({
+  kind: Schema8.Literal("webhook").annotations(kindLiteralAnnotations),
+  method: Schema8.optional(Schema8.String.annotations({
+    title: "Method",
+    [OptionsAnnotationId]: [
+      "GET",
+      "POST"
+    ]
+  })),
+  port: Schema8.optional(Schema8.Number.annotations({
+    title: "Port"
+  }))
+});
+var specWebhook = (opts) => ({
+  kind: "webhook",
+  method: opts?.method,
+  port: opts?.port
+});
+var Spec = Schema8.Union(EmailSpec, QueueSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
+  title: "Trigger"
+});
+var TriggerSchema = Schema8.Struct({
+  /**
+  * Function or workflow to invoke.
+  */
+  // TODO(dmaretskyi): Can be a Ref(FunctionType) or Ref(ComputeGraphType).
+  function: Schema8.optional(Ref4.Ref(Obj5.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: Schema8.optional(Schema8.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: Schema8.optional(Schema8.Boolean.annotations({
+    title: "Enabled"
+  })),
+  spec: Schema8.optional(Spec),
+  concurrency: Schema8.optional(Schema8.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: Schema8.optional(Schema8.Record({
+    key: Schema8.String,
+    value: Schema8.Any
+  }))
+}).pipe(Type5.object({
+  typename: "org.dxos.type.trigger",
+  version: "0.1.0"
+}), Annotation5.IconAnnotation.set({
+  icon: "ph--lightning--regular",
+  hue: "yellow"
+}), SystemTypeAnnotation.set(true));
+var Trigger = TriggerSchema;
+var make10 = (props) => Obj5.make(Trigger, props);
+
+// src/TriggerEvent.ts
+var TriggerEvent_exports = {};
+__export(TriggerEvent_exports, {
+  EmailEvent: () => EmailEvent,
+  QueueEvent: () => QueueEvent,
+  SubscriptionEvent: () => SubscriptionEvent,
+  TimerEvent: () => TimerEvent,
+  TriggerEvent: () => TriggerEvent,
+  WebhookEvent: () => WebhookEvent
+});
+import * as Schema9 from "effect/Schema";
+import { DXN as DXN2, Obj as Obj6, Ref as Ref5 } from "@dxos/echo";
+var EmailEvent = Schema9.Struct({
+  from: Schema9.String,
+  to: Schema9.String,
+  subject: Schema9.String,
+  created: Schema9.String,
+  body: Schema9.String
+});
+var QueueEvent = Schema9.Struct({
+  queue: DXN2.Schema,
+  item: Schema9.Any,
+  cursor: Schema9.String
+});
+var SubscriptionEvent = Schema9.Struct({
+  /**
+  * Type of the mutation.
+  */
+  // TODO(dmaretskyi): Specify enum.
+  type: Schema9.String,
+  /**
+  * Reference to the object that was changed or created.
+  */
+  subject: Ref5.Ref(Obj6.Unknown),
+  /**
+  * @deprecated
+  */
+  changedObjectId: Schema9.optional(Schema9.String)
+});
+var TimerEvent = Schema9.Struct({
+  tick: Schema9.Number
+});
+var WebhookEvent = Schema9.Struct({
+  url: Schema9.String,
+  method: Schema9.Literal("GET", "POST"),
+  headers: Schema9.Record({
+    key: Schema9.String,
+    value: Schema9.String
+  }),
+  bodyText: Schema9.String
+});
+var TriggerEvent = Schema9.Union(EmailEvent, QueueEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
+export {
+  Blueprint_exports as Blueprint,
+  Credential_exports as Credential,
+  FunctionError,
+  FunctionNotFoundError,
+  FunctionsAiMemoizationMissError,
+  FunctionsAiUpstreamError,
+  InvalidOperationInputError,
+  InvalidOperationOutputError,
+  InvokerNotInitializedError,
+  LayerSpec_exports as LayerSpec,
+  McpServer_exports as McpServer,
+  NoHandlerError,
+  Operation_exports as Operation,
+  OperationHandlerSet_exports as OperationHandlerSet,
+  OperationRegistry_exports as OperationRegistry,
+  Process_exports as Process,
+  Routine_exports as Routine,
+  Script_exports as Script,
+  ServiceNotAvailableError,
+  ServiceResolver_exports as ServiceResolver,
+  StorageService_exports as StorageService,
+  Template_exports as Template,
+  Trace_exports as Trace,
+  Trigger_exports as Trigger,
+  TriggerEvent_exports as TriggerEvent,
+  TriggerStateNotFoundError
+};
+//# sourceMappingURL=index.mjs.map