@dxos/compute 0.10.0 → 0.11.0

package/dist/lib/neutral/index.mjs

@@ -1,1232 +0,0 @@
-import {
-  AgentService_exports
-} from "./chunk-VSAZPWSJ.mjs";
-import {
-  StorageService_exports,
-  cell,
-  withDefault
-} from "./chunk-PF7XP7XP.mjs";
-import {
-  FunctionError,
-  FunctionNotFoundError,
-  FunctionsAiMemoizationMissError,
-  FunctionsAiUpstreamError,
-  InvalidOperationInputError,
-  InvalidOperationOutputError,
-  InvokerNotInitializedError,
-  NoHandlerError,
-  OperationHandlerProvider,
-  OperationHandlerSet_exports,
-  ServiceNotAvailableError,
-  TriggerStateNotFoundError,
-  getHandler,
-  getHandlerByKey
-} from "./chunk-Z3Y7FQGN.mjs";
-import {
-  NotifyOptions,
-  Operation_exports,
-  PersistentOperation,
-  deserialize,
-  invoke,
-  isIdempotent
-} from "./chunk-EVROJER7.mjs";
-import {
-  __export
-} from "./chunk-J5LGTIGS.mjs";
-
-// src/Skill.ts
-var Skill_exports = {};
-__export(Skill_exports, {
-  Hook: () => Hook,
-  HookSpec: () => HookSpec,
-  NotFoundError: () => NotFoundError,
-  Skill: () => Skill,
-  getKey: () => getKey,
-  getVersion: () => getVersion,
-  make: () => make3,
-  registryURI: () => registryURI,
-  resolve: () => resolve,
-  toolDefinitions: () => toolDefinitions,
-  upsert: () => upsert
-});
-import * as Effect2 from "effect/Effect";
-import * as Schema4 from "effect/Schema";
-import { ToolId } from "@dxos/ai";
-import { Annotation as Annotation2, Database as Database2, DXN as DXN3, Filter as Filter2, Obj as Obj2, Ref as Ref3, Registry as Registry2, Type as Type2, URI } from "@dxos/echo";
-import { BaseError } from "@dxos/errors";
-
-// 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 Effect from "effect/Effect";
-import * as Schema2 from "effect/Schema";
-import { Database, DXN, Filter, Ref, Registry } from "@dxos/echo";
-import { assertArgument, invariant } from "@dxos/invariant";
-import { log } from "@dxos/log";
-import { Text } from "@dxos/schema";
-import Handlebars from "@dxos/vendor-kbn-handlebars";
-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 = {}) => {
-  assertArgument(typeof source === "string", "source");
-  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) => Effect.gen(function* () {
-  const entries = yield* Effect.forEach(template.inputs ?? [], (input) => Effect.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: 69, S: this, A: ["input.operation", ""] });
-        const key = DXN.isDXN(input.operation) ? input.operation : `dxn:${input.operation}`;
-        const results = yield* Registry.runQuery(Filter.and(Filter.type(PersistentOperation), Filter.key(key)));
-        if (results.length === 0) {
-          return yield* Effect.fail(new FunctionNotFoundError(input.operation));
-        }
-        const fn = deserialize(results[0]);
-        const result = yield* invoke(fn, void 0).pipe(Effect.orDie);
-        return [
-          input.name,
-          result
-        ];
-      }
-      default: {
-        return yield* Effect.dieMessage(`Unsupported input kind: ${input.kind}`);
-      }
-    }
-  }));
-  const variables = Object.fromEntries(entries);
-  log("processTemplate", {
-    variables
-  }, { "~LogMeta": "~LogMeta", F: __dxlog_file, L: 91, S: this });
-  return process((yield* Database.load(template.source)).content, variables);
-});
-
-// src/Trigger.ts
-var Trigger_exports = {};
-__export(Trigger_exports, {
-  EmailSpec: () => EmailSpec,
-  FeedSpec: () => FeedSpec,
-  InputTemplate: () => InputTemplate,
-  Kinds: () => Kinds,
-  Spec: () => Spec,
-  SubscriptionSpec: () => SubscriptionSpec,
-  TimerSpec: () => TimerSpec,
-  Trigger: () => Trigger,
-  WebhookSpec: () => WebhookSpec,
-  make: () => make2,
-  specEmail: () => specEmail,
-  specFeed: () => specFeed,
-  specSubscription: () => specSubscription,
-  specTimer: () => specTimer,
-  specWebhook: () => specWebhook
-});
-import * as Schema3 from "effect/Schema";
-import * as SchemaAST from "effect/SchemaAST";
-import { Annotation, DXN as DXN2, Feed, Obj, QueryAST, Ref as Ref2, Type } from "@dxos/echo";
-import { HiddenAnnotation } from "@dxos/echo/Annotation";
-import { OptionsAnnotationId } from "@dxos/echo/Format";
-
-// src/Runnable.ts
-var Runnable_exports = {};
-__export(Runnable_exports, {
-  Runnable: () => Runnable
-});
-var Runnable = PersistentOperation;
-
-// src/Trigger.ts
-var Kinds = [
-  "email",
-  "feed",
-  "subscription",
-  "timer",
-  "webhook"
-];
-var kindLiteralAnnotations = {
-  title: "Kind"
-};
-var EmailSpec = Schema3.Struct({
-  kind: Schema3.Literal("email").annotations(kindLiteralAnnotations)
-});
-var specEmail = () => ({
-  kind: "email"
-});
-var FeedSpec = Schema3.Struct({
-  kind: Schema3.Literal("feed").annotations(kindLiteralAnnotations),
-  feed: Schema3.optional(Ref2.Ref(Feed.Feed).annotations({
-    title: "Feed"
-  }))
-});
-var specFeed = (feed) => ({
-  kind: "feed",
-  feed: Ref2.make(feed)
-});
-var SubscriptionSpec = Schema3.Struct({
-  kind: Schema3.Literal("subscription").annotations(kindLiteralAnnotations),
-  // TODO(burdon): Issue.
-  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 specSubscription = (query, options) => ({
-  kind: "subscription",
-  query: {
-    ast: query.ast
-  },
-  options: options ? {
-    deep: options.deep,
-    delay: options.delay
-  } : void 0
-});
-var TimerSpec = Schema3.Struct({
-  kind: Schema3.Literal("timer").annotations(kindLiteralAnnotations),
-  cron: Schema3.String.annotations({
-    title: "Cron",
-    [SchemaAST.ExamplesAnnotationId]: [
-      "0 0 * * *"
-    ]
-  })
-});
-var specTimer = (cron) => ({
-  kind: "timer",
-  cron
-});
-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 specWebhook = (opts) => ({
-  kind: "webhook",
-  method: opts?.method,
-  port: opts?.port
-});
-var Spec = Schema3.Union(EmailSpec, FeedSpec, SubscriptionSpec, TimerSpec, WebhookSpec).annotations({
-  title: "Trigger"
-});
-var InputTemplate = Schema3.Record({
-  key: Schema3.String,
-  value: Schema3.Any
-});
-var Trigger = class extends Type.makeObject(DXN2.make("org.dxos.type.trigger", "0.1.0"))(Schema3.Struct({
-  /**
-   * Runnable (operation or workflow) to invoke.
-   */
-  runnable: Schema3.optional(Ref2.Ref(Runnable).annotations({
-    title: "Runnable"
-  })),
-  spec: Schema3.optional(Spec),
-  enabled: Schema3.optional(Schema3.Boolean),
-  concurrency: Schema3.Number.pipe(Schema3.annotations({
-    title: "Concurrency",
-    default: 1,
-    description: "Maximum number of concurrent invocations of the trigger."
-  }), Annotation.FormInputAnnotation.set(false), Schema3.optional),
-  /**
-   * 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.String.pipe(Schema3.annotations({
-    title: "Input Node ID"
-  }), Annotation.FormInputAnnotation.set(false), Schema3.optional),
-  /**
-   * Passed as the input data to the runnable.
-   */
-  input: InputTemplate.pipe(Annotation.FormInputAnnotation.set(false), Schema3.optional)
-}).pipe(Annotation.IconAnnotation.set({
-  icon: "ph--lightning--regular",
-  hue: "yellow"
-}), HiddenAnnotation.set(true))) {
-};
-var make2 = (props) => Obj.make(Trigger, props);
-
-// src/Skill.ts
-var Skill = class extends Type2.makeObject(DXN3.make("org.dxos.type.skill", "0.2.0"))(Schema4.Struct({
-  /**
-   * Human-readable name of the skill.
-   */
-  name: Schema4.String.annotations({
-    description: "Human-readable name of the skill"
-  }),
-  /**
-   * Description of the skill's purpose and functionality.
-   */
-  description: Schema4.optional(Schema4.String).annotations({
-    description: "Description of the skill'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 skill is active.
-   */
-  tools: Schema4.Array(ToolId).annotations({
-    description: "Array of tools that the AI assistant can use when this skill is active"
-  }),
-  /**
-   * Whether an agent is allowed to auto-enable this skill in a conversation.
-   */
-  agentCanEnable: Schema4.optional(Schema4.Boolean).annotations({
-    description: "Whether an agent is allowed to auto-enable this skill in a conversation."
-  }),
-  /**
-   * Array of MCP servers that the AI assistant can use when this skill is active.
-   */
-  mcpServers: Schema4.optional(Schema4.Array(McpServer)),
-  /**
-   * Hooks triggered automatically at certain points in the agent's lifecycle.
-   */
-  hooks: Schema4.optional(Schema4.Array(Schema4.suspend(() => Hook)))
-}).pipe(Annotation2.LabelAnnotation.set([
-  "name"
-]), Annotation2.IconAnnotation.set({
-  icon: "ph--blueprint--regular",
-  hue: "sky"
-}))) {
-};
-var HookSpec = Schema4.Union(
-  /**
-  * Triggered when the agent is about to start a request.
-  * A request is a series of agent/tool turns that the model drives.
-  */
-  Schema4.TaggedStruct("begin-request", {}),
-  /**
-  * Triggered when the agent has completed a request.
-  * A request is a series of agent/tool turns that the model drives.
-  */
-  Schema4.TaggedStruct("end-request", {})
-);
-var Hook = Schema4.Struct({
-  /**
-  * What to do when the hook is triggered.
-  *
-  * Can be a Ref to a PersistentOperation.
-  */
-  function: Schema4.optional(Ref3.Ref(Obj2.Unknown).annotations({
-    title: "Function"
-  })),
-  /**
-  * Controls when the hook is triggered.
-  */
-  spec: HookSpec,
-  /**
-  * Passed as the input data to the function.
-  * Must match the function's input schema.
-  */
-  input: InputTemplate.pipe(Annotation2.FormInputAnnotation.set(false), Schema4.optional)
-});
-var make3 = ({ key, version, tools = [], instructions = make(), ...props }) => Obj2.make(Skill, {
-  [Obj2.Meta]: {
-    key,
-    version
-  },
-  tools,
-  instructions,
-  ...props
-});
-var getKey = (skill) => {
-  const key = Obj2.getMeta(skill).key;
-  if (key === void 0) {
-    throw new Error("Skill is missing the meta key.");
-  }
-  return key;
-};
-var getVersion = (skill) => Obj2.getMeta(skill).version;
-var toolDefinitions = ({ tools = [], operations = [] }) => [
-  ...operations.map((op) => ToolId.make(DXN3.getName(op.meta.key))),
-  ...tools.map((tool) => ToolId.make(tool))
-];
-var registryURI = (key) => DXN3.tryMake(`dxn:${key}`) ?? URI.make(key);
-var resolve = (key) => Effect2.gen(function* () {
-  const results = yield* Registry2.runQuery(Filter2.and(Filter2.type(Skill), Filter2.key(key)));
-  const skill = results[0];
-  if (!skill) {
-    return yield* Effect2.fail(new NotFoundError({
-      context: {
-        key
-      }
-    }));
-  }
-  return skill;
-});
-var upsert = (key) => Effect2.gen(function* () {
-  const local = yield* Database2.query(Filter2.and(Filter2.type(Skill), Filter2.key(key))).run;
-  if (local.length > 0) {
-    return local[0];
-  }
-  return yield* Database2.add(Obj2.clone(yield* resolve(key), {
-    deep: "all"
-  }));
-});
-var NotFoundError = class extends BaseError.extend("SkillNotFound", "Skill not found") {
-};
-
-// src/Credential.ts
-var Credential_exports = {};
-__export(Credential_exports, {
-  CredentialsService: () => CredentialsService
-});
-import * as Context from "effect/Context";
-import * as Effect3 from "effect/Effect";
-import * as Redacted from "effect/Redacted";
-var CredentialsService = class _CredentialsService extends Context.Tag("@dxos/functions/CredentialsService")() {
-  static getCredential = (query) => Effect3.gen(function* () {
-    const credentials = yield* _CredentialsService;
-    return yield* Effect3.promise(() => credentials.getCredential(query));
-  });
-  static getApiKey = (query) => Effect3.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/Header.ts
-var Header_exports = {};
-__export(Header_exports, {
-  byokLayer: () => byokLayer
-});
-import * as HttpClient from "@effect/platform/HttpClient";
-import * as HttpClientRequest from "@effect/platform/HttpClientRequest";
-import * as Effect4 from "effect/Effect";
-import * as Layer from "effect/Layer";
-import { BYOK_HEADER } from "@dxos/protocols";
-var byokLayer = (providerHost) => Layer.effect(HttpClient.HttpClient, Effect4.gen(function* () {
-  const client = yield* HttpClient.HttpClient;
-  const credentials = yield* CredentialsService;
-  return HttpClient.mapRequestEffect(client, (request) => Effect4.gen(function* () {
-    const matches = yield* Effect4.tryPromise(() => credentials.queryCredentials({
-      service: providerHost
-    })).pipe(Effect4.orElseSucceed(() => []));
-    const apiKey = matches.find((credential) => credential.apiKey)?.apiKey;
-    return apiKey ? HttpClientRequest.setHeader(request, BYOK_HEADER, apiKey) : request;
-  }));
-}));
-
-// src/Instructions.ts
-var Instructions_exports = {};
-__export(Instructions_exports, {
-  Instructions: () => Instructions,
-  make: () => make5
-});
-import * as Schema5 from "effect/Schema";
-import { Annotation as Annotation3, DXN as DXN4, Format, JsonSchema, Obj as Obj3, Ref as Ref4, Type as Type3 } from "@dxos/echo";
-import { Text as Text2 } from "@dxos/schema";
-var Instructions = class extends Type3.makeObject(DXN4.make("org.dxos.type.instructions", "0.1.0"))(Schema5.Struct({
-  name: Schema5.optional(Schema5.String),
-  description: Schema5.optional(Schema5.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"
-  }),
-  text: Ref4.Ref(Text2.Text).pipe(Format.FormatAnnotation.set(Format.TypeFormat.Markdown), Schema5.annotations({
-    title: "Instructions",
-    description: "Describe what the agent should do in each session."
-  })),
-  skills: Schema5.Array(Ref4.Ref(Skill)),
-  /**
-   * Context objects bound to the agent's session when this routine runs (sibling of `skills`).
-   * Generic `Ref.Ref(Obj.Unknown)` so any space object qualifies. Honored on every run path that
-   * executes a routine through the agent prompt, not only triggered automations.
-   */
-  objects: Schema5.Array(Ref4.Ref(Obj3.Unknown)).pipe(Schema5.annotations({
-    title: "Objects"
-  }), Schema5.optional)
-}).pipe(Annotation3.LabelAnnotation.set([
-  "name"
-]), Annotation3.IconAnnotation.set({
-  icon: "ph--scroll--regular",
-  hue: "sky"
-}), Annotation3.HiddenAnnotation.set(true))) {
-};
-var make5 = ({ name, description, input, output, text, skills = [], objects }) => {
-  const body = Text2.make({
-    content: text ?? ""
-  });
-  const instructions = Obj3.make(Instructions, {
-    name,
-    description,
-    input: JsonSchema.toJsonSchema(input ?? Schema5.Void),
-    output: JsonSchema.toJsonSchema(output ?? Schema5.Void),
-    text: Ref4.make(body),
-    skills,
-    objects
-  });
-  Obj3.setParent(body, instructions);
-  return instructions;
-};
-
-// src/LayerSpec.ts
-var LayerSpec_exports = {};
-__export(LayerSpec_exports, {
-  TypeId: () => TypeId,
-  make: () => make6
-});
-var TypeId = "~@dxos/functions/LayerSpec";
-var make6 = (opts, make12) => {
-  return {
-    [TypeId]: TypeId,
-    affinity: opts.affinity,
-    requires: opts.requires,
-    provides: opts.provides,
-    make: make12
-  };
-};
-
-// src/OperationRegistry.ts
-var OperationRegistry_exports = {};
-__export(OperationRegistry_exports, {
-  Service: () => Service,
-  layer: () => layer,
-  resolve: () => resolve2
-});
-import * as Context2 from "effect/Context";
-import * as Effect5 from "effect/Effect";
-import * as Layer2 from "effect/Layer";
-import { Database as Database3, Filter as Filter3, Query } from "@dxos/echo";
-var Service = class extends Context2.Tag("@dxos/operation/OperationRegistry")() {
-};
-var resolve2 = Effect5.serviceFunctionEffect(Service, (service) => service.resolve);
-var layer = Layer2.effect(Service, Effect5.gen(function* () {
-  const database = yield* Database3.Service;
-  const handlerSet = yield* OperationHandlerProvider;
-  return {
-    resolve: (key) => Database3.query(Query.select(Filter3.and(Filter3.type(PersistentOperation), Filter3.key(key)))).first.pipe(Effect5.flatten, Effect5.map(deserialize), Effect5.catchTag("NoSuchElementException", () => getHandlerByKey(handlerSet, key)), Effect5.option).pipe(Effect5.provideService(Database3.Service, database))
-  };
-}));
-
-// src/Process.ts
-var Process_exports = {};
-__export(Process_exports, {
-  ExitedEvent: () => ExitedEvent,
-  HarnessHostAnnotation: () => HarnessHostAnnotation,
-  ID: () => ID,
-  NotifyAnnotation: () => NotifyAnnotation,
-  ProcessMonitorService: () => ProcessMonitorService,
-  ProcessTypeId: () => ProcessTypeId,
-  SpawnedEvent: () => SpawnedEvent,
-  State: () => State,
-  TargetAnnotation: () => TargetAnnotation,
-  fromOperation: () => fromOperation,
-  isProcess: () => isProcess,
-  make: () => make8,
-  prettyProcessTree: () => prettyProcessTree
-});
-import * as RpcGroup from "@effect/rpc/RpcGroup";
-import * as Context4 from "effect/Context";
-import * as Effect7 from "effect/Effect";
-import * as Schema7 from "effect/Schema";
-import { Annotation as Annotation5 } from "@dxos/echo";
-import { assertArgument as assertArgument2 } from "@dxos/invariant";
-import { DXN as DXN6, URI as URI2 } from "@dxos/keys";
-import { log as log3 } 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: () => flatten2,
-  isEdgeRuntime: () => isEdgeRuntime,
-  isOfType: () => isOfType,
-  layerConsole: () => layerConsole,
-  layerNoop: () => layerNoop,
-  mergeSinks: () => mergeSinks,
-  noopSink: () => noopSink,
-  noopWriter: () => noopWriter,
-  testTraceService: () => testTraceService,
-  write: () => write,
-  writerLayerNoop: () => writerLayerNoop
-});
-import * as Context3 from "effect/Context";
-import * as Effect6 from "effect/Effect";
-import * as Layer3 from "effect/Layer";
-import * as Schema6 from "effect/Schema";
-import { Annotation as Annotation4, DXN as DXN5, Obj as Obj4, Ref as Ref5, Type as Type4 } from "@dxos/echo";
-import { log as log2 } from "@dxos/log";
-var __dxlog_file2 = "/__w/dxos/dxos/packages/core/compute/compute/src/Trace.ts";
-var TraceService = class extends Context3.Tag("@dxos/functions/TraceService")() {
-};
-function write(eventType, payload) {
-  return Effect6.gen(function* () {
-    log2("trace write", {
-      key: eventType.key,
-      isEphemeral: eventType.isEphemeral
-    }, { "~LogMeta": "~LogMeta", F: __dxlog_file2, L: 21, S: this });
-    const writer = yield* TraceService;
-    writer.write(eventType, payload);
-  });
-}
-var EventType = (key, opts) => {
-  return {
-    key,
-    schema: opts.schema,
-    isEphemeral: opts.isEphemeral
-  };
-};
-var Event = Schema6.Struct({
-  timestamp: Schema6.Number,
-  type: Schema6.String,
-  data: Schema6.Unknown
-});
-var isOfType = (eventType, event) => {
-  return event.type === eventType.key;
-};
-var RuntimeName = Schema6.String.pipe(Schema6.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 = Schema6.Struct({
-  pid: Schema6.optional(Schema6.String),
-  parentPid: Schema6.optional(Schema6.String),
-  processName: Schema6.optional(Schema6.String),
-  /**
-  * Space the message was produced in.
-  * Stored as a string to avoid circular dependency on `@dxos/keys`.
-  */
-  space: Schema6.optional(Schema6.String),
-  /**
-  * Ref to the conversation feed object if present.
-  */
-  conversation: Ref5.Ref(Obj4.Unknown).pipe(Schema6.optional),
-  /**
-  * Ref to the trigger object if invocation resulted from a trigger.
-  */
-  trigger: Ref5.Ref(Trigger).pipe(Schema6.optional),
-  /**
-  * ID of the tool call that created the current process.
-  */
-  toolCallId: Schema6.optional(Schema6.String),
-  /**
-  * Extensible name informing which runtime executed the code that produced the event.
-  */
-  runtimeName: Schema6.optional(RuntimeName)
-});
-var isEdgeRuntime = (name) => name === CommonRuntimeName.edgeIntrinsic || name === CommonRuntimeName.edgeWorkerLoader || name === CommonRuntimeName.edgeWorkerForPlatforms;
-var MessageData = Schema6.Struct({
-  meta: Meta,
-  isEphemeral: Schema6.Boolean,
-  events: Schema6.Array(Event)
-});
-var Message = class extends Type4.makeObject(DXN5.make("org.dxos.type.traceMessage", "0.1.0"))(MessageData.pipe(Annotation4.IconAnnotation.set({
-  icon: "ph--note--regular",
-  hue: "rose"
-}), Annotation4.HiddenAnnotation.set(true))) {
-};
-var flatten2 = (message) => {
-  return message.events.map((event) => ({
-    ...event,
-    meta: message.meta,
-    isEphemeral: message.isEphemeral
-  }));
-};
-var TraceSink = class extends Context3.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, Effect6.gen(function* () {
-  const sink = yield* TraceSink;
-  const clock = opts.clock ?? Date.now;
-  return {
-    write: (event, data) => {
-      sink.write(Obj4.make(Message, {
-        meta: opts.meta ?? {},
-        isEphemeral: event.isEphemeral,
-        events: [
-          {
-            type: event.key,
-            timestamp: clock(),
-            data
-          }
-        ]
-      }));
-    }
-  };
-}));
-var OperationStart = EventType("operation.start", {
-  schema: Schema6.Struct({
-    /** Operation key. */
-    key: Schema6.String,
-    /** Human-readable operation name. */
-    name: Schema6.optional(Schema6.String),
-    /** Phosphor icon identifier in `ph--<name>--<variant>` format. */
-    icon: Schema6.optional(Schema6.String)
-  }),
-  isEphemeral: false
-});
-var OperationEnd = EventType("operation.end", {
-  schema: Schema6.Struct({
-    /** Operation key. */
-    key: Schema6.String,
-    /** Human-readable operation name. */
-    name: Schema6.optional(Schema6.String),
-    /** Phosphor icon identifier in `ph--<name>--<variant>` format. */
-    icon: Schema6.optional(Schema6.String),
-    /** Outcome of the operation. */
-    outcome: Schema6.Literal("success", "failure"),
-    /** Error message if the operation failed. */
-    error: Schema6.optional(Schema6.String)
-  }),
-  isEphemeral: false
-});
-var OperationInput = EventType("operation.input", {
-  schema: Schema6.Struct({
-    /** Operation key. */
-    key: Schema6.String,
-    /** Human-readable operation name. */
-    name: Schema6.optional(Schema6.String),
-    /** Raw operation input. Shape determined by the operation definition. */
-    input: Schema6.Unknown
-  }),
-  isEphemeral: true
-});
-var OperationOutput = EventType("operation.output", {
-  schema: Schema6.Struct({
-    /** Operation key. */
-    key: Schema6.String,
-    /** Human-readable operation name. */
-    name: Schema6.optional(Schema6.String),
-    /** Raw operation output. Shape determined by the operation definition. */
-    output: Schema6.Unknown
-  }),
-  isEphemeral: true
-});
-var StatusUpdate = EventType("status.update", {
-  schema: Schema6.Struct({
-    /** Human-readable status message. */
-    message: Schema6.String
-  }),
-  isEphemeral: true
-});
-var emitStatus = (message) => write(StatusUpdate, {
-  message
-});
-
-// src/Process.ts
-var __dxlog_file3 = "/__w/dxos/dxos/packages/core/compute/compute/src/Process.ts";
-var ID = Schema7.String.pipe(Schema7.brand("ProcessId"));
-var TargetAnnotation = Annotation5.make({
-  id: "org.dxos.process.target",
-  schema: URI2.Schema
-});
-var NotifyAnnotation = Annotation5.make({
-  id: "org.dxos.process.notify",
-  schema: NotifyOptions
-});
-var HarnessHostAnnotation = Annotation5.make({
-  id: "org.dxos.process.harnessHost",
-  schema: Schema7.Boolean
-});
-var ProcessTypeId = "~@dxos/functions/Process";
-var isProcess = (executable) => typeof executable === "object" && executable !== null && ProcessTypeId in executable;
-var make8 = (opts, create) => {
-  assertArgument2(/^[a-z0-9]([a-z0-9.\-/]*[a-z0-9])?$/i.test(opts.key), "key", "Invalid key");
-  return {
-    [ProcessTypeId]: {},
-    ...opts,
-    rpcs: opts.rpcs ?? RpcGroup.make(),
-    create: (ctx) => create(ctx).pipe(Effect7.map((partial) => ({
-      onSpawn: () => Effect7.void,
-      onInput: () => Effect7.void,
-      onAlarm: () => Effect7.void,
-      onChildEvent: () => Effect7.void,
-      ...partial,
-      rpcHandlers: sanitizeRpcs(opts.rpcs, partial.rpcHandlers)
-    })))
-  };
-};
-var sanitizeRpcs = (defined, provided) => {
-  const needsRpcs = defined !== void 0 && defined.requests.size > 0;
-  if (!needsRpcs) {
-    return provided ?? Context4.empty();
-  }
-  if (!provided) {
-    throw new TypeError("Process declared RPCs but did not provide any handlers");
-  }
-  return provided;
-};
-var OperationStartedCell = cell(Schema7.parseJson(Schema7.Boolean), "operation/started").pipe(withDefault(() => false));
-var fromOperation = (op, handler) => make8({
-  key: DXN6.getName(op.meta.key),
-  input: op.input,
-  output: op.output,
-  services: op.services
-}, (ctx) => Effect7.gen(function* () {
-  const semaphore = yield* Effect7.makeSemaphore(1);
-  const idempotent = isIdempotent(op);
-  return {
-    onInput: (input) => Effect7.gen(function* () {
-      if (!idempotent) {
-        const started = yield* OperationStartedCell.get;
-        if (started) {
-          return yield* Effect7.die(new Error(`non-idempotent operation "${op.meta.key}" was interrupted; cannot retry safely`));
-        }
-        yield* OperationStartedCell.set(true);
-      }
-      log3("operation process invoking", {
-        key: op.meta.key,
-        name: op.meta.name
-      }, { "~LogMeta": "~LogMeta", F: __dxlog_file3, L: 104, S: this });
-      yield* write(OperationStart, {
-        key: op.meta.key,
-        name: op.meta.name,
-        icon: op.meta.icon
-      });
-      yield* write(OperationInput, {
-        key: op.meta.key,
-        name: op.meta.name,
-        input
-      });
-      const opHandler = yield* getHandler(handler, op).pipe(Effect7.orDie);
-      const output = yield* opHandler.handler(input).pipe(Effect7.orDie, Effect7.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,
-        icon: op.meta.icon,
-        outcome: "success"
-      });
-    }).pipe(Effect7.catchAllDefect((defect) => Effect7.gen(function* () {
-      const errorMessage = defect instanceof Error ? defect.message : String(defect);
-      yield* write(OperationEnd, {
-        key: op.meta.key,
-        name: op.meta.name,
-        icon: op.meta.icon,
-        outcome: "failure",
-        error: errorMessage
-      });
-      return yield* Effect7.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 Context4.Tag("@dxos/functions/ProcessMonitorService")() {
-};
-var SpawnedEvent = EventType("process.spawned", {
-  schema: Schema7.Void,
-  isEphemeral: false
-});
-var ExitedEvent = EventType("process.exited", {
-  schema: Schema7.Struct({
-    outcome: Schema7.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/Script.ts
-var Script_exports = {};
-__export(Script_exports, {
-  Script: () => Script,
-  make: () => make9
-});
-import * as Schema8 from "effect/Schema";
-import { Annotation as Annotation6, DXN as DXN7, Obj as Obj5, Ref as Ref6, Type as Type5 } from "@dxos/echo";
-import { FormInputAnnotation } from "@dxos/echo/Annotation";
-import { Text as Text3 } from "@dxos/schema";
-var Script = class extends Type5.makeObject(DXN7.make("org.dxos.type.script", "0.1.0"))(Schema8.Struct({
-  name: Schema8.String.pipe(Schema8.optional),
-  description: Schema8.String.pipe(Schema8.optional),
-  // TODO(burdon): Change to hash of deployed content.
-  // Whether source has changed since last deploy.
-  changed: Schema8.Boolean.pipe(FormInputAnnotation.set(false), Schema8.optional),
-  source: Ref6.Ref(Text3.Text).pipe(FormInputAnnotation.set(false))
-}).pipe(Annotation6.LabelAnnotation.set([
-  "name"
-]), Annotation6.IconAnnotation.set({
-  icon: "ph--code--regular",
-  hue: "sky"
-}))) {
-};
-var make9 = ({ source = "", ...props } = {}) => Obj5.make(Script, {
-  ...props,
-  source: Ref6.make(Text3.make({
-    content: source
-  }))
-});
-
-// src/ServiceResolver.ts
-var ServiceResolver_exports = {};
-__export(ServiceResolver_exports, {
-  ServiceResolver: () => ServiceResolver,
-  compose: () => compose,
-  empty: () => empty3,
-  fromContext: () => fromContext,
-  fromRequirements: () => fromRequirements,
-  layerRequirements: () => layerRequirements,
-  make: () => make11,
-  provide: () => provide,
-  resolve: () => resolve3,
-  resolveAll: () => resolveAll,
-  succeed: () => succeed2
-});
-import * as Context5 from "effect/Context";
-import * as Effect8 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 = Context5.GenericTag("@dxos/functions/ServiceResolver");
-var resolve3 = Effect8.serviceFunctionEffect(ServiceResolver, (_) => _.resolve);
-var resolveAll = (tags, context) => Effect8.gen(function* () {
-  const services = yield* Effect8.forEach(tags, (tag) => resolve3(tag, context).pipe(Effect8.map((service) => Context5.make(tag, service))));
-  return Context5.mergeAll(...services);
-});
-var succeed2 = (tag, getService) => {
-  return make11((tag1, context) => {
-    if (tag1.key !== tag.key) {
-      return Effect8.fail(new ServiceNotAvailableError(`Service not available: ${String(tag.key ?? tag)}`));
-    }
-    const service = getService(context);
-    return service;
-  });
-};
-var make11 = (resolveFn) => ({
-  [ServiceResolverTypeId]: ServiceResolverTypeId,
-  resolve: resolveFn
-});
-var fromContext = (ctx) => make11((tag, context) => Effect8.gen(function* () {
-  const service = Context5.getOption(ctx, tag);
-  if (Option.isNone(service)) {
-    return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-  }
-  return service.value;
-}));
-var fromRequirements = (...tags) => Effect8.contextWith((parentCtx) => {
-  const available = new Set(tags.map((tag) => tag.key));
-  return make11((tag, context) => Effect8.gen(function* () {
-    let result = Context5.empty();
-    if (!available.has(tag.key)) {
-      return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-    }
-    const service = Context5.getOption(parentCtx, tag);
-    if (Option.isNone(service)) {
-      return yield* Effect8.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) => make11((tag, context) => Effect8.gen(function* () {
-  for (const resolver of resolvers) {
-    const single = yield* resolver.resolve(tag, context).pipe(Effect8.either);
-    if (Either.isRight(single)) {
-      return single.right;
-    }
-  }
-  return yield* Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-}));
-var empty3 = make11((tag, context) => {
-  return Effect8.fail(new ServiceNotAvailableError(String(tag.key ?? tag)));
-});
-
-// src/TriggerEvent.ts
-var TriggerEvent_exports = {};
-__export(TriggerEvent_exports, {
-  EmailEvent: () => EmailEvent,
-  FeedEvent: () => FeedEvent,
-  SubscriptionEvent: () => SubscriptionEvent,
-  TimerEvent: () => TimerEvent,
-  TriggerEvent: () => TriggerEvent,
-  WebhookEvent: () => WebhookEvent
-});
-import * as Schema9 from "effect/Schema";
-import { Feed as Feed2, Obj as Obj6, Ref as Ref7 } from "@dxos/echo";
-var EmailEvent = Schema9.Struct({
-  from: Schema9.String,
-  to: Schema9.String,
-  subject: Schema9.String,
-  created: Schema9.String,
-  body: Schema9.String
-});
-var FeedEvent = Schema9.Struct({
-  feed: Ref7.Ref(Feed2.Feed),
-  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: Ref7.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, FeedEvent, SubscriptionEvent, TimerEvent, WebhookEvent);
-export {
-  AgentService_exports as AgentService,
-  Credential_exports as Credential,
-  FunctionError,
-  FunctionNotFoundError,
-  FunctionsAiMemoizationMissError,
-  FunctionsAiUpstreamError,
-  Header_exports as Header,
-  Instructions_exports as Instructions,
-  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,
-  Runnable_exports as Runnable,
-  Script_exports as Script,
-  ServiceNotAvailableError,
-  ServiceResolver_exports as ServiceResolver,
-  Skill_exports as Skill,
-  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